Index: fact/tools/rootmacros/PulseTemplates/FCalcPulseTemplate.C
===================================================================
--- fact/tools/rootmacros/PulseTemplates/FCalcPulseTemplate.C	(revision 13465)
+++ fact/tools/rootmacros/PulseTemplates/FCalcPulseTemplate.C	(revision 13641)
@@ -1,10 +1,6 @@
 /********************** FPulseTemplate ***********************
-* read FACT raw data
-* remove spikes
-* calculate baseline
-* find peaks (CFD and normal discriminator)
+* open a root-file with pulse overlay histograms
+* calculate most propable Pulse-Shape
 * compute pulse height and pulse integral spektrum of the peaks
-+ search for Peaks in data
-+ put peaks into different histos depending und Amplitude
 + draw histos for single, double, tripple, ....above 100mV Photonpulses
 + draw Parameterdevelopment depending on photon quantity
@@ -19,16 +15,10 @@
 #include <TROOT.h>
 #include <TCanvas.h>
-#include <TProfile.h>
 #include <TTimer.h>
-#include <TH1F.h>
-#include <TH2F.h>
 #include <Getline.h>
-#include <TLine.h>
-#include <TBox.h>
 #include <TMath.h>
 #include <TFile.h>
 #include <TStyle.h>
 #include <TString.h>
-#include <TProfile.h>
 
 #include <stdio.h>
@@ -48,179 +38,43 @@
 // rootmacros
 //----------------------------------------------------------------------------
-
-#include "../fits.h"
-
-#include "../openFits.h"
-#include "../openFits.c"
-
-#include "../discriminator.h"
-#include "../discriminator.C"
-#include "../zerosearch.h"
-#include "../zerosearch.C"
-#include "../factfir.C"
-
-#include "../DrsCalibration.C"
-#include "../DrsCalibration.h"
-
-#include "../SpikeRemoval.h"
-#include "../SpikeRemoval.C"
+#include "rootfilehandler.h"
+#include "pixel.h"
+#include "templateextractors.h"
 
 //----------------------------------------------------------------------------
 // Decleration of global variables
 //----------------------------------------------------------------------------
-
 bool breakout=false;
 
-int gNEvents;
-vector<int16_t> AllPixelDataVector;
-vector<int16_t> StartCellVector;
-unsigned int CurrentEventID;
-size_t PXLxROI;
-UInt_t gRegionOfInterest;
-UInt_t NumberOfPixels;
-TString histotitle;
-
-size_t TriggerOffsetROI, RC;
-size_t drs_n;
-vector<float> drs_basemean;
-vector<float> drs_gainmean;
-vector<float> drs_triggeroffsetmean;
-
-vector<float> Ameas(FAD_MAX_SAMPLES);   // copy of the data (measured amplitude
-vector<float> Vcorr(FAD_MAX_SAMPLES);   // corrected Values
-vector<float> Vslide(FAD_MAX_SAMPLES);  // sliding average result
-vector<float> Vcfd(FAD_MAX_SAMPLES);    // CDF result
-vector<float> Vcfd2(FAD_MAX_SAMPLES);   // CDF result + 2nd sliding average
-
-float gGainMean = 9;
-float gBSLMean = 0;
-
-typedef struct{
-  double maxAmpl;
-  int countOfMax;
-  } OverlayMaximum;
-
-//typedef struct{
-//  TString name;
-//  TString title;
-//  TString xTitle;
-//  TString yTitle;
-//  float yMax;
-//  float yMin;
-//} histAttrib_t;
-
-//histAttrib_t* gHistoAttrib[MAX_PULS_ORDER];
-//histAttrib_t* gMaximumAttrib[MAX_PULS_ORDER];
-//histAttrib_t* gMaxGausAttrib[MAX_PULS_ORDER];
-//histAttrib_t* gProfileAttrib[MAX_PULS_ORDER];
-
-
-// histograms
-const int Number_Of_Debug_Histo_Types = 7;
-
-const unsigned int
-        Ameas_ 	= 0,
-        N1mean_ = 1,
-        Vcorr_  = 2,
-        Vtest_  = 3,
-        Vslide_ = 4,
-        Vcfd_   = 5,
-        Vcfd2_  = 6;
-
-//const char* gHistoTypes[8] = {
-//    "hPixelOverlay",
-//    "hPixelMax",
-//    "hPixelEdgeOverlay",
-//    "hPixelProfile",
-//    "hAllPixelOverlay",
-//    "hAllPixelMax",
-//    "hAllPixelMaxGaus",
-//    "hAllPixelProfile"
-//};
-
-//----------------------------------------------------------------------------
-// Initialisation of histograms
+//----------------------------------------------------------------------------
+// Initialisation of Root Objects
 //----------------------------------------------------------------------------
 
 // Temporary Objects
-TH1F*       debugHistos = NULL;
-TH2F*       hOverlayTemp = NULL;
-TH1F*       hMaximumTemp = NULL;
-TH1D*       hProjPeak = NULL;
-TH1F*       hTesthisto = NULL;
-TH2F*       hTesthisto2 = NULL;
 
 //Pixelwise Histograms
-TH2F*       hPixelOverlay[MAX_PULS_ORDER]= {NULL};//histogrammm for overlay of detected Peaks
-TH2F*       hPixelEdgeOverlay[MAX_PULS_ORDER] = {NULL};
-TProfile*   hPixelProfile[MAX_PULS_ORDER] = {NULL};//histogrammm for Profile of detected Peaks
-TProfile*   hPixelProfile2[MAX_PULS_ORDER] = {NULL};//histogrammm for Profile of detected Peaks
-TH1F*       hPixelMax[MAX_PULS_ORDER] = {NULL};
-TH1F*       hPixelMedian[MAX_PULS_ORDER] = {NULL};
-TH1F*       hPixelMean[MAX_PULS_ORDER] = {NULL};
 
 //All Pixel Histograms
-TH2F*       hAllPixelOverlay[MAX_PULS_ORDER] = {NULL};
-TProfile*   hAllPixelProfile[MAX_PULS_ORDER] = {NULL};
-TProfile*   hAllPixelProfile2[MAX_PULS_ORDER] = {NULL};
-TH1F*       hAllPixelMax[MAX_PULS_ORDER]     = {NULL};
-TH1F*       hAllPixelMedian[MAX_PULS_ORDER] = {NULL};
-TH1F*       hAllPixelMean[MAX_PULS_ORDER] = {NULL};
-TH2F*       hAllPixelEdgeOverlay[MAX_PULS_ORDER] = {NULL};
-
-//Histogram Parameters
-Int_t       gPixelOverlayXaxisLeft = 0;
-Int_t       gPixelOverlayXaxisRight = 0;
 
 //Root-File Objects
-TObjArray*  hList = NULL;
-TObjArray*  hAllPixelList = NULL;
-TObjArray*  hRootList = NULL;
+TObjArray*  hAllPixelList       = NULL;
+TObjArray*  hRootList           = NULL;
 
 //Canvases
-TCanvas*    cgpPixelPulses[MAX_PULS_ORDER] = {NULL};
-TCanvas*    cgpAllPixelPulses[MAX_PULS_ORDER] = {NULL};
-TCanvas*    cgpTestHistos = NULL;
-//TCanvas*    gpcDevelopment = NULL;
+TCanvas**   cgpPixelPulses      = NULL;
+TCanvas**   cgpAllPixelPulses   = NULL;
+TCanvas**   cgpDistributions    = NULL;
+//TCanvas*    cgpTestHistos       = NULL;
 
 //----------------------------------------------------------------------------
 // Functions
 //----------------------------------------------------------------------------
-
-void BookHistos(int );
-void BookPixelHistos(int );
-void BookTestHistos( int );
-
-void DeletePixelHistos(int );
-void SaveHistograms( const char*, const char*, TObjArray*, int );
-
-void FillHistograms(vector<Region>*, int, int, int);
-void DrawPulseHistograms(int, int);
-void DrawMaximumHistograms( int, int );
-void DrawTestHistograms( int);
-
-void PlotPulseShapeOfMaxPropability(unsigned int, int, int);
-void FitMaxPropabilityPuls( TH1F* , int );
-
-Double_t MedianOfH1( TH1 *h1 );
-void PlotMedianEachSliceOfPulse(unsigned int, int, int);
-
-void UpdateCanvases( int, int);
-void DeletePixelCanvases( int );
-
-void CreateRootFile(const char*, int );
-TFile *OpenRootFile(const char*, int );
-void CloseRootFile(TFile *tf);
-
-TString CreateSubDirName(int); //creates a String containing the path to the subdirectory in root file
-TString CreateSubDirName(const char* );
-
-void WritePixelTemplateToCsv( TString, const char*, const char*, int, int);
-void WriteAllPixelTemplateToCsv( TString, const char*, const char*, int);
-//void SetHistogrammSettings( const char*, int, int , int);
-//void CreatePulseCanvas( TCanvas* , unsigned int, const char* , const char*, const char*, int);
-//void DeletePulseCanvas( TCanvas* , unsigned int);
-
-
+void DeletePixelCanvases( int, int );
+void
+UpdateCanvases(
+        int verbosityLevel,
+        int max_pulse_order,
+        bool testmode
+        );
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -229,66 +83,103 @@
 //----------------------------------------------------------------------------
 int FCalcPulseTemplate(
-  char*         datafilename        = "../data/2011/11/09/20111109_006.fits.gz",
-  const char*   drsfilename         = "../data/2011/11/09/20111109_003.drs.fits.gz",
-  const char*   OutRootFileName     = "../analysis/FPulseTemplate/20111109_006/20111109_006.pulses.root",
-  const char*   OutPutPath          = "../analysis/FPulseTemplate/20111109_006/Templates/",
-  bool          ProduceGraphic      = false,
-  int           refresh_rate        = 500,      //refresh rate for canvases
-  bool          spikeDebug          = false,
-  bool          debugPixel          = false,
-  bool          fitdata             = false,
-  int           verbosityLevel      = 0,        // different verbosity levels can be implemented here
-  int           firstevent          = 0,
-  int           nevents             = -1,
-  int           firstpixel          = 0,
-  int           npixel              = -1,
-  int           sampleSetSize       = 36,
-  int           AmplWindowWidth     = 14,       //Width of Window for selection of pulses to histograms
-  float         GainMean           = 8,
-  float         BSLMean            = -1,        //4 Histogramms will be drawn, decide how far pulsehights differ from eachother
-  int           avg1                = 8,
-  int           avg2                = 8,
-  int           OverlayWindowLeft   = 70,
-  int           OverlayWindowRight  = 230
+    TString     InRootFileName        = "20111109_006.pulses.root",
+    TString     InputPath           = "../analysis/FPulseTemplate/20111109_006/",
+    TString     OutputRootFileName     = "20111109_006.pulses.root",
+    TString     OutPutPath          = "../analysis/FPulseTemplate/20111109_006/Templates/",
+    bool        ProduceGraphic      = false,
+    bool        fitdata             = false,
+    bool        stats               = false,
+    bool        debugPixel          = false,
+    int         pixelSetSize        = 40,
+    int         maxPulseOrder       = 3,
+    int         refresh_rate        = 500,      //refresh rate for canvases
+    int         verbosityLevel      = 0,        // different verbosity levels can be implemented here
+    int         firstpixel          = 0,
+    int         npixel              = -1
         )
 {
-    gGainMean = GainMean;
-    gBSLMean = BSLMean;
-//----------------------------------------------------------------------------
-//	Save-Root-File Settings
-//----------------------------------------------------------------------------
-    CreateRootFile( OutRootFileName, verbosityLevel );
-
+
+//----------------------------------------------------------------------------
+//	Open-Root-File Settings
+//----------------------------------------------------------------------------
+    TFile * inputRootFile = OpenRootFile( InputPath, InRootFileName, verbosityLevel );
+
+//----------------------------------------------------------------------------
+//	global variable Settings
+//----------------------------------------------------------------------------
+    if ( npixel == -1 )
+    {
+        npixel = NPIX - firstpixel;
+    }
+
+
+    if ( pixelSetSize == -1 )
+    {
+        pixelSetSize = firstpixel +npixel;
+    }
+//    float GainMean  = GainMean;  // this has to be extracted from root files
+//    float BSLMean   = BSLMean;    // this has to be extracted from root files
 
 //----------------------------------------------------------------------------
 //	root global Settings
 //----------------------------------------------------------------------------
-
-    gPixelOverlayXaxisLeft = OverlayWindowLeft;
-    gPixelOverlayXaxisRight = OverlayWindowRight;
-
     gStyle->SetPalette(1,0);
     gROOT->SetStyle("Plain");
-//    gPad->SetGrid();
-
+    gPad->SetGrid();
+
+
+
+//----------------------------------------------------------------------------
+//	root Canvas Settings
+//----------------------------------------------------------------------------
+
+    //Canvas Pad numbering
+    int pulsesCanvasFrameNrs[4] = {
+        1,  // Top left
+        2,  // Top right
+        3,  // bottom left
+        4   // bootom right
+    };
+
+    //Canvas Pad numbering
+    int distributionCanvasFrameNrs[4] = {
+        1,  // Top left
+        2,  // Top right
+        3,  // bottom left
+        4   // bootom right
+    };
+
+    if (ProduceGraphic)
+    {
+
+        //Canvases
+        cgpPixelPulses      = new TCanvas*[maxPulseOrder];
+        cgpDistributions    = new TCanvas*[maxPulseOrder];
+
+        //TCanvas*    gpcDevelopment = NULL;
+        TString cName   = "";
+        TString cTitle  = "";
+
+        //naming of pulse canvases
         for (
-             int pulse_order = MAX_PULS_ORDER - 1;
+             int pulse_order = maxPulseOrder - 1;
              pulse_order >= 0 ;
              pulse_order--
               )
         {
-            TString cName   ="cgpPixelPulses";
-                    cName   += pulse_order;
-            TString cTitle   ="Pulses of Order: ";
-                    cTitle   += pulse_order;
-            cgpPixelPulses[pulse_order] = new TCanvas(cName,cTitle, 0,pulse_order*20,800,800);
+            cName   ="cgpDistributions";
+            cName   += pulse_order;
+            cTitle   ="Distributions of Pulses with Order of: ";
+            cTitle   += pulse_order;
+            cgpDistributions[pulse_order] = new TCanvas(cName,cTitle, 720,pulse_order*20,720,720);
+            cgpDistributions[pulse_order]->Divide(2, 2);
+            cName   ="cgpPixelPulses";
+            cName   += pulse_order;
+            cTitle   ="Overlays of Pulses with Order of: ";
+            cTitle   += pulse_order;
+            cgpPixelPulses[pulse_order] = new TCanvas(cName,cTitle, 0,pulse_order*20,720,720);
             cgpPixelPulses[pulse_order]->Divide(2, 2);
-                    cName   = "cgpAllPixelPulses";
-                    cName   += pulse_order;
-                    cTitle   ="AllPixel average of puls shapes of Order: ";
-                    cTitle   += pulse_order;
-            cgpAllPixelPulses[pulse_order] = new TCanvas( cName, cTitle, 801, pulse_order*20, 800, 800 );
-            cgpAllPixelPulses[pulse_order]->Divide(2, 2);
         }
+
 
         // Create (pointer to) Canvases, which are used in every run,
@@ -297,22 +188,16 @@
                 // the pointers anyway ...
 
-        TCanvas *cFiltered = NULL;
-        if (spikeDebug)
-        {
-          cFiltered = new TCanvas("cFiltered","filtered DRS Waveforms", 1,310,400,300);
-          cFiltered->Divide(1, 3);
-        }
-
-        cgpTestHistos = new TCanvas( "cgpTestHistos", "Test Histograms", 801, 0, 800, 800 );
-        cgpTestHistos->Divide(2,0);
+//        if (testmode)
+//        {
+//        //additional Test histograms
+//        cgpTestHistos = new TCanvas( "cgpTestHistos", "Test Histograms", 360, 420, 360, 360 );
+//        cgpTestHistos->Divide(2,0);
+//        }
+    }
+
 //-----------------------------------------------------------------------------
 // Filter-Settings
 //-----------------------------------------------------------------------------
-// CFD filter settings
-    int k_cfd = 10;
-    vector<double> a_cfd(k_cfd, 0);
-    double b_cfd = 1.;
-    a_cfd[0]=-0.75;
-    a_cfd[k_cfd-1]=1.;
+
 
 //-----------------------------------------------------------------------------
@@ -320,402 +205,194 @@
 //-----------------------------------------------------------------------------
 
-// Open the data file
-
-    fits * datafile;
-    // Opens the raw data file and 'binds' the variables given as
-    // Parameters to the data file. So they are filled with
-    // raw data as soon as datafile->GetRow(int) is called.
-    gNEvents = openDataFits(
-                    datafilename,
-                    &datafile,
-                    AllPixelDataVector,
-                    StartCellVector,
-                    CurrentEventID,
-                    gRegionOfInterest,
-                    NumberOfPixels,
-                    PXLxROI,
-                    verbosityLevel
-                );
-
-    if (gNEvents == 0)
-    {
-        cout << "return code of OpenDataFile:" << datafilename<< endl;
-        cout << "is zero -> aborting." << endl;
-        return 1;
-    }
-
-    if (verbosityLevel > 0)
-    {
-        cout << endl <<"number of events in file: "<< gNEvents << "\t";
-    }
-
-    if ( nevents == -1 || nevents > gNEvents ) nevents = gNEvents; // -1 means all!
-
-    if (verbosityLevel > 0)
-    {
-        cout <<"of, which "<< nevents << " will be processed"<< endl;
-        cout <<"Total # of Pixel: "<< NumberOfPixels << "\t";
-    }
-
-    if ( npixel == -1 || npixel > (int)NumberOfPixels  ) npixel = (int)NumberOfPixels; // -1 means all!
-
-    if (verbosityLevel > 0)
-    {
-        cout <<"of, which "<< npixel << " will be processed"<< endl;
-    }
-
-    //Get the DRS calibration
-    RC = openCalibFits(
-                drsfilename,
-                drs_basemean,
-                drs_gainmean,
-                drs_triggeroffsetmean,
-                TriggerOffsetROI
-                );
-
-    if (RC == 0)
-    {
-     cout << "return code of openCalibFits:" << drsfilename << endl;
-     cout << "is zero -> aborting." << endl;
-     return 1;
-    }
-
-    // Book the histograms
-    BookHistos(verbosityLevel );
-    BookTestHistos( verbosityLevel );
+//----------------------------------------------------------------------------
+// Initialize Pixel
+//----------------------------------------------------------------------------
+    Pixel** pixel = new Pixel*[NPIX];
+
+    for (int i = 0 ; i < NPIX; i++)
+    {
+        pixel[i] = NULL;
+    }
+
 //-------------------------------------
 // Loop over Pixel Sets
 //-------------------------------------
-    for ( int firstPixelOfSample = firstpixel;
-          firstPixelOfSample < firstpixel + npixel;
-          firstPixelOfSample += sampleSetSize )
-    {
-
+    for ( int firstPixelOfSet = firstpixel;
+          firstPixelOfSet < firstpixel + npixel;
+          firstPixelOfSet += pixelSetSize )
+    {
         if (verbosityLevel >= 0)
         {
             cout << "------------------------------------------------" << endl
-                 << "...processing Sample from Pixel: "
-                 << firstPixelOfSample;
+                 << "...processing Pixel: "
+                 << firstPixelOfSet
                  << "to Pixel: "
-                 << firstPixelOfSample+sampleSetSize-1 << endl;
+                 << firstPixelOfSet+pixelSetSize-1 << endl;
         }
-        BookPixelHistos(verbosityLevel );
-
-//--------------------------------------------------------------------
-// Loops over Every Event of Pixel
-//--------------------------------------------------------------------
-        for ( int ev = firstevent; ev < firstevent + nevents; ev++)
+
+        //--------------------------------------------------------------------
+        // Loops over every Pixel of a Set of Pixels
+        //--------------------------------------------------------------------
+        for ( int pixelID = firstPixelOfSet;
+                pixelID < firstPixelOfSet + pixelSetSize
+                && pixelID < firstpixel + npixel;
+                pixelID++ )
         {
-            // Get an Event --> consists of 1440 Pixel ...erm....data
-            datafile->GetRow( ev );
-
-            if (verbosityLevel > 0)
+
+            if (verbosityLevel > 1)
             {
              cout << "-------------------------------------" << endl
-                  << "...processing Event: " << CurrentEventID
-                  << "/" << nevents << " of Pixel: " << pixel << endl;
+                  << "...processing Set from Pixel "
+                  << firstPixelOfSet
+                  << " to Pixel "
+                  << firstPixelOfSet+pixelSetSize-1
+                  << " Pixel: " << pixelID
+                  << "/" << firstpixel + npixel -1 << endl;
             }
 
-//--------------------------------------------------------------------
-// Loops over every Pixel of a Set of Pixels
-//--------------------------------------------------------------------
-        for ( int pixel = firstPixelOfSample;
-            pixel < sampleSetSize || pixel < firstpixel + npixel;
-            pixel++ )
-        {
-            if (verbosityLevel > 0)
-           {
-             cout << "-------------------------------------" << endl
-                  << "...processing Pixel: " << pixel
-                  << "/" << nPixelSample << endl;
-           }
-
-//-------------------------------------
-// Apply Calibration
-//-------------------------------------
-            if (verbosityLevel > 2) cout << "...applying DrsCalibration";
-            applyDrsCalibration(
-                        Ameas,
-                        pixel,
-                        12,
-                        12,
-                        drs_basemean,
-                        drs_gainmean,
-                        drs_triggeroffsetmean,
-                        gRegionOfInterest,
-                        AllPixelDataVector,
-                        StartCellVector
+            //-------------------------------------
+            // Create individual Pixel
+            //-------------------------------------
+           pixel[pixelID] = new Pixel(
+                       pixelID,
+                       maxPulseOrder,  ///One should get this from the file
+                       verbosityLevel,
+                       stats,
+                       inputRootFile
+                    );
+
+            if (breakout)   break;
+
+            //-------------------------------------
+            // Histogramms of Maximas in Overlay Spectra
+            //-------------------------------------
+
+            for ( int pulse_order = 0 ;
+                  pulse_order < pixel[pixelID]->mMaxPulseOrder ;
+                  pulse_order ++)
+            {
+                if (verbosityLevel > 2)
+                {
+                    cout << "-------------------------------------" << endl
+                         << "...processing Set from Pixel "
+                         << firstPixelOfSet
+                         << " to Pixel "
+                         << firstPixelOfSet+pixelSetSize-1
+                         << " Pixel: " << pixelID
+                         << "/" << firstpixel + npixel -1 << endl
+                         << " Pulse-Order: " << pulse_order;
+                }
+
+                // Calculate Max Prop. Value of each slice
+                //-------------------------------------
+
+                //from Maximum Overlay
+                ExtractPulseTemplate(
+                            pixel[pixelID],
+                            "Maximum",
+                            pulse_order,
+                            verbosityLevel
+                            );
+
+                //from Edge Overlay
+                ExtractPulseTemplate(
+                            pixel[pixelID],
+                            "Edge",
+                            pulse_order,
+                            verbosityLevel
+                            );
+
+                WritePixelTemplateToCsv(
+                            pixel[pixelID],
+                            OutPutPath,
+                            "Maximum",
+                            pulse_order,
+                            verbosityLevel
+                            );
+
+                WritePixelTemplateToCsv(
+                            pixel[pixelID],
+                            OutPutPath,
+                            "Edge",
+                            pulse_order,
+                            verbosityLevel
+                            );
+
+                pixel[pixelID]->DrawTemplateHistograms(
+                            cgpPixelPulses,
+                            pulsesCanvasFrameNrs
+                            );
+
+                pixel[pixelID]->DrawEdgeTemplateHistograms(
+                            cgpPixelPulses,
+                            pulsesCanvasFrameNrs
+                            );
+
+
+
+            }
+            // End of Loop over pulsorder of current Pixel
+
+            if (ProduceGraphic)
+            {
+            UpdateCanvases(
+                        verbosityLevel,
+                        MAX_PULS_ORDER,
+                        false
                         );
-            if (verbosityLevel > 2) cout << "...done " << endl;
-
-//-------------------------------------
-// Apply Filters
-//-------------------------------------
-            // finds spikes in the raw data, and interpolates the value
-            // spikes are: 1 or 2 slice wide, positive non physical artifacts
-            if (verbosityLevel > 2) cout << "...removeing Spikes";
-            removeSpikes (Ameas, Vcorr);
-            if (verbosityLevel > 2) cout << "...done " << endl;
-
-            // filter Vcorr with sliding average using FIR filter function
-            if (verbosityLevel > 2) cout << "...applying sliding average filter";
-            sliding_avg(Vcorr, Vslide, avg1);
-            if (verbosityLevel > 2) cout << "...done " << endl;
-
-            // filter Vslide with CFD using FIR filter function
-            if (verbosityLevel > 2) cout << "...apllying factfir filter";
-            factfir(b_cfd , a_cfd, k_cfd, Vslide, Vcfd);
-            if (verbosityLevel > 2) cout << "...done " << endl;
-
-            // filter Vcfd with sliding average using FIR filter function
-            if (verbosityLevel > 2) cout << "...applying 2nd sliding average filter";
-            sliding_avg(Vcfd, Vcfd2, avg2);
-            if (verbosityLevel > 2) cout << "...done " << endl;
-
-//-------------------------------------
-// Search vor Zero crossings
-//-------------------------------------
-            if (verbosityLevel > 2) cout << endl << "...searching zero crossings" ;
-            // peaks in Ameas[] are found by searching for zero crossings
-            // in Vcfd2
-            // first Argument 1 means ... *rising* edge
-            // second Argument 1 means ... search with stepsize 1 ... 10 is okay as well
-            vector<Region>* pZXings = zerosearch( Vcfd2 , 1 , 8);
-            // pZXings means "zero cross ings"
-            EnlargeRegion(*pZXings, 10, 10);
-            findAbsMaxInRegions(*pZXings, Vslide);
-            removeMaximaBelow( *pZXings, 3.0);
-            removeRegionWithMaxOnEdge( *pZXings, 2);
-            removeRegionOnFallingEdge( *pZXings, 100);
-            findTimeOfHalfMaxLeft(*pZXings, Vcorr, gBSLMean, 5, 10, verbosityLevel );
-            if (verbosityLevel > 2) cout << "...done" << endl;
-
-//-----------------------------------------------------------------------------
-// Fill Overlay Histos
-//-----------------------------------------------------------------------------
-        FillHistograms(pZXings, AmplWindowWidth, ev, verbosityLevel );
-
-//-----------------------------------------------------------------------------
-// Spike Debug
-//-----------------------------------------------------------------------------
-        if ( spikeDebug )
-        {
-            // TODO do this correct. The vectors should be the rigt ones... this is just luck
-            debugHistos[Ameas_].GetXaxis()->Set(Ameas.size() , -0.5 , Ameas.size()-0.5);
-            debugHistos[Vcorr_].GetXaxis()->Set(Ameas.size() , -0.5 , Ameas.size()-0.5);
-            debugHistos[Vslide_].GetXaxis()->Set(Ameas.size() , -0.5 , Ameas.size()-0.5);
-            debugHistos[Vcfd_].GetXaxis()->Set(Ameas.size() , -0.5 , Ameas.size()-0.5);
-            debugHistos[Vcfd2_].GetXaxis()->Set(Ameas.size() , -0.5 , Ameas.size()-0.5);
-
-            for ( unsigned int sl = 0; sl < gRegionOfInterest; sl++)
+            }
+
+            if (debugPixel)
             {
-               debugHistos[Ameas_].SetBinContent(sl, Ameas[sl]);
-               debugHistos[Vcorr_].SetBinContent(sl, Vcorr[sl]);
-               debugHistos[Vslide_].SetBinContent( sl, Vslide[sl] );
-               debugHistos[Vcfd_].SetBinContent( sl, Vcfd[sl] );
-               debugHistos[Vcfd2_].SetBinContent( sl, Vcfd2[sl] );
+                //Process gui events asynchronously during input
+                cout << endl;
+                TTimer timer("gSystem->ProcessEvents();", 50, kFALSE);
+                timer.TurnOn();
+                TString input = Getline("Type 'q' to exit, <return> to go on: ");
+                timer.TurnOff();
+                if (input=="q\n")
+                {
+                       break;
+                }
             }
 
-
-            cFiltered->cd(1);
-            gPad->SetGrid();
-            debugHistos[Ameas_].Draw();
-
-            cFiltered->cd(2);
-            gPad->SetGrid();
-            debugHistos[Vcorr_].Draw();
-
-            cFiltered->cd(3);
-            gPad->SetGrid();
-            debugHistos[Vslide_].Draw();
-
-            TBox *OneBox;
-            vector<TBox*> MyBoxes;
-            for (unsigned int i=0; i<pZXings->size(); i++){
-                    OneBox = new TBox(
-                            pZXings->at(i).maxPos -10 ,
-                            pZXings->at(i).maxVal -0.5,
-                            pZXings->at(i).maxPos +10 ,
-                            pZXings->at(i).maxVal +0.5);
-                    OneBox->SetLineColor(kBlue);
-                    OneBox->SetLineWidth(1);
-                    OneBox->SetFillStyle(0);
-                    OneBox->SetFillColor(kRed);
-                    MyBoxes.push_back(OneBox);
-                    OneBox->Draw();
-            }
-
-//            cFiltered->cd(3);
-//            gPad->SetGrid();
-//            debugHistos[Vcfd2_].Draw();
-//            TLine *zeroline = new TLine(0, 0, 1024, 0);
-//            zeroline->SetLineColor(kBlue);
-//            zeroline->Draw();
-
-            cFiltered->Update();
-
-
-            //Process gui events asynchronously during input
-            TTimer timer("gSystem->ProcessEvents();", 50, kFALSE);
-            timer.TurnOn();
-            TString input = Getline("Type 'q' to exit, <return> to go on: ");
-            timer.TurnOff();
-            if (input=="q\n") {
-                    breakout=true;
-            }
-
-            //TODO!!!!!!!!!
-            // do some Garbage collection ...
-            // all the Objects on the heap should be deleted here.
-
-        }// end of if(spikeDebug)
-
-        delete pZXings;
-        if (breakout)   break;
-//-------------------------------------
-// Draw 1. Set of Pixel Histograms
-//-------------------------------------
-            if ((ev % refresh_rate) == 0)
+            if (verbosityLevel > 2)
             {
-                DrawPulseHistograms(
-                        verbosityLevel,
-                        MAX_PULS_ORDER
-                        );
-                DrawTestHistograms(
-                        verbosityLevel
-                        );
-              if (ProduceGraphic)
-              {
-                UpdateCanvases(
-                                verbosityLevel,
-                                MAX_PULS_ORDER
-                                );
-              }
-            }
-
-        if (breakout) break;
-
-        if (verbosityLevel > 2)
-        {
-            cout << endl << "-------------------------------------"<< endl;
-        }
-
-
-
-
-        }//End of Loop over Sample
-//-------------------------------------
-// end of Loops over Sample
-//-------------------------------------
-
-        }//End of Loop over Events
-//-------------------------------------
-// end of Loops over Events
-//-------------------------------------
-
-
-
-
-//-------------------------------------
-// Histogramms of Maximas in Overlay Spectra
-//-------------------------------------
-
-    PlotPulseShapeOfMaxPropability(
-            MAX_PULS_ORDER,
-            fitdata,
-            verbosityLevel
-         );
-
-    for (unsigned int pulse_order = 0 ; pulse_order < max_pulse_order ; pulse_order ++)
-    {
-    if (verbosityLevel > 2) cout << "\t...plotting most probable pulse of"
-                                 << "pulse order " << pulse_order;
-    PlotMedianEachSliceOfPulse(
-         hPixelOverlay[pulse_order],
-         hPixelMedian[pulse_order],
-         fitdata,
-         verbosityLevel
-         );
-
-    PlotMeanEachSliceOfPulse(
-         hPixelOverlay[pulse_order],
-         hPixelMean[pulse_order],
-         fitdata,
-         verbosityLevel
-         );
-    }
-         WritePixelTemplateToCsv(
-                     OutPutPath,
-                     "PulseTemplate_PointSet",
-                     "Maximum",
-                     pixel,
-                     verbosityLevel
-                     );
-
-       if (verbosityLevel > 2) cout << "...done" << endl;
-       //here is what happends at the end of each loop over all pixels
-       //Save Histograms of Pixel into Output rootfile
-       DrawPulseHistograms(
-               verbosityLevel,
-               MAX_PULS_ORDER
-               );
-
-       DrawMaximumHistograms(
-               verbosityLevel,
-               MAX_PULS_ORDER
-               );
-
-        if (ProduceGraphic)
-        {
-        UpdateCanvases(
-                       verbosityLevel,
-                       MAX_PULS_ORDER
-                       );
-        }
-
-//       SaveHistograms(
-//                   OutRootFileName,
-//                   CreateSubDirName(pixel),
-//                   hList,
-//                   verbosityLevel
-//                   );
-
-       if (debugPixel)
-       {
-           //Process gui events asynchronously during input
-           cout << endl;
-           TTimer timer("gSystem->ProcessEvents();", 50, kFALSE);
-           timer.TurnOn();
-           TString input = Getline("Type 'q' to exit, <return> to go on: ");
-           timer.TurnOff();
-           if (input=="q\n") {
-                   break;
-           }
-       }
-
-       DeletePixelHistos(verbosityLevel);
-
-       if (verbosityLevel > 2)
-       {
-           cout << endl << "...End of Pixel"
+            cout << endl << "...End of Pixel"
                 << endl << "------------------------------------------------"
                 << endl;
-       }
-    }
-    // End of Loop over all Pixels
+            }
+        }
+        // End of Loop over all Pixels of set
+
+        if (verbosityLevel > 1)
+        {
+        cout << endl << "...End of Loop over all Pixels of set"
+            << endl << "------------------------------------------------"
+            << endl;
+        }
+    }
+    // End of Loop over all Pixelsets
+
+    if (verbosityLevel > 0)
+    {
+    cout << endl << "...End of Loop over all Pixelsets"
+        << endl << "------------------------------------------------"
+        << endl;
+    }
 
 //-------------------------------------
-// Draw Histograms
+// Draw All Pixel Histograms
 //-------------------------------------
 
-    SaveHistograms(     //save histograms of all pixel into output root file
-                OutRootFileName,
-                CreateSubDirName("All"),
-                hAllPixelList,
-                verbosityLevel
-                );
+//    SaveHistograms(     //save histograms of all pixel into output root file
+//                OutInRootFileName,
+//                CreateSubDirName("All"),
+//                hAllPixelList,
+//                verbosityLevel
+//                );
 
 //    SaveHistograms(     //save histograms of generell results into output root file
-//                OutRootFileName,
+//                OutInRootFileName,
 //                "root",
 //                hRootList,
@@ -725,20 +402,20 @@
 
 
-    if (ProduceGraphic)
-    {
-        UpdateCanvases(
-                    verbosityLevel,
-                    MAX_PULS_ORDER
-                    );
-    }
-
-    WriteAllPixelTemplateToCsv(
-                OutPutPath,
-                "PulseTemplate_PointSet",
-                "Maximum",
-                verbosityLevel
-                );
-
-    DeletePixelCanvases( verbosityLevel );
+//    if (ProduceGraphic)
+//    {
+//        UpdateCanvases(
+//                    verbosityLevel,
+//                    MAX_PULS_ORDER
+//                    );
+//    }
+
+//    WriteAllPixelTemplateToCsv(
+//                OutPutPath,
+//                "PulseTemplate_PointSet",
+//                "Maximum",
+//                verbosityLevel
+//                );
+
+    DeletePixelCanvases( maxPulseOrder ,verbosityLevel );
     return( 0 );
 }
@@ -753,787 +430,25 @@
 // Funktions
 //-----------------------------------------------------------------------------
-
-/*
-ich erzeuge sowas wie 36 pixel mit ca 20 Histogrammen pro pixel
-wie viel speicher braucht das?
-Ich brauche eine möglichkeit jedes dieser histogramme zu identifizieren
-am besten ein array oder eine liste oder einen abstracten datentyp mit den histogrammen als attribute.
-ne klasse wäre super
-
-*/
 void
-BookPixelHistos(
-        int     sampleSize,
-
-        int     verbosityLevel
-        )
-{
-    if (verbosityLevel > 2) cout << endl << "...book pixel histograms" << endl;
-    hList = new TObjArray;
-
-    TString histoname;
-    for (int order = 0; order < MAX_PULS_ORDER; order ++)
-    {
-//        SetHistogramAttributes(
-//                    "PeakOverlay",
-//                    order,
-//                    gOverlayAttrib,
-//                    MaxAmplOfFirstPulse
-//                    );
-        histoname = "hPixelOverlay";
-        histoname += order;
-        if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-        hPixelOverlay[order] = new TH2F(
-                    histoname,
-                    "Overlay of detected pulses of one pulse order for one Pixel",
-                    gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,
-                    (-1*gPixelOverlayXaxisLeft)-0.5,
-                    gPixelOverlayXaxisRight-0.5 ,
-                    512,
-                    -55.5,
-                    200.5
-                    );
-        hPixelOverlay[order]->SetAxisRange(
-                    gBSLMean - 5,
-                    (gGainMean*(order+1)) + 10,
-                    "Y");
-        hPixelOverlay[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-        hPixelOverlay[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-        //hPixelProfile->SetBit(TH2F::kCanRebin);
-        hList->Add( hPixelOverlay[order] );
-
-    //------------------------------------------------------------------------
-//        SetHistogramAttributes(
-//                    "PeakMaximum",
-//                    order,
-//                    gMaximumAttrib,
-//                    MaxAmplOfFirstPulse
-//                    );
-        histoname = "hPixelMax";
-        histoname += order;
-        if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-        hPixelMax[order] = new TH1F(
-                    histoname,
-                    "Maximum value of each slice in overlay plot",
-                    gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,
-                    (-1*gPixelOverlayXaxisLeft)-0.5,
-                    gPixelOverlayXaxisRight-0.5
-                    );
-        hPixelMax[order]->SetAxisRange(
-                    gBSLMean - 5,
-                    (gGainMean*(order+1)) + 10,
-                    "Y");
-        hPixelMax[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-        hPixelMax[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-        hList->Add( hPixelMax[order] );
-
-//------------------------------------------------------------------------
-    //        SetHistogramAttributes(
-    //                    "PeakMaximum",
-    //                    order,
-    //                    gMaximumAttrib,
-    //                    MaxAmplOfFirstPulse
-    //                    );
-            histoname = "hPixelMedian";
-            histoname += order;
-            if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-            hPixelMedian[order] = new TH1F(
-                        histoname,
-                        "Median of each slice in overlay plot",
-                        gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,
-                        (-1*gPixelOverlayXaxisLeft)-0.5,
-                        gPixelOverlayXaxisRight-0.5
-                        );
-            hPixelMedian[order]->SetAxisRange(
-                        gBSLMean - 5,
-                        (gGainMean*(order+1)) + 10,
-                        "Y");
-            hPixelMedian[order]->SetLineColor(kRed);
-            hPixelMedian[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-            hPixelMedian[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-            hList->Add( hPixelMedian[order] );
-
-//------------------------------------------------------------------------
-    //        SetHistogramAttributes(
-    //                    "PeakMaximum",
-    //                    order,
-    //                    gMaximumAttrib,
-    //                    MaxAmplOfFirstPulse
-    //                    );
-            histoname = "hPixelMean";
-            histoname += order;
-            if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-            hPixelMean[order] = new TH1F(
-                        histoname,
-                        "Mean of each slice in overlay plot",
-                        gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,
-                        (-1*gPixelOverlayXaxisLeft)-0.5,
-                        gPixelOverlayXaxisRight-0.5
-                        );
-            hPixelMean[order]->SetAxisRange(
-                        gBSLMean - 5,
-                        (gGainMean*(order+1)) + 10,
-                        "Y");
-            hPixelMean[order]->SetLineColor(kBlue);
-            hPixelMean[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-            hPixelMean[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-            hList->Add( hPixelMean[order] );
-
-//------------------------------------------------------------------------
-//        SetHistogramAttributes(
-//                    "PeakMaxGaus",
-//                    order,
-//                    gMaxGausAttrib,
-//                    MaxAmplOfFirstPulse
-//                    );
-        histoname = "hPixelEdgeOverlay";
-        histoname += order;
-        if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-        hPixelEdgeOverlay[order] = new TH2F(
-                    histoname,
-                    "Overlay at rising edge of detected pulses of one pulse order for one Pixel ",
-                    gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,
-                    (-1*gPixelOverlayXaxisLeft)-0.5,
-                    gPixelOverlayXaxisRight-0.5 ,
-                    512,
-                    -55.5,
-                    200.5
-                    );
-
-        hPixelEdgeOverlay[order]->SetAxisRange(
-                    gBSLMean - 5,
-                    (gGainMean*(order+1)) + 10,
-                    "Y");
-        hPixelEdgeOverlay[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-        hPixelEdgeOverlay[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-        hList->Add( hPixelEdgeOverlay[order] );
-
-    //------------------------------------------------------------------------
-//        SetHistogramAttributes(
-//                    "PeakProfile",
-//                    order,
-//                    gProfileAttrib,
-//                    MaxAmplOfFirstPulse
-//                    );
-        histoname = "hPixelProfile";
-        histoname += order;
-        if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-        hPixelProfile[order] = new TProfile(
-                    histoname,
-                    "Mean value of each slice in overlay plot (Tprofile)",
-                    gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,//nbinsx
-                    (-1*gPixelOverlayXaxisLeft)-0.5,                 //xlow
-                    gPixelOverlayXaxisRight-0.5 ,                    //xup
-    //                512,                                            //nbinsy
-                    -55.5,                                          //ylow
-                    300.5,                                          //yup
-                    "s");                                           //option
-        hPixelProfile[order]->SetAxisRange(
-                    gBSLMean - 5,
-                    (gGainMean*(order+1)) + 10,
-                    "Y");
-        hPixelProfile[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-        hPixelProfile[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-        //hPixelProfile->SetBit(TH2F::kCanRebin);
-        hList->Add( hPixelProfile[order] );
-
-
-    //------------------------------------------------------------------------
-    //        SetHistogramAttributes(
-    //                    "PeakProfile",
-    //                    order,
-    //                    gProfileAttrib,
-    //                    MaxAmplOfFirstPulse
-    //                    );
-            histoname = "hPixelProfile2";
-            histoname += order;
-            if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-            hPixelProfile2[order] = new TProfile(
-                        histoname,
-                        "Mean value of each slice in overlay plot (Tprofile)",
-                        gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,//nbinsx
-                        (-1*gPixelOverlayXaxisLeft)-0.5,                 //xlow
-                        gPixelOverlayXaxisRight-0.5 ,                    //xup
-        //                512,                                            //nbinsy
-                        -55.5,                                          //ylow
-                        300.5,                                          //yup
-                        "s");                                           //option
-            hPixelProfile2[order]->SetLineColor(kRed);
-            hPixelProfile2[order]->SetAxisRange(
-                        gBSLMean - 5,
-                        (gGainMean*(order+1)) + 10,
-                        "Y");
-            hPixelProfile2[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-            hPixelProfile2[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-            //hPixelProfile->SetBit(TH2F::kCanRebin);
-
-
-
-
-    }
-    if (verbosityLevel > 2) cout << "...done" << endl;
-}
-//end of BookPixelHistos
-//----------------------------------------------------------------------------
-
-
-void DeletePixelHistos( int verbosityLevel )
-{
-    if (verbosityLevel > 2) cout << endl << "...delete current pixel histograms" ;
-    for (int order = 0; order < MAX_PULS_ORDER; order ++)
-    {
-        if (verbosityLevel > 3) cout << endl << "...deleting hPixelOverlay" << order;
-        delete hPixelOverlay[order];
-        if (verbosityLevel > 3) cout << endl << "...deleting hPixelMax" << order;
-        delete hPixelMax[order];
-        if (verbosityLevel > 3) cout << endl << "...deleting hPixelMedian" << order;
-        delete hPixelMedian[order];
-        if (verbosityLevel > 3) cout << endl << "...deleting hPixelMean" << order;
-        delete hPixelMean[order];
-        if (verbosityLevel > 3) cout << endl << "...deleting hPixelEdgeOverlay" << order;
-        delete hPixelEdgeOverlay[order];
-        if (verbosityLevel > 3) cout << endl << "...deleting hPixelProfile" << order;
-        delete hPixelProfile[order];
-        if (verbosityLevel > 3) cout << endl << "...deleting hPixelProfile2" << order;
-        delete hPixelProfile2[order];
-    }
-    if (verbosityLevel > 3) cout << endl << "...deleting hList";
-    delete hList;
-    if (verbosityLevel > 2) cout << endl << "...done" << endl;
-}
-//end of DeletePixelHistos
-//----------------------------------------------------------------------------
-
-void BookTestHistos( int verbosityLevel )
-{
-    if (verbosityLevel > 2) cout << endl << "...book pixel histograms" << endl;
-
-    hTesthisto = new TH1F (
-                "hTesthisto",
-                "Deviation of rising edge and maximum",
-                600,
-                -10.1,
-                10.1
-                );
-    hTesthisto->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-    hTesthisto->GetYaxis()->SetTitle( "counts" );
-
-    hTesthisto2 = new TH2F (
-                "hTesthisto2",
-                "Deviation of rising edge and maximum by event #",
-                gNEvents,
-                250,
-                800,
-                600,
-                -10.1,
-                10.1
-                );
-//    hTesthisto2->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-//    hTesthisto2->GetYaxis()->SetTitle( "counts" );
-//    hTesthisto2->SetMarkerStyle( 2 );
-
-    if (verbosityLevel > 2) cout << "...done" << endl;
-}
-//end of BookTestHistos
-//----------------------------------------------------------------------------
-
-void BookHistos( int verbosityLevel )
-{
-        if (verbosityLevel > 2) cout << endl << "...book histograms" << endl;
-    hAllPixelList = new TObjArray;
-    hRootList = new TObjArray;
-    debugHistos = new TH1F[ Number_Of_Debug_Histo_Types ];
-    for ( int type = 0; type < Number_Of_Debug_Histo_Types; type++){
-        debugHistos[ type ].SetBins(1024, 0, 1024);
-        debugHistos[ type ].SetLineColor(1);
-        debugHistos[ type ].SetLineWidth(2);
-        debugHistos[ type ].SetStats(false);
-
-        // set X axis paras
-        debugHistos[ type ].GetXaxis()->SetLabelSize(0.08);
-        debugHistos[ type ].GetXaxis()->SetTitleSize(0.08);
-        debugHistos[ type ].GetXaxis()->SetTitleOffset(1.0);
-        debugHistos[ type ].GetXaxis()->SetTitle(Form("Time slice [%.1f ns/slice]", 1./2.));
-
-        // set Y axis paras
-        debugHistos[ type ].GetYaxis()->SetLabelSize(0.08);
-        debugHistos[ type ].GetYaxis()->SetTitleSize(0.08);
-        debugHistos[ type ].GetYaxis()->SetTitleOffset(0.3);
-        debugHistos[ type ].GetYaxis()->SetTitle("Amplitude [mV]");
-    }
-
-    // All Pixel Histograms
-    //------------------------------------------------------------------------
-    TString histoname;
-    for (int order = 0; order < MAX_PULS_ORDER; order ++)
-    {
-//        SetHistogramAttributes(
-//                    "AllPixelPeakOverlay",
-//                    order,
-//                    gOverlayAttrib,
-//                    MaxAmplOfFirstPulse
-//                    );
-        histoname = "hAllPixelOverlay";
-        histoname += order;
-        if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-        hAllPixelOverlay[order] = new TH2F(
-                    histoname,
-                    "Overlay of detected Pulses of one Order for All Pixels",
-                    gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,
-                    (-1*gPixelOverlayXaxisLeft)-0.5,
-                    gPixelOverlayXaxisRight-0.5 ,
-                    512,
-                    -55.5,
-                    300.5
-                    );
-        hAllPixelOverlay[order]->SetAxisRange(
-                    gBSLMean - 5,
-                    (gGainMean*(order+1)) + 10,
-                    "Y");
-        hAllPixelOverlay[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-        hAllPixelOverlay[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-        //hAllPixelOverlay->SetBit(TH2F::kCanRebin);
-        hAllPixelList->Add( hAllPixelOverlay[order] );
-
-    //------------------------------------------------------------------------
-
-//        SetHistogramAttributes(
-//                    "AllPixelPeakMax",
-//                    order,
-//                    gMaximumAttrib,
-//                    MaxAmplOfFirstPulse
-//                    );
-        histoname = "hAllPixelMax";
-        histoname += order;
-        if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-        hAllPixelMax[order] = new TH1F(
-                    histoname,
-                    "Maximum value of each slice in overlay plot for All Pixels",
-                    gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,
-                    (-1*gPixelOverlayXaxisLeft)-0.5,
-                    gPixelOverlayXaxisRight-0.5
-                    );
-        hAllPixelMax[order]->SetAxisRange(
-                    gBSLMean - 5,
-                    (gGainMean*(order+1)) + 10,
-                    "Y");
-        hAllPixelMax[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-        hAllPixelMax[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-        hAllPixelList->Add( hAllPixelMax[order] );
-
-//------------------------------------------------------------------------
-//        SetHistogramAttributes(
-//                    "PeakMaximum",
-//                    order,
-//                    gMaximumAttrib,
-//                    MaxAmplOfFirstPulse
-//                    );
-        histoname = "hAllPixelMedian";
-        histoname += order;
-        if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-        hAllPixelMedian[order] = new TH1F(
-                    histoname,
-                    "Median of each slice in overlay plot for All Pixels",
-                    gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,
-                    (-1*gPixelOverlayXaxisLeft)-0.5,
-                    gPixelOverlayXaxisRight-0.5
-                    );
-        hAllPixelMedian[order]->SetAxisRange(
-                    gBSLMean - 5,
-                    (gGainMean*(order+1)) + 10,
-                    "Y");
-        hAllPixelMedian[order]->SetLineColor(kRed);
-        hAllPixelMedian[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-        hAllPixelMedian[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-        hAllPixelList->Add( hAllPixelMedian[order] );
-        if (verbosityLevel > 3) cout << "...BREAKPOINT in " << histoname << endl;
-//------------------------------------------------------------------------
-//        SetHistogramAttributes(
-//                    "PeakMaximum",
-//                    order,
-//                    gMaximumAttrib,
-//                    MaxAmplOfFirstPulse
-//                    );
-        histoname = "hAllPixelMean";
-        histoname += order;
-        if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-        hAllPixelMean[order] = new TH1F(
-                    histoname,
-                    "Mean of each slice in overlay plot for All Pixels",
-                    gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,
-                    (-1*gPixelOverlayXaxisLeft)-0.5,
-                    gPixelOverlayXaxisRight-0.5
-                    );
-        hAllPixelMean[order]->SetAxisRange(
-                    gBSLMean - 5,
-                    (gGainMean*(order+1)) + 10,
-                    "Y");
-        hAllPixelMean[order]->SetLineColor(kBlue);
-        hAllPixelMean[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-        hAllPixelMean[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-        hAllPixelList->Add( hAllPixelMean[order] );
-
-//------------------------------------------------------------------------
-//        SetHistogramAttributes(
-//                    "PeakMaxGaus",
-//                    order,
-//                    gMaxGausAttrib,
-//                    MaxAmplOfFirstPulse
-//                    );
-        histoname = "hAllPixelEdgeOverlay";
-        histoname += order;
-        if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-        hAllPixelEdgeOverlay[order] = new TH2F(
-                    histoname,
-                    "Overlay at rising edge of detected pulses of one pulse order for All Pixels ",
-                    gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,
-                    (-1*gPixelOverlayXaxisLeft)-0.5,
-                    gPixelOverlayXaxisRight-0.5 ,
-                    512,
-                    -55.5,
-                    200.5
-                    );
-
-        hAllPixelEdgeOverlay[order]->SetAxisRange(
-                    gBSLMean - 5,
-                    (gGainMean*(order+1)) + 10,
-                    "Y");
-        hAllPixelEdgeOverlay[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-        hAllPixelEdgeOverlay[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-        hAllPixelList->Add( hAllPixelEdgeOverlay[order] );
-
-//------------------------------------------------------------------------
-//        SetHistogramAttributes(
-//                    "AllPixelPeakProfile",
-//                    order,
-//                    gProfileAttrib,
-//                    MaxAmplOfFirstPulse
-//                    );
-        histoname = "hAllPixelProfile";
-        histoname += order;
-        if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-        hAllPixelProfile[order] = new TProfile(
-                    histoname,
-                    "Mean value of each slice in overlay plot for All Pixels (Tprofile)",
-                    gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,//nbinsx
-                    (-1*gPixelOverlayXaxisLeft)-0.5,                 //xlow
-                    gPixelOverlayXaxisRight-0.5 ,                    //xup
-    //                512,                                            //nbinsy
-                    -55.5,                                          //ylow
-                    300.5,                                          //yup
-                    "s");                                           //option
-        hAllPixelProfile[order]->SetAxisRange(
-                    gBSLMean - 5,
-                    (gGainMean*(order+1)) + 10,
-                    "Y");
-        hAllPixelProfile[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-        hAllPixelProfile[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-        //hPixelProfile->SetBit(TH2F::kCanRebin);
-        hAllPixelList->Add( hAllPixelProfile[order] );
-
-//------------------------------------------------------------------------
-//        SetHistogramAttributes(
-//                    "AllPixelPeakProfile",
-//                    order,
-//                    gProfileAttrib,
-//                    MaxAmplOfFirstPulse
-//                    );
-        histoname = "hAllPixelProfile2";
-        histoname += order;
-        if (verbosityLevel > 3) cout << "...booking " << histoname << endl;
-        hAllPixelProfile2[order] = new TProfile(
-                    histoname,
-                    "Mean value of each slice in overlay plot for All Pixels (Tprofile)",
-                    gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight ,//nbinsx
-                    (-1*gPixelOverlayXaxisLeft)-0.5,                 //xlow
-                    gPixelOverlayXaxisRight-0.5 ,                    //xup
-    //                512,                                            //nbinsy
-                    -55.5,                                          //ylow
-                    300.5,                                          //yup
-                    "s");                                           //option
-        hAllPixelProfile2[order]->SetAxisRange(
-                    gBSLMean - 5,
-                    (gGainMean*(order+1)) + 10,
-                    "Y");
-        hAllPixelProfile2[order]->SetLineColor(kRed);
-        hAllPixelProfile2[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
-        hAllPixelProfile2[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
-        //hPixelProfile->SetBit(TH2F::kCanRebin);
-        hAllPixelList->Add( hAllPixelProfile2[order] );
-
-
-
-    }//end of for over order
-    if (verbosityLevel > 2) cout << "...done" << endl;
-}
-// end of BookHistos
-//----------------------------------------------------------------------------
-
-
-void CreateRootFile(const char * loc_fname, int verbosityLevel)
-{
-    TFile* tf = new TFile(loc_fname,"UPDATE");
-    if (tf->IsZombie())
-    {
-        cout << "Error opening file" << endl;
-        exit(-1);
-    }
-    else {
-        if (verbosityLevel > 1) cout << "creating root-file successfull" << endl;
-        tf->Close();
-    }
-}
-//end of CreateRootFile
-//----------------------------------------------------------------------------
-
-
-TFile* OpenRootFile(const char * loc_fname, int verbosityLevel)
-{
-    TFile* tf = new TFile(loc_fname,"UPDATE");
-    if (tf->IsZombie())
-    {
-        cout << "Error opening file" << endl;
-        exit(-1);
-    }
-    else {
-        if (verbosityLevel > 1) cout << "...opening root-file:"
-                                     << loc_fname
-                                     << " successfull" << endl;
-    }
-    return tf;
-}
-//end of OpenRootFile
-//----------------------------------------------------------------------------
-
-
-void CloseRootFile(TFile* tf)
-{
-    if (tf->IsZombie())
-    {
-    cout << "Error closing file" << endl;
-    exit(-1);
-    } else {
-    tf->Close();
-    }
-}
-//end of CloseRootFile
-//----------------------------------------------------------------------------
-
-
-void SaveHistograms(
-        const char* loc_fname,
-        const char* subdirectory,
-        TObjArray* histList,
+DeletePixelCanvases(
+        int maxPulseOrder,
         int verbosityLevel
         )
 {
-    if (verbosityLevel > 2) cout << endl
-                                 << "...saving pixel histograms to subdirectory: "
-                                 << subdirectory << endl ;
-
-    TFile* tf = OpenRootFile(loc_fname, verbosityLevel);
-    if ( subdirectory != "root")
-    {
-        tf->cd();
-        tf->mkdir(subdirectory,subdirectory);
-        tf->cd(subdirectory);
-    }
-    else
-    {
-        tf->cd();
-    }
-    histList->Write(); // write the major histograms into the top level directory
-    if (verbosityLevel > 3) tf->ls();
-    CloseRootFile( tf ); // close the file
-    if (verbosityLevel > 2) cout << "...done" << endl;
+    if (verbosityLevel > 2) cout << endl << "...delete pixel Canvases" ;
+    for (int pulse_order = 0; pulse_order < maxPulseOrder; pulse_order++ )
+    {
+        delete cgpPixelPulses[pulse_order];
+        delete cgpDistributions[pulse_order];
+    }
+    delete[] cgpPixelPulses;
+    delete[] cgpDistributions;
 }
-// end of SaveHistograms
-//----------------------------------------------------------------------------
-
-
-TString CreateSubDirName(int pixel)
-{
-    TString path = "Pixel_";
-    path += pixel;
-//    cout << "path " << path << endl ;
-    return path;
-}
-// end of CreateSubDirName
-//----------------------------------------------------------------------------
-
-TString CreateSubDirName(const char* title)
-{
-    TString path = title;
-    path += "_Pixel";
-//    cout << "path " << path << endl ;
-    return path;
-}
-// end of CreateSubDirName
-//----------------------------------------------------------------------------
-
-void FillHistograms(
-        vector<Region>* pZXings,
-        int AmplWindowWidth,
-        int eventNumber,
-        int verbosityLevel
-        )
-{
-    if (verbosityLevel > 2) cout << endl << "...filling pulse histograms" ;
-    bool use_this_peak=false;
-    int order_of_pulse=0;
-    vector<Region>::iterator reg;
-
-    //Loop over all found zerocrossings in Region
-    for (reg = pZXings->begin() ; reg < pZXings->end() ; reg++)
-    {
-        //skip those who are at the Rim of the ROI
-        if (reg->maxPos < 12 || (unsigned int) reg->maxPos > gRegionOfInterest-12)
-        {
-            if (verbosityLevel > 2) cout << endl << "\t...out of range" << endl;
-            continue;
-        }
-        //domstest->Fill(reg->maxPos);
-
-        // Define axis range of Histogram
-        int Left = reg->maxPos - gPixelOverlayXaxisLeft;
-        int Right = reg->maxPos + gPixelOverlayXaxisRight;
-        int EdgeLeft = reg->halfRisingEdgePos - gPixelOverlayXaxisLeft;
-        int EdgeRight = reg->halfRisingEdgePos + gPixelOverlayXaxisRight;
-
-        if (Left < 0) Left =0;
-        if (Right > (int)Ameas.size() ) Right=Ameas.size() ;
-        if (EdgeLeft < 0) EdgeLeft =0;
-        if (EdgeRight > (int)Ameas.size() ) EdgeRight=Ameas.size() ;
-
-
-        hTesthisto->Fill( reg->slopeOfRisingEdge ) ;
-        hTesthisto2->Fill( eventNumber, reg->slopeOfRisingEdge ) ;
-
-        if (verbosityLevel > 2) cout << endl << "\t...choosing Histogram" ;
-
-        //determine order of pulse and which histogram shall be filled
-        if (verbosityLevel > 2) cout << endl << "\t...choosing Histogram" ;
-        for(int order = 0; order < MAX_PULS_ORDER; order++)
-        {
-            if (Ameas[reg->maxPos] >= ((gGainMean*(order+1)) - (AmplWindowWidth/2))
-                && Ameas[reg->maxPos] < ((gGainMean*(order+1)) + AmplWindowWidth/2))
-            {
-                //hOverlayTemp = hPixelOverlay[order];
-                if (verbosityLevel > 2) cout << "...#" << order ;
-                order_of_pulse = order;
-                use_this_peak = true;
-                break;
-            }
-         else if (order >= (MAX_PULS_ORDER - 1)){
-                use_this_peak = false;
-                if (verbosityLevel > 2) cout << "...NONE" << endl ;
-         }
-        }
-
-        //Fill overlay und profile histograms
-        if (use_this_peak){
-            if (verbosityLevel > 2) cout << "...filling" ;
-            for ( int pos = Left; pos < Right; pos++){
-//                if ();
-                hPixelOverlay[order_of_pulse]->Fill( pos - (reg->maxPos), Ameas[pos]) ;
-                hPixelProfile[order_of_pulse]->Fill( pos - (reg->maxPos), Ameas[pos]) ;
-                hAllPixelOverlay[order_of_pulse]->Fill( pos - (reg->maxPos), Ameas[pos]) ;
-                hAllPixelProfile[order_of_pulse]->Fill( pos - (reg->maxPos), Ameas[pos]) ;
-            }
-            for ( int pos = EdgeLeft; pos < EdgeRight; pos++){
-//                cout << endl << "###filling edge histo###" << endl;
-                hPixelEdgeOverlay[order_of_pulse]->Fill( pos - (reg->halfRisingEdgePos), Ameas[pos]) ;
-                hPixelProfile2[order_of_pulse]->Fill( pos - (reg->halfRisingEdgePos), Ameas[pos]) ;
-                hAllPixelEdgeOverlay[order_of_pulse]->Fill( pos - (reg->halfRisingEdgePos), Ameas[pos]) ;
-                hAllPixelProfile2[order_of_pulse]->Fill( pos - (reg->halfRisingEdgePos), Ameas[pos]) ;
-//                cout << endl << "######" << endl;
-            }
-            if (verbosityLevel > 2) cout << "...done" << endl;
-        }
-        //Breakout option
-        if (breakout)
-        break;
-   }
-    if (verbosityLevel > 2) cout << "...done" << endl;
-}
-// end of FillHistograms
-//----------------------------------------------------------------------------
-
-void DrawTestHistograms(
-        int verbosityLevel
-        )
-{
-    if (verbosityLevel > 2) cout << endl << "...drawing pulse histograms" ;
-
-    cgpTestHistos->cd(1);
-    hTesthisto->Draw();
-    cgpTestHistos->cd(2);
-    hTesthisto2->Draw("BOX");
-}
-// end of DrawTestHistograms
-//----------------------------------------------------------------------------
-
-void DrawPulseHistograms(
+
+void
+UpdateCanvases(
         int verbosityLevel,
-        int max_pulse_order
-        )
-{
-    if (verbosityLevel > 2) cout << endl << "...drawing pulse histograms" ;
-    for (int pulse_order = 0; pulse_order < max_pulse_order; pulse_order++)
-    {
-        cgpPixelPulses[pulse_order]->cd(1);
-        hPixelOverlay[pulse_order]->Draw("COLZ");
-        cgpPixelPulses[pulse_order]->cd(3);
-        hPixelProfile[pulse_order]->Draw("COLZ");
-        hPixelProfile2[pulse_order]->Draw("SAME");
-
-        cgpPixelPulses[pulse_order]->cd(2);
-        hPixelEdgeOverlay[pulse_order]->Draw("COLZ");
-//        cgpPixelPulses[pulse_order]->cd(4);
-//        hTesthisto->Draw();
-
-        cgpAllPixelPulses[pulse_order]->cd(1);
-        hAllPixelOverlay[pulse_order]->Draw("COLZ");
-        cgpAllPixelPulses[pulse_order]->cd(2);
-        hAllPixelEdgeOverlay[pulse_order]->Draw("COLZ");
-
-        cgpAllPixelPulses[pulse_order]->cd(3);
-        hAllPixelProfile[pulse_order]->Draw("COLZ");
-        hAllPixelProfile2[pulse_order]->Draw("SAME");
-
-    }
-}
-// end of DrawPulseHistograms
-//----------------------------------------------------------------------------
-
-
-void DrawMaximumHistograms(
-        int verbosityLevel,
-        int max_pulse_order
-        )
-{
-    if (verbosityLevel > 2) cout << endl << "...drawing maximum histograms" ;
-    for (int pulse_order = 0; pulse_order < max_pulse_order; pulse_order++)
-    {
-        cgpPixelPulses[pulse_order]->cd(4);
-        hPixelMax[pulse_order]->Draw();
-        hPixelMedian[pulse_order]->Draw("SAME");
-        hPixelMean[pulse_order]->Draw("SAME");
-
-        cgpAllPixelPulses[pulse_order]->cd(4);
-        hAllPixelMax[pulse_order]->Draw();
-        hAllPixelMedian[pulse_order]->Draw("SAME");
-        hAllPixelMean[pulse_order]->Draw("SAME");
-//        cgpAllPixelPulses[pulse_order]->cd(3);
-     //   hAllPixelMaxGaus[pulse_order]->Draw("COLZ");
-    }
-}
-// end of DrawMaximumHistograms
-//----------------------------------------------------------------------------
-
-
-void UpdateCanvases(
-        int verbosityLevel,
-        int max_pulse_order
+        int max_pulse_order,
+        bool testmode
         )
 {
@@ -1543,348 +458,22 @@
         cgpPixelPulses[pulse_order]->Modified();
         cgpPixelPulses[pulse_order]->Update();
-        cgpAllPixelPulses[pulse_order]->Modified();
-        cgpAllPixelPulses[pulse_order]->Update();
-        cgpTestHistos->Modified();
-        cgpTestHistos->Update();
+        cgpDistributions[pulse_order]->Modified();
+        cgpDistributions[pulse_order]->Update();
+//        if ( testmode )
+//        {
+//            cgpTestHistos->Modified();
+//            cgpTestHistos->Update();
+//        }
     }
 }
-// end of UpdateCanvases
-//----------------------------------------------------------------------------
-
-
-
-void
-PlotMedianEachSliceOfPulse(
-        unsigned int    max_pulse_order,
-        int             fitdata,
-        int             verbosityLevel
-        )
+//-----------------------------------------------------------------------------
+// MAIN Funktion for C compilation
+//-----------------------------------------------------------------------------
+
+int main()
 {
-    if (verbosityLevel > 2) cout << endl
-                                 << "...calculating pulse shape of slice's Median"
-                                 << endl;
-    for (unsigned int pulse_order = 0 ; pulse_order < max_pulse_order ; pulse_order ++)
-    {
-        if (verbosityLevel > 2) cout << "\t...calculation of "
-                                     << "pulse order " << pulse_order;
-
-        Int_t nbins = hPixelOverlay[pulse_order]->GetXaxis()->GetNbins();
-
-        for (Int_t TimeSlice=1;TimeSlice<=nbins;TimeSlice++) {
-           TH1 *h1 = hPixelOverlay[pulse_order]->ProjectionY("",TimeSlice,TimeSlice);
-           float median = MedianOfH1(h1);
-           float mean = h1->GetMean();
-           if (verbosityLevel > 2) printf("Median of Slice %d, Median=%g\n",TimeSlice,median);
-           delete h1;
-           hPixelMedian[pulse_order]->SetBinContent(TimeSlice, median );
-           hPixelMean[pulse_order]->SetBinContent(TimeSlice, mean );
-           hAllPixelMedian[pulse_order]->SetBinContent(TimeSlice, median );
-           hAllPixelMean[pulse_order]->SetBinContent(TimeSlice, mean );
-        }
-
-        if (verbosityLevel > 2) cout << "\t...done" << endl;
-
-        if (fitdata)
-        {
-           FitMaxPropabilityPuls(
-                    hPixelMedian[pulse_order],
-                    verbosityLevel
-                    );
-        }
-    }
+
+FCalcPulseTemplate();
+return 0;
+
 }
-// end of PlotMedianEachSliceOfPulse
-//----------------------------------------------------------------------------
-
-Double_t MedianOfH1 (
-        TH1*            h1
-        )
-{
-   //compute the median for 1-d histogram h1
-   Int_t nbins = h1->GetXaxis()->GetNbins();
-   Double_t *x = new Double_t[nbins];
-   Double_t *y = new Double_t[nbins];
-   for (Int_t i=0;i<nbins;i++) {
-      x[i] = h1->GetXaxis()->GetBinCenter(i+1);
-      y[i] = h1->GetBinContent(i+1);
-   }
-   Double_t median = TMath::Median(nbins,x,y);
-   delete [] x;
-   delete [] y;
-   return median;
-}
-// end of PlotMedianEachSliceOfPulse
-//----------------------------------------------------------------------------
-
-void
-PlotPulseShapeOfMaxPropability(
-        unsigned int    max_pulse_order,
-        int             fitdata,
-        int             verbosityLevel
-        )
-{
-    if (verbosityLevel > 2) cout << endl
-                                 << "...calculating pulse shape of max. propability"
-                                 << endl;
-    for (unsigned int pulse_order = 0 ; pulse_order < max_pulse_order ; pulse_order ++)
-    {
-        if (verbosityLevel > 2) cout << "\t...calculation of "
-                                     << "pulse order " << pulse_order;
-        //  vector max_value_of to number of timeslices in Overlay Spectra
-        float max_value_of_slice;
-
-        Int_t nbins = hPixelOverlay[pulse_order]->GetXaxis()->GetNbins();
-        if (verbosityLevel > 2) cout << "...generating projections" << endl;
-        for (Int_t TimeSlice=1;TimeSlice<=nbins;TimeSlice++)
-        {
-            if (verbosityLevel > 2) cout << "...Timeslice: " << TimeSlice;
-            //put maximumvalue of every Y-projection of every timeslice into vector
-            TH1D *h1 =	hPixelOverlay[pulse_order]->ProjectionY( "", TimeSlice,TimeSlice);
-
-            max_value_of_slice = h1->GetBinCenter( h1->GetMaximumBin() );
-
-            if (verbosityLevel > 2) cout << " with max value "
-                                         << max_value_of_slice << endl;
-            hPixelMax[pulse_order]->SetBinContent(TimeSlice, max_value_of_slice );
-            hAllPixelMax[pulse_order]->SetBinContent(TimeSlice, max_value_of_slice );
-            delete h1;
-        }
-
-        if (verbosityLevel > 2) cout << "\t...done" << endl;
-
-        if (fitdata)
-        {
-           FitMaxPropabilityPuls(
-                    hPixelMax[pulse_order],
-                    verbosityLevel
-                    );
-        }
-    }
-}
-
-
-void
-FitMaxPropabilityPuls(
-        TH1F*       hMaximumTemp,
-        int         verbosityLevel
-        )
-    {
-      if (verbosityLevel > 2) cout << "...fit Landau in histograms" ;
-      if (verbosityLevel > 2) cout << "\t...calculating Landaufit" ;
-      hMaximumTemp->Fit("landau", "", "", -50, 250);
-      if (verbosityLevel > 2) cout << "...done" << endl;
-    }
-
-
-//void SetHistogrammSettings(
-//        const char*     histoType,
-//        int             max_puls_order,
-//        int             MaxAmplOfFirstPulse,
-//        int             verbosityLevel
-//        )
-//{
-//    if (verbosityLevel > 2) cout << endl << "...set histogram Settings" << endl;
-//    for (int pulse_order = 1; pulse_order <= max_puls_order; pulse_order++)
-//    {
-//        qHistSetting[pulse_order].yMax = (MaxAmplOfFirstPulse * pulse_order);
-//        cout << "\t Max @ " << gHistSetting[pulse_order].yMax << endl;
-//        gHistSetting[pulse_order].name = "h";
-//        gHistSetting[pulse_order].name += histoType;
-//        gHistSetting[pulse_order].name += "PeakOverlay";
-//        gHistSetting[pulse_order].name += pulse_order;
-//        gHistSetting[pulse_order].title = "PeakOverlay with Amplitude around ";
-//        gHistSetting[pulse_order].title += gHistSetting[pulse_order].yMax;
-//        gHistSetting[pulse_order].title += " mV";
-//        gHistSetting[pulse_order].Mname = "h";
-//        gHistSetting[pulse_order].Mname += histoType;
-//        gHistSetting[pulse_order].Mname += "PeakMaximum";
-//        gHistSetting[pulse_order].Mname += pulse_order;
-//        gHistSetting[pulse_order].Mtitle = "Peak (approx) derived with Maximum of above Spektrum with Max of ";
-//        gHistSetting[pulse_order].Mtitle += gHistSetting[pulse_order].yMax;
-//        gHistSetting[pulse_order].Mtitle += " mV";
-//    }
-//    if (verbosityLevel > 2) cout << "...done" << endl;
-//}
-
-
-//void CreatePulseCanvas(
-//        TCanvas*    array_of_canvases,
-//        unsigned int        max_pulse_order,
-//        const char*      canvas_name,
-//        const char*      canvas_title,
-//        const char*      pixel,
-//        int verbosityLevel
-//        )
-//{
-//    if (verbosityLevel > 2) cout << "...building Canvases" ;
-
-//    for (
-//         unsigned int pulse_order = 1;
-//         pulse_order <= max_pulse_order;
-//         pulse_order++
-//          )
-//    {
-//        TString name = canvas_name;
-//                name += " ";
-//                name += pulse_order;
-//                name += " ";
-
-//                TString title = "Order ";
-//                title += pulse_order;
-//                title += " ";
-//                title += canvas_title;
-//                title += " of ";
-//                title += pixel;
-//                title += ". Pixel";
-
-//        array_of_canvases[pulse_order] = new TCanvas(name, title, 1, 1, 1400, 700);
-//        array_of_canvases[pulse_order].Divide(2,2);
-//    }
-//    if (verbosityLevel > 2) cout << "...done" << endl;
-//}
-
-
-//void
-//DeletePulseCanvas(
-//        TCanvas* array_of_canvases,
-//        unsigned int     max_pulse_order
-//        )
-//{
-//    for (
-//         unsigned int pulse_order = 1;
-//         pulse_order <= max_pulse_order;
-//         pulse_order++
-//          )
-//    {
-//        delete array_of_canvases[pulse_order];
-//    }
-//}
-
-
-
-
-void
-DeletePixelCanvases( int verbosityLevel )
-{
-    if (verbosityLevel > 2) cout << endl << "...delete pixel Canvas" ;
-    for (int pulse_order = 0; pulse_order < MAX_PULS_ORDER; pulse_order ++)
-    {
-        delete cgpPixelPulses[pulse_order];
-    }
-}
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-//void SetHistogramAttributes(
-//        const char*     histoType,
-//        int             pulse_order,
-//        histAttrib_t*   histoAttrib,
-//        int             max_ampl_of_first_pulse
-//        )
-//{
-//    histoAttrib[pulse_order].yMax = (max_ampl_of_first_pulse * pulse_order);
-//    histoAttrib[pulse_order].yMin = (histoAttrib[pulse_order].yMax/2);
-//    histoAttrib[pulse_order].name = "h";
-//    histoAttrib[pulse_order].name += histoType;
-//    histoAttrib[pulse_order].name = "_";
-//    histoAttrib[pulse_order].name += pulse_order;
-
-//    histoAttrib[pulse_order].title += histoType;
-//    histoAttrib[pulse_order].title += " with Amplitude around ";
-//    histoAttrib[pulse_order].title += histoAttrib[pulse_order].yMax;
-//    histoAttrib[pulse_order].title += " mV";
-
-//    histoAttrib[pulse_order].xTitle += "Timeslices [a.u.]";
-//    histoAttrib[pulse_order].yTitle += "Amplitude [mV]";
-//}
-
-void WritePixelTemplateToCsv(
-        TString         path,
-        const char*     csv_file_name,
-        const char*     overlay_method,
-        int             pixel,
-        int             verbosityLevel
-        )
-{
-    path += csv_file_name;
-    path += "_";
-    path += pixel;
-    path += ".csv";
-
-    Int_t nbins = hPixelMax[0]->GetXaxis()->GetNbins();
-    if (verbosityLevel > 0)
-    {
-        cout << "writing point-set to csv file: " ;
-        cout << path << endl;
-        cout << "...opening file" << endl;
-    }
-    if (verbosityLevel > 2) cout << "...number of bins " << nbins << endl;
-    ofstream out;
-    out.open( path );
-    out << "### point-set of a single photon pulse template" << endl;
-    out << "### template determined with pulse overlay at: "
-        << overlay_method << endl;
-    out << "### Slice's Amplitude determined by calculating the " << endl
-        << "### value of maximum propability of slice -> Amplitude1 " << endl
-        << "### mean of slice -> Amplitude2 " << endl
-        << "### median of slice -> Amplitude3 " << endl
-        << "### for each slice" << endl;
-    out << "### Pixel number (CHid): " << pixel << endl
-        << endl;
-
-    out << "time [slices],Amplitude1 [mV],Amplitude2 [mV],Amplitude3 [mV]" << endl;
-
-    for (int TimeSlice=1;TimeSlice<=nbins;TimeSlice++)
-    {
-        out << TimeSlice << "," ;
-        out << hPixelMax[0]->GetBinContent(TimeSlice) << ",";
-        out << hPixelMean[0]->GetBinContent(TimeSlice) << ",";
-        out << hPixelMedian[0]->GetBinContent(TimeSlice) << endl;
-    }
-    out.close();
-    if (verbosityLevel > 0) cout << "...file closed" << endl;
-}
-
-void WriteAllPixelTemplateToCsv(
-        TString         path,
-        const char*     csv_file_name,
-        const char*     overlay_method,
-        int             verbosityLevel
-        )
-{
-    path += csv_file_name;
-    path += "_AllPixel.csv";
-
-    Int_t nbins = hAllPixelMax[0]->GetXaxis()->GetNbins();
-    if (verbosityLevel > 0)
-    {
-        cout << "writing point-set to csv file: " ;
-        cout << path << endl;
-        cout << "...opening file" << endl;
-    }
-    if (verbosityLevel > 2) cout << "...number of bins " << nbins << endl;
-    ofstream out;
-    out.open( path );
-    out << "### point-set of a single photon pulse template" << endl;
-    out << "### template determined with pulse overlay at: "
-        << overlay_method << "of all Pixels";
-    out << "### Slice's Amplitude determined by calculating the " << endl
-        << "### value of maximum propability of slice -> Amplitude1 " << endl
-        << "### mean of slice -> Amplitude2 " << endl
-        << "### median of slice -> Amplitude3 " << endl
-        << "### for each slice" << endl
-        << endl;
-
-    out << "time [slices],Amplitude1 [mV],Amplitude2 [mV],Amplitude3 [mV]" << endl;
-
-    for (int TimeSlice=1;TimeSlice<=nbins;TimeSlice++)
-    {
-        out << TimeSlice << "," ;
-        out << hAllPixelMax[0]->GetBinContent(TimeSlice) << ",";
-        out << hAllPixelMean[0]->GetBinContent(TimeSlice) << ",";
-        out << hAllPixelMedian[0]->GetBinContent(TimeSlice) << endl;
-    }
-    out.close();
-    if (verbosityLevel > 0) cout << "...file closed" << endl;
-}
