Context Navigation

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

Visit:

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

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

Download in other formats: