Context Navigation

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

Visit:

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

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

Download in other formats: