1 | #include <iostream>
|
---|
2 | #include <TMath.h>
|
---|
3 | #include <TF1.h>
|
---|
4 | #include <TVectorF.h>
|
---|
5 |
|
---|
6 | #include "rootfilehandler.h"
|
---|
7 | #include "pixel.h" // class implemented
|
---|
8 | using namespace std;
|
---|
9 |
|
---|
10 | /////////////////////////////// PUBLIC ///////////////////////////////////////
|
---|
11 |
|
---|
12 | //============================= LIFECYCLE ====================================
|
---|
13 |
|
---|
14 |
|
---|
15 | Pixel::Pixel(
|
---|
16 | int pixelID,
|
---|
17 | int maxPulsorder,
|
---|
18 | int verbosityLevel,
|
---|
19 | bool stats,
|
---|
20 | TString options,
|
---|
21 | int pixelOverlayXaxisLeft,
|
---|
22 | int pixelOverlayXaxisRight,
|
---|
23 | float bSLMean,
|
---|
24 | float gainMean,
|
---|
25 | TFile* filename,
|
---|
26 | TFile* outfilename
|
---|
27 | )
|
---|
28 | {
|
---|
29 | mConstructorType = 1; //important for deletion 0 delete distribution 1 delete TemplateHistos
|
---|
30 |
|
---|
31 | mChid = pixelID;
|
---|
32 | mMaxPulseOrder = maxPulsorder;
|
---|
33 | mVerbosityLevel = verbosityLevel;
|
---|
34 | mStats = stats;
|
---|
35 | mOptions = options;
|
---|
36 | mPixelOverlayXaxisLeft = pixelOverlayXaxisLeft;
|
---|
37 | mPixelOverlayXaxisRight = pixelOverlayXaxisRight;
|
---|
38 | mBSLMean = bSLMean;
|
---|
39 | mGainMean = gainMean;
|
---|
40 | mRootFile = filename;
|
---|
41 | mOutRootFile = outfilename;
|
---|
42 |
|
---|
43 | hMaxOverlay = new TH2F*[mMaxPulseOrder];
|
---|
44 | hEdgeOverlay = new TH2F*[mMaxPulseOrder];
|
---|
45 | hMaxProfile = new TProfile*[mMaxPulseOrder];
|
---|
46 | hEdgeProfile = new TProfile*[mMaxPulseOrder];
|
---|
47 |
|
---|
48 | hPixelMax = new TH1F*[mMaxPulseOrder];
|
---|
49 | hPixelMedian = new TH1F*[mMaxPulseOrder];
|
---|
50 | hPixelMean = new TH1F*[mMaxPulseOrder];
|
---|
51 |
|
---|
52 | hPixelEdgeMax = new TH1F*[mMaxPulseOrder];
|
---|
53 | hPixelEdgeMedian = new TH1F*[mMaxPulseOrder];
|
---|
54 | hPixelEdgeMean = new TH1F*[mMaxPulseOrder];
|
---|
55 |
|
---|
56 | hList = new TList();
|
---|
57 | hMemberlist = new TList();
|
---|
58 |
|
---|
59 | if (mOptions.Contains("C") )
|
---|
60 | {
|
---|
61 | hChi2EdgetoMax = new TH1F*[mMaxPulseOrder];
|
---|
62 | }
|
---|
63 |
|
---|
64 | if (options.Contains("L"))
|
---|
65 | {
|
---|
66 | LoadPulseHistos( );
|
---|
67 | }
|
---|
68 | else
|
---|
69 | {
|
---|
70 | BookPixelHistos();
|
---|
71 | }
|
---|
72 |
|
---|
73 | if (mOptions.Contains("C"))
|
---|
74 | {
|
---|
75 | BookDistributionHistos();
|
---|
76 | }
|
---|
77 |
|
---|
78 | BookTemplateHistos();
|
---|
79 | BookEdgeTemplateHistos();
|
---|
80 | }
|
---|
81 |
|
---|
82 | Pixel::Pixel(
|
---|
83 | int pixelID,
|
---|
84 | int maxPulsorder,
|
---|
85 | int verbosityLevel,
|
---|
86 | bool stats,
|
---|
87 | TString options,
|
---|
88 | int pixelOverlayXaxisLeft,
|
---|
89 | int pixelOverlayXaxisRight,
|
---|
90 | float bSLMean,
|
---|
91 | float gainMean
|
---|
92 | )
|
---|
93 | {
|
---|
94 | mConstructorType = 0;
|
---|
95 |
|
---|
96 | mChid = pixelID;
|
---|
97 | mMaxPulseOrder = maxPulsorder;
|
---|
98 | mVerbosityLevel = verbosityLevel;
|
---|
99 | mStats = stats; ///TODO: HANDOVER THE VALUE
|
---|
100 | mOptions = options;
|
---|
101 | mPixelOverlayXaxisLeft = pixelOverlayXaxisLeft;
|
---|
102 | mPixelOverlayXaxisRight = pixelOverlayXaxisRight;
|
---|
103 | mBSLMean = bSLMean;
|
---|
104 | mGainMean = gainMean;
|
---|
105 |
|
---|
106 | hMaxOverlay = new TH2F*[mMaxPulseOrder];
|
---|
107 | hEdgeOverlay = new TH2F*[mMaxPulseOrder];
|
---|
108 | hMaxProfile = new TProfile*[mMaxPulseOrder];
|
---|
109 | hEdgeProfile = new TProfile*[mMaxPulseOrder];
|
---|
110 |
|
---|
111 | if (mOptions.Contains("S") )
|
---|
112 | {
|
---|
113 | hSlopeRisingEdge = new TH1F*[mMaxPulseOrder];
|
---|
114 | }
|
---|
115 |
|
---|
116 | if (mOptions.Contains("R") )
|
---|
117 | {
|
---|
118 | hRisingEdgeToMax = new TH1I*[mMaxPulseOrder];
|
---|
119 | }
|
---|
120 |
|
---|
121 | if (mOptions.Contains("M") )
|
---|
122 | {
|
---|
123 | hPosOfMax = new TH1I*[mMaxPulseOrder];
|
---|
124 | }
|
---|
125 |
|
---|
126 | hList = new TList();
|
---|
127 | hMemberlist = new TList();
|
---|
128 |
|
---|
129 | BookPixelHistos();
|
---|
130 | BookDistributionHistos();
|
---|
131 | }
|
---|
132 |
|
---|
133 | Pixel::~Pixel()
|
---|
134 | {
|
---|
135 | if (mVerbosityLevel > 1)
|
---|
136 | {
|
---|
137 | cout << endl << "...delete histograms of pixel " << mChid ;
|
---|
138 | cout << endl << "...mConstructorType = " << mConstructorType ;
|
---|
139 | }
|
---|
140 |
|
---|
141 | if (mConstructorType == 0)
|
---|
142 | {
|
---|
143 | DeleteDistributionHistos();
|
---|
144 | }
|
---|
145 |
|
---|
146 | if (mConstructorType == 1)
|
---|
147 | {
|
---|
148 | DeleteTemplateHistos();
|
---|
149 | DeleteEdgeTemplateHistos();
|
---|
150 | }
|
---|
151 |
|
---|
152 | DeletePixelHistos();
|
---|
153 | delete hList;
|
---|
154 | delete hMemberlist;
|
---|
155 |
|
---|
156 | hList = NULL;
|
---|
157 | hMemberlist = NULL;
|
---|
158 | if (mVerbosityLevel > 1)
|
---|
159 | {
|
---|
160 | cout << endl << "...histograms of pixel " << mChid ;
|
---|
161 | cout << "...deleted " << endl ;
|
---|
162 | }
|
---|
163 | }// ~Pixel
|
---|
164 |
|
---|
165 |
|
---|
166 | //============================= OPERATORS ====================================
|
---|
167 |
|
---|
168 | //XX&
|
---|
169 | //XX::operator=(const XX&);
|
---|
170 | //{
|
---|
171 | // return *this;
|
---|
172 |
|
---|
173 | //}// =
|
---|
174 |
|
---|
175 | //============================= OPERATIONS ===================================
|
---|
176 | void
|
---|
177 | Pixel::DrawOverlayHistograms(
|
---|
178 | TCanvas** pixelCanvas,
|
---|
179 | int* histoFrameNr
|
---|
180 | )
|
---|
181 | {
|
---|
182 | if (mVerbosityLevel > 2) cout << endl << "...drawing pulse histograms" ;
|
---|
183 | for (int pulse_order = 0; pulse_order < mMaxPulseOrder; pulse_order++)
|
---|
184 | {
|
---|
185 | pixelCanvas[pulse_order]->cd( histoFrameNr[0] );
|
---|
186 | hMaxOverlay[pulse_order]->Draw("COLZ");
|
---|
187 | pixelCanvas[pulse_order]->cd( histoFrameNr[2] );
|
---|
188 | hMaxProfile[pulse_order]->Draw();
|
---|
189 |
|
---|
190 | pixelCanvas[pulse_order]->cd( histoFrameNr[1] );
|
---|
191 | hEdgeOverlay[pulse_order]->Draw("COLZ");
|
---|
192 | pixelCanvas[pulse_order]->cd( histoFrameNr[3] );
|
---|
193 | hEdgeProfile[pulse_order]->Draw();
|
---|
194 | }
|
---|
195 | }
|
---|
196 | // end of DrawOverlayHistograms
|
---|
197 | //----------------------------------------------------------------------------
|
---|
198 |
|
---|
199 | void
|
---|
200 | Pixel::DrawDistributionHistograms(
|
---|
201 | TCanvas** pixelCanvas,
|
---|
202 | int* histoFrameNr
|
---|
203 | )
|
---|
204 | {
|
---|
205 | if (mVerbosityLevel > 2) cout << endl << "...drawing distribution histograms" ;
|
---|
206 | bool nothing_to_fill = true;
|
---|
207 | for (int pulse_order = 0; pulse_order < mMaxPulseOrder; pulse_order++)
|
---|
208 | {
|
---|
209 | if (mOptions.Contains("S") )
|
---|
210 | {
|
---|
211 | pixelCanvas[pulse_order]->cd( histoFrameNr[0] );
|
---|
212 | hSlopeRisingEdge[pulse_order]->Draw();
|
---|
213 | nothing_to_fill = false;
|
---|
214 | }
|
---|
215 |
|
---|
216 | if (mOptions.Contains("R") )
|
---|
217 | {
|
---|
218 | pixelCanvas[pulse_order]->cd( histoFrameNr[1] );
|
---|
219 | hRisingEdgeToMax[pulse_order]->Draw();
|
---|
220 | nothing_to_fill = false;
|
---|
221 | }
|
---|
222 |
|
---|
223 | if (mOptions.Contains("M") )
|
---|
224 | {
|
---|
225 | pixelCanvas[pulse_order]->cd( histoFrameNr[2] );
|
---|
226 | hPosOfMax[pulse_order]->Draw();
|
---|
227 | nothing_to_fill = false;
|
---|
228 | }
|
---|
229 |
|
---|
230 | }
|
---|
231 | if (nothing_to_fill)
|
---|
232 | {
|
---|
233 | cout << endl << "there were NO DISTRIBUTION HISTOGRAMS to fill" << endl;
|
---|
234 | }
|
---|
235 | }
|
---|
236 | // end of DrawDistributionHistograms
|
---|
237 | //----------------------------------------------------------------------------
|
---|
238 |
|
---|
239 | void
|
---|
240 | Pixel::DrawTemplateHistograms(
|
---|
241 | TCanvas** pixelCanvas,
|
---|
242 | int* histoFrameNr
|
---|
243 | )
|
---|
244 | {
|
---|
245 | int mrkStyle =1;
|
---|
246 | int mrkSize = 2;
|
---|
247 | if (mVerbosityLevel > 2) cout << "...drawing Template histograms" << endl ;
|
---|
248 | for (int pulse_order = 0; pulse_order < mMaxPulseOrder; pulse_order++)
|
---|
249 | {
|
---|
250 | pixelCanvas[pulse_order]->cd( histoFrameNr[0] );
|
---|
251 | hMaxOverlay[pulse_order]->Draw("COLZ");
|
---|
252 |
|
---|
253 | pixelCanvas[pulse_order]->cd( histoFrameNr[1] );
|
---|
254 | hPixelMax[pulse_order]->Draw("E1");
|
---|
255 | hPixelMax[pulse_order]->SetMarkerColor(kBlue);
|
---|
256 | hPixelMax[pulse_order]->SetLineColor(kBlack);
|
---|
257 | hPixelMax[pulse_order]->SetMarkerStyle(mrkStyle);
|
---|
258 | hPixelMax[pulse_order]->SetMarkerSize(mrkSize);
|
---|
259 |
|
---|
260 | pixelCanvas[pulse_order]->cd( histoFrameNr[2] );
|
---|
261 | hPixelMedian[pulse_order]->Draw("E1");
|
---|
262 | hPixelMedian[pulse_order]->SetMarkerColor(kBlue);
|
---|
263 | hPixelMedian[pulse_order]->SetLineColor(kBlack);
|
---|
264 | hPixelMedian[pulse_order]->SetMarkerStyle(mrkStyle);
|
---|
265 | hPixelMedian[pulse_order]->SetMarkerSize(mrkSize);
|
---|
266 |
|
---|
267 | pixelCanvas[pulse_order]->cd( histoFrameNr[3] );
|
---|
268 | hPixelMean[pulse_order]->Draw("E1");
|
---|
269 | hPixelMean[pulse_order]->SetMarkerColor(kBlue);
|
---|
270 | hPixelMean[pulse_order]->SetLineColor(kBlack);
|
---|
271 | hPixelMean[pulse_order]->SetMarkerStyle(mrkStyle);
|
---|
272 | hPixelMean[pulse_order]->SetMarkerSize(mrkSize);
|
---|
273 | // hPixelMax[pulse_order]->Draw("SAME");
|
---|
274 | // hPixelMedian[pulse_order]->Draw("SAME");
|
---|
275 |
|
---|
276 | }
|
---|
277 | }
|
---|
278 | // end of DrawTemplateHistograms
|
---|
279 | //----------------------------------------------------------------------------
|
---|
280 |
|
---|
281 | void
|
---|
282 | Pixel::DrawEdgeTemplateHistograms(
|
---|
283 | TCanvas** pixelCanvas,
|
---|
284 | int* histoFrameNr
|
---|
285 | )
|
---|
286 | {
|
---|
287 | int mrkStyle = 1;
|
---|
288 | int mrkSize = 3;
|
---|
289 |
|
---|
290 | if (mVerbosityLevel > 2) cout << endl << "...drawing Template histograms" ;
|
---|
291 | for (int pulse_order = 0; pulse_order < mMaxPulseOrder; pulse_order++)
|
---|
292 | {
|
---|
293 | pixelCanvas[pulse_order]->cd( histoFrameNr[4] );
|
---|
294 | hEdgeOverlay[pulse_order]->Draw("COLZ");
|
---|
295 |
|
---|
296 | pixelCanvas[pulse_order]->cd( histoFrameNr[5] );
|
---|
297 | hPixelEdgeMax[pulse_order]->Draw("E1");
|
---|
298 | hPixelEdgeMax[pulse_order]->SetLineColor(kBlack);
|
---|
299 | hPixelEdgeMax[pulse_order]->SetMarkerColor(kBlue);
|
---|
300 | hPixelEdgeMax[pulse_order]->SetMarkerStyle(mrkStyle);
|
---|
301 | hPixelEdgeMax[pulse_order]->SetMarkerSize(mrkSize);
|
---|
302 |
|
---|
303 | pixelCanvas[pulse_order]->cd( histoFrameNr[6] );
|
---|
304 | hPixelEdgeMedian[pulse_order]->Draw("E1");
|
---|
305 | hPixelEdgeMedian[pulse_order]->SetLineColor(kBlack);
|
---|
306 | hPixelEdgeMedian[pulse_order]->SetMarkerColor(kBlue);
|
---|
307 | hPixelEdgeMedian[pulse_order]->SetMarkerStyle(mrkStyle);
|
---|
308 | hPixelEdgeMedian[pulse_order]->SetMarkerSize(mrkSize);
|
---|
309 |
|
---|
310 | pixelCanvas[pulse_order]->cd( histoFrameNr[7] );
|
---|
311 | hPixelEdgeMean[pulse_order]->Draw("E1");
|
---|
312 | hPixelEdgeMean[pulse_order]->SetLineColor(kBlack);
|
---|
313 | hPixelEdgeMean[pulse_order]->SetMarkerColor(kBlue);
|
---|
314 | hPixelEdgeMean[pulse_order]->SetMarkerStyle(mrkStyle);
|
---|
315 | hPixelEdgeMean[pulse_order]->SetMarkerSize(mrkSize);
|
---|
316 | // hPixelEdgeMax[pulse_order]->Draw("SAME");
|
---|
317 | // hPixelEdgeMedian[pulse_order]->Draw("SAME");
|
---|
318 |
|
---|
319 | }
|
---|
320 | }
|
---|
321 | // end of DrawTemplateHistograms
|
---|
322 | //----------------------------------------------------------------------------
|
---|
323 |
|
---|
324 |
|
---|
325 |
|
---|
326 |
|
---|
327 | void
|
---|
328 | Pixel::SavePixelHistograms(
|
---|
329 | TString outRootFileName,
|
---|
330 | bool saveResults
|
---|
331 | )
|
---|
332 | {
|
---|
333 | if (mVerbosityLevel > 2) cout << endl << "Saving histograms of Pixel# " << mChid;
|
---|
334 | if (!saveResults) return;
|
---|
335 | SaveList(
|
---|
336 | outRootFileName,
|
---|
337 | CreateSubDirName( mChid ),
|
---|
338 | hList,
|
---|
339 | saveResults,
|
---|
340 | mVerbosityLevel
|
---|
341 | );
|
---|
342 | /*
|
---|
343 | we also need to save same values:
|
---|
344 |
|
---|
345 | EXAMPLE
|
---|
346 | root > TFile f("v.root","recreate")
|
---|
347 | root > TVectorD v(1)
|
---|
348 | root > v[0] = 3.14
|
---|
349 | root > v.Write("v")
|
---|
350 | and to read the file do
|
---|
351 | CODE: SELECT ALL
|
---|
352 | root > TFile f("v.root")
|
---|
353 | root > TVectorD *v = (TVectorD*)f.get("v");
|
---|
354 | root > v->Print()
|
---|
355 |
|
---|
356 | */
|
---|
357 | }
|
---|
358 | // end of SavePixelHistograms
|
---|
359 | //----------------------------------------------------------------------------
|
---|
360 |
|
---|
361 | TString
|
---|
362 | Pixel::HistoName(
|
---|
363 | TString histoname,
|
---|
364 | int order
|
---|
365 | )
|
---|
366 | {
|
---|
367 | histoname += mChid;
|
---|
368 | histoname += "_";
|
---|
369 | histoname += order;
|
---|
370 | return histoname;
|
---|
371 | }
|
---|
372 |
|
---|
373 | TString
|
---|
374 | Pixel::ChooseCycleNumber(
|
---|
375 | TString histoname,
|
---|
376 | int cycleNumber
|
---|
377 | )
|
---|
378 | {
|
---|
379 | histoname += ";";
|
---|
380 | histoname += cycleNumber;
|
---|
381 | return histoname;
|
---|
382 | }
|
---|
383 |
|
---|
384 | TString
|
---|
385 | Pixel::HistoTitle(
|
---|
386 | TString histo_title,
|
---|
387 | int order
|
---|
388 | )
|
---|
389 | {
|
---|
390 | histo_title += " [Pixel_Order] ";
|
---|
391 | histo_title += mChid;
|
---|
392 | histo_title += "_";
|
---|
393 | histo_title += order;
|
---|
394 | return histo_title;
|
---|
395 | }
|
---|
396 |
|
---|
397 | TString
|
---|
398 | Pixel::CsvFileName(
|
---|
399 | TString path,
|
---|
400 | TString overlayMethod,
|
---|
401 | int order
|
---|
402 | )
|
---|
403 | {
|
---|
404 | path += "CSV/";
|
---|
405 | path += overlayMethod;
|
---|
406 | path += "OverlayTemplate";
|
---|
407 | path += "_";
|
---|
408 | path += mChid;
|
---|
409 | path += "_";
|
---|
410 | path += order;
|
---|
411 | path += ".csv";
|
---|
412 | return path;
|
---|
413 | }
|
---|
414 |
|
---|
415 |
|
---|
416 | //============================= ACESS ===================================
|
---|
417 | //============================= INQUIRY ===================================
|
---|
418 | /////////////////////////////// PROTECTED ///////////////////////////////////
|
---|
419 |
|
---|
420 | /////////////////////////////// PRIVATE ///////////////////////////////////
|
---|
421 |
|
---|
422 | void
|
---|
423 | Pixel::BookPixelHistos()
|
---|
424 | {
|
---|
425 | if (mVerbosityLevel > 2) cout << endl << "...book pixel histograms" << endl;
|
---|
426 | for (int order = 0; order < mMaxPulseOrder; order++)
|
---|
427 | {
|
---|
428 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hMaxOverlay", order) << endl;
|
---|
429 | hMaxOverlay[order]=new TH2F(
|
---|
430 | HistoName("hMaxOverlay", order),
|
---|
431 | HistoTitle("Overlay at peak maximum of detected pulses of", order),
|
---|
432 | mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
|
---|
433 | (-1*mPixelOverlayXaxisLeft)-0.5,
|
---|
434 | mPixelOverlayXaxisRight-0.5 ,
|
---|
435 | 512,
|
---|
436 | -55.5,
|
---|
437 | 200.5
|
---|
438 | );
|
---|
439 |
|
---|
440 | hMaxOverlay[order]->SetAxisRange(
|
---|
441 | mBSLMean - 5,
|
---|
442 | (mGainMean*(order+1)) + 10,
|
---|
443 | "Y");
|
---|
444 | hMaxOverlay[order]->SetDrawOption("colz");
|
---|
445 | hMaxOverlay[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
446 | hMaxOverlay[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
|
---|
447 | //hMaxProfile->SetBit(TH2F::kCanRebin);
|
---|
448 | hMaxOverlay[order]->SetStats(mStats);
|
---|
449 | hList->Add( hMaxOverlay[order] );
|
---|
450 |
|
---|
451 | //------------------------------------------------------------------------
|
---|
452 |
|
---|
453 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hEdgeOverlay", order) << endl;
|
---|
454 | hEdgeOverlay[order] = new TH2F(
|
---|
455 | HistoName("hEdgeOverlay", order),
|
---|
456 | HistoTitle("Overlay at rising edge of detected pulses of", order),
|
---|
457 | mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
|
---|
458 | (-1*mPixelOverlayXaxisLeft)-0.5,
|
---|
459 | mPixelOverlayXaxisRight-0.5 ,
|
---|
460 | 512,
|
---|
461 | -55.5,
|
---|
462 | 200.5
|
---|
463 | );
|
---|
464 |
|
---|
465 | hEdgeOverlay[order]->SetAxisRange(
|
---|
466 | mBSLMean - 5,
|
---|
467 | (mGainMean*(order+1)) + 10,
|
---|
468 | "Y");
|
---|
469 | hEdgeOverlay[order]->SetDrawOption("colz");
|
---|
470 | hEdgeOverlay[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
471 | hEdgeOverlay[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
|
---|
472 | hEdgeOverlay[order]->SetStats(mStats);
|
---|
473 | hList->Add( hEdgeOverlay[order] );
|
---|
474 |
|
---|
475 | //------------------------------------------------------------------------
|
---|
476 |
|
---|
477 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hMaxProfile", order) << endl;
|
---|
478 | hMaxProfile[order] = new TProfile(
|
---|
479 | HistoName("hMaxProfile", order),
|
---|
480 | HistoTitle("Mean value of each slice in overlay plot (Tprofile)", order),
|
---|
481 | mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,//nbinsx
|
---|
482 | (-1*mPixelOverlayXaxisLeft)-0.5, //xlow
|
---|
483 | mPixelOverlayXaxisRight-0.5 , //xup
|
---|
484 | // 512, //nbinsy
|
---|
485 | -55.5, //ylow
|
---|
486 | 300.5, //yup
|
---|
487 | "s"); //option
|
---|
488 | hMaxProfile[order]->SetAxisRange(
|
---|
489 | mBSLMean - 5,
|
---|
490 | (mGainMean*(order+1)) + 10,
|
---|
491 | "Y");
|
---|
492 | hMaxProfile[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
493 | hMaxProfile[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
|
---|
494 | //hMaxProfile->SetBit(TH2F::kCanRebin);
|
---|
495 | hMaxProfile[order]->SetStats(mStats);
|
---|
496 | hList->Add( hMaxProfile[order] );
|
---|
497 |
|
---|
498 |
|
---|
499 | //------------------------------------------------------------------------
|
---|
500 |
|
---|
501 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hEdgeProfile", order) << endl;
|
---|
502 | hEdgeProfile[order] = new TProfile(
|
---|
503 | HistoName("hEdgeProfile", order),
|
---|
504 | HistoTitle("Mean value of each slice in overlay plot (Tprofile)", order),
|
---|
505 | mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,//nbinsx
|
---|
506 | (-1*mPixelOverlayXaxisLeft)-0.5, //xlow
|
---|
507 | mPixelOverlayXaxisRight-0.5 , //xup
|
---|
508 | // 512, //nbinsy
|
---|
509 | -55.5, //ylow
|
---|
510 | 300.5, //yup
|
---|
511 | "s"); //option
|
---|
512 | hEdgeProfile[order]->SetLineColor(kRed);
|
---|
513 | hEdgeProfile[order]->SetAxisRange(
|
---|
514 | mBSLMean - 5,
|
---|
515 | (mGainMean*(order+1)) + 10,
|
---|
516 | "Y");
|
---|
517 | hEdgeProfile[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
518 | hEdgeProfile[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
|
---|
519 | //hMaxProfile->SetBit(TH2F::kCanRebin);
|
---|
520 | hEdgeProfile[order]->SetStats(mStats);
|
---|
521 | hList->Add( hEdgeProfile[order] );
|
---|
522 |
|
---|
523 | }
|
---|
524 | if (mVerbosityLevel > 2) cout << "...done" << endl;
|
---|
525 | }
|
---|
526 | //end of BookPixelHistos
|
---|
527 | //----------------------------------------------------------------------------
|
---|
528 |
|
---|
529 | void
|
---|
530 | Pixel::BookDistributionHistos( )
|
---|
531 | {
|
---|
532 | if (!mOptions.IsNull() )
|
---|
533 | {
|
---|
534 | int x_min = 0;
|
---|
535 | int x_max = 0;
|
---|
536 |
|
---|
537 | for (int order =0; order < mMaxPulseOrder; order++)
|
---|
538 | {
|
---|
539 | if (mVerbosityLevel > 2) cout << endl
|
---|
540 | << "...book distribution histograms"
|
---|
541 | << endl;
|
---|
542 |
|
---|
543 | if (mOptions.Contains("S"))
|
---|
544 | {
|
---|
545 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hSlopeRisingEdge", order) << endl;
|
---|
546 | hSlopeRisingEdge[order] = new TH1F (
|
---|
547 | HistoName("hSlopeRisingEdge", order),
|
---|
548 | HistoTitle("Distribution of rising edge's slope", order),
|
---|
549 | 600,
|
---|
550 | -10.1,
|
---|
551 | 10.1
|
---|
552 | );
|
---|
553 | hSlopeRisingEdge[order]->SetAxisRange(
|
---|
554 | -1,
|
---|
555 | 7,
|
---|
556 | "X");
|
---|
557 | hSlopeRisingEdge[order]->GetXaxis()->SetTitle( "Slope Amplitude/time [mV/timeslices]" );
|
---|
558 | hSlopeRisingEdge[order]->GetYaxis()->SetTitle( "counts" );
|
---|
559 | hSlopeRisingEdge[order]->SetStats(mStats);
|
---|
560 | hList->Add( hSlopeRisingEdge[order] );
|
---|
561 | }
|
---|
562 |
|
---|
563 | if (mOptions.Contains("R"))
|
---|
564 | {
|
---|
565 | x_min = -15;
|
---|
566 | x_max = 35;
|
---|
567 |
|
---|
568 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hRisingEdgeToMax", order) << endl;
|
---|
569 | hRisingEdgeToMax[order] = new TH1I (
|
---|
570 | HistoName("hRisingEdgeToMax", order),
|
---|
571 | HistoTitle("Distribution of distance between rising edge and pulse's maximum", order),
|
---|
572 | x_max -x_min,
|
---|
573 | x_min,
|
---|
574 | x_max
|
---|
575 | );
|
---|
576 | hSlopeRisingEdge[order]->SetAxisRange(
|
---|
577 | -5,
|
---|
578 | 25,
|
---|
579 | "X");
|
---|
580 | hRisingEdgeToMax[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
581 | hRisingEdgeToMax[order]->GetYaxis()->SetTitle( "counts" );
|
---|
582 | hRisingEdgeToMax[order]->SetStats(mStats);
|
---|
583 | hList->Add( hRisingEdgeToMax[order] );
|
---|
584 | }
|
---|
585 |
|
---|
586 | if (mOptions.Contains("M"))
|
---|
587 | {
|
---|
588 | x_min = 10;
|
---|
589 | x_max = 290;
|
---|
590 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hPosOfMax", order) << endl;
|
---|
591 | hPosOfMax[order] = new TH1I (
|
---|
592 | HistoName("hPosOfMax", order),
|
---|
593 | HistoTitle("Distribution of pulse's maximum's positon", order),
|
---|
594 | x_max - x_min,
|
---|
595 | x_min,
|
---|
596 | x_max
|
---|
597 | );
|
---|
598 | hPosOfMax[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
599 | hPosOfMax[order]->GetYaxis()->SetTitle( "counts" );
|
---|
600 | hRisingEdgeToMax[order]->SetStats(mStats);
|
---|
601 | hList->Add( hPosOfMax[order] );
|
---|
602 | }
|
---|
603 |
|
---|
604 | if (mOptions.Contains("C"))
|
---|
605 | {
|
---|
606 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hSlopeRisingEdge", order) << endl;
|
---|
607 | hChi2EdgetoMax[order] = new TH1F (
|
---|
608 | HistoName("hChi2EdgetoMax", order),
|
---|
609 | HistoTitle("Distribution of CHI2 comparison of Edge and Max", order),
|
---|
610 | 600,
|
---|
611 | -299,
|
---|
612 | 300
|
---|
613 | );
|
---|
614 | hChi2EdgetoMax[order]->SetAxisRange(
|
---|
615 | -1,
|
---|
616 | 7,
|
---|
617 | "X");
|
---|
618 | hChi2EdgetoMax[order]->GetXaxis()->SetTitle( "p-Value" );
|
---|
619 | hChi2EdgetoMax[order]->GetYaxis()->SetTitle( "counts" );
|
---|
620 | hChi2EdgetoMax[order]->SetStats(mStats);
|
---|
621 | // hList->Add( hChi2EdgetoMax[order] );
|
---|
622 | }
|
---|
623 |
|
---|
624 | if (mVerbosityLevel > 2) cout << "...done" << endl;
|
---|
625 | }
|
---|
626 |
|
---|
627 | // Arrival Time Distributions
|
---|
628 | //----------------------------------
|
---|
629 | if (mVerbosityLevel > 3) cout << "\t...booking " << "hMaxPos" << endl;
|
---|
630 | hMaxPos = new TH1F (
|
---|
631 | "hMaxPos",
|
---|
632 | "Distribution of arrival times according to the EdgePos",
|
---|
633 | 1025,
|
---|
634 | -1,
|
---|
635 | 1024
|
---|
636 | );
|
---|
637 | // hMaxPos->SetAxisRange(
|
---|
638 | // 0,
|
---|
639 | // 1024,
|
---|
640 | // "X");
|
---|
641 | hMaxPos->SetDrawOption("colz");
|
---|
642 | hMaxPos->GetXaxis()->SetTitle( " arrival time [timeslices]" );
|
---|
643 | hMaxPos->GetYaxis()->SetTitle( "counts" );
|
---|
644 | hMaxPos->SetStats(mStats);
|
---|
645 | hList->Add( hMaxPos );
|
---|
646 |
|
---|
647 | if (mVerbosityLevel > 3) cout << "\t...booking " << "hEdgePos" << endl;
|
---|
648 | hEdgePos = new TH1F (
|
---|
649 | "hEdgePos",
|
---|
650 | "Distribution of arrival times according to the EdgePos",
|
---|
651 | 1125,
|
---|
652 | -1,
|
---|
653 | 1124
|
---|
654 | );
|
---|
655 | // hEdgePos->SetAxisRange(
|
---|
656 | // 0,
|
---|
657 | // 1024,
|
---|
658 | // "X");
|
---|
659 | hEdgePos->SetDrawOption("colz");
|
---|
660 | hEdgePos->GetXaxis()->SetTitle( " arrival time [timeslices]" );
|
---|
661 | hEdgePos->GetYaxis()->SetTitle( "counts" );
|
---|
662 | hEdgePos->SetStats(mStats);
|
---|
663 | hList->Add( hEdgePos );
|
---|
664 |
|
---|
665 | // Edge Slope Distributions
|
---|
666 | //----------------------------------
|
---|
667 | if (mVerbosityLevel > 3) cout << "\t...booking " << "hEdgeSlope" << endl;
|
---|
668 | hEdgeSlope = new TH1F (
|
---|
669 | "hEdgeSlope",
|
---|
670 | "Distribution of slope of leading edges",
|
---|
671 | 100,
|
---|
672 | -1.55,
|
---|
673 | 8.45
|
---|
674 | );
|
---|
675 | hEdgeSlope->SetAxisRange(
|
---|
676 | 0.5,
|
---|
677 | 7,
|
---|
678 | "X");
|
---|
679 | hEdgeSlope->SetDrawOption("colz");
|
---|
680 | hEdgeSlope->GetXaxis()->SetTitle( " slope [a.u.]" );
|
---|
681 | hEdgeSlope->GetYaxis()->SetTitle( "counts" );
|
---|
682 | hEdgeSlope->SetStats(mStats);
|
---|
683 | hList->Add( hEdgeSlope );
|
---|
684 |
|
---|
685 | // Edge Slope Distributions
|
---|
686 | //----------------------------------
|
---|
687 | if (mVerbosityLevel > 3) cout << "\t...booking " << "hMaxEdgeSlope" << endl;
|
---|
688 | hMaxEdgeSlope = new TH1F (
|
---|
689 | "hMaxEdgeSlope",
|
---|
690 | "Distribution of maximum slope in slices of leading edges",
|
---|
691 | 100,
|
---|
692 | -1.55,
|
---|
693 | 8.45
|
---|
694 | );
|
---|
695 | hMaxEdgeSlope->SetAxisRange(
|
---|
696 | 0.5,
|
---|
697 | 7,
|
---|
698 | "X");
|
---|
699 | hMaxEdgeSlope->SetDrawOption("colz");
|
---|
700 | hMaxEdgeSlope->GetXaxis()->SetTitle( " slope [a.u.]" );
|
---|
701 | hMaxEdgeSlope->GetYaxis()->SetTitle( "counts" );
|
---|
702 | hMaxEdgeSlope->SetStats(mStats);
|
---|
703 | hList->Add( hMaxEdgeSlope );
|
---|
704 |
|
---|
705 | // Intercept Distributions
|
---|
706 | //----------------------------------
|
---|
707 | if (mVerbosityLevel > 3) cout << "\t...booking " << "hIntercept" << endl;
|
---|
708 | hIntercept = new TH1F (
|
---|
709 | "hIntercept",
|
---|
710 | "Distribution of Intercept of leading edges",
|
---|
711 | 1041,
|
---|
712 | -1,
|
---|
713 | 1040
|
---|
714 | );
|
---|
715 | hIntercept->SetAxisRange(
|
---|
716 | -100,
|
---|
717 | 100,
|
---|
718 | "X");
|
---|
719 | hIntercept->SetDrawOption("colz");
|
---|
720 | hIntercept->GetXaxis()->SetTitle( " Intercept [a.u.]" );
|
---|
721 | hIntercept->GetYaxis()->SetTitle( "counts" );
|
---|
722 | hIntercept->SetStats(mStats);
|
---|
723 | hList->Add( hIntercept );
|
---|
724 |
|
---|
725 | // Edge lengt Distributions
|
---|
726 | //----------------------------------
|
---|
727 | if (mVerbosityLevel > 3) cout << "\t...booking " << "hEdgeLength" << endl;
|
---|
728 | hEdgeLength = new TH1F (
|
---|
729 | "hEdgeLength",
|
---|
730 | "Distribution of hEdgeLength of leading edges",
|
---|
731 | 200,
|
---|
732 | -0.5,
|
---|
733 | 199.5
|
---|
734 | );
|
---|
735 | hEdgeLength->SetAxisRange(
|
---|
736 | 0,
|
---|
737 | 100,
|
---|
738 | "X");
|
---|
739 | hEdgeLength->SetDrawOption("colz");
|
---|
740 | hEdgeLength->GetXaxis()->SetTitle( " edge length [a.u.]" );
|
---|
741 | hEdgeLength->GetYaxis()->SetTitle( "counts" );
|
---|
742 | hEdgeLength->SetStats(mStats);
|
---|
743 | hList->Add( hEdgeLength );
|
---|
744 |
|
---|
745 | // Pulse length Distributions
|
---|
746 | //----------------------------------
|
---|
747 | if (mVerbosityLevel > 3) cout << "\t...booking " << "hPulseLength" << endl;
|
---|
748 | hPulseLength = new TH1F (
|
---|
749 | "hPulseLength",
|
---|
750 | "Distribution of pulse lengthes",
|
---|
751 | 1024,
|
---|
752 | -0.5,
|
---|
753 | 1023.5
|
---|
754 | );
|
---|
755 | hPulseLength->SetAxisRange(
|
---|
756 | 0,
|
---|
757 | 600,
|
---|
758 | "X");
|
---|
759 | hPulseLength->SetDrawOption("colz");
|
---|
760 | hPulseLength->GetXaxis()->SetTitle( " pulse length [samples]" );
|
---|
761 | hPulseLength->GetYaxis()->SetTitle( "counts" );
|
---|
762 | hPulseLength->SetStats(mStats);
|
---|
763 | hList->Add( hPulseLength );
|
---|
764 |
|
---|
765 | if (mVerbosityLevel > 3) cout << "\t...booking " << "hPulseLengthAPcutoff" << endl;
|
---|
766 | hPulseLengthAPcutoff = new TH1F (
|
---|
767 | "hPulseLengthAPcutoff",
|
---|
768 | "Distribution of pulse lengthes due to afterpulse cut off",
|
---|
769 | 1024,
|
---|
770 | -0.5,
|
---|
771 | 1023.5
|
---|
772 | );
|
---|
773 | // hPulseLength->SetAxisRange(
|
---|
774 | // 0,
|
---|
775 | // 1024,
|
---|
776 | // "X");
|
---|
777 | hPulseLengthAPcutoff->SetDrawOption("colz");
|
---|
778 | hPulseLengthAPcutoff->GetXaxis()->SetTitle( " pulse length [samples]" );
|
---|
779 | hPulseLengthAPcutoff->GetYaxis()->SetTitle( "counts" );
|
---|
780 | hPulseLengthAPcutoff->SetStats(mStats);
|
---|
781 | hList->Add( hPulseLengthAPcutoff );
|
---|
782 |
|
---|
783 | if (mVerbosityLevel > 3) cout << "\t...booking " << "hPulseLengthTLcutoff" << endl;
|
---|
784 | hPulseLengthTLcutoff = new TH1F (
|
---|
785 | "hPulseLengthTLcutoff",
|
---|
786 | "Distribution of pulse lengthes due to time line cut off",
|
---|
787 | 1024,
|
---|
788 | -0.5,
|
---|
789 | 1023.5
|
---|
790 | );
|
---|
791 | // hPulseLengthTLcutoff->SetAxisRange(
|
---|
792 | // 0,
|
---|
793 | // 1024,
|
---|
794 | // "X");
|
---|
795 | hPulseLengthTLcutoff->SetDrawOption("colz");
|
---|
796 | hPulseLengthTLcutoff->GetXaxis()->SetTitle( " pulse length [samples]" );
|
---|
797 | hPulseLengthTLcutoff->GetYaxis()->SetTitle( "counts" );
|
---|
798 | hPulseLengthTLcutoff->SetStats(mStats);
|
---|
799 | hList->Add( hPulseLengthTLcutoff );
|
---|
800 |
|
---|
801 | // Amplitude Distributions
|
---|
802 | //----------------------------------
|
---|
803 |
|
---|
804 | if (mVerbosityLevel > 3) cout << "\t...booking " << "hMaxAmpl" << endl;
|
---|
805 | hMaxAmpl = new TH1F (
|
---|
806 | "hMaxAmpl",
|
---|
807 | "Distribution of MaxAmpl of leading edges",
|
---|
808 | 100*10,
|
---|
809 | 0,
|
---|
810 | 100
|
---|
811 | );
|
---|
812 | // hMaxAmpl->SetAxisRange(
|
---|
813 | // 0,
|
---|
814 | // 1024,
|
---|
815 | // "X");
|
---|
816 | hMaxAmpl->SetDrawOption("colz");
|
---|
817 | hMaxAmpl->GetXaxis()->SetTitle( " Amplitude [a.u.]" );
|
---|
818 | hMaxAmpl->GetYaxis()->SetTitle( "counts" );
|
---|
819 | hMaxAmpl->SetStats(mStats);
|
---|
820 | hList->Add( hMaxAmpl );
|
---|
821 |
|
---|
822 | // Discarted Pulses Distributions
|
---|
823 | //----------------------------------
|
---|
824 | if (mVerbosityLevel > 3) cout << "\t...booking " << "hDiscartedPulses" << endl;
|
---|
825 | hDiscartedPulses=new TProfile(
|
---|
826 | "hDiscartedPulses",
|
---|
827 | "DiscartedPulses vs. preperation step",
|
---|
828 | 15 ,
|
---|
829 | -0.5,
|
---|
830 | 14.5 /*,
|
---|
831 | 100,
|
---|
832 | 0,
|
---|
833 | 1*/
|
---|
834 | );
|
---|
835 |
|
---|
836 | // hDiscartedPulses->SetAxisRange(
|
---|
837 | // 0,
|
---|
838 | // 50,
|
---|
839 | // "Y");
|
---|
840 | hDiscartedPulses->SetAxisRange(
|
---|
841 | -0.5,
|
---|
842 | 9.5,
|
---|
843 | "X");
|
---|
844 | hDiscartedPulses->SetDrawOption("colz");
|
---|
845 | hDiscartedPulses->GetXaxis()->SetTitle( "step [a.u.]" );
|
---|
846 | hDiscartedPulses->GetYaxis()->SetTitle( "# discartep pulses [a.u.]" );
|
---|
847 | //hDiscartedPulses->SetBit(TH2F::kCanRebin);
|
---|
848 | hDiscartedPulses->SetStats(mStats);
|
---|
849 | hList->Add( hDiscartedPulses );
|
---|
850 |
|
---|
851 | // Afterpulse Distributions
|
---|
852 | //----------------------------------
|
---|
853 | if (mVerbosityLevel > 3) cout << "\t...booking " << "hAfterPulses" << endl;
|
---|
854 | hAfterPulses=new TH2F(
|
---|
855 | "hAfterPulses",
|
---|
856 | "amplitude distribution of pulses after trigger pulse",
|
---|
857 | 1024 ,
|
---|
858 | 0,
|
---|
859 | 1024 ,
|
---|
860 | 10*70,
|
---|
861 | -9,
|
---|
862 | 60
|
---|
863 | );
|
---|
864 |
|
---|
865 | // hMaxOverlay[order]->SetAxisRange(
|
---|
866 | // mBSLMean - 5,
|
---|
867 | // (mGainMean*(order+1)) + 10,
|
---|
868 | // "Y");
|
---|
869 | hAfterPulses->SetDrawOption("colz");
|
---|
870 | hAfterPulses->GetXaxis()->SetTitle( "delay [sample/ 0.5 ns]" );
|
---|
871 | hAfterPulses->GetYaxis()->SetTitle( "amplitude [mV]" );
|
---|
872 | //hDiscartedPulses->SetBit(TH2F::kCanRebin);
|
---|
873 | hAfterPulses->SetStats(mStats);
|
---|
874 | hList->Add( hAfterPulses );
|
---|
875 |
|
---|
876 | }
|
---|
877 | }
|
---|
878 | //end of BookDistributionHistos
|
---|
879 | //----------------------------------------------------------------------------
|
---|
880 |
|
---|
881 | void
|
---|
882 | Pixel::BookTemplateHistos()
|
---|
883 | {
|
---|
884 | if (mVerbosityLevel > 2) cout << endl << "...book pixel histograms" << endl;
|
---|
885 | for (int order = 0; order < mMaxPulseOrder; order++)
|
---|
886 | {
|
---|
887 | if (mVerbosityLevel > 3)
|
---|
888 | {
|
---|
889 | cout << "\t...booking " << HistoName("hPixelMax", order) << endl;
|
---|
890 | }
|
---|
891 |
|
---|
892 | hPixelMax[order]=new TH1F(
|
---|
893 | HistoName("hPixelMax", order),
|
---|
894 | HistoTitle("Maximum value of each slice in overlay plot of", order),
|
---|
895 | mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
|
---|
896 | (-1*mPixelOverlayXaxisLeft)-0.5,
|
---|
897 | mPixelOverlayXaxisRight-0.5
|
---|
898 | );
|
---|
899 |
|
---|
900 | hPixelMax[order]->SetAxisRange(
|
---|
901 | mBSLMean - 5,
|
---|
902 | (mGainMean*(order+1)) + 10,
|
---|
903 | "Y");
|
---|
904 | hPixelMax[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
905 | hPixelMax[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
|
---|
906 | //hMaxProfile->SetBit(TH2F::kCanRebin);
|
---|
907 | hPixelMax[order]->SetStats(mStats);
|
---|
908 | hList->Add( hPixelMax[order] );
|
---|
909 |
|
---|
910 | //------------------------------------------------------------------------
|
---|
911 |
|
---|
912 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hPixelMean", order) << endl;
|
---|
913 | hPixelMean[order] = new TH1F(
|
---|
914 | HistoName("hPixelMean", order),
|
---|
915 | HistoTitle("Mean value of each slice in overlay plot of", order),
|
---|
916 | mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
|
---|
917 | (-1*mPixelOverlayXaxisLeft)-0.5,
|
---|
918 | mPixelOverlayXaxisRight-0.5
|
---|
919 | );
|
---|
920 | hPixelMean[order]->SetLineColor(kBlue);
|
---|
921 | hPixelMean[order]->SetAxisRange(
|
---|
922 | mBSLMean - 5,
|
---|
923 | (mGainMean*(order+1)) + 10,
|
---|
924 | "Y");
|
---|
925 | hPixelMean[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
926 | hPixelMean[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
|
---|
927 | hPixelMean[order]->SetStats(mStats);
|
---|
928 | hList->Add( hPixelMean[order] );
|
---|
929 |
|
---|
930 | //------------------------------------------------------------------------
|
---|
931 |
|
---|
932 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hPixelMedian", order) << endl;
|
---|
933 | hPixelMedian[order] = new TH1F(
|
---|
934 | HistoName("hPixelMedian", order),
|
---|
935 | HistoTitle("Median value of each slice in overlay plot of", order),
|
---|
936 | mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,//nbinsx
|
---|
937 | (-1*mPixelOverlayXaxisLeft)-0.5, //xlow
|
---|
938 | mPixelOverlayXaxisRight-0.5 //xup
|
---|
939 | );
|
---|
940 | hPixelMedian[order]->SetLineColor(kRed);
|
---|
941 | hPixelMedian[order]->SetAxisRange(
|
---|
942 | mBSLMean - 5,
|
---|
943 | (mGainMean*(order+1)) + 10,
|
---|
944 | "Y");
|
---|
945 | hPixelMedian[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
946 | hPixelMedian[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
|
---|
947 | //hMaxProfile->SetBit(TH2F::kCanRebin);
|
---|
948 | hPixelMedian[order]->SetStats(mStats);
|
---|
949 | hList->Add( hPixelMedian[order] );
|
---|
950 |
|
---|
951 | }
|
---|
952 | if (mVerbosityLevel > 2) cout << "...done" << endl;
|
---|
953 | }
|
---|
954 | //end of BookTemplateHistos
|
---|
955 | //----------------------------------------------------------------------------
|
---|
956 |
|
---|
957 | void
|
---|
958 | Pixel::BookEdgeTemplateHistos()
|
---|
959 | {
|
---|
960 | if (mVerbosityLevel > 2) cout << endl << "...book pixel histograms" << endl;
|
---|
961 | for (int order = 0; order < mMaxPulseOrder; order++)
|
---|
962 | {
|
---|
963 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hPixelEdgeMax", order) << endl;
|
---|
964 | hPixelEdgeMax[order]=new TH1F(
|
---|
965 | HistoName("hPixelEdgeMax", order),
|
---|
966 | HistoTitle("Maximum value of each slice in overlay plot of", order),
|
---|
967 | mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
|
---|
968 | (-1*mPixelOverlayXaxisLeft)-0.5,
|
---|
969 | mPixelOverlayXaxisRight-0.5
|
---|
970 | );
|
---|
971 |
|
---|
972 | hPixelEdgeMax[order]->SetAxisRange(
|
---|
973 | mBSLMean - 5,
|
---|
974 | (mGainMean*(order+1)) + 10,
|
---|
975 | "Y");
|
---|
976 | hPixelEdgeMax[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
977 | hPixelEdgeMax[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
|
---|
978 | //hMaxProfile->SetBit(TH2F::kCanRebin);
|
---|
979 | hPixelEdgeMax[order]->SetStats(mStats);
|
---|
980 | hList->Add( hPixelEdgeMax[order] );
|
---|
981 |
|
---|
982 | //------------------------------------------------------------------------
|
---|
983 |
|
---|
984 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hPixelEdgeMean", order) << endl;
|
---|
985 | hPixelEdgeMean[order] = new TH1F(
|
---|
986 | HistoName("hPixelEdgeMean", order),
|
---|
987 | HistoTitle("Mean value of each slice in overlay plot of", order),
|
---|
988 | mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
|
---|
989 | (-1*mPixelOverlayXaxisLeft)-0.5,
|
---|
990 | mPixelOverlayXaxisRight-0.5
|
---|
991 | );
|
---|
992 | hPixelEdgeMean[order]->SetLineColor(kBlue);
|
---|
993 | hPixelEdgeMean[order]->SetAxisRange(
|
---|
994 | mBSLMean - 5,
|
---|
995 | (mGainMean*(order+1)) + 10,
|
---|
996 | "Y");
|
---|
997 | hPixelEdgeMean[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
998 | hPixelEdgeMean[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
|
---|
999 | hPixelEdgeMean[order]->SetStats(mStats);
|
---|
1000 | hList->Add( hPixelEdgeMean[order] );
|
---|
1001 |
|
---|
1002 | //------------------------------------------------------------------------
|
---|
1003 |
|
---|
1004 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hPixelEdgeMedian", order) << endl;
|
---|
1005 | hPixelEdgeMedian[order] = new TH1F(
|
---|
1006 | HistoName("hPixelEdgeMedian", order),
|
---|
1007 | HistoTitle("Median value of each slice in overlay plot of", order),
|
---|
1008 | mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,//nbinsx
|
---|
1009 | (-1*mPixelOverlayXaxisLeft)-0.5, //xlow
|
---|
1010 | mPixelOverlayXaxisRight-0.5 //xup
|
---|
1011 | );
|
---|
1012 | hPixelEdgeMedian[order]->SetLineColor(kRed);
|
---|
1013 | hPixelEdgeMedian[order]->SetAxisRange(
|
---|
1014 | mBSLMean - 5,
|
---|
1015 | (mGainMean*(order+1)) + 10,
|
---|
1016 | "Y");
|
---|
1017 | hPixelEdgeMedian[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
1018 | hPixelEdgeMedian[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
|
---|
1019 | //hMaxProfile->SetBit(TH2F::kCanRebin);
|
---|
1020 | hPixelEdgeMedian[order]->SetStats(mStats);
|
---|
1021 | hList->Add( hPixelEdgeMedian[order] );
|
---|
1022 |
|
---|
1023 | }
|
---|
1024 | if (mVerbosityLevel > 2) cout << "...done" << endl;
|
---|
1025 | }
|
---|
1026 | //end of BookEdgeTemplateHistos
|
---|
1027 | //----------------------------------------------------------------------------
|
---|
1028 |
|
---|
1029 | void
|
---|
1030 | Pixel::LoadPulseHistos()
|
---|
1031 | {
|
---|
1032 | mRootFile->cd();
|
---|
1033 |
|
---|
1034 | if (mVerbosityLevel > 2)
|
---|
1035 | {
|
---|
1036 | if (mVerbosityLevel > 3)
|
---|
1037 | {
|
---|
1038 | mRootFile->ls();
|
---|
1039 | }
|
---|
1040 | cout << "loading current File: " ;
|
---|
1041 | gFile->pwd();
|
---|
1042 | }
|
---|
1043 |
|
---|
1044 | mRootFile->cd( CreateSubDirName( mChid ) ); //Go to pixel's subdirectory
|
---|
1045 | mDirectory = gDirectory;
|
---|
1046 |
|
---|
1047 | if (mVerbosityLevel > 2)
|
---|
1048 | {
|
---|
1049 | if (mVerbosityLevel > 3)
|
---|
1050 | {
|
---|
1051 | gDirectory->ls();
|
---|
1052 | }
|
---|
1053 | cout << "Current Directory: " ;
|
---|
1054 | gDirectory->pwd();
|
---|
1055 | }
|
---|
1056 |
|
---|
1057 |
|
---|
1058 | if (mVerbosityLevel > 2) cout << endl << "...load pixel histograms" << endl;
|
---|
1059 | for (int order = 0; order < mMaxPulseOrder; order++)
|
---|
1060 | {
|
---|
1061 |
|
---|
1062 | if (mVerbosityLevel > 3) cout << "\t...loading " << ChooseCycleNumber( HistoName("hMaxOverlay", order), 1) << endl;
|
---|
1063 | hMaxOverlay[order] = (TH2F*)mDirectory->Get( ChooseCycleNumber( HistoName("hMaxOverlay", order), 1) );
|
---|
1064 |
|
---|
1065 | if (mVerbosityLevel > 3) cout << "\t...loading " << HistoName("hEdgeOverlay", order) << endl;
|
---|
1066 | hEdgeOverlay[order] = (TH2F*)mDirectory->Get( ChooseCycleNumber( HistoName("hEdgeOverlay", order), 1) );
|
---|
1067 |
|
---|
1068 | if (mVerbosityLevel > 3) cout << "\t...loading " << HistoName("hMaxProfile", order) << endl;
|
---|
1069 | hMaxProfile[order] = (TProfile*)mDirectory->Get( ChooseCycleNumber( HistoName("hMaxProfile", order), 1) );
|
---|
1070 |
|
---|
1071 | if (mVerbosityLevel > 3) cout << "\t...loading " << HistoName("hEdgeProfile", order) << endl;
|
---|
1072 | hEdgeProfile[order] = (TProfile*)mDirectory->Get( ChooseCycleNumber( HistoName("hEdgeProfile", order), 1) );
|
---|
1073 |
|
---|
1074 |
|
---|
1075 | }
|
---|
1076 | // mPixelOverlayXaxisRight =70; ///TODO: get it from the root file
|
---|
1077 | // mPixelOverlayXaxisLeft =230; ///TODO: get it from the root file
|
---|
1078 | // mBSLMean =-2; ///TODO: get it from the root file
|
---|
1079 | // mGainMean =11; ///TODO: get it from the root file
|
---|
1080 | // mOptions ="SRM"; ///TODO: get it from the root file
|
---|
1081 |
|
---|
1082 | // mPixelOverlayXaxisRight = hEdgeOverlay[0]->GetXaxis()->GetBinLowEdge(
|
---|
1083 | // hEdgeOverlay[0]->GetXaxis()->GetFirst()
|
---|
1084 | // );
|
---|
1085 |
|
---|
1086 | // mPixelOverlayXaxisLeft = hEdgeOverlay[0]->GetXaxis()->GetBinUpEdge(
|
---|
1087 | // hEdgeOverlay[0]->GetXaxis()->GetLast()
|
---|
1088 | // );
|
---|
1089 |
|
---|
1090 | mPixelOverlayXaxisLeft = hEdgeOverlay[0]->GetBinCenter(
|
---|
1091 | hEdgeOverlay[0]->GetXaxis()->GetFirst()
|
---|
1092 | );
|
---|
1093 |
|
---|
1094 | mPixelOverlayXaxisLeft *= -1;
|
---|
1095 |
|
---|
1096 | mPixelOverlayXaxisRight = hEdgeOverlay[0]->GetBinCenter(
|
---|
1097 | hEdgeOverlay[0]->GetXaxis()->GetLast()
|
---|
1098 | );
|
---|
1099 |
|
---|
1100 | }
|
---|
1101 | // end of LoadPulseHistos
|
---|
1102 | //----------------------------------------------------------------------------
|
---|
1103 |
|
---|
1104 | void
|
---|
1105 | Pixel::DeletePixelHistos()
|
---|
1106 | {
|
---|
1107 | if (mVerbosityLevel > 2)
|
---|
1108 | {
|
---|
1109 | cout << endl
|
---|
1110 | << endl
|
---|
1111 | << "\t...delete current overlay histograms of Pixel# " << mChid;
|
---|
1112 | }
|
---|
1113 | for (int order = 0;
|
---|
1114 | order < mMaxPulseOrder;
|
---|
1115 | order ++)
|
---|
1116 | {
|
---|
1117 | if (mVerbosityLevel > 3)
|
---|
1118 | cout << endl << "\t\t...deleting hMaxOverlay"
|
---|
1119 | << mChid << "_" << order;
|
---|
1120 |
|
---|
1121 | delete hMaxOverlay[order];
|
---|
1122 | hMaxOverlay[order] = NULL;
|
---|
1123 |
|
---|
1124 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hEdgeOverlay"
|
---|
1125 | << mChid << "_" << order ;
|
---|
1126 | delete hEdgeOverlay[order];
|
---|
1127 | hEdgeOverlay[order] = NULL;
|
---|
1128 |
|
---|
1129 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hMaxProfile"
|
---|
1130 | << mChid << "_" << order ;
|
---|
1131 | delete hMaxProfile[order];
|
---|
1132 | hMaxProfile[order] = NULL;
|
---|
1133 |
|
---|
1134 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hMaxProfile2"
|
---|
1135 | << mChid << "_" << order ;
|
---|
1136 | delete hEdgeProfile[order];
|
---|
1137 | hEdgeProfile[order] = NULL;
|
---|
1138 | }
|
---|
1139 | if (mVerbosityLevel > 3) cout << endl << "\t...deleting histogram Arrays";
|
---|
1140 |
|
---|
1141 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hMaxOverlay";
|
---|
1142 | delete[] hMaxOverlay;
|
---|
1143 | hMaxOverlay = NULL;
|
---|
1144 |
|
---|
1145 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hEdgeOverlay";
|
---|
1146 | delete[] hEdgeOverlay;
|
---|
1147 | hEdgeOverlay = NULL;
|
---|
1148 |
|
---|
1149 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hMaxProfile";
|
---|
1150 | delete[] hMaxProfile;
|
---|
1151 | hMaxProfile = NULL;
|
---|
1152 |
|
---|
1153 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hEdgeProfile";
|
---|
1154 | delete[] hEdgeProfile;
|
---|
1155 | hEdgeProfile = NULL;
|
---|
1156 | }
|
---|
1157 | // end of DeletePixelHistos
|
---|
1158 | //----------------------------------------------------------------------------
|
---|
1159 |
|
---|
1160 | void
|
---|
1161 | Pixel::DeleteDistributionHistos()
|
---|
1162 | {
|
---|
1163 | if (mVerbosityLevel > 2)
|
---|
1164 | {
|
---|
1165 | cout << endl
|
---|
1166 | << "\t...delete current distribution histograms" ;
|
---|
1167 | }
|
---|
1168 |
|
---|
1169 | delete hMaxPos;
|
---|
1170 | delete hEdgePos;
|
---|
1171 | delete hEdgeSlope;
|
---|
1172 | delete hMaxEdgeSlope;
|
---|
1173 | delete hIntercept;
|
---|
1174 | delete hEdgeLength;
|
---|
1175 | delete hPulseLength;
|
---|
1176 | delete hPulseLengthAPcutoff;
|
---|
1177 | delete hPulseLengthTLcutoff;
|
---|
1178 | delete hMaxAmpl;
|
---|
1179 | delete hDiscartedPulses;
|
---|
1180 | delete hAfterPulses;
|
---|
1181 |
|
---|
1182 | for (int order = 0;
|
---|
1183 | order < mMaxPulseOrder;
|
---|
1184 | order ++)
|
---|
1185 | {
|
---|
1186 | if (mOptions.Contains("S"))
|
---|
1187 | {
|
---|
1188 | if (mVerbosityLevel > 3) cout << endl
|
---|
1189 | << "\t\t...deleting hSlopeRisingEdge"
|
---|
1190 | << mChid << "_" << order ;
|
---|
1191 | delete hSlopeRisingEdge[order];
|
---|
1192 | }
|
---|
1193 |
|
---|
1194 | if (mOptions.Contains("R"))
|
---|
1195 | {
|
---|
1196 | if (mVerbosityLevel > 3) cout << endl
|
---|
1197 | << "\t\t...deleting hRisingEdgeToMax"
|
---|
1198 | << mChid << "_" << order ;
|
---|
1199 | delete hRisingEdgeToMax[order];
|
---|
1200 | }
|
---|
1201 |
|
---|
1202 | if (mOptions.Contains("M"))
|
---|
1203 | {
|
---|
1204 | if (mVerbosityLevel > 3) cout << endl
|
---|
1205 | << "\t\t...deleting hPosOfMax"
|
---|
1206 | << mChid << "_" << order ;
|
---|
1207 |
|
---|
1208 | delete hPosOfMax[order];
|
---|
1209 | }
|
---|
1210 |
|
---|
1211 | }
|
---|
1212 | if (mVerbosityLevel > 3) cout << endl << "\t...deleting histogram Arrays";
|
---|
1213 |
|
---|
1214 | if (mOptions.Contains("S"))
|
---|
1215 | {
|
---|
1216 | if (mVerbosityLevel > 3)
|
---|
1217 | cout << endl << "\t\t...deleting hSlopeRisingEdge";
|
---|
1218 | delete[] hSlopeRisingEdge;
|
---|
1219 | hSlopeRisingEdge = NULL;
|
---|
1220 | }
|
---|
1221 |
|
---|
1222 | if (mOptions.Contains("R"))
|
---|
1223 | {
|
---|
1224 | if (mVerbosityLevel > 3)
|
---|
1225 | cout << endl << "\t\t...deleting hRisingEdgeToMax";
|
---|
1226 | delete[] hRisingEdgeToMax;
|
---|
1227 | hRisingEdgeToMax = NULL;
|
---|
1228 | }
|
---|
1229 |
|
---|
1230 | if (mOptions.Contains("M"))
|
---|
1231 | {
|
---|
1232 | if (mVerbosityLevel > 3)
|
---|
1233 | cout << endl << "\t\t...deleting hPosOfMax";
|
---|
1234 | delete[] hPosOfMax;
|
---|
1235 | hPosOfMax = NULL;
|
---|
1236 | }
|
---|
1237 | }
|
---|
1238 | // end of DeletePixelHistos
|
---|
1239 | //----------------------------------------------------------------------------
|
---|
1240 |
|
---|
1241 | void
|
---|
1242 | Pixel::DeleteTemplateHistos()
|
---|
1243 | {
|
---|
1244 | if (mVerbosityLevel > 2)
|
---|
1245 | {
|
---|
1246 | cout << endl
|
---|
1247 | << "\t...delete current template histograms of Pixel# " << mChid;
|
---|
1248 | }
|
---|
1249 | for (int order = 0;
|
---|
1250 | order < mMaxPulseOrder;
|
---|
1251 | order ++)
|
---|
1252 | {
|
---|
1253 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelMean"
|
---|
1254 | << mChid << "_" << order ;
|
---|
1255 | delete hPixelMean[order];
|
---|
1256 | hPixelMean[order] = NULL;
|
---|
1257 |
|
---|
1258 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelMedian"
|
---|
1259 | << mChid << "_" << order ;
|
---|
1260 | delete hPixelMedian[order];
|
---|
1261 | hPixelMedian[order] = NULL;
|
---|
1262 |
|
---|
1263 | if (mVerbosityLevel > 3)
|
---|
1264 | cout << endl << "\t\t...deleting hPixelMax"
|
---|
1265 | << mChid << "_" << order;
|
---|
1266 | delete hPixelMax[order];
|
---|
1267 | hPixelMax[order] = NULL;
|
---|
1268 |
|
---|
1269 | }
|
---|
1270 | if (mVerbosityLevel > 3) cout << endl << "\t...deleting histogram Arrays";
|
---|
1271 |
|
---|
1272 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelMax";
|
---|
1273 | delete[] hPixelMax;
|
---|
1274 | hPixelMax = NULL;
|
---|
1275 |
|
---|
1276 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelMedian";
|
---|
1277 | delete[] hPixelMedian;
|
---|
1278 | hPixelMedian = NULL;
|
---|
1279 |
|
---|
1280 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelMean";
|
---|
1281 | delete[] hPixelMean;
|
---|
1282 | hPixelMean = NULL;
|
---|
1283 | }
|
---|
1284 | // end of DeleteTemplateHistos
|
---|
1285 | //----------------------------------------------------------------------------
|
---|
1286 |
|
---|
1287 | void
|
---|
1288 | Pixel::DeleteEdgeTemplateHistos()
|
---|
1289 | {
|
---|
1290 | if (mVerbosityLevel > 2)
|
---|
1291 | {
|
---|
1292 | cout << endl
|
---|
1293 | << "\t...delete current Edge template histograms of Pixel# " << mChid;
|
---|
1294 | }
|
---|
1295 | for (int order = 0;
|
---|
1296 | order < mMaxPulseOrder;
|
---|
1297 | order ++)
|
---|
1298 | {
|
---|
1299 | if (mVerbosityLevel > 3)
|
---|
1300 | cout << endl << "\t\t...deleting hPixelEdgeMax"
|
---|
1301 | << mChid << "_" << order;
|
---|
1302 |
|
---|
1303 | delete hPixelEdgeMax[order];
|
---|
1304 | hPixelEdgeMax[order] = NULL;
|
---|
1305 |
|
---|
1306 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelEdgeMedian"
|
---|
1307 | << mChid << "_" << order ;
|
---|
1308 | delete hPixelEdgeMedian[order];
|
---|
1309 | hPixelEdgeMedian[order] = NULL;
|
---|
1310 |
|
---|
1311 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelEdgeMean"
|
---|
1312 | << mChid << "_" << order ;
|
---|
1313 | delete hPixelEdgeMean[order];
|
---|
1314 | hPixelEdgeMean[order] = NULL;
|
---|
1315 |
|
---|
1316 | }
|
---|
1317 | if (mVerbosityLevel > 3) cout << endl << "\t...deleting histogram Arrays";
|
---|
1318 |
|
---|
1319 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelEdgeMax";
|
---|
1320 | delete[] hPixelEdgeMax;
|
---|
1321 | hPixelEdgeMax = NULL;
|
---|
1322 |
|
---|
1323 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelEdgeMedian";
|
---|
1324 | delete[] hPixelEdgeMedian;
|
---|
1325 | hPixelEdgeMedian = NULL;
|
---|
1326 |
|
---|
1327 | if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelEdgeMean";
|
---|
1328 | delete[] hPixelEdgeMean;
|
---|
1329 | hPixelEdgeMean = NULL;
|
---|
1330 | }
|
---|
1331 | // end of DeleteTemplateHistos
|
---|
1332 | //----------------------------------------------------------------------------
|
---|
1333 |
|
---|
1334 | void
|
---|
1335 | Pixel::MakeTH1Pretty(
|
---|
1336 | TH1* histo,
|
---|
1337 | TString histName,
|
---|
1338 | TString histTitle,
|
---|
1339 | int order
|
---|
1340 | )
|
---|
1341 | {
|
---|
1342 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName(histName, order) << endl;
|
---|
1343 |
|
---|
1344 | histo->SetNameTitle(
|
---|
1345 | HistoName(histName, order),
|
---|
1346 | HistoTitle(histTitle, order)
|
---|
1347 | );
|
---|
1348 |
|
---|
1349 | histo->SetBins(
|
---|
1350 | mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
|
---|
1351 | (-1*mPixelOverlayXaxisLeft)-0.5,
|
---|
1352 | mPixelOverlayXaxisRight-0.5
|
---|
1353 | );
|
---|
1354 |
|
---|
1355 | histo->SetAxisRange(
|
---|
1356 | mBSLMean - 5,
|
---|
1357 | (mGainMean*(order+1)) + 10,
|
---|
1358 | "Y");
|
---|
1359 | histo->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
1360 | histo->GetYaxis()->SetTitle( "Amplitude [mV]" );
|
---|
1361 | //histo->SetBit(TH2F::kCanRebin);
|
---|
1362 | histo->SetStats(mStats);
|
---|
1363 | }
|
---|
1364 | // end of MakeTH2Pretty
|
---|
1365 | //----------------------------------------------------------------------------
|
---|
1366 |
|
---|
1367 |
|
---|
1368 | void
|
---|
1369 | Pixel::MakeTH2Pretty(
|
---|
1370 | TH2* histo,
|
---|
1371 | TString histName,
|
---|
1372 | TString histTitle,
|
---|
1373 | int order
|
---|
1374 | )
|
---|
1375 | {
|
---|
1376 | if (mVerbosityLevel > 3) cout << "\t...designing " << HistoName(histName, order) << endl;
|
---|
1377 |
|
---|
1378 | histo->SetNameTitle(
|
---|
1379 | HistoName(histName, order),
|
---|
1380 | HistoTitle(histTitle, order)
|
---|
1381 | );
|
---|
1382 |
|
---|
1383 | histo->SetBins(
|
---|
1384 | mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
|
---|
1385 | (-1*mPixelOverlayXaxisLeft)-0.5,
|
---|
1386 | mPixelOverlayXaxisRight-0.5 ,
|
---|
1387 | 512,
|
---|
1388 | -55.5,
|
---|
1389 | 200.5
|
---|
1390 | );
|
---|
1391 |
|
---|
1392 | histo->SetAxisRange(
|
---|
1393 | mBSLMean - 5,
|
---|
1394 | (mGainMean*(order+1)) + 10,
|
---|
1395 | "Y");
|
---|
1396 |
|
---|
1397 | histo->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
1398 | histo->GetYaxis()->SetTitle( "Amplitude [mV]" );
|
---|
1399 | //histo->SetBit(TH2F::kCanRebin);
|
---|
1400 | histo->SetStats(mStats);
|
---|
1401 | }
|
---|
1402 | // end of MakeTH2Pretty
|
---|
1403 | //----------------------------------------------------------------------------
|
---|
1404 |
|
---|
1405 | void
|
---|
1406 | Pixel::MakeTProfilePretty(
|
---|
1407 | TProfile* histo,
|
---|
1408 | TString histName,
|
---|
1409 | TString histTitle,
|
---|
1410 | int order
|
---|
1411 | )
|
---|
1412 | {
|
---|
1413 | if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName(histName, order) << endl;
|
---|
1414 |
|
---|
1415 | histo->SetNameTitle(
|
---|
1416 | HistoName(histName, order),
|
---|
1417 | HistoTitle(histTitle, order)
|
---|
1418 | );
|
---|
1419 |
|
---|
1420 | histo->SetBins(
|
---|
1421 | mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
|
---|
1422 | (-1*mPixelOverlayXaxisLeft)-0.5,
|
---|
1423 | mPixelOverlayXaxisRight-0.5
|
---|
1424 | );
|
---|
1425 | histo->SetOption( "s" );
|
---|
1426 |
|
---|
1427 | histo->SetAxisRange(
|
---|
1428 | mBSLMean - 5,
|
---|
1429 | (mGainMean*(order+1)) + 10,
|
---|
1430 | "Y");
|
---|
1431 |
|
---|
1432 | histo->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
|
---|
1433 | histo->GetYaxis()->SetTitle( "Amplitude [mV]" );
|
---|
1434 | //histo->SetBit(TH2F::kCanRebin);
|
---|
1435 | histo->SetStats(mStats);
|
---|
1436 | }
|
---|
1437 | // end of MakeTProfilePretty
|
---|
1438 | //----------------------------------------------------------------------------
|
---|
1439 |
|
---|
1440 |
|
---|
1441 | void
|
---|
1442 | Pixel::ShiftHistoInY(
|
---|
1443 | TH1* histo,
|
---|
1444 | float shift
|
---|
1445 | )
|
---|
1446 | {
|
---|
1447 | int min_bin = histo->GetXaxis()->GetFirst();
|
---|
1448 | int max_bin = histo->GetXaxis()->GetLast();
|
---|
1449 |
|
---|
1450 | for (int bin = min_bin; bin <= max_bin; bin++)
|
---|
1451 | {
|
---|
1452 | histo->AddBinContent( bin, shift);
|
---|
1453 | }
|
---|
1454 |
|
---|
1455 | }
|
---|
1456 |
|
---|
1457 | void
|
---|
1458 | Pixel::SetRangeUser(float xMin, float xMax, int order)
|
---|
1459 | {
|
---|
1460 | hMaxOverlay[order]->GetXaxis()->SetRangeUser(xMin, xMax);
|
---|
1461 | hEdgeOverlay[order]->GetXaxis()->SetRangeUser(xMin, xMax);
|
---|
1462 |
|
---|
1463 | hPixelMax[order]->GetXaxis()->SetRangeUser(xMin, xMax);
|
---|
1464 | hPixelMedian[order]->GetXaxis()->SetRangeUser(xMin, xMax);
|
---|
1465 | hPixelMean[order]->GetXaxis()->SetRangeUser(xMin, xMax);
|
---|
1466 |
|
---|
1467 | hPixelEdgeMax[order]->GetXaxis()->SetRangeUser(xMin, xMax);
|
---|
1468 | hPixelEdgeMedian[order]->GetXaxis()->SetRangeUser(xMin, xMax);
|
---|
1469 | hPixelEdgeMean[order]->GetXaxis()->SetRangeUser(xMin, xMax);
|
---|
1470 |
|
---|
1471 | return;
|
---|
1472 | }
|
---|
1473 |
|
---|
1474 | void
|
---|
1475 | Pixel::NormalizeSamplesTH2F(TH2F* histo)
|
---|
1476 | {
|
---|
1477 |
|
---|
1478 | int first = histo->GetXaxis()->GetFirst();
|
---|
1479 | int last = histo->GetXaxis()->GetLast();
|
---|
1480 |
|
---|
1481 | TH2F *hTemp = new TH2F(*histo);
|
---|
1482 | hTemp->Reset();
|
---|
1483 |
|
---|
1484 | for (int i = first; i < last; i++)
|
---|
1485 | {
|
---|
1486 | TH1* hTemp1D = histo->ProjectionY("_px1", i, i+1);
|
---|
1487 | double integral = hTemp1D->Integral();
|
---|
1488 | // double maximum = hTemp->GetBinContent(hTemp->GetMaximumBin());
|
---|
1489 | hTemp1D->Scale(1/integral);
|
---|
1490 | // hTemp->Scale(1/maximum);
|
---|
1491 | int first_sl = hTemp1D->GetXaxis()->GetFirst();
|
---|
1492 | int last_sl = hTemp1D->GetXaxis()->GetLast();
|
---|
1493 |
|
---|
1494 | for (int j = first_sl; j < last_sl; j++)
|
---|
1495 | {
|
---|
1496 | hTemp->SetBinContent(i, j, hTemp->GetBinContent(j));
|
---|
1497 | }
|
---|
1498 | }
|
---|
1499 |
|
---|
1500 | histo->Reset();
|
---|
1501 | histo->Add(hTemp);
|
---|
1502 |
|
---|
1503 | delete hTemp;
|
---|
1504 | return;
|
---|
1505 | }
|
---|
1506 |
|
---|
1507 | void
|
---|
1508 | Pixel::Normalize2Dhistos(int order)
|
---|
1509 | {
|
---|
1510 | NormalizeSamplesTH2F(hMaxOverlay[order]);
|
---|
1511 | NormalizeSamplesTH2F(hEdgeOverlay[order]);
|
---|
1512 | return;
|
---|
1513 | }
|
---|
1514 |
|
---|
1515 |
|
---|