From b1bd82ca0f51e34f80458b9e751aefb9926ef9b1 Mon Sep 17 00:00:00 2001 From: Ali Yazgili Date: Fri, 10 Nov 2017 11:57:22 +0100 Subject: [PATCH] Mein Kommentar --- MABS_run_analyzer/ChargeSpektrum.c | 6 +- MABS_run_analyzer/HistogramType.c | 23 +++-- MABS_run_analyzer/HistogramType.h | 14 +-- MABS_run_analyzer/Run.c | 152 ++++++++++++++++++++++++----- MABS_run_analyzer/Run.h | 10 +- 5 files changed, 160 insertions(+), 45 deletions(-) diff --git a/MABS_run_analyzer/ChargeSpektrum.c b/MABS_run_analyzer/ChargeSpektrum.c index 68ec319..e8b065b 100644 --- a/MABS_run_analyzer/ChargeSpektrum.c +++ b/MABS_run_analyzer/ChargeSpektrum.c @@ -129,11 +129,9 @@ void ChargeSpektrum(TString runnumber = "") if (analysisis.Contains("signal")) { // calibrated analysis // TODO Delete the following two lines - runs[runi]->processed->plotSignal(1000,49000); + runs[runi]->processed->plotSignal(100,1000); } - - if (analysisis.Contains("depl")) { // depletion analysis compareHistogramVector.push_back(runs[runi]->histogramdynamicalthreshold->normalized->SeedPerc); @@ -308,8 +306,6 @@ void ChargeSpektrum(TString runnumber = "") } - - // write all histograms to a dat file, can be imported by ORIGIN or Excel. Leave this line ;) runs[runi]->writeAllHistogramsToFile(); diff --git a/MABS_run_analyzer/HistogramType.c b/MABS_run_analyzer/HistogramType.c index 046fc5e..a8b0d68 100644 --- a/MABS_run_analyzer/HistogramType.c +++ b/MABS_run_analyzer/HistogramType.c @@ -57,6 +57,7 @@ void HistogramType::initHistograms(Int_t gotcolor, Int_t gotstyle) { initHistogramCustom(pixeltimefiredDistrib, "Fire counter" + histogramdescription, color, style, 0, labbook->frames_foundDB/100, labbook->frames_foundDB/100, "times fired", "Counts"); initHistogramCustom(LeakageCurrentInPixel, "Leakage current per pixel" + histogramdescription, color, style, 0, cursensorinfo->columns*cursensorinfo->rows, cursensorinfo->columns*cursensorinfo->rows, "Pixel index", "Average CDS"); initHistogramCustom(LeakageCurrentInPixelSorted, "Leakage current per pixel sorted" + histogramdescription, color, style, 0, cursensorinfo->columns*cursensorinfo->rows, cursensorinfo->columns*cursensorinfo->rows, "Pixel index", "Average CDS"); + initHistogramCustom(LeakageCurrentDistrib, "Average Leakage current per pixel" + histogramdescription, color, style, 0, 20, 200, "Average CDS", "Count"); // initHistogram(LeakageCurrentInPixelSorted, "Leakage current" + histogramdescription, color, style); initHistogramCustom(pixelHadGoodVeto, "Number of times pixel had good veto" + histogramdescription, color, style, 0, cursensorinfo->columns*cursensorinfo->rows, cursensorinfo->columns*cursensorinfo->rows, "Pixel index", "Counter good veto"); @@ -172,8 +173,10 @@ Bool_t HistogramType::calibrateHistograms( Float_t gotgain ) { if (SeedPerc != 0) calibrated->SeedPerc = SeedPerc; if (clustermultiplicity != 0) calibrated->clustermultiplicity = clustermultiplicity; if (histAvgCluster != 0) calibrate2DHistogramCounts(calibrated->histAvgCluster, histAvgCluster); - if (LeakageCurrentInPixel != 0) calibrateHistogramYAxis(calibrated->LeakageCurrentInPixel, LeakageCurrentInPixel); - if (LeakageCurrentInPixelSorted != 0) calibrateHistogramYAxis(calibrated->LeakageCurrentInPixelSorted, LeakageCurrentInPixelSorted); + if (LeakageCurrentDistrib != 0) calibrateHistogram(calibrated->LeakageCurrentDistrib,LeakageCurrentDistrib, gain / 3.7 / pow10(-3) * (1.6*pow10(-19)) * pow10(15)); + if (LeakageCurrentInPixel != 0) calibrateHistogramYAxis(calibrated->LeakageCurrentInPixel, LeakageCurrentInPixel, gain / 3.7 / pow10(-3) * (1.6*pow10(-19)) * pow10(15)); + if (LeakageCurrentInPixelSorted != 0) calibrateHistogramYAxis(calibrated->LeakageCurrentInPixelSorted,LeakageCurrentInPixelSorted, gain / 3.7 / pow10(-3) * (1.6*pow10(-19)) * pow10(15)); + calibrated->posSeed = posSeed * gain; calibrated->posSum = posSum * gain; @@ -214,7 +217,7 @@ Bool_t HistogramType::calibrateHistograms( Float_t gotgain ) { calibrated->RTSpixel = RTSpixel; calibrated->percentageofRTSpixel = percentageofRTSpixel; calibrated->avgLeakageCurrentInChip = avgLeakageCurrentInChip * gain; - calibrated->medianLeakageCurrent = medianLeakageCurrent * gain / 3.7 / pow10(-3) * (1.6*pow10(-19)) * pow10(15); + calibrated->medianLeakageCurrent = medianLeakageCurrent * gain / 3.7 / pow10(-3) * (1.6*pow10(-19)) * pow10(15); // TODO: Factor 3.7 is hardcoded, replace with calculation of readout time: f.e. in Mi19: 192*192/1e7*1e3 [in ms] calibrated->medianLeakageCurrentMinus = medianLeakageCurrentMinus * gain / 3.7 / pow10(-3) * (1.6*pow10(-19)) * pow10(15); calibrated->medianLeakageCurrentPlus = medianLeakageCurrentPlus * gain / 3.7 / pow10(-3) * (1.6*pow10(-19)) * pow10(15); @@ -223,15 +226,17 @@ Bool_t HistogramType::calibrateHistograms( Float_t gotgain ) { return 1; } -void HistogramType::calibrateHistogram(TH1FO* &histogrampointernew, TH1FO* &histogrampointerold) { +void HistogramType::calibrateHistogram(TH1FO* &histogrampointernew, TH1FO* &histogrampointerold, Double_t scalefactor) { histogrampointernew = (TH1FO*)histogrampointerold->Clone(); histogrampointernew->SetName(Form("%s Calibr.", histogrampointerold->GetName())); histogrampointernew->SetTitle(Form("%s Calibr.", histogrampointerold->GetTitle())); histogrampointernew->GetXaxis()->SetTitle("Collected charge [e]"); int nbins = histogrampointernew->GetXaxis()->GetNbins(); double new_bins[nbins+1]; + if (scalefactor != 0) + scalefactor = gain; for(int i=0; i <= nbins; i++){ - new_bins[i] = histogrampointernew->GetBinLowEdge(i)*gain; + new_bins[i] = histogrampointernew->GetBinLowEdge(i)*scalefactor; // cout << "histogrampointernew->GetBinCenter(i): " << histogrampointernew->GetBinLowEdge(i) << " * gain " << gain << " = " << histogrampointernew->GetBinLowEdge(i)*gain << endl; } histogrampointernew->SetBins(nbins, new_bins); @@ -240,14 +245,16 @@ void HistogramType::calibrateHistogram(TH1FO* &histogrampointernew, TH1FO* &hist } -void HistogramType::calibrateHistogramYAxis(TH1FO* &histogrampointernew, TH1FO* &histogrampointerold) { +void HistogramType::calibrateHistogramYAxis(TH1FO* &histogrampointernew, TH1FO* &histogrampointerold, Double_t scalefactor) { histogrampointernew = (TH1FO*)histogrampointerold->Clone(); histogrampointernew->SetName(Form("%s Calibr.", histogrampointerold->GetName())); histogrampointernew->SetTitle(Form("%s Calibr.", histogrampointerold->GetTitle())); histogrampointernew->GetYaxis()->SetTitle("Collected charge [e]"); int nbins = histogrampointernew->GetXaxis()->GetNbins(); + if (scalefactor != 0) + scalefactor = gain; for(int x=0; x <= nbins; x++){ - histogrampointernew->SetBinContent(x,histogrampointerold->GetBinContent(x)*gain); + histogrampointernew->SetBinContent(x,histogrampointerold->GetBinContent(x)*scalefactor); } histogrampointernew->GetYaxis()->SetTitle(Form("Entries [1/%.1f e]",histogrampointernew->GetBinWidth(1))); histogrampointernew->itsHistogramType = histogrampointerold->itsHistogramType; @@ -301,8 +308,10 @@ Bool_t HistogramType::normalizeHistograms( Int_t got_frames_found ) { if (clustermultiplicity != 0) normalized->clustermultiplicity = clustermultiplicity; if (normalized->Noise != 0)normalized->Noise = Noise; if (normalized->histAvgCluster != 0) normalized->histAvgCluster = (TH2F*)histAvgCluster->Clone(); + if (normalized->LeakageCurrentDistrib != 0) normalized->LeakageCurrentDistrib = (TH1FO*)LeakageCurrentDistrib->Clone(); if (normalized->LeakageCurrentInPixel != 0)normalized->LeakageCurrentInPixel = (TH1FO*)LeakageCurrentInPixel->Clone(); if (normalized->LeakageCurrentInPixelSorted != 0)normalized->LeakageCurrentInPixelSorted = (TH1FO*)LeakageCurrentInPixelSorted->Clone(); + normalized->frames_found = frames_found; normalized->posSeed = posSeed; normalized->posSum = posSum; diff --git a/MABS_run_analyzer/HistogramType.h b/MABS_run_analyzer/HistogramType.h index eb6fa09..97f0e4c 100644 --- a/MABS_run_analyzer/HistogramType.h +++ b/MABS_run_analyzer/HistogramType.h @@ -91,11 +91,11 @@ private: //***************** /** * @brief rescales one specific histogram from ADU to electrons along the x axis */ - void calibrateHistogram(TH1FO* &histogrampointernew, TH1FO* &histogrampointerold); + void calibrateHistogram(TH1FO* &histogrampointernew, TH1FO* &histogrampointerold, Double_t scalefactor = 0); /** * @brief rescales one specific histogram from ADU to electrons along the y axis */ - void calibrateHistogramYAxis(TH1FO* &histogrampointernew, TH1FO* &histogrampointerold); + void calibrateHistogramYAxis(TH1FO* &histogrampointernew, TH1FO* &histogrampointerold, Double_t scalefactor = 0); /** * @brief normalizes one specific histogram with #frames_found along the y axis, so it can be compared graphically */ @@ -174,10 +174,12 @@ public: TH1FO* pixeltimefired = 0; /// Pixel numbers fired, times fired is on the x axis TH1FO* pixeltimefiredDistrib = 0; - /// Pixel numbers fired, times fired is on the x axis + /// x axis pixel number, y axis average pedestal TH1FO* LeakageCurrentInPixel = 0; - /// Pixel numbers fired, times fired is on the x axis + /// A sorted LeakageCurrentInPixel hisotgram, NOT pixel number on x axis, y axis is the average leakage current of a (some) pixel TH1FO* LeakageCurrentInPixelSorted = 0; + /// Pixel numbers fired, times fired is on the x axis + TH1FO* LeakageCurrentDistrib = 0; /// shows the time a specific pixel number had a "good" veto value, in the range of the veto peak TH1FO* pixelHadGoodVeto = 0; @@ -215,8 +217,8 @@ public: /// what is the propability that other pixel are over the threshold and fire. TH1FO* clustermultiplicity=0; - /// Average Noise value - Float_t avgNoise = 0; + /// Median Noise value + Float_t avgNoise = 0; // TODO: vchange name to median /// Positive Noise sigma Float_t avgNoisePlus = 0; /// Negative Noise sigma diff --git a/MABS_run_analyzer/Run.c b/MABS_run_analyzer/Run.c index fe64446..b2993e0 100644 --- a/MABS_run_analyzer/Run.c +++ b/MABS_run_analyzer/Run.c @@ -1106,19 +1106,24 @@ string Run::to_str_w_prec(const Float_t a_value, int precision = 3) Bool_t Run::binLeakageCurrent(HistogramType* oneHistogramClass) { + Double_t const probabilities[] = {0.158655254, 0.5, 1-0.158655254}; // sigma/2 from gaus to the left and to the right //{0.17, 0.5, 1-0.17}; // Double_t const probabilities[] = {0.25, 0.5, 0.75}; // sigma/2 from gaus to the left and to the right, an area of 68% must be within the interesting range //{0.17, 0.5, 1-0.17}; Double_t pedestals [cursensorinfo.columns*cursensorinfo.rows]; for (Int_t pixeli=0; pixelifNoiseTree->GetEntries(); framei++) { // loop over all frames - processed->fNoiseTree->GetEntry(framei); + processed->fNoiseTree->GetEntry(framei); // init noise init for current frame for (Int_t pixeli=0; pixelifNoiseInfo.fPedestals[pixeli]; + pedestals[pixeli] += processed->fNoiseInfo.fPedestals[pixeli]; // sum up all pedestals for a given pixel, we need this to calculate an average F0 (average signal) } } + + Bool_t RTSpixel =false; u_int numberofconsideredpixel=0; u_int poscounter = 0; @@ -1126,7 +1131,7 @@ Bool_t Run::binLeakageCurrent(HistogramType* oneHistogramClass) RTSpixel = false; oneHistogramClass->LeakageCurrentInPixel->SetBinContent(pixeli, 0); for (u_int RTSpixeli=poscounter; RTSpixeli < oneHistogramClass->RTSpixel.size(); RTSpixeli++) { // loop over all RTS pixel - if (pixeli == oneHistogramClass->RTSpixel[RTSpixeli]) { + if (pixeli == oneHistogramClass->RTSpixel[RTSpixeli]) { // ignore RTS pixel in Leakage current calculation poscounter = RTSpixeli; RTSpixel = true; } @@ -1142,31 +1147,18 @@ Bool_t Run::binLeakageCurrent(HistogramType* oneHistogramClass) // cout << colorcyan << "Excluded: " << pixeli << endlr; } } -// for (u_int pixeli=0; (int)pixeliRun(); -// - std::vector sortedHistogram; + std::vector sortedHistogram; // for (Int_t pixeli=1; pixeli <= oneHistogramClass->LeakageCurrentInPixel->GetNbinsX(); pixeli++) { - if (oneHistogramClass->LeakageCurrentInPixel->GetBinContent(pixeli) != 0) // != 0 TODO + oneHistogramClass->LeakageCurrentDistrib->Fill(oneHistogramClass->LeakageCurrentInPixel->GetBinContent(pixeli)); + if (oneHistogramClass->LeakageCurrentInPixel->GetBinContent(pixeli) != 0) // != 0 // not RTS pixel sortedHistogram.push_back(oneHistogramClass->LeakageCurrentInPixel->GetBinContent(pixeli)); // cout << oneHistogramClass->LeakageCurrentInPixel->GetBinContent(pixeli) << " " << endl; } std::sort(sortedHistogram.begin(),sortedHistogram.end()); // oneHistogramClass->LeakageCurrentInPixelSorted->SetBins(sortedHistogram.size(), 0, sortedHistogram.size()); - for (UInt_t pixeli=1; pixeli <= sortedHistogram.size(); pixeli++) { - oneHistogramClass->LeakageCurrentInPixelSorted->SetBinContent(pixeli, sortedHistogram.at(pixeli-1)); + for (UInt_t pixeli=0; pixeli < sortedHistogram.size(); pixeli++) { + oneHistogramClass->LeakageCurrentInPixelSorted->SetBinContent(pixeli+1, sortedHistogram.at(pixeli)); // be aware that, histograms in root start at 1 and vectors start at 0 ! } oneHistogramClass->avgLeakageCurrentInChip /= numberofconsideredpixel; @@ -1180,6 +1172,13 @@ Bool_t Run::binLeakageCurrent(HistogramType* oneHistogramClass) oneHistogramClass->medianLeakageCurrentPlus = oneHistogramClass->medianLeakageCurrentPlus - oneHistogramClass->medianLeakageCurrent; oneHistogramClass->medianLeakageCurrentMinus = oneHistogramClass->LeakageCurrentInPixelSorted->GetBinContent(lastbinabovezero*probabilities[0]); oneHistogramClass->medianLeakageCurrentMinus = oneHistogramClass->medianLeakageCurrentMinus - oneHistogramClass->medianLeakageCurrent; + +// TCanvas *c1 = new TCanvas("c1","c1",600,400); +// oneHistogramClass->LeakageCurrentInPixelSorted->Draw(""); +// c1->Update(); +// TCanvas *c2 = new TCanvas("c2","c2",600,400); +// oneHistogramClass->LeakageCurrentDistrib->Draw(""); +// c2->Update(); // cout << "medianLeakageCurrent: " << oneHistogramClass->medianLeakageCurrent << endl; // cout << "medianLeakageCurrentPlus: " << oneHistogramClass->medianLeakageCurrentPlus << endl; // cout << "medianLeakageCurrentMinus: " << oneHistogramClass->medianLeakageCurrentMinus << endl; @@ -1194,7 +1193,7 @@ Bool_t Run::binLeakageCurrent(HistogramType* oneHistogramClass) // cout << colorcyan << "oneHistogramClass->avgLeakageCurrentInChip: " << oneHistogramClass->avgLeakageCurrentInChip << endlr; // cout << colorcyan << "oneHistogramClass->medianLeakageCurrent: " << oneHistogramClass->medianLeakageCurrent << endlr; -// TCanvas *c1 = new TCanvas("c1","c1",600,400); + // TH2F *hcandle = new TH2F("hcandle","Option CANDLE6 example ",40,-4,4,40,-20,20); // Float_t px, py; // for (Int_t pixeli=0; pixeli < oneHistogramClass->LeakageCurrentInPixel->GetNbinsX(); pixeli++) { @@ -1245,7 +1244,7 @@ Bool_t Run::binNoise(HistogramType* oneHistogramClass) Bool_t Run::binF0() { - averageF0Hist =new TH1F(Form("%d AvgF0",labbook.runnumber), Form("%d AvgF0",labbook.runnumber), processed->fHitTree->GetEntries(), 0, processed->fHitTree->GetEntries()); + averageF0Hist =new TH1F(Form("%d AvgF0 for whole chip",labbook.runnumber), Form("%d AvgF0 for whole chip",labbook.runnumber), processed->fHitTree->GetEntries(), 0, processed->fHitTree->GetEntries()); averageF0Hist->SetLineStyle(rootlinestyle[plotStyle]); averageF0Hist->SetLineColor(rootcolors[plotStyle]); averageF0Hist->SetStats(kTRUE); @@ -1260,7 +1259,7 @@ Bool_t Run::binF0() for (Int_t framei=0; frameifHitTree->GetEntries(); framei++) // loop over all frames { processed->fHitTree->GetEntry(framei); - Float_t avgF0InCurFrame = processed->fNoiseInfo.AvgF0; + Double_t avgF0InCurFrame = processed->fNoiseInfo.AvgF0; averageF0Hist->SetBinContent(framei, avgF0InCurFrame); labbook.averageF0+=avgF0InCurFrame; // labbook.averageF0 + = avgF0InCurFrame; @@ -1268,12 +1267,115 @@ Bool_t Run::binF0() labbook.averageF0 /= processed->fHitTree->GetEntries(); for (Int_t framei=0; frameifHitTree->GetEntries(); framei++) // loop over all frames { - Float_t avgF0InCurFrame = processed->fNoiseInfo.AvgF0; + Double_t avgF0InCurFrame = processed->fNoiseInfo.AvgF0; labbook.sigmaF0 += pow(avgF0InCurFrame-labbook.averageF0,2); // labbook.averageF0 + = avgF0InCurFrame; } labbook.sigmaF0 /= processed->fHitTree->GetEntries(); labbook.sigmaF0 = sqrt(labbook.sigmaF0); + + averageF0PixelwiseStart =new TH1F(Form("%d AvgF0 per Pixel, first 1000 frames",labbook.runnumber), Form("%d AvgF0 per Pixel, first 1000 frames",labbook.runnumber), cursensorinfo.columns * cursensorinfo.rows, 0, cursensorinfo.columns * cursensorinfo.rows); + averageF0PixelwiseStart->SetLineStyle(1); + averageF0PixelwiseStart->SetLineColor(1); + averageF0PixelwiseStart->SetStats(kTRUE); + averageF0PixelwiseStart->SetStats(111111111); + averageF0PixelwiseStart->SetLineWidth(3); // TODO: set to 3 again + averageF0PixelwiseStart->GetXaxis()->SetTitle("pixel #"); + averageF0PixelwiseStart->GetYaxis()->SetTitle("Average F0"); + averageF0PixelwiseStart->GetXaxis()->CenterTitle(); + averageF0PixelwiseStart->GetYaxis()->CenterTitle(); + averageF0DistrStart =new TH1F(Form("%d AvgF0, first 1000 frames",labbook.runnumber), Form("%d AvgF0, first 1000 frames",labbook.runnumber), 10000, 0, 10000); + averageF0DistrStart->SetLineStyle(1); + averageF0DistrStart->SetLineColor(1); + averageF0DistrStart->SetStats(kTRUE); + averageF0DistrStart->SetStats(111111111); + averageF0DistrStart->SetLineWidth(3); // TODO: set to 3 again + averageF0DistrStart->GetXaxis()->SetTitle("Average F0"); + averageF0DistrStart->GetYaxis()->SetTitle("counts"); + averageF0DistrStart->GetXaxis()->CenterTitle(); + averageF0DistrStart->GetYaxis()->CenterTitle(); + + for (Int_t framei=processed->fHitTree->GetEntries()-1000; frameifHitTree->GetEntries(); framei++) { // loop over all frames + processed->getFrame(framei); + for (Int_t pixeli=0; pixeliGetF0Frame(); + avgF0ForPixel[pixeli] += fF0matrix[pixeli]; // sum up all pedestals for a given pixel, we need this to calculate an average F0 (average signal) + numberofconsideredpixel++; + } + + Double_t const probabilities[] = {0.158655254, 0.5, 1-0.158655254}; // sigma/2 from gaus to the left and to the right //{0.17, 0.5, 1-0.17}; + Double_t avgF0ForPixel [cursensorinfo.columns*cursensorinfo.rows]; + Double_t numberofconsideredpixel = 0; + Int_t* fF0matrix; + + for (Int_t pixeli=0; pixeligetFrame(framei); + for (Int_t pixeli=0; pixeliGetF0Frame(); + avgF0ForPixel[pixeli] += fF0matrix[pixeli]; // sum up all pedestals for a given pixel, we need this to calculate an average F0 (average signal) + numberofconsideredpixel++; + } + } + } + + for (Int_t pixeli=0; pixeliFill(pixeli+1, avgF0ForPixel[pixeli]); + averageF0DistrStart->Fill(avgF0ForPixel[pixeli]); + } + + + // next histograms + averageF0PixelwiseEnd = (TH1F*) averageF0PixelwiseStart->Clone(); + averageF0PixelwiseEnd->SetLineColor(11); + averageF0DistrEnd = (TH1F*) averageF0DistrStart->Clone(); + averageF0DistrEnd->SetLineColor(11); + numberofconsideredpixel = 0; + // Avarege F0 wird überall nicht Null gesetzt, deshalb der doppelter Wert. !! + // Unsere Loesungsansatz ist eine zwei For Schleife + // for (Int_t framei=processed->fHitTree->GetEntries()-1000; frameifHitTree->GetEntries(); framei++) { // loop over all frames + for (Int_t pixeli=0; pixelifHitTree->GetEntries()-1000; frameifHitTree->GetEntries(); framei++) { // loop over all frames + processed->getFrame(framei); + for (Int_t pixeli=0; pixeliGetF0Frame(); + avgF0ForPixel[pixeli] += fF0matrix[pixeli]; // sum up all pedestals for a given pixel, we need this to calculate an average F0 (average signal) + numberofconsideredpixel++; + } + } + } + + for (Int_t pixeli=0; pixeliFill(pixeli+1, avgF0ForPixel[pixeli]); + averageF0DistrEnd->Fill(avgF0ForPixel[pixeli]); + } + + + TCanvas *c1 = new TCanvas("c1","c1",600,400); + averageF0DistrStart->Draw(""); + averageF0DistrEnd->Draw("SAME"); + c1->Update(); + + TCanvas *c2 = new TCanvas("c2","c2",600,400); + averageF0PixelwiseStart->Draw(""); + averageF0PixelwiseEnd->Draw("SAME"); + c2->Update(); + + + + return 0; } diff --git a/MABS_run_analyzer/Run.h b/MABS_run_analyzer/Run.h index 405cca7..aeb7be9 100644 --- a/MABS_run_analyzer/Run.h +++ b/MABS_run_analyzer/Run.h @@ -405,8 +405,14 @@ public: vector HistogramClassVector; /** @brief The average F0 value of the run over the complete chip in dependance of the time */ - TH1F* averageF0Hist = 0; - + TH1F* averageF0Hist = 0; + + /** @brief The average F0 value of the run over some frames, for each pixel */ + TH1F* averageF0PixelwiseStart = 0; // Over first 1000 frames + TH1F* averageF0PixelwiseEnd = 0; // Over last 1000 frames + + TH1F* averageF0DistrStart = 0; // Over first 1000 frames + TH1F* averageF0DistrEnd = 0; // Over last 1000 frames /** @brief Plots all histograms from #Run::HistogramType into one canvas * -- 2.43.0