Context Navigation

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

Visit:

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

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

Download in other formats: