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");
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;
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);
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);
}
-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;
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;
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; pixeli<cursensorinfo.columns*cursensorinfo.rows ; pixeli++) { // loop over all pixel
pedestals[pixeli]=0;
}
+
+ // sum up all pedestals for a given pixel, we need this to calculate an average F0 (average signal)
for (Int_t framei=0; framei<processed->fNoiseTree->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; pixeli<cursensorinfo.columns*cursensorinfo.rows ; pixeli++) { // loop over all pixel
if (pixeli%cursensorinfo.columns) // Not marker pixel
- pedestals[pixeli] += processed->fNoiseInfo.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;
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;
}
// cout << colorcyan << "Excluded: " << pixeli << endlr;
}
}
-// for (u_int pixeli=0; (int)pixeli<cursensorinfo.columns*cursensorinfo.rows ; pixeli+=cursensorinfo.columns) { // loop over all pixel
-// cout << " " << pedestals[pixeli] << " " << pedestals[pixeli+1] << " " << pedestals[pixeli+2];
-// }
-// TThread *th1, *th2, *th3, *th4;
-// typedef struct {
-// char name[64];
-// TRandom *r;
-// Long64_t n;
-// Int_t color;
-// } args_t;
-// args_t args1, args2, args3, args4;
-// th1 = new TThread("th1", sortThread, (void*) &args1);
-// th1->Run();
-//
- std::vector<Float_t> sortedHistogram;
+ std::vector<Float_t> 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;
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;
// 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++) {
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);
for (Int_t framei=0; framei<processed->fHitTree->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;
labbook.averageF0 /= processed->fHitTree->GetEntries();
for (Int_t framei=0; framei<processed->fHitTree->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; framei<processed->fHitTree->GetEntries(); framei++) { // loop over all frames
+ processed->getFrame(framei);
+ for (Int_t pixeli=0; pixeli<cursensorinfo.columns*cursensorinfo.rows ; pixeli++) { // loop over all pixel
+ if (pixeli%cursensorinfo.columns) { // Not marker pixel
+ fF0matrix = processed->GetF0Frame();
+ 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; pixeli<cursensorinfo.columns*cursensorinfo.rows ; pixeli++) { // loop over all pixel
+ avgF0ForPixel[pixeli]=0;
+ }
+
+ for (Int_t framei = 1000; framei < 2000; framei++) { // loop over 1000 frames
+ processed->getFrame(framei);
+ for (Int_t pixeli=0; pixeli<cursensorinfo.columns*cursensorinfo.rows ; pixeli++) { // loop over all pixel
+ if (pixeli%cursensorinfo.columns) { // Not marker pixel
+ fF0matrix = processed->GetF0Frame();
+ 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; pixeli<cursensorinfo.columns*cursensorinfo.rows ; pixeli++) { // loop over all pixel
+ avgF0ForPixel[pixeli] /= 1000;
+ averageF0PixelwiseStart->Fill(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; framei<processed->fHitTree->GetEntries(); framei++) { // loop over all frames
+ for (Int_t pixeli=0; pixeli<cursensorinfo.columns*cursensorinfo.rows ; pixeli++) { // loop over all pixel
+ avgF0ForPixel[pixeli]=0;
+ }
+ // }
+
+ for (Int_t framei=processed->fHitTree->GetEntries()-1000; framei<processed->fHitTree->GetEntries(); framei++) { // loop over all frames
+ processed->getFrame(framei);
+ for (Int_t pixeli=0; pixeli<cursensorinfo.columns*cursensorinfo.rows ; pixeli++) { // loop over all pixel
+ if (pixeli%cursensorinfo.columns) { // Not marker pixel
+ fF0matrix = processed->GetF0Frame();
+ 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; pixeli<cursensorinfo.columns*cursensorinfo.rows ; pixeli++) { // loop over all pixel
+ avgF0ForPixel[pixeli] /= 1000;
+ averageF0PixelwiseEnd->Fill(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;
}
jspc29 / radhard.git / commitdiff