Context Navigation

source: trunk/MagicSoft/Mars/mjobs/MJCalibration.cc@ 7922

Visit:

Last change on this file since 7922 was 7898, checked in by tbretz, 19 years ago
* empty log message *
File size: 69.2 KB

Line
1	/* ======================================================================== *\
2	!
3	! *
4	! * This file is part of MARS, the MAGIC Analysis and Reconstruction
5	! * Software. It is distributed to you in the hope that it can be a useful
6	! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
7	! * It is distributed WITHOUT ANY WARRANTY.
8	! *
9	! * Permission to use, copy, modify and distribute this software and its
10	! * documentation for any purpose is hereby granted without fee,
11	! * provided that the above copyright notice appear in all copies and
12	! * that both that copyright notice and this permission notice appear
13	! * in supporting documentation. It is provided "as is" without express
14	! * or implied warranty.
15	! *
16	!
17	!
18	! Author(s): Thomas Bretz, 1/2004 <mailto:tbretz@astro.uni-wuerzburg.de>
19	! Author(s): Markus Gaug, 02/2004 <mailto:markus@ifae.es>
20	!
21	! Copyright: MAGIC Software Development, 2000-2005
22	!
23	!
24	\* ======================================================================== */
25
26	/////////////////////////////////////////////////////////////////////////////
27	//
28	// MJCalibration
29	//
30	// Do one calibration loop over serious of runs with the same pulser
31	// colour and the same intensity. The following containers (rectangular) and
32	// tasks (ellipses) are called to produce an MCalibrationChargeCam and to
33	// update the MCalibrationQECam: (MCalibrate is not called from this class)
34	//
35	//Begin_Html
36	/*
37	<img src="images/CalibClasses.gif">
38	*/
39	//End_Html
40	//
41	// Different signal extractors can be set with the command SetExtractor()
42	// Only extractors deriving from MExtractor can be set, default is MExtractSlidingWindow
43	//
44	// Different arrival time extractors can be set with the command SetTimeExtractor()
45	// Only extractors deriving from MExtractTime can be set, default is MExtractTimeHighestIntegral
46	//
47	// At the end of the eventloop, plots and results are displayed, depending on
48	// the flags set (see DisplayResult())
49	//
50	// If the flag SetFullDisplay() is set, all MHCameras will be displayed.
51	// if the flag SetDataCheckDisplay() is set, only the most important ones are displayed
52	// Otherwise, (default: SetNormalDisplay()), a good selection of plots is given
53	//
54	// The absolute light calibration devices Blind Pixel and PIN Diode can be switched on
55	// and off with the commands:
56	//
57	// - SetUseBlindPixel(Bool_t )
58	// - SetUsePINDiode(Bool_t )
59	//
60	// See also: MHCalibrationChargePix, MHCalibrationChargeCam, MHGausEvents
61	// MHCalibrationChargeBlindPix, MHCalibrationChargePINDiode
62	// MCalibrationChargePix, MCalibrationChargeCam, MCalibrationChargeCalc
63	// MCalibrationBlindPix, MCalibrationChargePINDiode,
64	// MCalibrationQECam, MBadPixelsPix, MBadPixelsCam
65	//
66	// If the flag RelTimeCalibration() is set, a calibration of the relative arrival
67	// times is also performed. The following containers (rectangular) and
68	// tasks (ellipses) are called to produce an MCalibrationRelTimeCam used by
69	// MCalibrateTime to correct timing offset between pixels: (MCalibrateTime is not
70	// called from this class)
71	//
72	//Begin_Html
73	/*
74	<img src="images/RelTimeClasses.gif">
75	*/
76	//End_Html
77	//
78	// Different arrival time extractors can be set directly with the command
79	// SetTimeExtractor(MExtractor *)
80	//
81	// Resource file entries are case sensitive!
82	//
83	// See also: MHCalibrationRelTimePix, MHCalibrationRelTimeCam, MHGausEvents
84	// MCalibrationRelTimePix, MCalibrationRelTimeCam
85	// MBadPixelsPix, MBadPixelsCam
86	//
87	/////////////////////////////////////////////////////////////////////////////
88	#include "MJCalibration.h"
89
90	#include <TFile.h>
91	#include <TF1.h>
92	#include <TStyle.h>
93	#include <TCanvas.h>
94	#include <TSystem.h>
95	#include <TLine.h>
96	#include <TLatex.h>
97	#include <TLegend.h>
98	#include <TRegexp.h>
99	#include <TPaveText.h>
100	#include <TPaveStats.h>
101	#include <TEnv.h>
102
103	#include "MLog.h"
104	#include "MLogManip.h"
105
106	#include "MRunIter.h"
107	#include "MSequence.h"
108	#include "MParList.h"
109	#include "MTaskList.h"
110	#include "MEvtLoop.h"
111
112	#include "MHCamera.h"
113	#include "MGeomCam.h"
114
115	#include "MPedestalCam.h"
116	#include "MCalibColorSteer.h"
117
118	#include "MCalibrationIntensityChargeCam.h"
119	#include "MCalibrationIntensityBlindCam.h"
120	#include "MCalibrationIntensityRelTimeCam.h"
121	#include "MCalibrationIntensityQECam.h"
122
123	#include "MCalibrationPatternDecode.h"
124	#include "MCalibrationCam.h"
125	#include "MCalibrationHiLoCam.h"
126	#include "MCalibrationHiLoPix.h"
127	#include "MCalibrationQECam.h"
128	#include "MCalibrationQEPix.h"
129	#include "MCalibrationChargeCam.h"
130	#include "MCalibrationChargePix.h"
131	#include "MCalibrationChargePINDiode.h"
132	#include "MCalibrationBlindPix.h"
133	#include "MCalibrationBlindCam.h"
134	#include "MCalibrationBlindCamOneOldStyle.h"
135	#include "MCalibrationBlindCamTwoNewStyle.h"
136	#include "MCalibrationBlindCamThreeNewStyle.h"
137	#include "MCalibrationChargeCalc.h"
138	#include "MCalibColorSet.h"
139	#include "MCalibrationRelTimeCam.h"
140	#include "MCalibrationRelTimeCalc.h"
141
142	#include "MHGausEvents.h"
143	#include "MHCalibrationCam.h"
144	#include "MHCalibrationChargeCam.h"
145	#include "MHCalibrationChargeBlindCam.h"
146	#include "MHCalibrationChargePINDiode.h"
147	#include "MHCalibrationRelTimeCam.h"
148	#include "MHCalibrationPix.h"
149
150	#include "MReadMarsFile.h"
151	#include "MPedCalcPedRun.h"
152	#include "MRawFileRead.h"
153	#include "MGeomApply.h"
154	#include "MTaskEnv.h"
155	#include "MBadPixelsMerge.h"
156	#include "MBadPixelsCam.h"
157	#include "MExtractTime.h"
158	#include "MExtractor.h"
159	#include "MExtractPINDiode.h"
160	#include "MExtractBlindPixel.h"
161	//#include "MExtractSlidingWindow.h"
162	//#include "MExtractTimeHighestIntegral.h"
163	#include "MExtractTimeAndChargeSpline.h"
164	#include "MFCosmics.h"
165	#include "MFTriggerPattern.h"
166	#include "MContinue.h"
167	#include "MFillH.h"
168
169	#include "MTriggerPatternDecode.h"
170
171	#include "MArrivalTimeCam.h"
172
173	#include "MStatusDisplay.h"
174
175	ClassImp(MJCalibration);
176
177	using namespace std;
178
179	const Int_t MJCalibration::gkIFAEBoxInaugurationRun = 20113;
180	const Int_t MJCalibration::gkSecondBlindPixelInstallation = 31693;
181	const Int_t MJCalibration::gkSpecialPixelsContInstallation = 34057;
182	const Int_t MJCalibration::gkThirdBlindPixelInstallation = 43308;
183	const TString MJCalibration::fgReferenceFile = "mjobs/calibrationref.rc";
184	const TString MJCalibration::fgHiLoCalibFile = "mjobs/hilocalib_df46.root";
185
186	// --------------------------------------------------------------------------
187	//
188	// Default constructor.
189	//
190	// - fExtractor to NULL, fTimeExtractor to NULL, fColor to kNONE,
191	// fDisplay to kNormalDisplay, kRelTimes to kFALSE, kataCheck to kFALSE, kDebug to kFALSE,
192	// kIntensity to kFALSE
193	// - SetUseBlindPixel()
194	// - SetUsePINDiode()
195	//
196	MJCalibration::MJCalibration(const char name, const char title)
197	: fExtractor(NULL), fTimeExtractor(NULL),
198	fColor(MCalibrationCam::kNONE), fDisplayType(kDataCheckDisplay),
199	fGeometry("MGeomCamMagic")
200	{
201
202	fName = name ? name : "MJCalibration";
203	fTitle = title ? title : "Tool to create the calibration constants for one calibration run";
204
205	SetHiLoCalibration();
206	SetRelTimeCalibration();
207	SetDebug(kFALSE);
208	SetIntensity(kFALSE);
209
210	SetReferenceFile();
211	SetHiLoCalibFile();
212
213	fConvFADC2PheMin = 0.;
214	fConvFADC2PheMax = 1.5;
215	fConvFADC2PhotMin = 0.;
216	fConvFADC2PhotMax = 10.;
217	fQEMin = 0.;
218	fQEMax = 0.3;
219	fArrivalTimeMin = 1.;
220	fArrivalTimeMax = 10.;
221	fTimeOffsetMin = -3.;
222	fTimeOffsetMax = 3.;
223	fTimeResolutionMin = 0.;
224	fTimeResolutionMax = 1.;
225
226	fRefFADC2PheInner = 0.14;
227	fRefFADC2PheOuter = 0.4;
228	fRefConvFADC2PheInner = 0.14;
229	fRefConvFADC2PheOuter = 0.52;
230	fRefQEInner = 0.18;
231	fRefQEOuter = 0.12;
232	fRefArrivalTimeInner = 4.5;
233	fRefArrivalTimeOuter = 5.0;
234	fRefArrivalTimeRmsInner = 0.5;
235	fRefArrivalTimeRmsOuter = 0.5;
236	fRefTimeOffsetInner = -0.23;
237	fRefTimeOffsetOuter = 0.39;
238	fRefTimeResolutionInner = 0.153;
239	fRefTimeResolutionOuter = 0.128;
240
241	}
242
243	void MJCalibration::DrawTab(MParList &plist, const char cont, const char name, Option_t *opt)
244	{
245	TObject *obj = plist.FindObject(cont);
246	if (!obj)
247	return;
248
249	fDisplay->AddTab(name);
250	obj->DrawClone(opt);
251	}
252
253	// --------------------------------------------------------------------------
254	//
255	// Display the results in MStatusDisplay:
256	//
257	// - Add "Calibration" to the MStatusDisplay title
258	// - Retrieve the MGeomCam from MParList
259	// - Initialize the following MHCamera's:
260	// 1) MCalibrationPix::GetMean()
261	// 2) MCalibrationPix::Sigma()
262	// 3) MCalibrationChargePix::GetRSigma()
263	// 4) MCalibrationChargePix::GetRSigmaPerCharge()
264	// 5) MCalibrationChargePix::GetPheFFactorMethod()
265	// 6) MCalibrationChargePix::GetMeanConvFADC2Phe()
266	// 7) MCalibrationChargePix::GetMeanFFactorFADC2Phot()
267	// 8) MCalibrationQEPix::GetQECascadesFFactor()
268	// 9) MCalibrationQEPix::GetQECascadesBlindPixel()
269	// 10) MCalibrationQEPix::GetQECascadesPINDiode()
270	// 11) MCalibrationQEPix::GetQECascadesCombined()
271	// 12) MCalibrationQEPix::IsAverageQEFFactorAvailable()
272	// 13) MCalibrationQEPix::IsAverageQEBlindPixelAvailable()
273	// 14) MCalibrationQEPix::IsAverageQEPINDiodeAvailable()
274	// 15) MCalibrationQEPix::IsAverageQECombinedAvailable()
275	// 16) MCalibrationChargePix::IsHiGainSaturation()
276	// 17) MCalibrationPix::GetHiLoMeansDivided()
277	// 18) MCalibrationPix::GetHiLoSigmasDivided()
278	// 19) MCalibrationChargePix::GetHiGainPickup()
279	// 20) MCalibrationChargePix::GetLoGainPickup()
280	// 21) MCalibrationChargePix::GetHiGainBlackout()
281	// 22) MCalibrationChargePix::GetLoGainBlackout()
282	// 23) MCalibrationPix::IsExcluded()
283	// 24) MBadPixelsPix::IsUnsuitable(MBadPixelsPix::kUnsuitableRun)
284	// 25) MBadPixelsPix::IsUnsuitable(MBadPixelsPix::kUnreliableRun)
285	// 26) MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kHiGainOscillating)
286	// 27) MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kLoGainOscillating)
287	// 28) MCalibrationChargePix::GetAbsTimeMean()
288	// 29) MCalibrationChargePix::GetAbsTimeRms()
289	//
290	// If the flag SetFullDisplay() is set, all MHCameras will be displayed.
291	// if the flag SetDataCheckDisplay() is set, only the most important ones are displayed
292	// and otherwise, (default: SetNormalDisplay()), a good selection of plots is given
293	//
294	void MJCalibration::DisplayResult(MParList &plist)
295	{
296	if (!fDisplay)
297	return;
298
299	TString drawoption = "nonew ";
300	if (fDisplayType == kDataCheckDisplay)
301	drawoption += "datacheck";
302	if (fDisplayType == kFullDisplay)
303	drawoption += "all";
304
305	if (IsUsePINDiode())
306	DrawTab(plist, "MHCalibrationChargePINDiode", "PINDiode", drawoption);
307	if (IsUseBlindPixel())
308	DrawTab(plist, "MHCalibrationChargeBlindCam", "BlindPix", drawoption);
309	if (IsRelTimes())
310	DrawTab(plist, "MHCalibrationRelTimeCam", "Time", drawoption);
311	DrawTab(plist, "MHCalibrationChargeCam", "Charge", drawoption);
312
313	//
314	// Update display
315	//
316	TString title = fDisplay->GetTitle();
317	title += "-- Calibration ";
318	title += Form("calib%08d", fSequence.GetSequence());
319	title += " --";
320	fDisplay->SetTitle(title);
321
322	//
323	// Get container from list
324	//
325	MGeomCam &geomcam = (MGeomCam)plist.FindObject("MGeomCam");
326
327	// Create histograms to display
328	MHCamera disp1 (geomcam, "Charge", "Fitted Mean Signal (Charges)");
329	MHCamera disp2 (geomcam, "SigmaCharge", "Sigma of Fitted Signal");
330	MHCamera disp3 (geomcam, "RSigma", "Reduced Sigmas");
331	MHCamera disp4 (geomcam, "RSigmaPerCharge", "Reduced Sigma per Charge");
332	MHCamera disp5 (geomcam, "NumPhes", "Number Photo-electrons");
333	MHCamera disp6 (geomcam, "ConvFADC2Phes", "Phes per Charge (Before Flat-Field)");
334	MHCamera disp7 (geomcam, "TotalFFactor", "Total F-Factor(F-Factor Method)");
335	MHCamera disp8 (geomcam, "CascadesQEFFactor", "Cascades QE (F-Factor Method)");
336	MHCamera disp9 (geomcam, "CascadesQEBlindPix","Cascades QE (Blind Pixel Method)");
337	MHCamera disp10(geomcam, "CascadesQEPINDiode","Cascades QE (PIN Diode Method)");
338	MHCamera disp11(geomcam, "CascadesQECombined","Cascades QE (Combined Method)");
339	MHCamera disp12(geomcam, "FFactorValid", "Pixels with Valid F-Factor Calibration");
340	MHCamera disp13(geomcam, "BlindPixelValid", "Pixels with valid BlindPixel Calibration");
341	MHCamera disp14(geomcam, "PINdiodeValid", "Pixels with Valid PINDiode Calibration");
342	MHCamera disp15(geomcam, "CombinedValid", "Pixels with Valid Combined Calibration");
343	MHCamera disp16(geomcam, "Saturation", "Pixels with Saturated Hi Gain");
344	MHCamera disp17(geomcam, "ConversionMeans", "Conversion HiGain.vs.LoGain Means");
345	MHCamera disp18(geomcam, "ConversionSigmas", "Conversion HiGain.vs.LoGain Sigmas");
346	MHCamera disp19(geomcam, "HiGainPickup", "Number Pickup Events Hi Gain");
347	MHCamera disp20(geomcam, "LoGainPickup", "Number Pickup Events Lo Gain");
348	MHCamera disp21(geomcam, "HiGainBlackout", "Number Blackout Events Hi Gain");
349	MHCamera disp22(geomcam, "LoGainBlackout", "Number Blackout Events Lo Gain");
350	MHCamera disp23(geomcam, "Excluded", "Pixels Previously Excluded");
351	MHCamera disp24(geomcam, "UnSuitable", "Pixels NOT Suited for Further Analysis");
352	MHCamera disp25(geomcam, "UnReliable", "Pixels Suitable, but NOT Reliable for Further Analysis");
353	MHCamera disp26(geomcam, "HiGainOscillating", "Oscillating Pixels High Gain");
354	MHCamera disp27(geomcam, "LoGainOscillating", "Oscillating Pixels Low Gain");
355	MHCamera disp28(geomcam, "AbsTimeMean", "Abs. Arrival Times");
356	MHCamera disp29(geomcam, "AbsTimeRms", "RMS of Arrival Times");
357	MHCamera disp30(geomcam, "MeanTime", "Mean Rel. Arrival Times");
358	MHCamera disp31(geomcam, "SigmaTime", "Sigma Rel. Arrival Times");
359	MHCamera disp32(geomcam, "TimeProb", "Probability of Time Fit");
360	MHCamera disp33(geomcam, "TimeNotFitValid", "Pixels with not valid Fit Results");
361	MHCamera disp34(geomcam, "TimeOscillating", "Oscillating Pixels");
362	MHCamera disp35(geomcam, "TotalConv", "Conversion Factor to Photons");
363	MHCamera disp36(geomcam, "RMSperMean", "Charge histogram RMS per Mean");
364	MHCamera disp37(geomcam, "TotalConvPhe", "Conversion Factor to equiv. Phe's");
365
366	MCalibrationChargeCam *cam = NULL;
367	MCalibrationQECam *qecam = NULL;
368	MCalibrationRelTimeCam *relcam = NULL;
369	MBadPixelsCam *badcam = NULL;
370
371	if (IsIntensity())
372	{
373	cam = (MCalibrationChargeCam*) fIntensCalibCam.GetCam();
374	qecam = (MCalibrationQECam*) fIntensQECam.GetCam();
375	relcam = (MCalibrationRelTimeCam*)fIntensRelTimeCam.GetCam();
376	badcam = (MBadPixelsCam*) fIntensBadCam.GetCam();
377	}
378	else
379	{
380	cam = &fCalibrationCam;
381	qecam = &fQECam;
382	relcam = &fRelTimeCam;
383	badcam = &fBadPixels;
384	}
385
386	// Fitted charge means and sigmas
387	disp1.SetCamContent(*cam, 0);
388	disp1.SetCamError( *cam, 1);
389	disp2.SetCamContent(*cam, 2);
390	disp2.SetCamError( *cam, 3);
391
392	// Reduced Sigmas and reduced sigmas per charge
393	disp3.SetCamContent(*cam, 5);
394	disp3.SetCamError( *cam, 6);
395	disp4.SetCamContent(*cam, 7);
396	disp4.SetCamError( *cam, 8);
397
398	// F-Factor Method
399	disp5.SetCamContent(*cam, 9);
400	disp5.SetCamError( *cam, 10);
401	disp6.SetCamContent(*cam, 11);
402	disp6.SetCamError( *cam, 12);
403	disp7.SetCamContent(*cam, 13);
404	disp7.SetCamError( *cam, 14);
405
406	// Quantum Efficiencies
407	disp8.SetCamContent (*qecam, 0 );
408	disp8.SetCamError (*qecam, 1 );
409	disp9.SetCamContent (*qecam, 2 );
410	disp9.SetCamError (*qecam, 3 );
411	disp10.SetCamContent(*qecam, 4 );
412	disp10.SetCamError (*qecam, 5 );
413	disp11.SetCamContent(*qecam, 6 );
414	disp11.SetCamError (*qecam, 7 );
415
416	// Valid flags
417	disp12.SetCamContent(*qecam, 8 );
418	disp13.SetCamContent(*qecam, 9 );
419	disp14.SetCamContent(*qecam, 10);
420	disp15.SetCamContent(*qecam, 11);
421
422	// Conversion Hi-Lo
423	disp16.SetCamContent(*cam, 25);
424	disp17.SetCamContent(*cam, 16);
425	disp17.SetCamError (*cam, 17);
426	disp18.SetCamContent(*cam, 18);
427	disp18.SetCamError (*cam, 19);
428
429	// Pickup and Blackout
430	disp19.SetCamContent(*cam, 21);
431	disp20.SetCamContent(*cam, 22);
432	disp21.SetCamContent(*cam, 23);
433	disp22.SetCamContent(*cam, 24);
434
435	// Pixels with defects
436	disp23.SetCamContent(*cam, 20);
437	disp24.SetCamContent(*badcam, 6);
438	disp25.SetCamContent(*badcam, 7);
439
440	// Oscillations
441	disp26.SetCamContent(*badcam, 10);
442	disp27.SetCamContent(*badcam, 11);
443
444	// Arrival Times
445	disp28.SetCamContent(*cam, 26);
446	disp28.SetCamError( *cam, 27);
447	disp29.SetCamContent(*cam, 27);
448
449	// RMS and Mean
450	disp36.SetCamContent(*cam,32);
451	disp36.SetCamError(*cam,33);
452
453	disp1.SetYTitle("Q [FADC cnts]");
454	disp2.SetYTitle("\\sigma_{Q} [FADC cnts]");
455
456	disp3.SetYTitle("\\sqrt{\\sigma^{2}_{Q} - RMS^{2}_{Ped}} [FADC cnts]");
457	disp4.SetYTitle("Red.Sigma/<Q> [1]");
458
459	disp5.SetYTitle("Photo-electons [1]");
460	disp6.SetYTitle("Phes/<Q> [FADC cnts^{-1}]");
461	disp7.SetYTitle("Total F-Factor [1]");
462
463	disp8.SetYTitle("QE [1]");
464	disp9.SetYTitle("QE [1]");
465	disp10.SetYTitle("QE [1]");
466	disp11.SetYTitle("QE [1]");
467
468	disp12.SetYTitle("[1]");
469	disp13.SetYTitle("[1]");
470	disp14.SetYTitle("[1]");
471	disp15.SetYTitle("[1]");
472	disp16.SetYTitle("[1]");
473
474	disp17.SetYTitle("<Q>(High)/<Q>(Low) [1]");
475	disp18.SetYTitle("\\sigma_{Q}(High)/\\sigma_{Q}(Low) [1]");
476
477	disp19.SetYTitle("[1]");
478	disp20.SetYTitle("[1]");
479	disp21.SetYTitle("[1]");
480	disp22.SetYTitle("[1]");
481	// disp23.SetYTitle("[1]");
482	// disp24.SetYTitle("[1]");
483	// disp25.SetYTitle("[1]");
484	disp26.SetYTitle("[1]");
485	disp27.SetYTitle("[1]");
486
487	disp28.SetYTitle("Mean Abs. Time [FADC sl.]");
488	disp29.SetYTitle("RMS Abs. Time [FADC sl.]");
489	disp35.SetYTitle("Conv.Factor [Ph/FADC cnts]");
490	disp36.SetYTitle("Charge RMS/<Q> [1]");
491	disp37.SetYTitle("Conv.Factor [Phe/FADC cnts]");
492
493	for (UInt_t i=0;i<geomcam.GetNumPixels();i++)
494	{
495
496	MCalibrationChargePix &pix = (MCalibrationChargePix&)(*cam) [i];
497	MCalibrationQEPix &qe = (MCalibrationQEPix&) (*qecam)[i];
498
499	if (!pix.IsFFactorMethodValid())
500	continue;
501
502	const Float_t convphe = pix.GetMeanConvFADC2Phe();
503	const Float_t quaeff = qe.GetQECascadesFFactor();
504
505	disp35.Fill(i,convphe/quaeff);
506	disp35.SetUsed(i);
507
508	disp37.Fill(i,convphe/quaeff*MCalibrationQEPix::gkDefaultAverageQE);
509	disp37.SetUsed(i);
510	}
511
512
513	if (IsRelTimes())
514	{
515	disp30.SetCamContent(*relcam,0);
516	disp30.SetCamError( *relcam,1);
517	disp31.SetCamContent(*relcam,2);
518	disp31.SetCamError( *relcam,3);
519	disp32.SetCamContent(*relcam,4);
520	disp33.SetCamContent(fBadPixels,20);
521	disp34.SetCamContent(fBadPixels,21);
522
523	disp30.SetYTitle("Time Offset [FADC units]");
524	disp31.SetYTitle("Timing resolution [FADC units]");
525	disp32.SetYTitle("P_{Time} [1]");
526	disp33.SetYTitle("[1]");
527	disp34.SetYTitle("[1]");
528	}
529
530	if (fDisplayType == kDataCheckDisplay)
531	{
532
533	TCanvas &c1 = fDisplay->AddTab("FitCharge");
534	c1.Divide(3, 3);
535
536	//
537	// MEAN CHARGES
538	//
539
540	c1.cd(1);
541	gPad->SetBorderMode(0);
542	gPad->SetTicks();
543	MHCamera obj1=(MHCamera)disp1.DrawCopy("hist");
544	//
545	// for the datacheck, fix the ranges!!
546	//
547	// obj1->SetMinimum(fChargeMin);
548	// obj1->SetMaximum(fChargeMax);
549	//
550	// Set the datacheck sizes:
551	//
552	FixDataCheckHist((TH1D*)obj1);
553	obj1->SetStats(kFALSE);
554	//
555	// set reference lines
556	//
557	// DisplayReferenceLines(obj1,0);
558
559	c1.cd(4);
560	gPad->SetBorderMode(0);
561	obj1->SetPrettyPalette();
562	obj1->Draw();
563
564	c1.cd(7);
565	gPad->SetBorderMode(0);
566	gPad->SetTicks();
567	TH1D obj2 = (TH1D)obj1->Projection(obj1->GetName());
568	obj2->Draw();
569	obj2->SetBit(kCanDelete);
570	obj2->Fit("gaus","Q");
571	TF1 *fun2 = obj2->GetFunction("gaus");
572	fun2->SetLineColor(kYellow);
573	gPad->Modified();
574	gPad->Update();
575	TPaveStats st = (TPaveStats)obj2->GetListOfFunctions()->FindObject("stats");
576	st->SetY1NDC(0.55);
577	st->SetY2NDC(0.89);
578	st->SetX1NDC(0.65);
579	st->SetX2NDC(0.99);
580	gPad->Modified();
581	gPad->Update();
582	//
583	// Set the datacheck sizes:
584	//
585	FixDataCheckHist(obj2);
586	obj2->SetStats(1);
587
588	//
589	// Display the outliers as dead and noisy pixels
590	//
591	DisplayOutliers(obj2,"low-ampl.","high-ampl.");
592	TLatex flattex;
593	flattex.SetTextSize(0.07);
594	const Double_t minl = obj2->GetBinCenter(obj2->GetXaxis()->GetFirst());
595	const Double_t maxl = obj2->GetBinCenter(obj2->GetXaxis()->GetLast());
596	flattex.DrawLatex(minl+0.015*(maxl-minl),obj2->GetBinContent(obj2->GetMaximumBin())/1.35,
597	Form("Flatfield precision: %4.2f%%",
598	fun2->GetParameter(2)/fun2->GetParameter(1)*100.));
599
600	//
601	// RMS per Charge
602	//
603
604	c1.cd(2);
605	gPad->SetBorderMode(0);
606	gPad->SetTicks();
607	MHCamera obj3=(MHCamera)disp36.DrawCopy("hist");
608	//
609	// for the datacheck, fix the ranges!!
610	//
611	// obj3->SetMinimum(0.);
612	// obj3->SetMaximum(fChargeMax);
613	//
614	// Set the datacheck sizes:
615	//
616	FixDataCheckHist((TH1D*)obj3);
617	obj3->SetStats(kFALSE);
618	//
619	// set reference lines
620	//
621	// DisplayReferenceLines(obj3,0);
622
623	c1.cd(5);
624	gPad->SetBorderMode(0);
625	obj3->SetPrettyPalette();
626	obj3->Draw();
627
628	c1.cd(8);
629	gPad->SetBorderMode(0);
630	if (geomcam.InheritsFrom("MGeomCamMagic"))
631	DisplayDoubleProject(&disp36, "dead", "noisy");
632
633	//
634	// PHOTO ELECTRONS
635	//
636
637	c1.cd(3);
638	gPad->SetBorderMode(0);
639	gPad->SetTicks();
640	MHCamera obj4=(MHCamera)disp5.DrawCopy("hist");
641	//
642	// for the datacheck, fix the ranges!!
643	//
644	// obj3->SetMinimum(fChargeMin);
645	// obj3->SetMaximum(fChargeMax);
646	//
647	// Set the datacheck sizes:
648	//
649	FixDataCheckHist((TH1D*)obj4);
650	obj4->SetStats(kFALSE);
651	//
652	// set reference lines
653	//
654	// DisplayReferenceLines(obj3,0);
655
656	c1.cd(6);
657	gPad->SetBorderMode(0);
658	obj4->SetPrettyPalette();
659	obj4->Draw();
660
661	c1.cd(9);
662	gPad->SetBorderMode(0);
663	if (geomcam.InheritsFrom("MGeomCamMagic"))
664	DisplayDoubleProject(&disp5, "dead", "noisy");
665
666	//
667	// CONVERSION FACTORS
668	//
669	TCanvas &c2 = fDisplay->AddTab("Conversion");
670	c2.Divide(3,3);
671
672	c2.cd(1);
673	gPad->SetBorderMode(0);
674	gPad->SetTicks();
675	MHCamera obj5=(MHCamera)disp6.DrawCopy("hist");
676	//
677	// for the datacheck, fix the ranges!!
678	//
679	obj5->SetMinimum(fConvFADC2PheMin);
680	obj5->SetMaximum(fConvFADC2PheMax);
681	//
682	// Set the datacheck sizes:
683	//
684	FixDataCheckHist((TH1D*)obj5);
685	obj5->SetStats(kFALSE);
686	//
687	// set reference lines
688	//
689	DisplayReferenceLines(obj5,2);
690
691	c2.cd(4);
692	gPad->SetBorderMode(0);
693	obj5->SetPrettyPalette();
694	obj5->Draw();
695
696	c2.cd(7);
697	gPad->SetBorderMode(0);
698	if (geomcam.InheritsFrom("MGeomCamMagic"))
699	DisplayDoubleProject(&disp6, "noisy", "dead");
700
701	//
702	// QUANTUM EFFICIENCY
703	//
704	c2.cd(2);
705	gPad->SetBorderMode(0);
706	gPad->SetTicks();
707	MHCamera obj6=(MHCamera)disp8.DrawCopy("hist");
708	//
709	// for the datacheck, fix the ranges!!
710	//
711	obj6->SetMinimum(fQEMin);
712	obj6->SetMaximum(fQEMax);
713	//
714	// Set the datacheck sizes:
715	//
716	FixDataCheckHist((TH1D*)obj6);
717	obj6->SetStats(kFALSE);
718	//
719	// set reference lines
720	//
721	DisplayReferenceLines(obj6,0);
722
723	c2.cd(5);
724	gPad->SetBorderMode(0);
725	obj6->SetPrettyPalette();
726	obj6->Draw();
727
728	c2.cd(8);
729	gPad->SetBorderMode(0);
730	if (geomcam.InheritsFrom("MGeomCamMagic"))
731	DisplayDoubleProject(&disp8, "noisy", "dead");
732
733	//
734	// CONVERSION FADC TO PHOTONS
735	//
736
737	c2.cd(3);
738	gPad->SetBorderMode(0);
739	gPad->SetTicks();
740	MHCamera obj7=(MHCamera)disp37.DrawCopy("hist");
741	//
742	// for the datacheck, fix the ranges!!
743	//
744	obj7->SetMinimum(fConvFADC2PheMin);
745	obj7->SetMaximum(fConvFADC2PheMax);
746	//
747	// Set the datacheck sizes:
748	//
749	FixDataCheckHist((TH1D*)obj7);
750	obj7->SetStats(kFALSE);
751	//
752	// set reference lines
753	//
754	DisplayReferenceLines(obj7,1);
755
756	c2.cd(6);
757	gPad->SetBorderMode(0);
758	obj7->SetPrettyPalette();
759	obj7->Draw();
760	c2.cd(9);
761	gPad->SetBorderMode(0);
762	if (geomcam.InheritsFrom("MGeomCamMagic"))
763	DisplayDoubleProject(&disp37, "noisy", "dead");
764
765	//
766	// ARRIVAL TIMES
767	//
768	TCanvas &c3 = fDisplay->AddTab("AbsTimes");
769	c3.Divide(2,3);
770
771	c3.cd(1);
772	gPad->SetBorderMode(0);
773	gPad->SetTicks();
774	MHCamera obj10=(MHCamera)disp28.DrawCopy("hist");
775	//
776	// for the datacheck, fix the ranges!!
777	//
778	obj10->SetMinimum(fArrivalTimeMin);
779	obj10->SetMaximum(fArrivalTimeMax);
780	//
781	// Set the datacheck sizes:
782	//
783	FixDataCheckHist((TH1D*)obj10);
784	obj10->SetStats(kFALSE);
785	//
786	// set reference lines
787	//
788	DisplayReferenceLines(obj10,3);
789
790	c3.cd(3);
791	gPad->SetBorderMode(0);
792	obj10->SetPrettyPalette();
793	obj10->Draw();
794
795	c3.cd(5);
796	gPad->SetBorderMode(0);
797	if (geomcam.InheritsFrom("MGeomCamMagic"))
798	DisplayDoubleProject(&disp28, "early", "late");
799
800	//
801	// ARRIVAL TIMES JITTER
802	//
803	c3.cd(2);
804	gPad->SetBorderMode(0);
805	gPad->SetTicks();
806	MHCamera obj11=(MHCamera)disp29.DrawCopy("hist");
807	//
808	// for the datacheck, fix the ranges!!
809	//
810	// obj11->SetMinimum(fArrivalTimeMin);
811	// obj11->SetMaximum(fArrivalTimeMax);
812	//
813	// Set the datacheck sizes:
814	//
815	FixDataCheckHist((TH1D*)obj11);
816	obj11->SetStats(kFALSE);
817	//
818	// set reference lines
819	//
820	DisplayReferenceLines(obj11,4);
821
822	c3.cd(4);
823	gPad->SetBorderMode(0);
824	obj11->SetPrettyPalette();
825	obj11->Draw();
826
827	c3.cd(6);
828	gPad->SetBorderMode(0);
829	if (geomcam.InheritsFrom("MGeomCamMagic"))
830	DisplayDoubleProject(&disp29, "", "jittering");
831
832	//
833	// UNSUITABLE PIXELS
834	//
835	TCanvas &c4 = fDisplay->AddTab("Defect");
836	c4.Divide(2,2);
837
838	c4.cd(1);
839	gPad->SetBorderMode(0);
840	gPad->SetTicks();
841	MHCamera obj8=(MHCamera)disp24.DrawCopy("hist");
842	//
843	// for the datacheck, fix the ranges!!
844	//
845	const Double_t max = 10.;
846	obj8->SetMinimum(0.);
847	obj8->SetMaximum(max);
848	//
849	// Set the datacheck sizes:
850	//
851	FixDataCheckHist((TH1D*)obj8);
852	obj8->SetStats(kFALSE);
853
854	gStyle->SetPalette(1);
855	const Int_t numcol = gStyle->GetNumberOfColors()-3;
856
857	TPaveText *pave = new TPaveText(0.0,0.0,0.99,0.99);
858	pave->SetBit(kCanDelete);
859	pave->ConvertNDCtoPad();
860	pave->SetTextSize(0.045);
861	pave->AddText(" ");
862	TText *t1 = pave->AddText(Form("Signal smaller 4.5 Pedestal RMS: %3i pixels",
863	CountBadPixels(&disp24,1)));
864	t1->SetTextColor(gStyle->GetColorPalette(Int_t(1./max*numcol)));
865	t1->SetTextAlign(12);
866	TText *t4 = pave->AddText(Form("Low Gain Saturation: %3i pixels",
867	CountBadPixels(&disp24,2)));
868	t4->SetTextColor(gStyle->GetColorPalette(Int_t(2./max*numcol)));
869	t4->SetTextAlign(12);
870	TText *t5 = pave->AddText(Form("Mean Arr. Time In First Extraction Bin: %3i pixels",
871	CountBadPixels(&disp24,3)));
872	t5->SetTextColor(gStyle->GetColorPalette(Int_t(3./max*numcol)));
873	t5->SetTextAlign(12);
874	TText *t6 = pave->AddText(Form("Mean Arr. Time In Last 2 Extraction Bins: %3i pixels",
875	CountBadPixels(&disp24,4)));
876	t6->SetTextColor(gStyle->GetColorPalette(Int_t(4./max*numcol)));
877	t6->SetTextAlign(12);
878	TText *t10= pave->AddText(Form("High-Gain Histogram Overflow: %3i pixels",
879	CountBadPixels(&disp24,5 )));
880	t10->SetTextColor(gStyle->GetColorPalette(Int_t(5./max*numcol)));
881	t10->SetTextAlign(12);
882	TText *t11= pave->AddText(Form("Low-Gain Histogram Overflow: %3i pixels",
883	CountBadPixels(&disp24,6 )));
884	t11->SetTextColor(gStyle->GetColorPalette(Int_t(6./max*numcol)));
885	t11->SetTextAlign(12);
886	TText *t12= pave->AddText(Form("Presumably dead from Ped. Rms: %3i pixels",
887	CountBadPixels(&disp24,7 )));
888	t12->SetTextColor(gStyle->GetColorPalette(Int_t(7./max*numcol)));
889	t12->SetTextAlign(12);
890	TText *t13= pave->AddText(Form("Fluctuating Pulse Arrival Times: %3i pixels",
891	CountBadPixels(&disp24,8 )));
892	t13->SetTextColor(gStyle->GetColorPalette(Int_t(8./max*numcol)));
893	t13->SetTextAlign(12);
894	TText *t17 = pave->AddText(Form("Deviating Number of Photo-electrons: %3i pixels",
895	CountBadPixels(&disp24,9 )));
896	t17->SetTextColor(gStyle->GetColorPalette(Int_t(9./max*numcol)));
897	t17->SetTextAlign(12);
898	TText *t15= pave->AddText(Form("Too many Low-Gain Blackout Events: %3i pixels",
899	CountBadPixels(&disp24,10 )));
900	t15->SetTextColor(gStyle->GetColorPalette(Int_t(10./max*numcol)));
901	t15->SetTextAlign(12);
902	TText *t14= pave->AddText(Form("Previously Excluded: %3i pixels",
903	CountBadPixels(&disp24,11)));
904	t14->SetTextColor(gStyle->GetColorPalette(Int_t(11./max*numcol)));
905	t14->SetTextAlign(12);
906	pave->Draw();
907
908	c4.cd(3);
909	gPad->SetBorderMode(0);
910	obj8->Draw();
911	obj8->SetPrettyPalette();
912
913	//
914	// UNRELIABLE PIXELS
915	//
916
917	c4.cd(2);
918	gPad->SetBorderMode(0);
919	gPad->SetTicks();
920	MHCamera obj9=(MHCamera)disp25.DrawCopy("hist");
921	//
922	// for the datacheck, fix the ranges!!
923	//
924	const Double_t max2 = 9.;
925	obj9->SetMinimum(0.);
926	obj9->SetMaximum(max2);
927	//
928	// Set the datacheck sizes:
929	//
930	FixDataCheckHist((TH1D*)obj9);
931	obj9->SetStats(kFALSE);
932
933	gStyle->SetPalette(1);
934
935	TPaveText *pave2 = new TPaveText(0.0,0.0,0.99,0.99);
936	pave2->SetBit(kCanDelete);
937	pave2->ConvertNDCtoPad();
938	pave2->SetTextSize(0.05);
939	pave2->AddText(" ");
940	TText *t3 = pave2->AddText(Form("Signal Sigma smaller Pedestal RMS: %3i pixels",
941	CountBadPixels(&disp25,1)));
942	t3->SetTextColor(gStyle->GetColorPalette(Int_t(1./max2*numcol)));
943	t3->SetTextAlign(12);
944	TText *tt1 = pave2->AddText(Form("High Gain Signals could not be fitted: %3i pixels",
945	CountBadPixels(&disp25,3)));
946	tt1->SetTextColor(gStyle->GetColorPalette(Int_t(3./max2*numcol)));
947	tt1->SetTextAlign(12);
948	TText *tt2 = pave2->AddText(Form("Low Gain Signals could not be fitted: %3i pixels",
949	CountBadPixels(&disp25,4)));
950	tt2->SetTextColor(gStyle->GetColorPalette(Int_t(4./max2*numcol)));
951	tt2->SetTextAlign(12);
952	TText *tt3 = pave2->AddText(Form("Relative Arr. Times could not be fitted: %3i pixels",
953	CountBadPixels(&disp25,5)));
954	tt3->SetTextColor(gStyle->GetColorPalette(Int_t(5./max2*numcol)));
955	tt3->SetTextAlign(12);
956	TText *tt4 = pave2->AddText(Form("High Gain Signals Oscillation: %3i pixels",
957	CountBadPixels(&disp25,6)));
958	tt4->SetTextColor(gStyle->GetColorPalette(Int_t(6./max2*numcol)));
959	tt4->SetTextAlign(12);
960	TText *tt5 = pave2->AddText(Form("Low Gain Signals Oscillation: %3i pixels",
961	CountBadPixels(&disp25,7)));
962	tt5->SetTextColor(gStyle->GetColorPalette(Int_t(7./max2*numcol)));
963	tt5->SetTextAlign(12);
964	TText *tt6 = pave2->AddText(Form("Relative Arr. Times Oscillation: %3i pixels",
965	CountBadPixels(&disp25,8)));
966	tt6->SetTextColor(gStyle->GetColorPalette(Int_t(8./max2*numcol)));
967	tt6->SetTextAlign(12);
968	TText *tt8 = pave2->AddText(Form("Deviating global F-Factor: %3i pixels",
969	CountBadPixels(&disp25,9)));
970	tt8->SetTextColor(gStyle->GetColorPalette(Int_t(9./max2*numcol)));
971	tt8->SetTextAlign(12);
972	pave2->Draw();
973
974	c4.cd(4);
975	gPad->SetBorderMode(0);
976	obj9->SetPrettyPalette();
977	obj9->Draw();
978
979	if (IsRelTimes())
980	{
981	TCanvas &c5 = fDisplay->AddTab("RelTimes");
982	c5.Divide(2,3);
983
984	//
985	// MEAN REL. ARR. TIMES
986	//
987	c5.cd(1);
988	gPad->SetBorderMode(0);
989	gPad->SetTicks();
990	MHCamera obj10=(MHCamera)disp30.DrawCopy("hist");
991	//
992	// for the datacheck, fix the ranges!!
993	//
994	obj10->SetMinimum(fTimeOffsetMin);
995	obj10->SetMaximum(fTimeOffsetMax);
996	//
997	// Set the datacheck sizes:
998	//
999	FixDataCheckHist((TH1D*)obj10);
1000	obj10->SetStats(kFALSE);
1001	//
1002	// set reference lines
1003	//
1004	DisplayReferenceLines(obj10,5);
1005
1006	c5.cd(3);
1007	gPad->SetBorderMode(0);
1008	obj10->SetPrettyPalette();
1009	obj10->Draw();
1010
1011	c5.cd(5);
1012	gPad->SetBorderMode(0);
1013	if (geomcam.InheritsFrom("MGeomCamMagic"))
1014	DisplayDoubleProject(&disp30, "early", "late");
1015
1016	//
1017	// JITTER Rel. Arr. Times
1018	//
1019	c5.cd(2);
1020	gPad->SetBorderMode(0);
1021	gPad->SetTicks();
1022	MHCamera obj11=(MHCamera)disp31.DrawCopy("hist");
1023	//
1024	// for the datacheck, fix the ranges!!
1025	//
1026	obj11->SetMinimum(fTimeResolutionMin);
1027	obj11->SetMaximum(fTimeResolutionMax);
1028	//
1029	// Set the datacheck sizes:
1030	//
1031	FixDataCheckHist((TH1D*)obj11);
1032	obj11->SetStats(kFALSE);
1033	//
1034	// set reference lines
1035	//
1036	DisplayReferenceLines(obj11,6);
1037
1038	c5.cd(4);
1039	gPad->SetBorderMode(0);
1040	obj11->SetPrettyPalette();
1041	obj11->Draw();
1042
1043	c5.cd(6);
1044	gPad->SetBorderMode(0);
1045	if (geomcam.InheritsFrom("MGeomCamMagic"))
1046	DisplayDoubleProject(&disp31, "too stable", "jittering");
1047
1048	}
1049	return;
1050	}
1051
1052	if (fDisplayType == kNormalDisplay)
1053	{
1054
1055	// Charges
1056	TCanvas &c11 = fDisplay->AddTab("FitCharge");
1057	c11.Divide(2, 4);
1058
1059	disp1.CamDraw(c11, 1, 2, 5, 1);
1060	disp2.CamDraw(c11, 2, 2, 5, 1);
1061
1062	// Reduced Sigmas
1063	TCanvas &c12 = fDisplay->AddTab("RedSigma");
1064	c12.Divide(2,4);
1065
1066	disp3.CamDraw(c12, 1, 2, 5, 1);
1067	disp4.CamDraw(c12, 2, 2, 5, 1);
1068
1069	// F-Factor
1070	TCanvas &c13 = fDisplay->AddTab("Phe's");
1071	c13.Divide(3,4);
1072
1073	disp5.CamDraw(c13, 1, 3, 5, 1);
1074	disp6.CamDraw(c13, 2, 3, 5, 1);
1075	disp7.CamDraw(c13, 3, 3, 5, 1);
1076
1077	// QE's
1078	TCanvas &c14 = fDisplay->AddTab("QE's");
1079	c14.Divide(4,4);
1080
1081	disp8.CamDraw(c14, 1, 4, 5, 1);
1082	disp9.CamDraw(c14, 2, 4, 5, 1);
1083	disp10.CamDraw(c14, 3, 4, 5, 1);
1084	disp11.CamDraw(c14, 4, 4, 5, 1);
1085
1086	// Defects
1087	TCanvas &c15 = fDisplay->AddTab("Defect");
1088	// c15.Divide(5,2);
1089	c15.Divide(4,2);
1090
1091	/*
1092	disp23.CamDraw(c15, 1, 5, 0);
1093	disp24.CamDraw(c15, 2, 5, 0);
1094	disp25.CamDraw(c15, 3, 5, 0);
1095	disp26.CamDraw(c15, 4, 5, 0);
1096	disp27.CamDraw(c15, 5, 5, 0);
1097	*/
1098	disp24.CamDraw(c15, 1, 4, 0);
1099	disp25.CamDraw(c15, 2, 4, 0);
1100	disp26.CamDraw(c15, 3, 4, 0);
1101	disp27.CamDraw(c15, 4, 4, 0);
1102
1103	// Abs. Times
1104	TCanvas &c16 = fDisplay->AddTab("AbsTimes");
1105	c16.Divide(2,3);
1106
1107	disp28.CamDraw(c16, 1, 2, 5);
1108	disp29.CamDraw(c16, 2, 2, 5);
1109
1110	if (IsRelTimes())
1111	{
1112	// Rel. Times
1113	TCanvas &c17 = fDisplay->AddTab("RelTimes");
1114	c17.Divide(2,4);
1115
1116	disp30.CamDraw(c17, 1, 2, 5, 1);
1117	disp31.CamDraw(c17, 2, 2, 5, 1);
1118	}
1119
1120	return;
1121	}
1122
1123	if (fDisplayType == kFullDisplay)
1124	{
1125	MHCalibrationCam cam = (MHCalibrationCam)plist.FindObject("MHCalibrationChargeCam");
1126
1127	for (Int_t sector=1;sector<cam->GetAverageSectors();sector++)
1128	{
1129	cam->GetAverageHiGainSector(sector).DrawClone("all");
1130	cam->GetAverageLoGainSector(sector).DrawClone("all");
1131	}
1132
1133	// Charges
1134	TCanvas &c21 = fDisplay->AddTab("FitCharge");
1135	c21.Divide(2, 4);
1136
1137	disp1.CamDraw(c21, 1, 2, 2, 1);
1138	disp2.CamDraw(c21, 2, 2, 2, 1);
1139
1140	// Reduced Sigmas
1141	TCanvas &c23 = fDisplay->AddTab("RedSigma");
1142	c23.Divide(2,4);
1143
1144	disp3.CamDraw(c23, 1, 2, 2, 1);
1145	disp4.CamDraw(c23, 2, 2, 2, 1);
1146
1147	// F-Factor
1148	TCanvas &c24 = fDisplay->AddTab("Phe's");
1149	c24.Divide(3,5);
1150
1151	disp5.CamDraw(c24, 1, 3, 2, 1, 1);
1152	disp6.CamDraw(c24, 2, 3, 2, 1, 1);
1153	disp7.CamDraw(c24, 3, 3, 2, 1, 1);
1154
1155	// QE's
1156	TCanvas &c25 = fDisplay->AddTab("QE's");
1157	c25.Divide(4,5);
1158
1159	disp8.CamDraw(c25, 1, 4, 2, 1, 1);
1160	disp9.CamDraw(c25, 2, 4, 2, 1, 1);
1161	disp10.CamDraw(c25, 3, 4, 2, 1, 1);
1162	disp11.CamDraw(c25, 4, 4, 2, 1, 1);
1163
1164	// Validity
1165	TCanvas &c26 = fDisplay->AddTab("Valid");
1166	c26.Divide(4,2);
1167
1168	disp12.CamDraw(c26, 1, 4, 0);
1169	disp13.CamDraw(c26, 2, 4, 0);
1170	disp14.CamDraw(c26, 3, 4, 0);
1171	disp15.CamDraw(c26, 4, 4, 0);
1172
1173	// Other info
1174	TCanvas &c27 = fDisplay->AddTab("HiLoGain");
1175	c27.Divide(3,3);
1176
1177	disp16.CamDraw(c27, 1, 3, 0);
1178	disp17.CamDraw(c27, 2, 3, 1);
1179	disp18.CamDraw(c27, 3, 3, 1);
1180
1181	// Pickup
1182	TCanvas &c28 = fDisplay->AddTab("Pickup");
1183	c28.Divide(4,2);
1184
1185	disp19.CamDraw(c28, 1, 4, 0);
1186	disp20.CamDraw(c28, 2, 4, 0);
1187	disp21.CamDraw(c28, 3, 4, 0);
1188	disp22.CamDraw(c28, 4, 4, 0);
1189
1190	// Defects
1191	TCanvas &c29 = fDisplay->AddTab("Defect");
1192	// c29.Divide(5,2);
1193	c29.Divide(4,2);
1194
1195	disp24.CamDraw(c29, 1, 4, 0);
1196	disp25.CamDraw(c29, 2, 4, 0);
1197	disp26.CamDraw(c29, 3, 4, 0);
1198	disp27.CamDraw(c29, 4, 4, 0);
1199
1200	// Abs. Times
1201	TCanvas &c30 = fDisplay->AddTab("AbsTimes");
1202	c30.Divide(2,3);
1203
1204	disp28.CamDraw(c30, 1, 2, 2);
1205	disp29.CamDraw(c30, 2, 2, 1);
1206
1207	if (IsRelTimes())
1208	{
1209	// Rel. Times
1210	TCanvas &c31 = fDisplay->AddTab("RelTimes");
1211	c31.Divide(3,5);
1212
1213	disp30.CamDraw(c31, 1, 3, 2, 1, 1);
1214	disp31.CamDraw(c31, 2, 3, 2, 1, 1);
1215	disp32.CamDraw(c31, 3, 3, 4, 1, 1);
1216
1217	// Time Defects
1218	TCanvas &c32 = fDisplay->AddTab("DefTime");
1219	c32.Divide(2,2);
1220
1221	disp33.CamDraw(c32, 1, 2, 0);
1222	disp34.CamDraw(c32, 2, 2, 0);
1223
1224	MHCalibrationCam cam = (MHCalibrationCam)plist.FindObject("MHCalibrationRelTimeCam");
1225
1226	for (Int_t sector=1;sector<cam->GetAverageSectors();sector++)
1227	{
1228	cam->GetAverageHiGainSector(sector).DrawClone("fourierevents");
1229	cam->GetAverageLoGainSector(sector).DrawClone("fourierevents");
1230	}
1231
1232	}
1233
1234	return;
1235	}
1236	}
1237
1238
1239	void MJCalibration::DisplayReferenceLines(MHCamera *cam, const Int_t what) const
1240	{
1241
1242	const MGeomCam *geom = cam->GetGeometry();
1243
1244	Double_t x = geom->InheritsFrom("MGeomCamMagic") ? 397 : cam->GetNbinsX() ;
1245
1246	TLine line;
1247	line.SetLineStyle(kDashed);
1248	line.SetLineWidth(3);
1249	line.SetLineColor(kBlue);
1250
1251	TLine *l1 = NULL;
1252
1253	switch (what)
1254	{
1255	case 0:
1256	l1 = line.DrawLine(0, fRefQEInner, x, fRefQEInner);
1257	break;
1258	case 1:
1259	l1 = line.DrawLine(0, fRefConvFADC2PheInner, x, fRefConvFADC2PheInner);
1260	break;
1261	case 2:
1262	l1 = line.DrawLine(0, fRefFADC2PheInner, x, fRefFADC2PheInner );
1263	break;
1264	case 3:
1265	l1 = line.DrawLine(0, fRefArrivalTimeInner, x, fRefArrivalTimeInner );
1266	break;
1267	case 4:
1268	l1 = line.DrawLine(0, fRefArrivalTimeRmsInner, x, fRefArrivalTimeRmsInner );
1269	break;
1270	case 5:
1271	l1 = line.DrawLine(0, fRefTimeOffsetInner, x, fRefTimeOffsetInner );
1272	break;
1273	case 6:
1274	l1 = line.DrawLine(0, fRefTimeResolutionInner, x, fRefTimeResolutionInner );
1275	break;
1276	default:
1277	break;
1278	}
1279
1280	if (geom->InheritsFrom("MGeomCamMagic"))
1281	{
1282	const Double_t x2 = cam->GetNbinsX();
1283
1284	switch (what)
1285	{
1286	case 0:
1287	line.DrawLine(x2, fRefQEOuter, 398, fRefQEOuter);
1288	break;
1289	case 1:
1290	line.DrawLine(x2, fRefConvFADC2PheOuter, 398, fRefConvFADC2PheOuter );
1291	break;
1292	case 2:
1293	line.DrawLine(x2, fRefFADC2PheOuter, 398, fRefFADC2PheOuter);
1294	break;
1295	case 3:
1296	line.DrawLine(x2, fRefArrivalTimeOuter, 398, fRefArrivalTimeOuter);
1297	break;
1298	case 4:
1299	line.DrawLine(x2, fRefArrivalTimeRmsOuter, 398, fRefArrivalTimeRmsOuter);
1300	break;
1301	case 5:
1302	line.DrawLine(x2, fRefTimeOffsetOuter, 398, fRefTimeOffsetOuter);
1303	break;
1304	case 6:
1305	line.DrawLine(x2, fRefTimeResolutionOuter, 398, fRefTimeResolutionOuter);
1306	break;
1307	default:
1308	break;
1309	}
1310	}
1311
1312	TLegend *leg = new TLegend(0.6,0.85,0.9 ,0.95);
1313	leg->SetBit(kCanDelete);
1314	leg->AddEntry(l1, "Reference","l");
1315	leg->Draw();
1316	}
1317
1318	void MJCalibration::DisplayOutliers(TH1D hist, const char whatsmall, const char* whatbig) const
1319	{
1320
1321	const Int_t kNotDraw = 1<<9;
1322	TF1 *f = hist->GetFunction("gaus");
1323	f->ResetBit(kNotDraw);
1324
1325	const Float_t mean = f->GetParameter(1);
1326	const Float_t lolim = mean - 4.0*f->GetParameter(2);
1327	const Float_t uplim = mean + 4.0*f->GetParameter(2);
1328	const Stat_t dead = hist->Integral(0,hist->FindBin(lolim)-1);
1329	const Stat_t noisy = hist->Integral(hist->FindBin(uplim)+1,hist->GetNbinsX()+1);
1330
1331	const Double_t max = hist->GetBinContent(hist->GetMaximumBin());
1332
1333	const Double_t minl = hist->GetBinCenter(hist->GetXaxis()->GetFirst());
1334	const Double_t maxl = hist->GetBinCenter(hist->GetXaxis()->GetLast());
1335
1336	TLatex deadtex;
1337	deadtex.SetTextSize(0.07);
1338	deadtex.DrawLatex(minl+0.015*(maxl-minl),max/1.1,
1339	Form("%3i %s pixels",(Int_t)dead,whatsmall));
1340
1341	TLatex noisytex;
1342	noisytex.SetTextSize(0.07);
1343	noisytex.DrawLatex(minl+0.015*(maxl-minl),max/1.2,
1344	Form("%3i %s pixels",(Int_t)noisy,whatbig));
1345
1346	}
1347
1348	void MJCalibration::FixDataCheckHist(TH1D *hist) const
1349	{
1350
1351	hist->SetDirectory(NULL);
1352
1353	//
1354	// set the labels bigger
1355	//
1356	TAxis *xaxe = hist->GetXaxis();
1357	TAxis *yaxe = hist->GetYaxis();
1358
1359	xaxe->CenterTitle();
1360	yaxe->CenterTitle();
1361	xaxe->SetTitleSize(0.06);
1362	yaxe->SetTitleSize(0.06);
1363	xaxe->SetTitleOffset(0.8);
1364	yaxe->SetTitleOffset(0.85);
1365	xaxe->SetLabelSize(0.05);
1366	yaxe->SetLabelSize(0.05);
1367
1368	}
1369
1370	const Int_t MJCalibration::CountBadPixels(MHCamera *cam, const Int_t what) const
1371	{
1372	Int_t cnt = 0;
1373
1374	for (UInt_t pix=0; pix<cam->GetNumPixels(); pix++)
1375	if (TMath::Nint(cam->GetPixContent(pix)) == what)
1376	cnt++;
1377
1378	return cnt;
1379	}
1380
1381	// --------------------------------------------------------------------------
1382	//
1383	// Retrieve the output file written by WriteResult()
1384	//
1385	const char* MJCalibration::GetOutputFileName() const
1386	{
1387	return Form("calib%08d.root", fSequence.GetSequence());
1388	}
1389
1390	// --------------------------------------------------------------------------
1391	//
1392	// Read the following values from resource file:
1393	//
1394	// ConvFADC2PheMin
1395	// ConvFADC2PheMax
1396	// ConvFADC2PhotMin
1397	// ConvFADC2PhotMax
1398	//
1399	// QEMin
1400	// QEMax
1401	//
1402	// ArrivalTimeMin
1403	// ArrivalTimeMax
1404	//
1405	// TimeOffsetMin
1406	// TimeOffsetMax
1407	// TimeResolutionMin
1408	// TimeResolutionMax
1409	//
1410	// RefConvFADC2PheInner
1411	// RefConvFADC2PheOuter
1412	// RefConvFADC2PhotInner
1413	// RefConvFADC2PhotOuter
1414	//
1415	// RefQEInner
1416	// RefQEOuter
1417	//
1418	// RefArrivalTimeInner
1419	// RefArrivalTimeOuter
1420	// RefArrivalTimeRmsInner
1421	// RefArrivalTimeRmsOuter
1422	//
1423	// RefTimeOffsetInner
1424	// RefTimeOffsetOuter
1425	// RefTimeResolutionInner
1426	// RefTimeResolutionOuter
1427	//
1428	void MJCalibration::ReadReferenceFile()
1429	{
1430	TEnv refenv(fReferenceFile);
1431
1432	fConvFADC2PheMin = refenv.GetValue("ConvFADC2PheMin",fConvFADC2PheMin);
1433	fConvFADC2PheMax = refenv.GetValue("ConvFADC2PheMax",fConvFADC2PheMax);
1434	fConvFADC2PhotMin = refenv.GetValue("ConvFADC2PhotMin",fConvFADC2PhotMin);
1435	fConvFADC2PhotMax = refenv.GetValue("ConvFADC2PhotMax",fConvFADC2PhotMax);
1436	fQEMin = refenv.GetValue("QEMin",fQEMin);
1437	fQEMax = refenv.GetValue("QEMax",fQEMax);
1438	fArrivalTimeMin = refenv.GetValue("ArrivalTimeMin",fArrivalTimeMin);
1439	fArrivalTimeMax = refenv.GetValue("ArrivalTimeMax",fArrivalTimeMax);
1440	fTimeOffsetMin = refenv.GetValue("TimeOffsetMin",fTimeOffsetMin);
1441	fTimeOffsetMax = refenv.GetValue("TimeOffsetMax",fTimeOffsetMax);
1442	fTimeResolutionMin = refenv.GetValue("TimeResolutionMin",fTimeResolutionMin);
1443	fTimeResolutionMax = refenv.GetValue("TimeResolutionMax",fTimeResolutionMax);
1444
1445	fRefFADC2PheInner = refenv.GetValue("RefFADC2PheInner",fRefFADC2PheInner);
1446	fRefFADC2PheOuter = refenv.GetValue("RefFADC2PheOuter",fRefFADC2PheOuter);
1447	fRefConvFADC2PhotInner = refenv.GetValue("RefConvFADC2PhotInner",fRefConvFADC2PhotInner);
1448	fRefConvFADC2PhotOuter = refenv.GetValue("RefConvFADC2PhotOuter",fRefConvFADC2PhotOuter);
1449	fRefConvFADC2PheInner = refenv.GetValue("RefConvFADC2PheInner",fRefConvFADC2PheInner);
1450	fRefConvFADC2PheOuter = refenv.GetValue("RefConvFADC2PheOuter",fRefConvFADC2PheOuter);
1451	fRefQEInner = refenv.GetValue("RefQEInner",fRefQEInner);
1452	fRefQEOuter = refenv.GetValue("RefQEOuter",fRefQEOuter);
1453	fRefArrivalTimeInner = refenv.GetValue("RefArrivalTimeInner",fRefArrivalTimeInner);
1454	fRefArrivalTimeOuter = refenv.GetValue("RefArrivalTimeOuter",fRefArrivalTimeOuter);
1455	fRefArrivalTimeRmsInner = refenv.GetValue("RefArrivalTimeRmsInner",fRefArrivalTimeRmsInner);
1456	fRefArrivalTimeRmsOuter = refenv.GetValue("RefArrivalTimeRmsOuter",fRefArrivalTimeRmsOuter);
1457	fRefTimeOffsetInner = refenv.GetValue("RefTimeOffsetInner",fRefTimeOffsetInner);
1458	fRefTimeOffsetOuter = refenv.GetValue("RefTimeOffsetOuter",fRefTimeOffsetOuter);
1459	fRefTimeResolutionInner = refenv.GetValue("RefTimeResolutionInner",fRefTimeResolutionInner);
1460	fRefTimeResolutionOuter = refenv.GetValue("RefTimeResolutionOuter",fRefTimeResolutionOuter);
1461	}
1462
1463	// --------------------------------------------------------------------------
1464	//
1465	// Read the following values from resource file:
1466	//
1467	// MCalibrationHiLoCam
1468	//
1469	Bool_t MJCalibration::ReadHiLoCalibFile()
1470	{
1471
1472	if (!fIsHiLoCalibration)
1473	return kTRUE;
1474
1475	TFile file(fHiLoCalibFile,"READ");
1476	if (!file.IsOpen())
1477	{
1478	*fLog << err << "ERROR - Couldn't open file " << fHiLoCalibFile << " for reading... abort." << endl;
1479	return kFALSE;
1480	}
1481
1482	MCalibrationHiLoCam hilocam;
1483	if (hilocam.Read()<=0)
1484	{
1485	*fLog << err << "Unable to read MCalibrationHiLoCam from " << fHiLoCalibFile << "... abort." << endl;
1486	return kFALSE;
1487	}
1488	if (hilocam.GetSize() < 1)
1489	{
1490	*fLog << err << "MCalibationHiLoCam is un-initialized in file " << fHiLoCalibFile << "... abort." << endl;
1491	return kFALSE;
1492	}
1493
1494	*fLog << all << "Hi-/Lo-Gain intercalibration constants read from " << fHiLoCalibFile << endl << endl;
1495
1496	if (fCalibrationCam.GetSize() < 1)
1497	fCalibrationCam.InitSize(hilocam.GetSize());
1498
1499	if (fBadPixels.GetSize() < 1)
1500	fBadPixels.InitSize(hilocam.GetSize());
1501
1502	if (fCalibrationCam.GetSize() != hilocam.GetSize())
1503	{
1504	*fLog << err << "Size mismatch MCalibationHiLoCam and MCalibrationChargeCam.. abort." << endl;
1505	return kFALSE;
1506	}
1507
1508	for (Int_t i=0;i<hilocam.GetSize();i++)
1509	{
1510	const MCalibrationHiLoPix &pix = (MCalibrationHiLoPix&)hilocam[i];
1511
1512	const Float_t ratio = pix.GetHiLoChargeRatio();
1513	const Float_t raterr = pix.GetHiLoChargeRatioErr();
1514	const Float_t sigma = pix.GetHiLoChargeRatioSigma();
1515
1516	if (ratio < 0.)
1517	{
1518	fBadPixels[i].SetUncalibrated(MBadPixelsPix::kConversionHiLoNotValid);
1519	continue;
1520	}
1521
1522	MCalibrationChargePix &cpix = (MCalibrationChargePix&)fCalibrationCam[i];
1523
1524	cpix.SetConversionHiLo(ratio);
1525	cpix.SetConversionHiLoErr(raterr);
1526	cpix.SetConversionHiLoSigma(sigma);
1527	}
1528
1529	return kTRUE;
1530	}
1531
1532	// --------------------------------------------------------------------------
1533	//
1534	// MJCalibration allows to setup several option by a resource file:
1535	// MJCalibration.Display: full, datacheck, normal
1536	// MJCalibration.RelTimeCalibration: yes,no
1537	// MJCalibration.DataCheck: yes,no
1538	// MJCalibration.Debug: yes,no
1539	// MJCalibration.Intensity: yes,no
1540	// MJCalibration.UseBlindPixel: yes,no
1541	// MJCalibration.UsePINDiode: yes,no
1542	// MJCalibration.Geometry: MGeomCamMagic, MGeomCamECO1000
1543	//
1544	// Name of a file containing reference values (see ReadReferenceFile)
1545	// Prefix.ReferenceFile: filename
1546	// (see ReadReferenceFile)
1547	//
1548	// For more details see the class description and the corresponding Getters
1549	//
1550	Bool_t MJCalibration::CheckEnvLocal()
1551	{
1552	TString dis = GetEnv("Display", "");
1553	if (dis.BeginsWith("Full", TString::kIgnoreCase))
1554	SetFullDisplay();
1555	if (dis.BeginsWith("DataCheck", TString::kIgnoreCase))
1556	SetDataCheckDisplay();
1557	if (dis.BeginsWith("Normal", TString::kIgnoreCase))
1558	SetNormalDisplay();
1559
1560	if (!MJCalib::CheckEnvLocal())
1561	return kFALSE;
1562
1563	SetRelTimeCalibration(GetEnv("RelTimeCalibration", IsRelTimes()));
1564	SetIntensity(GetEnv("IntensityCalibration", IsIntensity()));
1565	SetDebug(GetEnv("Debug", IsDebug()));
1566
1567	SetUseBlindPixel(GetEnv("UseBlindPixel", IsUseBlindPixel()));
1568	SetUsePINDiode(GetEnv("UsePINDiode", IsUsePINDiode()));
1569	SetGeometry(GetEnv("Geometry", fGeometry));
1570
1571	fReferenceFile = GetEnv("ReferenceFile",fReferenceFile.Data());
1572	ReadReferenceFile();
1573
1574	fHiLoCalibFile = GetEnv("HiLoCalibFile",fHiLoCalibFile.Data());
1575
1576	if (IsUseMC() && !fHiLoCalibFile.EndsWith("_mc.root"))
1577	{
1578	if (!fHiLoCalibFile.EndsWith(".root"))
1579	{
1580	*fLog << warn << "WARNING - Hi-/Lo-Gain intercalibration file ";
1581	*fLog << fHiLoCalibFile << " has not .root as extension..." << endl;
1582	}
1583	else
1584	fHiLoCalibFile.Insert(fHiLoCalibFile.Length()-5, "_mc");
1585	}
1586
1587	return ReadHiLoCalibFile();
1588	}
1589
1590	void MJCalibration::InitBlindPixel(MExtractBlindPixel &blindext,
1591	MHCalibrationChargeBlindCam &blindcam)
1592	{
1593
1594	Int_t run = fSequence.GetLastRun();
1595
1596	//
1597	// Initialize the blind pixel. Unfortunately, there is a hardware difference
1598	// in the first blind pixel until run "gkSecondBlindPixelInstallation" and the
1599	// later setup. The first needs to use a filter because of the length of
1600	// spurious NSB photon signals. The latter get better along extracting the amplitude
1601	// from a small window.
1602	//
1603	if (run < gkSecondBlindPixelInstallation)
1604	{
1605	MCalibrationBlindCamOneOldStyle blindresults;
1606	if (IsIntensity())
1607	blindresults.Copy(*fIntensBlindCam.GetCam());
1608	else
1609	blindresults.Copy(fCalibrationBlindCam);
1610
1611	blindext.SetExtractionType(MExtractBlindPixel::kIntegral);
1612	blindext.SetExtractionType(MExtractBlindPixel::kFilter);
1613	blindext.SetRange(10,19,0,6);
1614	blindext.SetNSBFilterLimit(70);
1615	}
1616	else if (run < gkThirdBlindPixelInstallation)
1617	{
1618
1619	MCalibrationBlindCamTwoNewStyle blindresults;
1620
1621	if (IsIntensity())
1622	blindresults.Copy(*fIntensBlindCam.GetCam());
1623	else
1624	blindresults.Copy(fCalibrationBlindCam);
1625
1626	blindext.SetNumBlindPixels(blindresults.GetSize());
1627	for (Int_t i=0;i<blindresults.GetSize();i++)
1628	blindext.SetBlindPixelIdx(blindresults[i].GetPixId(),i);
1629
1630	blindext.SetExtractionType(MExtractBlindPixel::kAmplitude);
1631	blindext.SetExtractionType(MExtractBlindPixel::kFilter);
1632	blindext.SetRange(5,8,0,2);
1633	blindext.SetNSBFilterLimit(38);
1634
1635	}
1636	else
1637	{
1638
1639	MCalibrationBlindCamThreeNewStyle blindresults;
1640
1641	if (IsIntensity())
1642	blindresults.Copy(*fIntensBlindCam.GetCam());
1643	else
1644	blindresults.Copy(fCalibrationBlindCam);
1645
1646	blindext.SetNumBlindPixels(blindresults.GetSize());
1647
1648	for (Int_t i=0;i<blindresults.GetSize();i++)
1649	blindext.SetBlindPixelIdx(blindresults[i].GetPixId(),i);
1650
1651	blindext.SetExtractionType(MExtractBlindPixel::kAmplitude);
1652	blindext.SetExtractionType(MExtractBlindPixel::kFilter);
1653	blindext.SetDataType(MExtractBlindPixel::kRawEvt2);
1654	blindext.SetRange(5,8,0,2);
1655	blindext.SetNSBFilterLimit(38);
1656
1657	}
1658
1659	}
1660
1661	// --------------------------------------------------------------------------
1662	//
1663	// Execute the task list and the eventloop:
1664	//
1665	// - Check the colour of the files in fRuns (FindColor()), otherwise return
1666	// - Check for consistency between run numbers and number of files
1667	// - Add fRuns to MReadMarsFile
1668	// - Put into MParList:
1669	// 1) MPedestalCam (pedcam)
1670	// 2) MCalibrationQECam (fQECam)
1671	// 3) MCalibrationChargeCam (fCalibrationCam)
1672	// 4) MCalibrationRelTimeCam (fRelTimeCam) (only if flag IsRelTimes() is chosen)
1673	// 5) MBadPixelsCam (fBadPixels)
1674	// 6) MCalibrationChargePINDiode
1675	// 7) MCalibrationBlindPix
1676	// - Put into the MTaskList:
1677	// 1) MReadMarsFile
1678	// 2) MBadPixelsMerge
1679	// 3) MGeomApply
1680	// 4) MExtractor
1681	// 5) MExtractPINDiode
1682	// 6) MExtractBlindPixel
1683	// 7) MExtractTime (only if flag IsRelTimes() is chosen)
1684	// 8) MContinue(MFCosmics)
1685	// 9) MFillH("MHCalibrationChargePINDiode", "MExtractedSignalPINDiode", "FillPINDiode")
1686	// 10) MFillH("MHCalibrationChargeBlindCam", "MExtractedSignalBlindPixel", "FillBlindCam")
1687	// 11) MFillH("MHCalibrationChargeCam", "MExtractedSignalCam", "FillChargeCam")
1688	// 12) MFillH("MHCalibrationChargeCam", "MExtractedSignalCam", "FillRelTime")
1689	// 13) MCalibrationChargeCalc
1690	// 14) MFillH("MHCalibrationRelTimeCam", "MArrivalTimeCam") (only if flag IsRelTimes() is chosen)
1691	// 15) MCalibrationRelTimeCalc
1692	// - Execute MEvtLoop
1693	// - DisplayResult()
1694	// - WriteResult()
1695	//
1696	Bool_t MJCalibration::Process(MPedestalCam &pedcam)
1697	{
1698	if (!fSequence.IsValid())
1699	{
1700	*fLog << err << "ERROR - Sequence invalid..." << endl;
1701	return kFALSE;
1702	}
1703
1704	*fLog << inf;
1705	fLog->Separator(GetDescriptor());
1706	*fLog << "Calculate calibration constants from Sequence #";
1707	*fLog << fSequence.GetSequence() << endl << endl;
1708
1709	// --------------------------------------------------------------------------------
1710
1711	if (!CheckEnv())
1712	return kFALSE;
1713
1714	// --------------------------------------------------------------------------------
1715
1716	// Setup Tasklist
1717	MParList plist;
1718	MTaskList tlist;
1719	plist.AddToList(&tlist);
1720	plist.AddToList(this); // take care of fDisplay!
1721
1722	MDirIter iter;
1723	const Int_t n0 = fSequence.SetupCalRuns(iter, fPathData, IsUseRawData());
1724	const Int_t n1 = fSequence.GetNumCalRuns();
1725	if (n0==0)
1726	{
1727	*fLog << err << "ERROR - No input files of sequence found!" << endl;
1728	return kFALSE;
1729	}
1730	if (n0!=n1)
1731	{
1732	*fLog << err << "ERROR - Number of files found ("
1733	<< n0 << ") doesn't match number of files in sequence ("
1734	<< n1 << ")" << endl;
1735	if (fLog->GetDebugLevel()>4)
1736	{
1737	*fLog << dbg << "Files which are searched:" << endl;
1738	iter.Print();
1739	}
1740	return kFALSE;
1741	}
1742
1743	//
1744	// Input containers
1745	//
1746	pedcam.SetName("MPedestalCam"); // MPedestalFundamental
1747	plist.AddToList(&pedcam);
1748	plist.AddToList(&fBadPixels);
1749
1750	//
1751	// Calibration Results containers
1752	//
1753	if (IsIntensity())
1754	{
1755
1756	MCalibrationChargeCam cam = (MCalibrationChargeCam)fIntensCalibCam.GetCam();
1757	cam->InitSize(fCalibrationCam.GetSize());
1758	cam->MergeHiLoConversionFactors(fCalibrationCam);
1759
1760	plist.AddToList(&fIntensQECam);
1761	plist.AddToList(&fIntensCalibCam);
1762	// plist.AddToList(&fIntensCalibrationPINDiode);
1763	plist.AddToList(&fIntensRelTimeCam);
1764	plist.AddToList(&fIntensBadCam);
1765	if (IsUseBlindPixel())
1766	plist.AddToList(&fIntensBlindCam);
1767	}
1768	else
1769	{
1770	plist.AddToList(&fQECam);
1771	plist.AddToList(&fCalibrationCam);
1772	plist.AddToList(&fRelTimeCam);
1773	if (IsUseBlindPixel())
1774	plist.AddToList(&fCalibrationBlindCam);
1775	if (IsUsePINDiode())
1776	plist.AddToList(&fCalibrationPINDiode);
1777	}
1778
1779	//
1780	// Initialize two histogram containers which could be modified in this class
1781	//
1782	MHCalibrationRelTimeCam reltimecam;
1783	MHCalibrationChargeCam chargecam;
1784	MHCalibrationChargeBlindCam blindcam;
1785	plist.AddToList(&chargecam);
1786
1787	if (IsUseBlindPixel())
1788	plist.AddToList(&blindcam);
1789	if (IsRelTimes())
1790	plist.AddToList(&reltimecam);
1791	//
1792	// Data Reading tasks
1793	//
1794	MReadMarsFile read("Events");
1795	MRawFileRead rawread(NULL);
1796
1797	if (IsUseRawData())
1798	{
1799	rawread.AddFiles(iter);
1800	tlist.AddToList(&rawread);
1801	}
1802	else
1803	{
1804	read.DisableAutoScheme();
1805	read.AddFiles(iter);
1806	tlist.AddToList(&read);
1807	}
1808
1809	//
1810	// Other Tasks
1811	//
1812
1813	// Set the default for data version earlier than 5, where no valid
1814	// trigger pattern exists. There should not be pin diode or other
1815	// types of events inside the calibration files which should be skipped,
1816	// anyway. So we set the default such that the MContinue ccalib
1817	// will never be executed.
1818	MTriggerPatternDecode trgpat;
1819	MFTriggerPattern fcalib("CalibFilter");
1820	fcalib.SetDefault(kFALSE);
1821	fcalib.DenyCalibration(MFTriggerPattern::kPrescaled);
1822
1823	MContinue ccalib(&fcalib,"ContTrigPattern");
1824
1825	MCalibrationPatternDecode decode;
1826	MGeomApply apply;
1827	apply.SetGeometry(fGeometry);
1828
1829	MBadPixelsMerge merge(&fBadPixels);
1830	MExtractPINDiode pinext;
1831	MExtractBlindPixel blindext;
1832
1833	if (IsUseBlindPixel())
1834	InitBlindPixel(blindext, blindcam);
1835
1836	// MExtractSlidingWindow extract2;
1837	// MExtractTimeHighestIntegral timehigh;
1838	MCalibrationChargeCalc calcalc;
1839	MCalibrationRelTimeCalc timecalc;
1840	calcalc.SetExtractor(fExtractor);
1841	calcalc.SetOutputFile("");
1842	timecalc.SetOutputFile("");
1843
1844	if (IsDebug())
1845	{
1846	chargecam.SetDebug();
1847	calcalc.SetDebug();
1848	}
1849
1850	//
1851	// Calibration histogramming
1852	//
1853	MFillH fillpin("MHCalibrationChargePINDiode", "MExtractedSignalPINDiode", "FillPINDiode");
1854	MFillH fillbnd("MHCalibrationChargeBlindCam", "MExtractedSignalBlindPixel", "FillBlindCam");
1855	MFillH fillcam("MHCalibrationChargeCam", "MExtractedSignalCam", "FillChargeCam");
1856	MFillH filltme("MHCalibrationRelTimeCam", "MArrivalTimeCam", "FillRelTime");
1857	fillpin.SetBit(MFillH::kDoNotDisplay);
1858	fillbnd.SetBit(MFillH::kDoNotDisplay);
1859	fillcam.SetBit(MFillH::kDoNotDisplay);
1860	filltme.SetBit(MFillH::kDoNotDisplay);
1861
1862	//
1863	// Set default extractors in case, none has been set...
1864	//
1865	/*
1866	if (!fExtractor)
1867	fExtractor = &extract2;
1868	if (!fTimeExtractor)
1869	fTimeExtractor = &timehigh;
1870	*/
1871	MExtractTimeAndChargeSpline spline;
1872	if (!fExtractor)
1873	fExtractor = &spline;
1874	// if (!fTimeExtractor)
1875	// fTimeExtractor = &timehigh;
1876
1877	const Bool_t istimecharge = fExtractor->InheritsFrom("MExtractTimeAndCharge");
1878
1879	//
1880	// Look if the extractor is a pure charge or also a time extractor
1881	//
1882	if (istimecharge)
1883	{
1884	if (fExtractorCam.GetSize() == pedcam.GetSize())
1885	calcalc.SetPedestals(&fExtractorCam);
1886	else
1887	{
1888	*fLog << err << GetDescriptor() << "ERROR - ";
1889	*fLog << "Used Extractor derives from MExtractTimeAndCharge, " << endl;
1890	*fLog << "but MExtractorCam size " << fExtractorCam.GetSize() << " ";
1891	*fLog << "mismatch pedcam size " << pedcam.GetSize() << "! " << endl;
1892	return kFALSE;
1893	}
1894	}
1895
1896	//
1897	// Setup more tasks and tasklist
1898	//
1899	MTaskEnv taskenv("ExtractSignal");
1900	taskenv.SetDefault(fExtractor);
1901
1902	tlist.AddToList(&trgpat);
1903	if (fColor != MCalibrationCam::kCT1)
1904	tlist.AddToList(&ccalib);
1905	tlist.AddToList(&decode);
1906	tlist.AddToList(&merge);
1907	tlist.AddToList(&apply);
1908
1909	MPedCalcPedRun pedcalc;
1910	pedcalc.SetExtractWindow(fExtractor->GetHiGainFirst(),TMath::Nint(fExtractor->GetNumHiGainSamples()));
1911
1912	if (IsIntensity())
1913	tlist.AddToList(&pedcalc);
1914
1915	MCalibColorSet colorset;
1916	if (fColor != MCalibrationCam::kNONE)
1917	colorset.SetExplicitColor(fColor);
1918	tlist.AddToList(&colorset);
1919
1920	tlist.AddToList(&taskenv);
1921
1922	if (IsUsePINDiode())
1923	tlist.AddToList(&pinext);
1924	if (IsUseBlindPixel())
1925	tlist.AddToList(&blindext);
1926
1927	MTaskEnv taskenv2("ExtractTime");
1928	if (!istimecharge)
1929	{
1930	taskenv2.SetDefault(fTimeExtractor);
1931
1932	if (IsRelTimes())
1933	tlist.AddToList(&taskenv2);
1934	}
1935
1936	//
1937	// Apply a filter against cosmics
1938	// (will have to be needed in the future
1939	// when the calibration hardware-trigger is working)
1940	//
1941	MFCosmics cosmics;
1942	cosmics.SetMaxEmptyPixels(0.05);
1943	cosmics.SetMaxAcceptedFraction(0.5); // max=0.5 cosmics
1944
1945	MContinue cont(&cosmics, "ContCosmics");
1946	tlist.AddToList(&cont);
1947
1948	MCalibColorSteer steer;
1949	if (IsIntensity())
1950	tlist.AddToList(&steer);
1951
1952	if (IsRelTimes())
1953	{
1954	tlist.AddToList(&filltme);
1955	tlist.AddToList(&timecalc);
1956	}
1957
1958	tlist.AddToList(&fillcam);
1959
1960	if (IsUseBlindPixel())
1961	tlist.AddToList(&fillbnd);
1962	if (IsUsePINDiode())
1963	tlist.AddToList(&fillpin);
1964
1965	tlist.AddToList(&calcalc);
1966
1967	// Create and setup the eventloop
1968	MEvtLoop evtloop(fName);
1969	evtloop.SetParList(&plist);
1970	evtloop.SetDisplay(fDisplay);
1971	evtloop.SetLogStream(fLog);
1972	if (!SetupEnv(evtloop))
1973	return kFALSE;
1974
1975	if (!taskenv.GetTask() && !taskenv2.GetTask())
1976	{
1977	*fLog << err << "ERROR - Neither ExtractSignal nor ExtractTime initialized or both '<dummy>'." << endl;
1978	return kFALSE;
1979	}
1980
1981	if (!WriteTasks(taskenv.GetTask(), istimecharge ? 0 : taskenv2.GetTask()))
1982	return kFALSE;
1983
1984	// Execute first analysis
1985	const Bool_t rc = evtloop.Eventloop();
1986
1987	if (!fCalibrationPINDiode.IsValid())
1988	SetUsePINDiode(kFALSE);
1989
1990	const Int_t numexec = IsUseRawData() ? rawread.GetNumExecutions() : read.GetNumExecutions();
1991	if (numexec>0)
1992	{
1993	DisplayResult(plist);
1994	if (!WriteResult(plist))
1995	return kFALSE;
1996	}
1997
1998	if (!rc)
1999	{
2000	*fLog << err << GetDescriptor() << ": Failed." << endl;
2001	return kFALSE;
2002	}
2003
2004	// --------------------------------------------------------------------------------
2005
2006	if (fIsPixelCheck)
2007	{
2008	chargecam[fCheckedPixId].DrawClone("datacheck");
2009	chargecam(fCheckedPixId).DrawClone("datacheck");
2010
2011	if (IsRelTimes())
2012	{
2013	reltimecam[fCheckedPixId].DrawClone("");
2014	reltimecam(fCheckedPixId).DrawClone("");
2015	}
2016	}
2017
2018	*fLog << all << GetDescriptor() << ": Done." << endl;
2019
2020	return kTRUE;
2021	}
2022
2023	/*
2024	Bool_t MJCalibration::WriteEventloop(MEvtLoop &evtloop) const
2025	{
2026	if (IsNoStorage())
2027	return kTRUE;
2028
2029	if (fPathOut.IsNull())
2030	return kTRUE;
2031
2032	const TString oname(GetOutputFile());
2033
2034	*fLog << inf << "Writing to file: " << oname << endl;
2035
2036	TFile file(oname, fOverwrite?"RECREATE":"NEW", "File created by MJCalibration", 9);
2037	if (!file.IsOpen())
2038	{
2039	*fLog << err << "ERROR - Couldn't open file " << oname << " for writing..." << endl;
2040	return kFALSE;
2041	}
2042
2043	if (evtloop.Write(fName)<=0)
2044	{
2045	*fLog << err << "Unable to write MEvtloop to " << oname << endl;
2046	return kFALSE;
2047	}
2048
2049	return kTRUE;
2050	}
2051	*/
2052
2053	Bool_t MJCalibration::WriteTasks(MTask t1, MTask t2) const
2054	{
2055	if (IsNoStorage())
2056	return kTRUE;
2057
2058	TObjArray cont;
2059	if (t1)
2060	cont.Add(t1);
2061	if (t2)
2062	cont.Add(t2);
2063
2064	return WriteContainer(cont, GetOutputFileName(), fOverwrite?"RECREATE":"NEW");
2065	}
2066
2067	// --------------------------------------------------------------------------
2068	//
2069	// Write the result into the output file GetOutputFile(), if fOutputPath exists.
2070	//
2071	// The following containers are written:
2072	// - MStatusDisplay
2073	// - MCalibrationChargeCam or MCalibrationIntensityChargeCam
2074	// - MCalibrationBlindCam or MCalibrationIntensityBlindCam
2075	// - MCalibrationQECam or MCalibrationIntensityQECam
2076	// - MCalibrationChargePINDiode
2077	// - MBadPixelsCam
2078	// If the flag kRelTimes is set, then also:
2079	// - MCalibrationRelTimeCam or MCalibrationIntensityRelTimeCam
2080	//
2081	Bool_t MJCalibration::WriteResult(MParList &plist)
2082	{
2083	if (IsNoStorage())
2084	return kTRUE;
2085
2086	TObjArray cont;
2087
2088	if (IsIntensity())
2089	{
2090	cont.Add(&fIntensBadCam);
2091	cont.Add(&fIntensCalibCam);
2092	cont.Add(&fIntensQECam);
2093	cont.Add(&fIntensBlindCam);
2094	}
2095	else
2096	{
2097	cont.Add(&fBadPixels);
2098	cont.Add(&fCalibrationCam);
2099	cont.Add(&fQECam);
2100	cont.Add(&fCalibrationBlindCam);
2101	}
2102	cont.Add(&fCalibrationPINDiode);
2103
2104	//if (IsRelTimes())
2105	cont.Add(IsIntensity() ? (TObject)&fIntensRelTimeCam : (TObject)&fRelTimeCam);
2106
2107	if (fExtractorCam.GetSize() != 0)
2108	cont.Add(&fExtractorCam);
2109
2110	TObject *pedcam = plist.FindObject("MPedestalCam");
2111	if (!pedcam)
2112	*fLog << warn << " - WARNING - MPedestalCam (fundamental)... not found for writing!" << endl;
2113	else
2114	cont.Add(pedcam);
2115
2116	TObject *geom = plist.FindObject("MGeomCam");
2117	if (!geom)
2118	*fLog << warn << " - WARNING - MGeomCam... not found for writing!" << endl;
2119	else
2120	cont.Add(geom);
2121
2122	if (IsHistsStorage())
2123	{
2124	cont.Add(plist.FindObject("MHCalibrationChargeCam"));
2125	cont.Add(plist.FindObject("MHCalibrationChargeBlindCam"));
2126	cont.Add(plist.FindObject("MHCalibrationChargePINDiode"));
2127	if (IsRelTimes())
2128	cont.Add(plist.FindObject("MHCalibrationRelTimeCam"));
2129	}
2130
2131	return WriteContainer(cont, GetOutputFileName(), "UPDATE");
2132	}
2133
2134	void MJCalibration::DisplayDoubleProject(MHCamera cam, const char whatsmall, const char* whatbig) const
2135	{
2136
2137	TArrayI inner(1);
2138	inner[0] = 0;
2139
2140	TArrayI outer(1);
2141	outer[0] = 1;
2142
2143	TArrayI s1(3);
2144	s1[0] = 6;
2145	s1[1] = 1;
2146	s1[2] = 2;
2147
2148	TArrayI s2(3);
2149	s2[0] = 3;
2150	s2[1] = 4;
2151	s2[2] = 5;
2152
2153	TVirtualPad *pad = gPad;
2154	pad->Divide(2,1);
2155
2156	TH1D *inout[2];
2157
2158	for (int i=0; i<2; i++)
2159	{
2160	pad->cd(i+1);
2161	gPad->SetBorderMode(0);
2162	gPad->SetTicks();
2163
2164	inout[i] = cam->ProjectionS(TArrayI(), TArrayI(1,&i), i==0 ? "Inner" : "Outer");
2165	FixDataCheckHist(inout[i]);
2166	inout[i]->SetTitle(Form("%s %s",cam->GetTitle(),i==0 ? "Inner" : "Outer"));
2167	inout[i]->SetDirectory(NULL);
2168	inout[i]->SetLineColor(kRed+i);
2169	inout[i]->SetBit(kCanDelete);
2170	inout[i]->Draw();
2171	//
2172	// Display the outliers as dead and noisy pixels
2173	//
2174	if (!inout[i]->Fit("gaus","0Q"))
2175	DisplayOutliers(inout[i],whatsmall,whatbig);
2176
2177	gPad->Modified();
2178	gPad->Update();
2179	TPaveStats st = (TPaveStats)inout[i]->GetListOfFunctions()->FindObject("stats");
2180	st->SetY1NDC(0.6);
2181	st->SetY2NDC(0.9);
2182	st->SetX1NDC(0.55);
2183	st->SetX2NDC(0.99);
2184	gPad->Modified();
2185	gPad->Update();
2186
2187	TLegend *leg2 = new TLegend(0.55,0.4,0.99,0.6);
2188
2189	//
2190	// Display the two half of the camera separately
2191	//
2192	TH1D *half[2];
2193	half[0] = cam->ProjectionS(s1, TArrayI(1,&i), "Sector 6-1-2");
2194	half[1] = cam->ProjectionS(s2, TArrayI(1,&i), "Sector 3-4-5");
2195
2196	for (int j=0; j<2; j++)
2197	{
2198	half[j]->SetLineColor(kRed+i+2*j+1);
2199	half[j]->SetDirectory(NULL);
2200	half[j]->SetBit(kCanDelete);
2201	half[j]->Draw("same");
2202	leg2->AddEntry(half[j], half[j]->GetName(), "l");
2203	}
2204	leg2->Draw();
2205	}
2206	}

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

Download in other formats: