Context Navigation

source: fact/tools/rootmacros/PulseTemplates/pixel.C@ 13646

Visit:

Last change on this file since 13646 was 13646, checked in by Jens Buss, 12 years ago
add constuctor for pixel without ID but name
File size: 32.0 KB

Line
1	#include <iostream>
2	#include "TObjArray.h"
3	#include "TCanvas.h"
4
5	#include "rootfilehandler.h"
6	#include "pixel.h" // class implemented
7	using namespace std;
8
9	/////////////////////////////// PUBLIC ///////////////////////////////////////
10
11	//============================= LIFECYCLE ====================================
12
13	Pixel::Pixel(
14	TString pixelname,
15	int maxPulsorder,
16	int verbosityLevel,
17	bool stats,
18	TFile* filename
19	)
20	{
21	mConstructorType = 1; //important for deletion 0 delete distribution 1 delete TemplateHistos
22	mChid = -1;
23	mName = pixelname;
24	mStats = stats;
25	mMaxPulseOrder = maxPulsorder;
26	mVerbosityLevel = verbosityLevel;
27	mRootFile = filename;
28
29	hMaxOverlay = new TH2F*[mMaxPulseOrder];
30	hEdgeOverlay = new TH2F*[mMaxPulseOrder];
31	hMaxProfile = new TProfile*[mMaxPulseOrder];
32	hEdgeProfile = new TProfile*[mMaxPulseOrder];
33
34	hPixelMax = new TH1F*[mMaxPulseOrder];
35	hPixelMedian = new TH1F*[mMaxPulseOrder];
36	hPixelMean = new TH1F*[mMaxPulseOrder];
37
38	hPixelEdgeMax = new TH1F*[mMaxPulseOrder];
39	hPixelEdgeMedian = new TH1F*[mMaxPulseOrder];
40	hPixelEdgeMean = new TH1F*[mMaxPulseOrder];
41
42	hList = new TObjArray;
43
44	BookPixelHistos();
45	BookTemplateHistos();
46	}
47
48	Pixel::Pixel(
49	int pixelID,
50	int maxPulsorder,
51	int verbosityLevel,
52	bool stats,
53	TFile* filename
54	)
55	{
56	mConstructorType = 1; //important for deletion 0 delete distribution 1 delete TemplateHistos
57	mChid = pixelID;
58	mStats = stats;
59	mMaxPulseOrder = maxPulsorder;
60	mVerbosityLevel = verbosityLevel;
61	mRootFile = filename;
62
63	hMaxOverlay = new TH2F*[mMaxPulseOrder];
64	hEdgeOverlay = new TH2F*[mMaxPulseOrder];
65	hMaxProfile = new TProfile*[mMaxPulseOrder];
66	hEdgeProfile = new TProfile*[mMaxPulseOrder];
67
68	hPixelMax = new TH1F*[mMaxPulseOrder];
69	hPixelMedian = new TH1F*[mMaxPulseOrder];
70	hPixelMean = new TH1F*[mMaxPulseOrder];
71
72	hPixelEdgeMax = new TH1F*[mMaxPulseOrder];
73	hPixelEdgeMedian = new TH1F*[mMaxPulseOrder];
74	hPixelEdgeMean = new TH1F*[mMaxPulseOrder];
75
76	hList = new TObjArray;
77
78	LoadPulseHistos( );
79	BookTemplateHistos();
80	}
81
82	Pixel::Pixel(
83	int pixelID,
84	int maxPulsorder,
85	int verbosityLevel,
86	bool stats,
87	TFile* filename,
88	int pixelOverlayXaxisLeft,
89	int pixelOverlayXaxisRight,
90	float bSLMean,
91	float gainMean,
92	TString options
93	)
94	{
95	mConstructorType = 0;
96	mChid = pixelID;
97	mStats = stats; ///TODO: HANDOVER THE VALUE
98	mMaxPulseOrder = maxPulsorder;
99	mVerbosityLevel = verbosityLevel;
100	mOptions = options;
101	mPixelOverlayXaxisLeft = pixelOverlayXaxisLeft;
102	mPixelOverlayXaxisRight = pixelOverlayXaxisRight;
103	mBSLMean = bSLMean;
104	mGainMean = gainMean;
105	mRootFile = filename;
106
107	hMaxOverlay = new TH2F*[mMaxPulseOrder];
108	hEdgeOverlay = new TH2F*[mMaxPulseOrder];
109	hMaxProfile = new TProfile*[mMaxPulseOrder];
110	hEdgeProfile = new TProfile*[mMaxPulseOrder];
111
112	if (mOptions.Contains("S") )
113	{
114	hSlopeRisingEdge = new TH1F*[mMaxPulseOrder];
115	}
116
117	if (mOptions.Contains("R") )
118	{
119	hRisingEdgeToMax = new TH1I*[mMaxPulseOrder];
120	}
121
122	if (mOptions.Contains("M") )
123	{
124	hPosOfMax = new TH1I*[mMaxPulseOrder];
125	}
126
127	hList = new TObjArray;
128
129	BookPixelHistos();
130	BookDistributionHistos();
131	}
132
133	Pixel::~Pixel()
134	{
135	if (mVerbosityLevel > 1) cout << endl << "...delete histograms of pixel " << mChid ;
136
137	DeletePixelHistos();
138	if (mConstructorType == 0)
139	{
140	DeleteDistributionHistos();
141	}
142
143	if (mConstructorType == 1)
144	{
145	DeleteTemplateHistos();
146	}
147	delete hList;
148	hList = NULL;
149
150	}// ~Pixel
151
152
153	//============================= OPERATORS ====================================
154
155	//XX&
156	//XX::operator=(const XX&);
157	//{
158	// return *this;
159
160	//}// =
161
162	//============================= OPERATIONS ===================================
163	void
164	Pixel::BookPixelHistos()
165	{
166	if (mVerbosityLevel > 2) cout << endl << "...book pixel histograms" << endl;
167	for (int order = 0; order < mMaxPulseOrder; order++)
168	{
169	if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hMaxOverlay", order) << endl;
170	hMaxOverlay[order]=new TH2F(
171	HistoName("hMaxOverlay", order),
172	HistoTitle("Overlay at peak maximum of detected pulses of", order),
173	mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
174	(-1*mPixelOverlayXaxisLeft)-0.5,
175	mPixelOverlayXaxisRight-0.5 ,
176	512,
177	-55.5,
178	200.5
179	);
180
181	hMaxOverlay[order]->SetAxisRange(
182	mBSLMean - 5,
183	(mGainMean*(order+1)) + 10,
184	"Y");
185	hMaxOverlay[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
186	hMaxOverlay[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
187	//hMaxProfile->SetBit(TH2F::kCanRebin);
188	hMaxOverlay[order]->SetStats(mStats);
189	hList->Add( hMaxOverlay[order] );
190
191	//------------------------------------------------------------------------
192
193	if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hEdgeOverlay", order) << endl;
194	hEdgeOverlay[order] = new TH2F(
195	HistoName("hEdgeOverlay", order),
196	HistoTitle("Overlay at rising edge of detected pulses of", order),
197	mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
198	(-1*mPixelOverlayXaxisLeft)-0.5,
199	mPixelOverlayXaxisRight-0.5 ,
200	512,
201	-55.5,
202	200.5
203	);
204
205	hEdgeOverlay[order]->SetAxisRange(
206	mBSLMean - 5,
207	(mGainMean*(order+1)) + 10,
208	"Y");
209	hEdgeOverlay[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
210	hEdgeOverlay[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
211	hEdgeOverlay[order]->SetStats(mStats);
212	hList->Add( hEdgeOverlay[order] );
213
214	//------------------------------------------------------------------------
215
216	if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hMaxProfile", order) << endl;
217	hMaxProfile[order] = new TProfile(
218	HistoName("hMaxProfile", order),
219	HistoTitle("Mean value of each slice in overlay plot (Tprofile)", order),
220	mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,//nbinsx
221	(-1*mPixelOverlayXaxisLeft)-0.5, //xlow
222	mPixelOverlayXaxisRight-0.5 , //xup
223	// 512, //nbinsy
224	-55.5, //ylow
225	300.5, //yup
226	"s"); //option
227	hMaxProfile[order]->SetAxisRange(
228	mBSLMean - 5,
229	(mGainMean*(order+1)) + 10,
230	"Y");
231	hMaxProfile[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
232	hMaxProfile[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
233	//hMaxProfile->SetBit(TH2F::kCanRebin);
234	hMaxProfile[order]->SetStats(mStats);
235	hList->Add( hMaxProfile[order] );
236
237
238	//------------------------------------------------------------------------
239
240	if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hEdgeProfile", order) << endl;
241	hEdgeProfile[order] = new TProfile(
242	HistoName("hEdgeProfile", order),
243	HistoTitle("Mean value of each slice in overlay plot (Tprofile)", order),
244	mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,//nbinsx
245	(-1*mPixelOverlayXaxisLeft)-0.5, //xlow
246	mPixelOverlayXaxisRight-0.5 , //xup
247	// 512, //nbinsy
248	-55.5, //ylow
249	300.5, //yup
250	"s"); //option
251	hEdgeProfile[order]->SetLineColor(kRed);
252	hEdgeProfile[order]->SetAxisRange(
253	mBSLMean - 5,
254	(mGainMean*(order+1)) + 10,
255	"Y");
256	hEdgeProfile[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
257	hEdgeProfile[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
258	//hMaxProfile->SetBit(TH2F::kCanRebin);
259	hEdgeProfile[order]->SetStats(mStats);
260	hList->Add( hEdgeProfile[order] );
261
262	}
263	if (mVerbosityLevel > 2) cout << "...done" << endl;
264	}
265	//end of BookPixelHistos
266	//----------------------------------------------------------------------------
267
268	void
269	Pixel::BookDistributionHistos( )
270	{
271	if (!mOptions.IsNull() )
272	{
273	int x_min = 0;
274	int x_max = 0;
275
276	for (int order =0; order < mMaxPulseOrder; order++)
277	{
278	if (mVerbosityLevel > 2) cout << endl
279	<< "...book distribution histograms"
280	<< endl;
281
282	if (mOptions.Contains("S"))
283	{
284	if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hSlopeRisingEdge", order) << endl;
285	hSlopeRisingEdge[order] = new TH1F (
286	HistoName("hSlopeRisingEdge", order),
287	HistoTitle("Distribution of rising edge's slope", order),
288	600,
289	-10.1,
290	10.1
291	);
292	hSlopeRisingEdge[order]->SetAxisRange(
293	-1,
294	7,
295	"X");
296	hSlopeRisingEdge[order]->GetXaxis()->SetTitle( "Slope Amplitude/time [mV/timeslices]" );
297	hSlopeRisingEdge[order]->GetYaxis()->SetTitle( "counts" );
298	hSlopeRisingEdge[order]->SetStats(mStats);
299	hList->Add( hSlopeRisingEdge[order] );
300	}
301
302	if (mOptions.Contains("R"))
303	{
304	x_min = -15;
305	x_max = 35;
306
307	if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hRisingEdgeToMax", order) << endl;
308	hRisingEdgeToMax[order] = new TH1I (
309	HistoName("hRisingEdgeToMax", order),
310	HistoTitle("Distribution of distance between rising edge and pulse's maximum", order),
311	x_max -x_min,
312	x_min,
313	x_max
314	);
315	hSlopeRisingEdge[order]->SetAxisRange(
316	-5,
317	25,
318	"X");
319	hRisingEdgeToMax[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
320	hRisingEdgeToMax[order]->GetYaxis()->SetTitle( "counts" );
321	hRisingEdgeToMax[order]->SetStats(mStats);
322	hList->Add( hRisingEdgeToMax[order] );
323	}
324
325	if (mOptions.Contains("M"))
326	{
327	x_min = 10;
328	x_max = 290;
329	if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hPosOfMax", order) << endl;
330	hPosOfMax[order] = new TH1I (
331	HistoName("hPosOfMax", order),
332	HistoTitle("Distribution of pulse's maximum's positon", order),
333	x_max - x_min,
334	x_min,
335	x_max
336	);
337	hPosOfMax[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
338	hPosOfMax[order]->GetYaxis()->SetTitle( "counts" );
339	hRisingEdgeToMax[order]->SetStats(mStats);
340	hList->Add( hPosOfMax[order] );
341	}
342
343	if (mVerbosityLevel > 2) cout << "...done" << endl;
344	}
345	}
346	}
347	//end of BookDistributionHistos
348	//----------------------------------------------------------------------------
349
350	void
351	Pixel::BookTemplateHistos()
352	{
353	if (mVerbosityLevel > 2) cout << endl << "...book pixel histograms" << endl;
354	for (int order = 0; order < mMaxPulseOrder; order++)
355	{
356	if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hPixelMax", order) << endl;
357	hPixelMax[order]=new TH1F(
358	HistoName("hPixelMax", order),
359	HistoTitle("Maximum value of each slice in overlay plot of", order),
360	mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
361	(-1*mPixelOverlayXaxisLeft)-0.5,
362	mPixelOverlayXaxisRight-0.5
363	);
364
365	hPixelMax[order]->SetAxisRange(
366	mBSLMean - 5,
367	(mGainMean*(order+1)) + 10,
368	"Y");
369	hPixelMax[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
370	hPixelMax[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
371	//hMaxProfile->SetBit(TH2F::kCanRebin);
372	hPixelMax[order]->SetStats(mStats);
373	hList->Add( hPixelMax[order] );
374
375	//------------------------------------------------------------------------
376
377	if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hPixelMean", order) << endl;
378	hPixelMean[order] = new TH1F(
379	HistoName("hPixelMean", order),
380	HistoTitle("Mean value of each slice in overlay plot of", order),
381	mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
382	(-1*mPixelOverlayXaxisLeft)-0.5,
383	mPixelOverlayXaxisRight-0.5
384	);
385	hPixelMean[order]->SetLineColor(kBlue);
386	hPixelMean[order]->SetAxisRange(
387	mBSLMean - 5,
388	(mGainMean*(order+1)) + 10,
389	"Y");
390	hPixelMean[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
391	hPixelMean[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
392	hPixelMean[order]->SetStats(mStats);
393	hList->Add( hPixelMean[order] );
394
395	//------------------------------------------------------------------------
396
397	if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hPixelMedian", order) << endl;
398	hPixelMedian[order] = new TH1F(
399	HistoName("hPixelMedian", order),
400	HistoTitle("Median value of each slice in overlay plot of", order),
401	mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,//nbinsx
402	(-1*mPixelOverlayXaxisLeft)-0.5, //xlow
403	mPixelOverlayXaxisRight-0.5 //xup
404	);
405	hPixelMedian[order]->SetLineColor(kRed);
406	hPixelMedian[order]->SetAxisRange(
407	mBSLMean - 5,
408	(mGainMean*(order+1)) + 10,
409	"Y");
410	hPixelMedian[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
411	hPixelMedian[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
412	//hMaxProfile->SetBit(TH2F::kCanRebin);
413	hPixelMedian[order]->SetStats(mStats);
414	hList->Add( hPixelMedian[order] );
415
416	}
417	if (mVerbosityLevel > 2) cout << "...done" << endl;
418	}
419	//end of BookTemplateHistos
420	//----------------------------------------------------------------------------
421
422	void
423	Pixel::BookEdgeTemplateHistos()
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("hPixelEdgeMax", order) << endl;
429	hPixelEdgeMax[order]=new TH1F(
430	HistoName("hPixelEdgeMax", order),
431	HistoTitle("Maximum value of each slice in overlay plot of", order),
432	mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
433	(-1*mPixelOverlayXaxisLeft)-0.5,
434	mPixelOverlayXaxisRight-0.5
435	);
436
437	hPixelEdgeMax[order]->SetAxisRange(
438	mBSLMean - 5,
439	(mGainMean*(order+1)) + 10,
440	"Y");
441	hPixelEdgeMax[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
442	hPixelEdgeMax[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
443	//hMaxProfile->SetBit(TH2F::kCanRebin);
444	hPixelEdgeMax[order]->SetStats(mStats);
445	hList->Add( hPixelEdgeMax[order] );
446
447	//------------------------------------------------------------------------
448
449	if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hPixelEdgeMean", order) << endl;
450	hPixelEdgeMean[order] = new TH1F(
451	HistoName("hPixelEdgeMean", order),
452	HistoTitle("Mean value of each slice in overlay plot of", order),
453	mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,
454	(-1*mPixelOverlayXaxisLeft)-0.5,
455	mPixelOverlayXaxisRight-0.5
456	);
457	hPixelEdgeMean[order]->SetLineColor(kBlue);
458	hPixelEdgeMean[order]->SetAxisRange(
459	mBSLMean - 5,
460	(mGainMean*(order+1)) + 10,
461	"Y");
462	hPixelEdgeMean[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
463	hPixelEdgeMean[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
464	hPixelEdgeMean[order]->SetStats(mStats);
465	hList->Add( hPixelEdgeMean[order] );
466
467	//------------------------------------------------------------------------
468
469	if (mVerbosityLevel > 3) cout << "\t...booking " << HistoName("hPixelEdgeMedian", order) << endl;
470	hPixelEdgeMedian[order] = new TH1F(
471	HistoName("hPixelEdgeMedian", order),
472	HistoTitle("Median value of each slice in overlay plot of", order),
473	mPixelOverlayXaxisLeft + mPixelOverlayXaxisRight ,//nbinsx
474	(-1*mPixelOverlayXaxisLeft)-0.5, //xlow
475	mPixelOverlayXaxisRight-0.5 //xup
476	);
477	hPixelEdgeMedian[order]->SetLineColor(kRed);
478	hPixelEdgeMedian[order]->SetAxisRange(
479	mBSLMean - 5,
480	(mGainMean*(order+1)) + 10,
481	"Y");
482	hPixelEdgeMedian[order]->GetXaxis()->SetTitle( "Timeslices [a.u.]" );
483	hPixelEdgeMedian[order]->GetYaxis()->SetTitle( "Amplitude [mV]" );
484	//hMaxProfile->SetBit(TH2F::kCanRebin);
485	hPixelEdgeMedian[order]->SetStats(mStats);
486	hList->Add( hPixelEdgeMedian[order] );
487
488	}
489	if (mVerbosityLevel > 2) cout << "...done" << endl;
490	}
491	//end of BookEdgeTemplateHistos
492	//----------------------------------------------------------------------------
493
494
495	void
496	Pixel::DrawOverlayHistograms(
497	TCanvas** pixelCanvas,
498	int* histoFrameNr
499	)
500	{
501	if (mVerbosityLevel > 2) cout << endl << "...drawing pulse histograms" ;
502	for (int pulse_order = 0; pulse_order < mMaxPulseOrder; pulse_order++)
503	{
504	pixelCanvas[pulse_order]->cd( histoFrameNr[0] );
505	hMaxOverlay[pulse_order]->Draw("COLZ");
506	pixelCanvas[pulse_order]->cd( histoFrameNr[2] );
507	hMaxProfile[pulse_order]->Draw();
508	hEdgeProfile[pulse_order]->Draw("SAME");
509
510	pixelCanvas[pulse_order]->cd( histoFrameNr[1] );
511	hEdgeOverlay[pulse_order]->Draw("COLZ");
512	}
513	}
514	// end of DrawOverlayHistograms
515	//----------------------------------------------------------------------------
516
517	void
518	Pixel::DrawDistributionHistograms(
519	TCanvas** pixelCanvas,
520	int* histoFrameNr
521	)
522	{
523	if (mVerbosityLevel > 2) cout << endl << "...drawing distribution histograms" ;
524	bool nothing_to_fill = true;
525	for (int pulse_order = 0; pulse_order < mMaxPulseOrder; pulse_order++)
526	{
527	if (mOptions.Contains("S") )
528	{
529	pixelCanvas[pulse_order]->cd( histoFrameNr[0] );
530	hSlopeRisingEdge[pulse_order]->Draw();
531	nothing_to_fill = false;
532	}
533
534	if (mOptions.Contains("R") )
535	{
536	pixelCanvas[pulse_order]->cd( histoFrameNr[1] );
537	hRisingEdgeToMax[pulse_order]->Draw();
538	nothing_to_fill = false;
539	}
540
541	if (mOptions.Contains("M") )
542	{
543	pixelCanvas[pulse_order]->cd( histoFrameNr[2] );
544	hPosOfMax[pulse_order]->Draw();
545	nothing_to_fill = false;
546	}
547
548	}
549	if (nothing_to_fill)
550	{
551	cout << endl << "there were NO DISTRIBUTION HISTOGRAMS to fill" << endl;
552	}
553	}
554	// end of DrawDistributionHistograms
555	//----------------------------------------------------------------------------
556
557	void
558	Pixel::DrawTemplateHistograms(
559	TCanvas** pixelCanvas,
560	int* histoFrameNr
561	)
562	{
563	if (mVerbosityLevel > 2) cout << endl << "...drawing Template histograms" ;
564	for (int pulse_order = 0; pulse_order < mMaxPulseOrder; pulse_order++)
565	{
566	pixelCanvas[pulse_order]->cd( histoFrameNr[0] );
567	hPixelMax[pulse_order]->Draw();
568
569	pixelCanvas[pulse_order]->cd( histoFrameNr[1] );
570	hPixelMedian[pulse_order]->Draw();
571
572	pixelCanvas[pulse_order]->cd( histoFrameNr[2] );
573	hPixelMean[pulse_order]->Draw();
574
575	}
576	}
577	// end of DrawTemplateHistograms
578	//----------------------------------------------------------------------------
579
580	void
581	Pixel::DrawEdgeTemplateHistograms(
582	TCanvas** pixelCanvas,
583	int* histoFrameNr
584	)
585	{
586	if (mVerbosityLevel > 2) cout << endl << "...drawing Template histograms" ;
587	for (int pulse_order = 0; pulse_order < mMaxPulseOrder; pulse_order++)
588	{
589	pixelCanvas[pulse_order]->cd( histoFrameNr[0] );
590	hPixelEdgeMax[pulse_order]->Draw();
591
592	pixelCanvas[pulse_order]->cd( histoFrameNr[1] );
593	hPixelEdgeMedian[pulse_order]->Draw();
594
595	pixelCanvas[pulse_order]->cd( histoFrameNr[2] );
596	hPixelEdgeMean[pulse_order]->Draw();
597
598	}
599	}
600	// end of DrawTemplateHistograms
601	//----------------------------------------------------------------------------
602
603	void
604	Pixel::DeletePixelHistos()
605	{
606	if (mVerbosityLevel > 2)
607	{
608	cout << endl
609	<< "\t...delete current overlay histograms of Pixel# " << mChid;
610	}
611	for (int order = 0;
612	order < mMaxPulseOrder;
613	order ++)
614	{
615	if (mVerbosityLevel > 3)
616	cout << endl << "\t\t...deleting hMaxOverlay"
617	<< mChid << "_" << order
618	<< " hMaxOverlay[order] adr " << hMaxOverlay[order]
619	<< " hMaxOverlay adr " << hMaxOverlay
620	;
621
622	delete hMaxOverlay[order];
623	hMaxOverlay[order] = NULL;
624
625	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hEdgeOverlay"
626	<< mChid << "_" << order ;
627	delete hEdgeOverlay[order];
628	hEdgeOverlay[order] = NULL;
629
630	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hMaxProfile"
631	<< mChid << "_" << order ;
632	delete hMaxProfile[order];
633	hMaxProfile[order] = NULL;
634
635	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hMaxProfile2"
636	<< mChid << "_" << order ;
637	delete hEdgeProfile[order];
638	hEdgeProfile[order] = NULL;
639	}
640	if (mVerbosityLevel > 3) cout << endl << "\t...deleting histogram Arrays";
641
642	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hMaxOverlay";
643	delete[] hMaxOverlay;
644	hMaxOverlay = NULL;
645
646	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hEdgeOverlay";
647	delete[] hEdgeOverlay;
648	hEdgeOverlay = NULL;
649
650	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hMaxProfile";
651	delete[] hMaxProfile;
652	hMaxProfile = NULL;
653
654	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hEdgeProfile";
655	delete[] hEdgeProfile;
656	hEdgeProfile = NULL;
657	}
658	// end of DeletePixelHistos
659	//----------------------------------------------------------------------------
660
661	void
662	Pixel::DeleteDistributionHistos()
663	{
664	if (mVerbosityLevel > 2)
665	{
666	cout << endl
667	<< "\t...delete current distribution histograms" ;
668	}
669
670	for (int order = 0;
671	order < mMaxPulseOrder;
672	order ++)
673	{
674	if (mOptions.Contains("S"))
675	{
676	if (mVerbosityLevel > 3) cout << endl
677	<< "\t\t...deleting hSlopeRisingEdge"
678	<< mChid << "_" << order ;
679	delete hSlopeRisingEdge[order];
680	}
681
682	if (mOptions.Contains("R"))
683	{
684	if (mVerbosityLevel > 3) cout << endl
685	<< "\t\t...deleting hRisingEdgeToMax"
686	<< mChid << "_" << order ;
687	delete hRisingEdgeToMax[order];
688	}
689
690	if (mOptions.Contains("M"))
691	{
692	if (mVerbosityLevel > 3) cout << endl
693	<< "\t\t...deleting hPosOfMax"
694	<< mChid << "_" << order ;
695
696	delete hPosOfMax[order];
697	}
698
699	}
700	if (mVerbosityLevel > 3) cout << endl << "\t...deleting histogram Arrays";
701
702	if (mOptions.Contains("S"))
703	{
704	if (mVerbosityLevel > 3)
705	cout << endl << "\t\t...deleting hSlopeRisingEdge";
706	delete[] hSlopeRisingEdge;
707	hSlopeRisingEdge = NULL;
708	}
709
710	if (mOptions.Contains("R"))
711	{
712	if (mVerbosityLevel > 3)
713	cout << endl << "\t\t...deleting hRisingEdgeToMax";
714	delete[] hRisingEdgeToMax;
715	hRisingEdgeToMax = NULL;
716	}
717
718	if (mOptions.Contains("M"))
719	{
720	if (mVerbosityLevel > 3)
721	cout << endl << "\t\t...deleting hPosOfMax";
722	delete[] hPosOfMax;
723	hPosOfMax = NULL;
724	}
725	}
726	// end of DeletePixelHistos
727	//----------------------------------------------------------------------------
728
729	void
730	Pixel::DeleteTemplateHistos()
731	{
732	if (mVerbosityLevel > 2)
733	{
734	cout << endl
735	<< "\t...delete current template histograms of Pixel# " << mChid;
736	}
737	for (int order = 0;
738	order < mMaxPulseOrder;
739	order ++)
740	{
741	if (mVerbosityLevel > 3)
742	cout << endl << "\t\t...deleting hPixelMax"
743	<< mChid << "_" << order
744	<< " hPixelMax[order] adr " << hPixelMax[order]
745	<< " hPixelMax adr " << hPixelMax
746	;
747
748	delete hPixelMax[order];
749	hPixelMax[order] = NULL;
750
751	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelMedian"
752	<< mChid << "_" << order ;
753	delete hPixelMedian[order];
754	hPixelMedian[order] = NULL;
755
756	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelMean"
757	<< mChid << "_" << order ;
758	delete hPixelMean[order];
759	hPixelMean[order] = NULL;
760
761	}
762	if (mVerbosityLevel > 3) cout << endl << "\t...deleting histogram Arrays";
763
764	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelMax";
765	delete[] hPixelMax;
766	hPixelMax = NULL;
767
768	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelMedian";
769	delete[] hPixelMedian;
770	hPixelMedian = NULL;
771
772	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelMean";
773	delete[] hPixelMean;
774	hPixelMean = NULL;
775	}
776	// end of DeleteTemplateHistos
777	//----------------------------------------------------------------------------
778
779	void
780	Pixel::DeleteEdgeTemplateHistos()
781	{
782	if (mVerbosityLevel > 2)
783	{
784	cout << endl
785	<< "\t...delete current template histograms of Pixel# " << mChid;
786	}
787	for (int order = 0;
788	order < mMaxPulseOrder;
789	order ++)
790	{
791	if (mVerbosityLevel > 3)
792	cout << endl << "\t\t...deleting hPixelEdgeMax"
793	<< mChid << "_" << order
794	<< " hPixelEdgeMax[order] adr " << hPixelEdgeMax[order]
795	<< " hPixelEdgeMax adr " << hPixelEdgeMax
796	;
797
798	delete hPixelEdgeMax[order];
799	hPixelEdgeMax[order] = NULL;
800
801	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelEdgeMedian"
802	<< mChid << "_" << order ;
803	delete hPixelEdgeMedian[order];
804	hPixelEdgeMedian[order] = NULL;
805
806	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelEdgeMean"
807	<< mChid << "_" << order ;
808	delete hPixelEdgeMean[order];
809	hPixelEdgeMean[order] = NULL;
810
811	}
812	if (mVerbosityLevel > 3) cout << endl << "\t...deleting histogram Arrays";
813
814	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelEdgeMax";
815	delete[] hPixelEdgeMax;
816	hPixelEdgeMax = NULL;
817
818	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelEdgeMedian";
819	delete[] hPixelEdgeMedian;
820	hPixelEdgeMedian = NULL;
821
822	if (mVerbosityLevel > 3) cout << endl << "\t\t...deleting hPixelEdgeMean";
823	delete[] hPixelEdgeMean;
824	hPixelEdgeMean = NULL;
825	}
826	// end of DeleteTemplateHistos
827	//----------------------------------------------------------------------------
828
829	void
830	Pixel::SavePixelHistograms(
831	TString outRootFileName,
832	bool saveResults
833	)
834	{
835	if (mVerbosityLevel > 2) cout << endl << "Saving histograms of Pixel# " << mChid;
836	if (!saveResults) return;
837	SaveHistograms(
838	outRootFileName,
839	CreateSubDirName( mChid ),
840	hList,
841	saveResults,
842	mVerbosityLevel
843	);
844	}
845	// end of SavePixelHistograms
846	//----------------------------------------------------------------------------
847
848	void
849	Pixel::LoadPulseHistos()
850	{
851	mRootFile->cd();
852	mRootFile->cd(CreateSubDirName( mChid ));
853	for (int order = 0; order < mMaxPulseOrder; order++)
854	{
855	hMaxOverlay[order] = (TH2F*)mRootFile->Get( HistoName("hMaxOverlay", order) );
856	hEdgeOverlay[order] = (TH2F*)mRootFile->Get( HistoName("hEdgeOverlay", order) );
857	hMaxProfile[order] = (TProfile*)mRootFile->Get( HistoName("hMaxProfile", order) );
858	hEdgeProfile[order] = (TProfile*)mRootFile->Get( HistoName("hEdgeProfile", order) );
859	}
860	}
861	// end of LoadPulseHistos
862	//----------------------------------------------------------------------------
863
864	TString
865	Pixel::HistoName(
866	TString histoname,
867	int order
868	)
869	{
870	histoname += mChid;
871	histoname += "_";
872	histoname += order;
873	return histoname;
874	}
875
876	TString
877	Pixel::HistoTitle(
878	TString histo_title,
879	int order
880	)
881	{
882	histo_title += " [Pixel_Order] ";
883	histo_title += mChid;
884	histo_title += "_";
885	histo_title += order;
886	return histo_title;
887	}
888
889	TString
890	Pixel::CsvFileName(
891	TString path,
892	TString overlayMethod,
893	int order
894	)
895	{
896	path += "CSV/";
897	path += overlayMethod;
898	path += "OverlayTemplate";
899	path += "_";
900	path += mChid;
901	path += "_";
902	path += order;
903	path += ".csv";
904	return path;
905	}
906
907
908	//============================= ACESS ===================================
909	//============================= INQUIRY ===================================
910	/////////////////////////////// PROTECTED ///////////////////////////////////
911
912	/////////////////////////////// PRIVATE ///////////////////////////////////
913
914
915
916
917
918
919
920

Note: See TracBrowser for help on using the repository browser.

Download in other formats: