Index: /fact/tools/rootmacros/PulseTemplates/FCalcPulseTemplate.C =================================================================== --- /fact/tools/rootmacros/PulseTemplates/FCalcPulseTemplate.C (revision 13640) +++ /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 #include -#include #include -#include -#include #include -#include -#include #include #include #include #include -#include #include @@ -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 AllPixelDataVector; -vector StartCellVector; -unsigned int CurrentEventID; -size_t PXLxROI; -UInt_t gRegionOfInterest; -UInt_t NumberOfPixels; -TString histotitle; - -size_t TriggerOffsetROI, RC; -size_t drs_n; -vector drs_basemean; -vector drs_gainmean; -vector drs_triggeroffsetmean; - -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 - -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*, 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 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* 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, 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 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) + 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, 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* 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::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;iGetXaxis()->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; -}