Index: /fact/tools/rootmacros/FPulseTemplate.C =================================================================== --- /fact/tools/rootmacros/FPulseTemplate.C (revision 13377) +++ /fact/tools/rootmacros/FPulseTemplate.C (revision 13378) @@ -30,4 +30,5 @@ #include #include +#include #include @@ -38,5 +39,5 @@ #define NCELL 1024 #define FAD_MAX_SAMPLES 1024 - +#define MAX_PULS_ORDER 1 #define HAVE_ZLIB @@ -67,11 +68,11 @@ bool breakout=false; -bool UseThisPeak=false; -int NEvents; + +int gNEvents; vector AllPixelDataVector; vector StartCellVector; unsigned int CurrentEventID; size_t PXLxROI; -UInt_t RegionOfInterest; +UInt_t gRegionOfInterest; UInt_t NumberOfPixels; TString histotitle; @@ -83,9 +84,12 @@ vector drs_triggeroffsetmean; -vector Ameas(FAD_MAX_SAMPLES); // copy of the data (measured amplitude -vector Vcorr(FAD_MAX_SAMPLES); // corrected Values +vector Ameas(FAD_MAX_SAMPLES); // copy of the data (measured amplitude +vector Vcorr(FAD_MAX_SAMPLES); // corrected Values vector Vslide(FAD_MAX_SAMPLES); // sliding average result vector Vcfd(FAD_MAX_SAMPLES); // CDF result -vector Vcfd2(FAD_MAX_SAMPLES); // CDF result + 2nd sliding average +vector Vcfd2(FAD_MAX_SAMPLES); // CDF result + 2nd sliding average + +float gGainMean = 9; +float gBSLMean = 0; typedef struct{ @@ -94,17 +98,21 @@ } OverlayMaximum; -typedef struct{ - TString name; - TString title; - TString Mname; - TString Mtitle; - float yMax; -} hist_t; - -hist_t histSetting[4]; - -vector SingleMaximum; +//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 NumberOfDebugHistoTypes = 7; +const int Number_Of_Debug_Histo_Types = 7; const unsigned int @@ -117,29 +125,52 @@ Vcfd2_ = 6; +//const char* gHistoTypes[8] = { +// "hPixelOverlay", +// "hPixelMax", +// "hPixelEdgeOverlay", +// "hPixelProfile", +// "hAllPixelOverlay", +// "hAllPixelMax", +// "hAllPixelMaxGaus", +// "hAllPixelProfile" +//}; + //---------------------------------------------------------------------------- // Initialisation of histograms //---------------------------------------------------------------------------- -TH1F* h= NULL; -TH1F *debugHistos= NULL; -TH2F *hOverlayTemp = NULL; -TH2F *hPeakOverlay[4];//histogrammm for overlay of detected Peaks -TH2F *hSinglePeakOverlay;//histogrammm for overlay of detected Peaks -TH2F *hDoublePeakOverlay; -TH2F *hTripplePeakOverlay; -TH2F *hLargePeakOverlay; - -TH1F *hMaximumTemp = NULL; -TH1F *hPeakMaximum[4]; -TH1F *hSinglePeakMaximum; -TH1F *hDoublePeakMaximum; -TH1F *hTripplePeakMaximum; -TH1F *hLargePeakMaximum; -TH1D *hProjPeak = NULL; -int gPeakOverlayXaxisLeft; -int hPeakOverlayXaxisRight; - -TObjArray hList; -TObjArray hListBaseline; +// Temporary Objects +TH1F* debugHistos = NULL; +TH2F* hOverlayTemp = NULL; +TH1F* hMaximumTemp = NULL; +TH1D* hProjPeak = NULL; +TH1F* hTesthisto = NULL; + +//Pixelwise Histograms +TH2F* hPixelOverlay[MAX_PULS_ORDER]= {NULL};//histogrammm for overlay of detected Peaks +TProfile* hPixelProfile[MAX_PULS_ORDER] = {NULL};//histogrammm for Profile of detected Peaks +TH1F* hPixelMax[MAX_PULS_ORDER] = {NULL}; +TH2F* hPixelEdgeOverlay[MAX_PULS_ORDER] = {NULL}; + +//All Pixel Histograms +TH2F* hAllPixelOverlay[MAX_PULS_ORDER] = {NULL}; +TProfile* hAllPixelProfile[MAX_PULS_ORDER] = {NULL}; +TH1F* hAllPixelMax[MAX_PULS_ORDER] = {NULL}; +TH1F* hAllPixelMaxGaus[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; + +//Canvases +TCanvas* cgpPixelPulses[MAX_PULS_ORDER] = {NULL}; +TCanvas* cgpAllPixelPulses[MAX_PULS_ORDER] = {NULL}; +TCanvas* cgpTestHistos = NULL; +//TCanvas* gpcDevelopment = NULL; //---------------------------------------------------------------------------- @@ -147,6 +178,28 @@ //---------------------------------------------------------------------------- -void BookHistos( ); -void SaveHistograms( const char * ); +void BookHistos(int ); +void BookPixelHistos(int ); +void BookTestHistos( int ); +void DeletePixelHistos(int ); +void SaveHistograms( const char*, const char*, TObjArray*, int ); +void FillHistograms(vector*, int, int); +void PlotPulseShapeOfMaxPropability(unsigned int, int, int); +void DrawPulseHistograms(int, int); +void FitMaxPropabilityPuls( TH1F* , int ); +void DrawMaximumHistograms( int, int ); +void DrawTestHistograms( 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 SetHistogrammSettings( const char*, int, int , int); +//void CreatePulseCanvas( TCanvas* , unsigned int, const char* , const char*, const char*, int); +//void DeletePulseCanvas( TCanvas* , unsigned int); + //---------------------------------------------------------------------------- @@ -156,74 +209,88 @@ //---------------------------------------------------------------------------- int FPulseTemplate( - char* datafilename = "../data/2011/11/10/20111110_005.fits.gz", - const char* drsfilename = "../data/2011/11/10/20111110_003.drs.fits.gz", - const char* OutRootFileName = "../analysis/20111110_003.test.root", - bool ProduceGraphic = true, - bool spikeDebug = false, - bool fitdata = false, - int verbosityLevel = 1, // different verbosity levels can be implemented here - int firstevent = 0, - int nevents = -1, - int firstpixel = 400, - int npixel = 1, - int PintervalWidth = 5, - int PintervalMin = 8, - int PintervalMax = 32, //4 Histogramms will be drawn, decide how far pulsehights differ from eachother - int avg1 = 14, - int avg2 = 8, - int OverlayWindowLeft = 70, - int OverlayWindowRight = 230) -{ -//----------------------------------------------------------------------------- -// histogramm Settings -//----------------------------------------------------------------------------- - - gPeakOverlayXaxisLeft = OverlayWindowLeft; - hPeakOverlayXaxisRight = OverlayWindowRight; - - gStyle->SetPalette(1,0); - gROOT->SetStyle("Plain"); - -// Create (pointer to) Canvases, which are used in every run, -// also in 'non-debug' runs - // Canvases only need if spike Debug, but I want to deklare - // the pointers anyway ... + 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", + bool ProduceGraphic = true, + int refresh_rate = 500, //refresh rate for canvases + bool spikeDebug = false, + bool debugPixel = true, + bool fitdata = false, + int verbosityLevel = 1, // different verbosity levels can be implemented here + int firstevent = 272, + int nevents = 500, + int firstpixel = 1100, + int npixel = 1, + 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 + ) +{ + gGainMean = GainMean; + gBSLMean = BSLMean; +//---------------------------------------------------------------------------- +// Save-Root-File Settings +//---------------------------------------------------------------------------- + CreateRootFile( OutRootFileName, verbosityLevel ); + + +//---------------------------------------------------------------------------- +// root global Settings +//---------------------------------------------------------------------------- + + gPixelOverlayXaxisLeft = OverlayWindowLeft; + gPixelOverlayXaxisRight = OverlayWindowRight; + + gStyle->SetPalette(1,0); + gROOT->SetStyle("Plain"); +// gPad->SetGrid(); + + for ( + int pulse_order = MAX_PULS_ORDER - 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); + 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, + // also in 'non-debug' runs + // Canvases only need if spike Debug, but I want to deklare + // the pointers anyway ... + TCanvas *cFiltered = NULL; - if (spikeDebug){ + if (spikeDebug) + { cFiltered = new TCanvas("cFiltered","filtered DRS Waveforms", 1,310,400,300); cFiltered->Divide(1, 3); } - // Canvases to show the peak template - TCanvas *cPulsetypes = NULL; - cPulsetypes = new TCanvas("cPulsetypes", "Overlay of detected Peaks", 1, 1, 1400, 700); - cPulsetypes->Divide(4,2); - - - for (int stepper = 0; stepper < 4; stepper++){ - if (stepper == 0) histSetting[stepper].yMax = PintervalMin; - else if (stepper == 3) histSetting[stepper].yMax = PintervalMax; - else histSetting[stepper].yMax = ((PintervalMax-PintervalMin)*(stepper)/3)+PintervalMin; - cout << "Max @ " << histSetting[stepper].yMax << endl; - histSetting[stepper].name = "hPeakOverlay"; - histSetting[stepper].name += stepper; - histSetting[stepper].title = "PeakOverlay with Amplitude around "; - histSetting[stepper].title += histSetting[stepper].yMax; - histSetting[stepper].title += " mV"; - histSetting[stepper].Mname = "hPeakMaximum"; - histSetting[stepper].Mname += stepper; - histSetting[stepper].Mtitle = "Peak (approx) derived with Maximum of above Spektrum with Max of "; - histSetting[stepper].Mtitle += histSetting[stepper].yMax; - histSetting[stepper].Mtitle += " mV"; - } - + + cgpTestHistos = new TCanvas( "cgpTestHistos", "Test Histograms", 801, 0, 800, 800 ); + cgpTestHistos->Divide(2,0); //----------------------------------------------------------------------------- // Filter-Settings //----------------------------------------------------------------------------- // CFD filter settings - int k_cfd = 10; - vector a_cfd(k_cfd, 0); - double b_cfd = 1.; - a_cfd[0]=-0.75; - a_cfd[k_cfd-1]=1.; + int k_cfd = 10; + vector a_cfd(k_cfd, 0); + double b_cfd = 1.; + a_cfd[0]=-0.75; + a_cfd[k_cfd-1]=1.; //----------------------------------------------------------------------------- @@ -233,159 +300,166 @@ // 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. - NEvents = openDataFits( datafilename, &datafile, - AllPixelDataVector, StartCellVector, CurrentEventID, - RegionOfInterest, NumberOfPixels, PXLxROI, verbosityLevel); - if (NEvents == 0){ - cout << "return code of OpenDataFile:" << datafilename<< endl; - cout << "is zero -> aborting." << endl; - return 1; - } - - if (verbosityLevel > 0) - cout <<"number of events in file: "<< NEvents << "\t"; - if ( nevents == -1 || nevents > NEvents ) nevents = NEvents; // -1 means all! - if (verbosityLevel > 0) - cout <<"of, which "<< nevents << "will be processed"<< endl; - - if (verbosityLevel > 0) - 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){ + 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( ); - -//----------------------------------------------------------------------------- -// Loops over Every Event and Pixel -//----------------------------------------------------------------------------- - for ( int ev = firstevent; ev < firstevent + nevents; ev++) { - // Get an Event --> consists of 1440 Pixel ...erm....data - datafile->GetRow( ev ); - -//------------------------------------- -// Loop over every Pixel of Event -//------------------------------------- - - for ( int pix = firstpixel; pix < firstpixel + npixel; pix++ ){ - if (verbosityLevel > 0){ - cout << endl; - if (pix == firstpixel){ - cout << "...processing Event: " << CurrentEventID << "/" << nevents << endl; - } + } + + // Book the histograms + BookHistos(verbosityLevel ); + BookTestHistos( verbosityLevel ); +//------------------------------------- +// Loop over every Pixel +//------------------------------------- + for ( int pixel = firstpixel; pixel < firstpixel + npixel; pixel++ ) + { + if (verbosityLevel > 0) + { + cout << "------------------------------------------------" << endl + << "...processing Pixel: " << pixel << endl; + } + + BookPixelHistos(verbosityLevel ); + +//-------------------------------------------------------------------- +// Loops over Every Event of Pixel +//-------------------------------------------------------------------- + for ( int ev = firstevent; ev < firstevent + nevents; ev++) + { + // Get an Event --> consists of 1440 Pixel ...erm....data + datafile->GetRow( ev ); + + if (verbosityLevel > 0) + { + cout << "-------------------------------------" << endl + << "...processing Event: " << CurrentEventID + << "/" << nevents << " of Pixel: " << pixel << endl; } //------------------------------------- +// Apply Calibration +//------------------------------------- + if (verbosityLevel > 2) cout << "...applying DrsCalibration"; + applyDrsCalibration( + Ameas, + pixel, + 12, + 12, + drs_basemean, + drs_gainmean, + drs_triggeroffsetmean, + gRegionOfInterest, + AllPixelDataVector, + StartCellVector + ); + if (verbosityLevel > 2) cout << "...done " << endl; + +//------------------------------------- // Apply Filters //------------------------------------- - cout << "...applying DrsCalibration"; - applyDrsCalibration( Ameas,pix,12,12, - drs_basemean, drs_gainmean, drs_triggeroffsetmean, - RegionOfInterest, AllPixelDataVector, StartCellVector); - cout << "...done " << endl; - - // finds spikes in the raw data, and interpolates the value - // spikes are: 1 or 2 slice wide, positive non physical artifacts - cout << "...removeing Spikes"; - removeSpikes (Ameas, Vcorr); - cout << "...done " << endl; - // filter Vcorr with sliding average using FIR filter function - cout << "...applying sliding average filter"; - sliding_avg(Vcorr, Vslide, avg1); - cout << "...done " << endl; - // filter Vslide with CFD using FIR filter function - cout << "...apllying factfir filter"; - factfir(b_cfd , a_cfd, k_cfd, Vslide, Vcfd); - cout << "...done " << endl; - // filter Vcfd with sliding average using FIR filter function - cout << "...applying 2nd sliding average filter"; - sliding_avg(Vcfd, Vcfd2, avg2); - cout << "...done " << endl; + // 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 //------------------------------------- - // 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 * zXings = zerosearch( Vcfd2 , 1 , 8); - // zXings means "zero cross ings" - EnlargeRegion(*zXings, 10, 10); - findAbsMaxInRegions(*zXings, Vslide); - removeMaximaBelow( *zXings, 3.0); - removeRegionWithMaxOnEdge( *zXings, 2); - removeRegionOnFallingEdge( *zXings, 100); + 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* 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, Vslide, gBSLMean, 5, 10, verbosityLevel ); + if (verbosityLevel > 2) cout << "...done" << endl; //----------------------------------------------------------------------------- // Fill Overlay Histos //----------------------------------------------------------------------------- - vector::iterator it; - for (it = zXings->begin() ; it < zXings->end() ; it++){ - if (it->maxPos < 12 || it->maxPos > RegionOfInterest-12) - continue; - //domstest->Fill(it->maxPos); - int Left = it->maxPos - OverlayWindowLeft; - int Right = it->maxPos + OverlayWindowRight; - if (Left < 0) - Left =0; - if (Right > (int)Vcorr.size() ) - Right=Vcorr.size() ; - - cout << "...choosing Histogram" ; - for(int stepper = 0; stepper < 4; stepper++){ - if (Vslide[it->maxPos] >= (histSetting[stepper].yMax - (PintervalWidth/2)) && Vslide[it->maxPos] < (histSetting[stepper].yMax + PintervalWidth/2)){ - hOverlayTemp = hPeakOverlay[stepper]; - cout << "...#" << stepper ; - UseThisPeak = true; - break; - } - else if (stepper > 2){ - UseThisPeak = false; - cout << "...NONE" << endl ; - } - } - -// if (Vslide[it->maxPos] >= 5 && Vslide[it->maxPos] < 13) hOverlayTemp = &*hSinglePeakOverlay; -// else if (Vslide[it->maxPos] >= 13 && Vslide[it->maxPos] < 23) hOverlayTemp = hDoublePeakOverlay; -// else if (Vslide[it->maxPos] >= 23 && Vslide[it->maxPos] < 33) hOverlayTemp = hTripplePeakOverlay; -// else if (Vslide[it->maxPos] >= 33) hOverlayTemp = hLargePeakOverlay; - if (UseThisPeak){ - cout << "...filling" ; - for ( int pos = Left; pos < Right; pos++){ - // if (Vslide[it->maxPos] >= 5 && Vslide[it->maxPos] < 15) hSinglePeakOverlay->Fill( pos - (it->maxPos), Vslide[pos]); - // else if (Vslide[it->maxPos] >= 15 && Vslide[it->maxPos] < 25) hDoublePeakOverlay->Fill( pos - (it->maxPos), Vslide[pos]); - // else if (Vslide[it->maxPos] >= 25 && Vslide[it->maxPos] < 35) hTripplePeakOverlay->Fill( pos - (it->maxPos), Vslide[pos]); - // else if (Vslide[it->maxPos] >= 35) hOverlayTemp = hLargePeakOverlay; - - hOverlayTemp->Fill( pos - (it->maxPos), Vslide[pos]) ; - } - cout << "...done" << endl; - } - - } + FillHistograms(pZXings, AmplWindowWidth, 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 < RegionOfInterest; sl++){ + 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++) + { debugHistos[Ameas_].SetBinContent(sl, Ameas[sl]); debugHistos[Vcorr_].SetBinContent(sl, Vcorr[sl]); @@ -393,423 +467,950 @@ debugHistos[Vcfd_].SetBinContent( sl, Vcfd[sl] ); debugHistos[Vcfd2_].SetBinContent( sl, Vcfd2[sl] ); + } + + + 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 MyBoxes; + for (unsigned int i=0; isize(); 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, 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) + { + 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 Events +//------------------------------------- +// end of Loops over Events +//------------------------------------- + +//------------------------------------- +// Histogramms of Maximas in Overlay Spectra +//------------------------------------- + + PlotPulseShapeOfMaxPropability( + MAX_PULS_ORDER, + fitdata, + 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 + TTimer timer("gSystem->ProcessEvents();", 50, kFALSE); + timer.TurnOn(); + TString input = Getline("Type 'q' to exit, to go on: "); + timer.TurnOff(); + if (input=="q\n") { + break; + } + } + + DeletePixelHistos(verbosityLevel); + + if (verbosityLevel > 2) + { + cout << endl << "...End of Pixel" + << endl << "------------------------------------------------" + << endl; + } + } + // End of Loop over all Pixels + +//------------------------------------- +// Draw Histograms +//------------------------------------- + + SaveHistograms( //save histograms of all pixel into output root file + OutRootFileName, + CreateSubDirName("All"), + hAllPixelList, + verbosityLevel + ); + +// SaveHistograms( //save histograms of generell results into output root file +// OutRootFileName, +// "root", +// hRootList, +// verbosityLevel +// ); + + + + if (ProduceGraphic) + { + UpdateCanvases( + verbosityLevel, + MAX_PULS_ORDER + ); + } + + DeletePixelCanvases( verbosityLevel ); + return( 0 ); +} +//---------------------------------------------------------------------------- +// end of main function +//----------------------------------------------------------------------------- + + + + +//----------------------------------------------------------------------------- +// Funktions +//----------------------------------------------------------------------------- + + +void BookPixelHistos( 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, + 300.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( +// "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, + 300.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 + hPixelMax[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] ); + } + 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 hPixelEdgeOverlay" << order; + delete hPixelEdgeOverlay[order]; + if (verbosityLevel > 3) cout << endl << "...deleting hPixelProfile" << order; + delete hPixelProfile[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", + 200, + -300, + 300 + ); + hTesthisto->GetXaxis()->SetTitle( "Timeslices [a.u.]" ); + hTesthisto->GetYaxis()->SetTitle( "counts" ); + + 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( +// "AllPixelPeakMaxGaus", +// order, +// gMaxGausAttrib, +// MaxAmplOfFirstPulse +// ); + histoname = "hAllPixelMaxGaus"; + histoname += order; + if (verbosityLevel > 3) cout << "...booking " << histoname << endl; + hAllPixelMaxGaus[order] = new TH1F( + histoname, + "Mean value of each slice in overlay plot for All Pixels", + gPixelOverlayXaxisLeft + gPixelOverlayXaxisRight , + (-1*gPixelOverlayXaxisLeft)-0.5, + gPixelOverlayXaxisRight-0.5 + ); + hAllPixelMaxGaus[order]->SetAxisRange( + gBSLMean - 5, + (gGainMean*(order+1)) + 10, + "Y"); + hAllPixelMaxGaus[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" ); + hAllPixelMaxGaus[order]->GetYaxis()->SetTitle( "Amplitude [mV]" ); + hAllPixelList->Add( hAllPixelMaxGaus[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] ); + + + + }//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, + 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; +} +// 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* pZXings, + int AmplWindowWidth, + int verbosityLevel + ) +{ + if (verbosityLevel > 2) cout << endl << "...filling pulse histograms" ; + bool use_this_peak=false; + int order_of_pulse=0; + vector::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)Vcorr.size() ) Right=Vcorr.size() ; + + hTesthisto->Fill( reg->maxPos - reg->halfRisingEdgePos ) ; + + 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 ; } - - - cFiltered->cd(1); - gPad->SetGrid(); - debugHistos[Vcorr_].Draw(); - - cFiltered->cd(2); - gPad->SetGrid(); - debugHistos[Vslide_].Draw(); - - TBox *OneBox; - vector MyBoxes; - for (unsigned int i=0; isize(); i++){ - OneBox = new TBox( - zXings->at(i).maxPos -10 , - zXings->at(i).maxVal -0.5, - zXings->at(i).maxPos +10 , - zXings->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(); - - //OVERLAY PEAKS - for(int stepper = 0; stepper < 4; stepper++){ - cPulsetypes->cd(stepper+1); - gPad->SetGrid(); - hPeakOverlay[stepper]->Draw("COLZ"); - } - - -// cPulsetypes->cd(1); -// gPad->SetGrid(); -// hSinglePeakOverlay->Draw("COLZ"); -// -// cPulsetypes->cd(2); -// gPad->SetGrid(); -// hDoublePeakOverlay->Draw("COLZ"); -// -// cPulsetypes->cd(3); -// gPad->SetGrid(); -// hTripplePeakOverlay->Draw("COLZ"); -// -// cPulsetypes->cd(4); -// gPad->SetGrid(); -// hLargePeakOverlay->Draw("COLZ"); - - cPulsetypes->Modified(); - cPulsetypes->Update(); - - //Process gui events asynchronously during input - TTimer timer("gSystem->ProcessEvents();", 50, kFALSE); - timer.TurnOn(); - TString input = Getline("Type 'q' to exit, 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 zXings; - if (breakout) - break; - - } - //------------------------------------- - // end of loop over pixels - //------------------------------------- - if (ProduceGraphic){ - if (ev % 50 == 0){ - - //OVERLAY PEAKS - cout << "...drawing histograms after Loop over Pixels" ; - for(int stepper = 0; stepper < 4; stepper++){ - cPulsetypes->cd(stepper+1); - gPad->SetGrid(); - hPeakOverlay[stepper]->Draw("COLZ"); - cout << "..." << stepper << "/3" ; - } -// cPulsetypes->cd(1); -// gPad->SetGrid(); -// hSinglePeakOverlay->Draw("COLZ"); -// -// cPulsetypes->cd(2); -// gPad->SetGrid(); -// hDoublePeakOverlay->Draw("hLargePeakOverlayCOLZ"); -// -// cPulsetypes->cd(3); -// gPad->SetGrid(); -// hTripplePeakOverlay->Draw("COLZ"); -// -// cPulsetypes->cd(4); -// gPad->SetGrid(); -// hLargePeakOverlay->Draw("COLZ"); - // cPulsetypes->cd(5); - // hSinglePeakMaximum->Draw(""); - cout << "...done" << endl; - cPulsetypes->Modified(); - cPulsetypes->Update(); - } - } - if (breakout) - break; } -//------------------------------------- -// end of loop over Events -//------------------------------------- - -//------------------------------------- -// Histogramm of Maximas in Overlay Spectra -//------------------------------------- - cout << "...producing Maximum peaks:" << endl; - for (unsigned int cnt = 0 ; cnt < 4 ; cnt ++){ - cout << "\t ...peak type " << cnt; - hOverlayTemp = hPeakOverlay[cnt]; - hMaximumTemp = hPeakMaximum[cnt]; -// if (cnt == 1){ -// hMaximumTemp = hSinglePeakMaximum; -// hOverlayTemp = hSinglePeakOverlay; -// } -// else if (cnt == 2){ -// hMaximumTemp = hDoublePeakMaximum; -// hOverlayTemp = hDoublePeakOverlay; -// } -// else if (cnt == 3){ -// hMaximumTemp = hTripplePeakMaximum; -// hOverlayTemp = hTripplePeakOverlay; -// } -// else if (cnt == 4){ -// hMaximumTemp = hLargePeakMaximum; -// hOverlayTemp = hLargePeakOverlay; -// } - // resize vector SingleMaximum to number of timeslices in Overlay Spectra - SingleMaximum.resize(hOverlayTemp->GetNbinsX()); - cout << "\t ...peak type " << cnt; - //put maximumvalue of every Y-projection of every timeslice into vector - for (int TimeSlice = 0; TimeSlice <= hOverlayTemp->GetNbinsX(); TimeSlice++ ){ - histotitle = "hproj_py"; - histotitle += cnt ; - hProjPeak = hOverlayTemp->ProjectionY(histotitle, TimeSlice, TimeSlice, ""); - SingleMaximum[ TimeSlice ].maxAmpl = (hProjPeak->GetMaximumBin() * 0.5) - 3.5; - SingleMaximum[ TimeSlice ].countOfMax = hProjPeak->GetBinContent( hProjPeak->GetMaximumBin() ); - hMaximumTemp->SetBinContent(TimeSlice, SingleMaximum[ TimeSlice ].maxAmpl ); - } - cout << "...done" << endl; - if (fitdata){ - cout << "...calculating Landaufit" ; - hMaximumTemp->Fit("landau", "", "", -50, 250); - cout << "...done" << endl; + //Fill overlay und profile histograms + if (use_this_peak){ + if (verbosityLevel > 2) cout << "...filling" ; + for ( int pos = Left; pos < Right; pos++){ + 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]) ; +// cout << endl << "######" << endl; + } + if (verbosityLevel > 2) cout << "...done" << endl; } - } -//------------------------------------- -// Draw Histograms -//------------------------------------- - if (ProduceGraphic){ - //OVERLAY PEAKS - cout << "...drawing overlay histograms" ; - for(int stepper = 0; stepper < 4; stepper++){ - cPulsetypes->cd(stepper+1); - gPad->SetGrid(); - hPeakOverlay[stepper]->ResetStats(); - hPeakOverlay[stepper]->Draw("COLZ"); - } - cout << "...done" << endl; - cout << "...drawing peak-shape histograms" ; - for(int stepper = 0; stepper < 4; stepper++){ - cPulsetypes->cd(5+stepper); - gPad->SetGrid(); - hPeakMaximum[stepper]->ResetStats(); - hPeakMaximum[stepper]->Draw(); - } - cout << "...done" << endl; - -//cout << "producing...So" << endl; -// cPulsetypes->cd(1); -// gPad->SetGrid(); -// hSinglePeakOverlay->ResetStats(); -// hSinglePeakOverlay->Draw("COLZ"); -//cout << "producing...DO" << endl; -// cPulsetypes->cd(2); -// gPad->SetGrid(); -// hDoublePeakOverlay->ResetStats(); -// hDoublePeakOverlay->Draw("COLZ"); -//cout << "producing...TO" << endl; -// cPulsetypes->cd(3); -// gPad->SetGrid(); -// hTripplePeakOverlay->ResetStats(); -// hTripplePeakOverlay->Draw("COLZ"); -//cout << "producing...LO" << endl; -// cPulsetypes->cd(4); -// gPad->SetGrid(); -// hLargePeakOverlay->ResetStats(); -// hLargePeakOverlay->Draw("COLZ"); -//cout << "producing...SM" << endl; -// cPulsetypes->cd(5); -// hSinglePeakMaximum->ResetStats(); -// hSinglePeakMaximum->Draw(""); -//cout << "producing...DM" << endl; -// cPulsetypes->cd(6); -// hDoublePeakMaximum->ResetStats(); -// hDoublePeakMaximum->Draw(""); -//cout << "producing...TM" << endl; -// cPulsetypes->cd(7); -// hTripplePeakMaximum->ResetStats(); -// hTripplePeakMaximum->Draw(""); -//cout << "producing...LM" << endl; -// cPulsetypes->cd(8); -// hLargePeakMaximum->ResetStats(); -// hLargePeakMaximum->Draw(""); -//cout << "producing...Done" << endl; - - - - - cPulsetypes->Modified(); - cPulsetypes->Update(); - -// cPixelPeakOverlay->cd(); -// hPixelPeakOverlay->Draw("COLZ"); -// cPixelPeakOverlay->Modified(); -// cPixelPeakOverlay->Update(); - + //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(); +} +// end of DrawTestHistograms +//---------------------------------------------------------------------------- + +void DrawPulseHistograms( + 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(2); + hPixelProfile[pulse_order]->Draw("COLZ"); + cgpPixelPulses[pulse_order]->cd(3); + 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); + hAllPixelProfile[pulse_order]->Draw("COLZ"); + + } +} +// 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("LF2"); + + cgpAllPixelPulses[pulse_order]->cd(4); + hAllPixelMax[pulse_order]->Draw(); +// cgpAllPixelPulses[pulse_order]->cd(3); + // hAllPixelMaxGaus[pulse_order]->Draw("COLZ"); + } +} +// end of DrawMaximumHistograms +//---------------------------------------------------------------------------- + + +void UpdateCanvases( + int verbosityLevel, + int max_pulse_order + ) +{ + if (verbosityLevel > 3) cout << endl << "...updating canvases" ; + for (int pulse_order = 0; pulse_order < max_pulse_order; pulse_order++) + { + cgpPixelPulses[pulse_order]->Modified(); + cgpPixelPulses[pulse_order]->Update(); + cgpAllPixelPulses[pulse_order]->Modified(); + cgpAllPixelPulses[pulse_order]->Update(); + cgpTestHistos->Modified(); + cgpTestHistos->Update(); + } +} +// end of UpdateCanvases +//---------------------------------------------------------------------------- + + + +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...calculating of " + << "pulse order " << pulse_order; + // vector max_value_of to number of timeslices in Overlay Spectra + vector max_value_of; + max_value_of.resize(hPixelOverlay[pulse_order]->GetNbinsX()); + + for (int TimeSlice = 0; + TimeSlice <= hPixelOverlay[pulse_order]->GetNbinsX(); + TimeSlice++ ) + { + histotitle = "hproj_py"; //generate title of histogram of which MaxVal + histotitle += pulse_order ; //will be calculated + + //put maximumvalue of every Y-projection of every timeslice into vector + hProjPeak = hPixelOverlay[pulse_order]->ProjectionY(histotitle, TimeSlice, TimeSlice, ""); + max_value_of[ TimeSlice ].maxAmpl = (hProjPeak->GetMaximumBin() * 0.5) - 3.5; + max_value_of[ TimeSlice ].countOfMax = hProjPeak->GetBinContent( hProjPeak->GetMaximumBin() ); + hPixelMax[pulse_order]->SetBinContent(TimeSlice, max_value_of[ TimeSlice ].maxAmpl ); } - SaveHistograms( OutRootFileName ); - - return( 0 ); -} - -// booking and parameter settings for all histos -void BookHistos( ){ - - debugHistos = new TH1F[ NumberOfDebugHistoTypes ]; - for ( int type = 0; type < NumberOfDebugHistoTypes; type++){ - debugHistos[ type ].SetBins(1024, 0, 1024); - debugHistos[ type ].SetLineColor(1); - debugHistos[ type ].SetLineWidth(2); - - // set X axis paras - debugHistos[ type ].GetXaxis()->SetLabelSize(0.1); - debugHistos[ type ].GetXaxis()->SetTitleSize(0.1); - debugHistos[ type ].GetXaxis()->SetTitleOffset(1.2); - debugHistos[ type ].GetXaxis()->SetTitle(Form("Time slice (%.1f ns/slice)", 1./2.)); - - // set Y axis paras - debugHistos[ type ].GetYaxis()->SetLabelSize(0.1); - debugHistos[ type ].GetYaxis()->SetTitleSize(0.1); - debugHistos[ type ].GetYaxis()->SetTitleOffset(0.3); - debugHistos[ type ].GetYaxis()->SetTitle("Amplitude (a.u.)"); + + if (verbosityLevel > 2) cout << "\t...done" << endl; + + if (fitdata) + { + FitMaxPropabilityPuls( + hPixelMax[pulse_order], + verbosityLevel + ); } -/* - ProjHistos = new TH1D[ NumberOfTimeSlices ]; - for ( int type = 0; type < NumberOfTimeSlices; type++){ - ProjHistos[ type ].SetBins(1024, 0, 1024); - ProjHistos[ type ].SetLineColor(1); - ProjHistos[ type ].SetLineWidth(2); - - // set X axis paras - ProjHistos[ type ].GetXaxis()->SetLabelSize(0.1); - ProjHistos[ type ].GetXaxis()->SetTitleSize(0.1); - ProjHistos[ type ].GetXaxis()->SetTitleOffset(1.2); - ProjHistos[ type ].GetXaxis()->SetTitle(Form("Time slice (%.1f ns/slice)", 1./2.)); - - // set Y axis paras - ProjHistos[ type ].GetYaxis()->SetLabelSize(0.1); - ProjHistos[ type ].GetYaxis()->SetTitleSize(0.1); - ProjHistos[ type ].GetYaxis()->SetTitleOffset(0.3); - ProjHistos[ type ].GetYaxis()->SetTitle("Amplitude (a.u.)"); - } -*/ - -//----------------------------------------------------------------------------- - - for (int stepper = 0; stepper < 4; stepper ++){ - hPeakOverlay[stepper] = new TH2F(histSetting[stepper].name, histSetting[stepper].title, - gPeakOverlayXaxisLeft + hPeakOverlayXaxisRight , (-1*gPeakOverlayXaxisLeft)-0.5, hPeakOverlayXaxisRight-0.5 , - 512, -55.5, 300.5); - hPeakOverlay[stepper]->SetAxisRange(-5.5, histSetting[stepper].yMax+ 25.5, "Y"); - hPeakOverlay[stepper]->GetXaxis()->SetTitle( "Timeslices" ); - hPeakOverlay[stepper]->GetYaxis()->SetTitle( "Amplitude [a.u.]" ); - //hSinglePeakOverlay->SetBit(TH2F::kCanRebin); - hList.Add( hPeakOverlay[stepper] ); - - hPeakMaximum[stepper] = new TH1F(histSetting[stepper].Mname, histSetting[stepper].Mtitle, - gPeakOverlayXaxisLeft + hPeakOverlayXaxisRight , - (-1*gPeakOverlayXaxisLeft)-0.5, - hPeakOverlayXaxisRight-0.5 - ); - hPeakMaximum[stepper]->SetAxisRange(-0.5, histSetting[stepper].yMax + 15.5, "Y"); - hPeakMaximum[stepper]->GetXaxis()->SetTitle( "Timeslices" ); - hPeakMaximum[stepper]->GetYaxis()->SetTitle( "Amplitude [a.u.]" ); - hList.Add( hPeakMaximum[stepper] ); - } -//----------------------------------------------------------------------------- - - - -//----------------------------------------------------------------------------- - hSinglePeakOverlay = new TH2F("hSinglePeakOverlay", "Overlay of detected Single Photon Peaks", - gPeakOverlayXaxisLeft + hPeakOverlayXaxisRight , (-1*gPeakOverlayXaxisLeft)-0.5, hPeakOverlayXaxisRight-0.5 , - 512, -55.5, 300.5); - hSinglePeakOverlay->SetAxisRange(-5.5, 35.5, "Y"); - hSinglePeakOverlay->GetXaxis()->SetTitle( "Timeslices" ); - hSinglePeakOverlay->GetYaxis()->SetTitle( "Amplitude [a.u.]" ); - //hSinglePeakOverlay->SetBit(TH2F::kCanRebin); - hList.Add( hSinglePeakOverlay ); - - hSinglePeakMaximum = new TH1F("hSinglePeakMaximum", "Single Peak derived with Maximum of above Spektrum", - gPeakOverlayXaxisLeft + hPeakOverlayXaxisRight , - (-1*gPeakOverlayXaxisLeft)-0.5, - hPeakOverlayXaxisRight-0.5 - ); - hSinglePeakMaximum->SetAxisRange(-0.5, 25.5, "Y"); - hSinglePeakMaximum->GetXaxis()->SetTitle( "Timeslices" ); - hSinglePeakMaximum->GetYaxis()->SetTitle( "Amplitude [a.u.]" ); - hList.Add( hSinglePeakMaximum ); -//----------------------------------------------------------------------------- - - hDoublePeakOverlay = new TH2F("hDoublePeakOverlay", "Overlay of detected Double Photon Peaks", - gPeakOverlayXaxisLeft + hPeakOverlayXaxisRight , (-1*gPeakOverlayXaxisLeft)-0.5, hPeakOverlayXaxisRight-0.5 , - 512, -55.5, 300.5); - hDoublePeakOverlay->SetAxisRange(-5.5, 35.5, "Y"); - hDoublePeakOverlay->GetXaxis()->SetTitle( "Timeslices" ); - hDoublePeakOverlay->GetYaxis()->SetTitle( "Amplitude [a.u.]" ); - //hSinglePeakOverlay->SetBit(TH2F::kCanRebin); - hList.Add( hDoublePeakOverlay );; - - hDoublePeakMaximum = new TH1F("hSinglePeakMaximum", "Double Peak derived with Maximum of above Spektrum", - gPeakOverlayXaxisLeft + hPeakOverlayXaxisRight , - (-1*gPeakOverlayXaxisLeft)-0.5, - hPeakOverlayXaxisRight-0.5 - ); - hDoublePeakMaximum->SetAxisRange(-0.5, 25.5, "Y"); - hDoublePeakMaximum->GetXaxis()->SetTitle( "Timeslices" ); - hDoublePeakMaximum->GetYaxis()->SetTitle( "Amplitude [a.u.]" ); - hList.Add( hDoublePeakMaximum ); - //----------------------------------------------------------------------------- - - hTripplePeakOverlay= new TH2F("hTripplePeakOverlay", "Overlay of detected Tripple Photon Peaks", - gPeakOverlayXaxisLeft + hPeakOverlayXaxisRight , (-1*gPeakOverlayXaxisLeft)-0.5, hPeakOverlayXaxisRight-0.5 , - 512, -55.5, 300.5); - hTripplePeakOverlay->SetAxisRange(-5.5, 35.5, "Y"); - hTripplePeakOverlay->GetXaxis()->SetTitle( "Timeslices" ); - hTripplePeakOverlay->GetYaxis()->SetTitle( "Amplitude [a.u.]" ); - //hTripplePeakOverlay->SetBit(TH2F::kCanRebin); - hList.Add( hTripplePeakOverlay );; - - hTripplePeakMaximum = new TH1F("hSinglePeakMaximum", "Triple Peak derived with Maximum of above Spektrum", - gPeakOverlayXaxisLeft + hPeakOverlayXaxisRight , - (-1*gPeakOverlayXaxisLeft)-0.5, - hPeakOverlayXaxisRight-0.5 - ); - hTripplePeakMaximum->SetAxisRange(-0.5, 25.5, "Y"); - hTripplePeakMaximum->GetXaxis()->SetTitle( "Timeslices" ); - hTripplePeakMaximum->GetYaxis()->SetTitle( "Amplitude [a.u.]" ); - hList.Add( hTripplePeakMaximum ); - //----------------------------------------------------------------------------- - - hLargePeakOverlay= new TH2F("hLargePeakOverlay", "Overlay of detected Multi Photon Peaks", - gPeakOverlayXaxisLeft + hPeakOverlayXaxisRight , (-1*gPeakOverlayXaxisLeft)-0.5, hPeakOverlayXaxisRight-0.5 , - 512, -5.5, 300.5 ); - hLargePeakOverlay->SetAxisRange(-5.5, 200.5, "Y"); - hLargePeakOverlay->GetXaxis()->SetTitle( "Timeslices" ); - hLargePeakOverlay->GetYaxis()->SetTitle( "Amplitude [a.u.]" ); - //hLargePeakOverlay->SetBit(TH2F::kCanRebin); - hList.Add( hLargePeakOverlay );; - - hLargePeakMaximum = new TH1F("hLargePeakMaximum", "Peak derived with Maximum of above Spektrum", - gPeakOverlayXaxisLeft + hPeakOverlayXaxisRight , - (-1*gPeakOverlayXaxisLeft)-0.5, - hPeakOverlayXaxisRight-0.5 - ); - hLargePeakMaximum->SetAxisRange(-0.5, 50.5, "Y"); - hLargePeakMaximum->GetXaxis()->SetTitle( "Timeslices" ); - hLargePeakMaximum->GetYaxis()->SetTitle( "Amplitude [a.u.]" ); - hList.Add( hLargePeakMaximum ); - //----------------------------------------------------------------------------- - -// hPixelPeakOverlay = new TH2F("hPixelPeakOverlay", "Maximum of Statistic of overlayed Peaks", -// gPeakOverlayXaxisLeft + hPeakOverlayXaxisRight , (-1*gPeakOverlayXaxisLeft)-0.5, hPeakOverlayXaxisRight-0.5 , -// 512, -55.5, 200.5 ); -// hPixelPeakOverlay->GetXaxis()->SetTitle( "Timeslices" ); -// hPixelPeakOverlay->GetYaxis()->SetTitle( "Amplitude [a.u.]" ); -// hList.Add( hPixelPeakOverlay ); - -// hEventPeakOverlay = new TH2F("hEventPeakOverlay", "Overlay of detected Peaks of all Pixel of one Event", -// gPeakOverlayXaxisLeft + hPeakOverlayXaxisRight , (-1*gPeakOverlayXaxisLeft)-0.5, hPeakOverlayXaxisRight-0.5 , -// 4096, -48.5, 200.5 ); -// hEventPeakOverlay->GetXaxis()->SetTitle( "Timeslices" ); -// hEventPeakOverlay->GetYaxis()->SetTitle( "Amplitude [a.u.]" ); -// hList.Add( hEventPeakOverlay ); - -} - -void SaveHistograms(const char * loc_fname ){ - // create the histogram file (replace if already existing) - TFile tf( loc_fname, "RECREATE"); - - hList.Write(); // write the major histograms into the top level directory - - tf.Close(); // close the file -} // end of SaveHistograms( char * loc_fname ) - + } +} + + +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]"; +//}