Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

MCalibrationChargeCalc.cc

Visit:

Last change on this file was 10166, checked in by tbretz, 14 years ago
Removed the old obsolete cvs header line.
File size: 79.3 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): Markus Gaug 02/2004 <mailto:markus@ifae.es>
19	! Author(s): Thomas Bretz <mailto:tbretz@astro.uni-wuerzburg.de>
20	!
21	! Copyright: MAGIC Software Development, 2000-2007
22	!
23	!
24	\* ======================================================================== */
25	//////////////////////////////////////////////////////////////////////////////
26	//
27	// MCalibrationChargeCalc
28	//
29	// Task to calculate the calibration conversion factors and quantum efficiencies
30	// from the fit results to the summed FADC slice distributions delivered by
31	// MCalibrationChargeCam, MCalibrationChargePix, MCalibrationChargeBlindPix and
32	// MCalibrationChargePINDiode, calculated and filled by MHCalibrationChargeCam,
33	// MHCalibrationChargePix, MHCalibrationChargeBlindPix and MHCalibrationChargePINDiode.
34	//
35	// PreProcess(): Initialize pointers to MCalibrationChargeCam, MCalibrationChargeBlindPix
36	// MCalibrationChargePINDiode and MCalibrationQECam
37	//
38	// Initialize pulser light wavelength
39	//
40	// ReInit(): MCalibrationCam::InitSize(NumPixels) is called from MGeomApply (which allocates
41	// memory in a TClonesArray of type MCalibrationChargePix)
42	// Initializes pointer to MBadPixelsCam
43	//
44	// Process(): Nothing to be done, histograms getting filled by MHCalibrationChargeCam
45	//
46	// PostProcess(): - FinalizePedestals()
47	// - FinalizeCharges()
48	// - FinalizeFFactorMethod()
49	// - FinalizeBadPixels()
50	// - FinalizeBlindCam()
51	// - FinalizePINDiode()
52	// - FinalizeFFactorQECam()
53	// - FinalizeBlindPixelQECam()
54	// - FinalizePINDiodeQECam()
55	//
56	// Input Containers:
57	// MCalibrationChargeCam
58	// MCalibrationChargeBlindPix
59	// MCalibrationChargePINDiode
60	// MCalibrationQECam
61	// MPedestalCam
62	// MBadPixelsCam
63	// MGeomCam
64	// MTime
65	//
66	// Output Containers:
67	// MCalibrationChargeCam
68	// MCalibrationChargeBlindPix
69	// MCalibrationChargePINDiode
70	// MCalibrationQECam
71	// MBadPixelsCam
72	//
73	//
74	// Preliminary description of the calibration in photons (email from 12/02/04)
75	//
76	// Why calibrating in photons:
77	// ===========================
78	//
79	// At the Barcelona meeting in 2002, we decided to calibrate the camera in
80	// photons. This for the following reasons:
81	//
82	// * The physical quantity arriving at the camera are photons. This is
83	// the direct physical information from the air shower. The photons
84	// have a flux and a spectrum.
85	//
86	// * The photon fluxes depend mostly on the shower energy (with
87	// corrections deriving from the observation conditions), while the photon
88	// spectra depend mostly on the observation conditions: zenith angle,
89	// quality of the air, also the impact parameter of the shower.
90	//
91	// * The photomultiplier, in turn, has different response properties
92	// (quantum efficiencies) for photons of different colour. (Moreover,
93	// different pixels have slightly different quantum efficiencies).
94	// The resulting number of photo-electrons is then amplified (linearly)
95	// with respect to the photo-electron flux.
96	//
97	// * In the ideal case, one would like to disentagle the effects
98	// of the observation conditions from the primary particle energy (which
99	// one likes to measure). To do so, one needs:
100	//
101	// 1) A reliable calibration relating the FADC counts to the photo-electron
102	// flux -> This is accomplished with the F-Factor method.
103	//
104	// 2) A reliable calibration of the wavelength-dependent quantum efficiency
105	// -> This is accomplished with the combination of the three methods,
106	// together with QE-measurements performed by David in order to do
107	// the interpolation.
108	//
109	// 3) A reliable calibration of the observation conditions. This means:
110	// - Tracing the atmospheric conditions -> LIDAR
111	// - Tracing the observation zenith angle -> Drive System
112	//
113	// 4) Some knowlegde about the impact parameter:
114	// - This is the only part which cannot be accomplished well with a
115	// single telescope. We would thus need to convolute the spectrum
116	// over the distribution of impact parameters.
117	//
118	//
119	// How an ideal calibration would look like:
120	// =========================================
121	//
122	// We know from the combined PIN-Diode and Blind-Pixel Method the response of
123	// each pixel to well-measured light fluxes in three representative
124	// wavelengths (green, blue, UV). We also know the response to these light
125	// fluxes in photo-electrons. Thus, we can derive:
126	//
127	// - conversion factors to photo-electrons
128	// - conversion factors to photons in three wavelengths.
129	//
130	// Together with David's measurements and some MC-simulation, we should be
131	// able to derive tables for typical Cherenkov-photon spectra - convoluted
132	// with the impact parameters and depending on the athmospheric conditions
133	// and the zenith angle (the "outer parameters").
134	//
135	// From these tables we can create "calibration tables" containing some
136	// effective quantum efficiency depending on these outer parameters and which
137	// are different for each pixel.
138	//
139	// In an ideal MCalibrate, one would thus have to convert first the FADC
140	// slices to Photo-electrons and then, depending on the outer parameters,
141	// look up the effective quantum efficiency and get the mean number of
142	// photons which is then used for the further analysis.
143	//
144	// How the (first) MAGIC calibration should look like:
145	// ===================================================
146	//
147	// For the moment, we have only one reliable calibration method, although
148	// with very large systematic errors. This is the F-Factor method. Knowing
149	// that the light is uniform over the whole camera (which I would not at all
150	// guarantee in the case of the CT1 pulser), one could in principle already
151	// perform a relative calibration of the quantum efficiencies in the UV.
152	// However, the spread in QE at UV is about 10-15% (according to the plot
153	// that Abelardo sent around last time. The spread in photo-electrons is 15%
154	// for the inner pixels, but much larger (40%) for the outer ones.
155	//
156	// I'm not sure if we can already say that we have measured the relative
157	// difference in quantum efficiency for the inner pixels and produce a first
158	// QE-table for each pixel. To so, I would rather check in other wavelengths
159	// (which we can do in about one-two weeks when the optical transmission of
160	// the calibration trigger is installed).
161	//
162	// Thus, for the moment being, I would join Thomas proposal to calibrate in
163	// photo-electrons and apply one stupid average quantum efficiency for all
164	// pixels. This keeping in mind that we will have much preciser information
165	// in about one to two weeks.
166	//
167	//
168	// What MCalibrate should calculate and what should be stored:
169	// ===========================================================
170	//
171	// It is clear that in the end, MCerPhotEvt will store photons.
172	// MCalibrationCam stores the conversionfactors to photo-electrons and also
173	// some tables of how to apply the conversion to photons, given the outer
174	// parameters. This is not yet implemented and not even discussed.
175	//
176	// To start, I would suggest that we define the "average quantum efficiency"
177	// (maybe something like 25+-3%) and apply them equally to all
178	// photo-electrons. Later, this average factor can be easily replaced by a
179	// pixel-dependent factor and later by a (pixel-dependent) table.
180	//
181	//
182	// ClassVersion 2:
183	// - Float_t fPheErrLimit;
184	// + Float_t fPheErrLowerLimit; // Lower limit acceptance nr. phe's w.r.t. area idx mean (in sigmas)
185	// + Float_t fPheErrUpperLimit; // Upper limit acceptance nr. phe's w.r.t. area idx mean (in sigmas)
186	//
187	//
188	// ClassVersion 3:
189	// + Bool_t fUseExtractorRes; // Include extractor resolution in F-Factor method
190	//
191	// ClassVersion 4:
192	// + Float_t fUnsuitablesLimit; // Limit for relative number of unsuitable pixels
193	// + Float_t fUnreliablesLimit; // Limit for relative number of unreliable pixels
194	// + Float_t fExternalNumPhes; // External mean number of photo-electrons set from outside
195	// + Float_t fExternalNumPhesRelVar; // External rel. var. number of photo-electrons set from outside
196	//
197	// ClassVersion 5:
198	// - TString fOutputPath
199	// - TString fOutputFile
200	//
201	// ClassVersion 6:
202	// - Bool_t fContinousCalibration
203	//
204	//////////////////////////////////////////////////////////////////////////////
205	#include "MCalibrationChargeCalc.h"
206
207	#include <TSystem.h>
208	#include <TH1.h>
209	#include <TF1.h>
210
211	#include "MLog.h"
212	#include "MLogManip.h"
213
214	#include "MMath.h"
215
216	#include "MParList.h"
217
218	#include "MCalibrationPattern.h"
219
220	#include "MGeomCam.h"
221	#include "MGeom.h"
222	#include "MHCamera.h"
223
224	#include "MPedestalCam.h"
225	#include "MPedestalPix.h"
226
227	#include "MHCalibrationChargeCam.h"
228	#include "MHCalibrationChargeBlindCam.h"
229
230	#include "MCalibrationChargeCam.h"
231	#include "MCalibrationChargePix.h"
232	#include "MCalibrationChargePINDiode.h"
233	#include "MCalibrationBlindPix.h"
234	#include "MCalibrationBlindCam.h"
235
236	#include "MExtractedSignalCam.h"
237	#include "MExtractedSignalPix.h"
238	#include "MExtractedSignalBlindPixel.h"
239	#include "MExtractedSignalPINDiode.h"
240
241	#include "MBadPixelsCam.h"
242
243	#include "MCalibrationQECam.h"
244	#include "MCalibrationQEPix.h"
245
246	ClassImp(MCalibrationChargeCalc);
247
248	using namespace std;
249
250	const Float_t MCalibrationChargeCalc::fgChargeLimit = 4.5;
251	const Float_t MCalibrationChargeCalc::fgChargeErrLimit = 0.;
252	const Float_t MCalibrationChargeCalc::fgChargeRelErrLimit = 1.;
253	const Float_t MCalibrationChargeCalc::fgLambdaErrLimit = 0.2;
254	const Float_t MCalibrationChargeCalc::fgLambdaCheckLimit = 0.5;
255	const Float_t MCalibrationChargeCalc::fgPheErrLowerLimit = 6.0;
256	const Float_t MCalibrationChargeCalc::fgPheErrUpperLimit = 5.5;
257	const Float_t MCalibrationChargeCalc::fgFFactorErrLimit = 4.5;
258	const Float_t MCalibrationChargeCalc::fgArrTimeRmsLimit = 5.0;
259	const Float_t MCalibrationChargeCalc::fgUnsuitablesLimit = 0.1;
260	const Float_t MCalibrationChargeCalc::fgUnreliablesLimit = 0.3;
261
262	const char *MCalibrationChargeCalc::fgNamePedestalCam = "MPedestalCam";
263
264
265	// --------------------------------------------------------------------------
266	//
267	// Default constructor.
268	//
269	// Sets the pointer to fQECam and fGeom to NULL
270	//
271	// Calls AddToBranchList for:
272	// - MRawEvtData.fHiGainPixId
273	// - MRawEvtData.fLoGainPixId
274	// - MRawEvtData.fHiGainFadcSamples
275	// - MRawEvtData.fLoGainFadcSamples
276	//
277	// Initializes:
278	// - fArrTimeRmsLimit to fgArrTimeRmsLimit
279	// - fChargeLimit to fgChargeLimit
280	// - fChargeErrLimit to fgChargeErrLimit
281	// - fChargeRelErrLimit to fgChargeRelErrLimit
282	// - fFFactorErrLimit to fgFFactorErrLimit
283	// - fLambdaCheckLimit to fgLambdaCheckLimit
284	// - fLambdaErrLimit to fgLambdaErrLimit
285	// - fNamePedestalCam to fgNamePedestalCam
286	// - fPheErrLowerLimit to fgPheErrLowerLimit
287	// - fPheErrUpperLimit to fgPheErrUpperLimit
288	// - fPulserColor to MCalibrationCam::kCT1
289	// - fOutputPath to "."
290	// - fOutputFile to "ChargeCalibStat.txt"
291	// - flag debug to kFALSE
292	// - IsUseExtractorRes to kFALSE
293	// - IsUseExternalNumPhes to kFALSE
294	// - fExternalNumPhes to 0.
295	// - fExternalNumPhesRelVar to 0.
296	//
297	// Sets all checks
298	//
299	// Calls:
300	// - Clear()
301	//
302	MCalibrationChargeCalc::MCalibrationChargeCalc(const char name, const char title)
303	: fPulserColor(MCalibrationCam::kNONE), fContinousCalibration(kFALSE),
304	fGeom(NULL), fSignal(NULL), fCalibPattern(NULL), fExtractor(NULL)
305	{
306
307	fName = name ? name : "MCalibrationChargeCalc";
308	fTitle = title ? title : "Task to calculate the calibration constants and MCalibrationCam ";
309
310	AddToBranchList("MRawEvtData.fHiGainPixId");
311	AddToBranchList("MRawEvtData.fLoGainPixId");
312	AddToBranchList("MRawEvtData.fHiGainFadcSamples");
313	AddToBranchList("MRawEvtData.fLoGainFadcSamples");
314
315	SetArrTimeRmsLimit ();
316	SetChargeLimit ();
317	SetChargeErrLimit ();
318	SetChargeRelErrLimit ();
319	SetDebug ( kFALSE );
320	SetFFactorErrLimit ();
321	SetLambdaCheckLimit ();
322	SetLambdaErrLimit ();
323	SetNamePedestalCam ();
324	SetPheErrLowerLimit ();
325	SetPheErrUpperLimit ();
326	SetUnsuitablesLimit ();
327	SetUnreliablesLimit ();
328	SetUseExtractorRes ();
329	SetUseUnreliables ();
330	SetUseExternalNumPhes(kFALSE);
331
332	SetExternalNumPhes ();
333	SetExternalNumPhesRelVar();
334
335	SetCheckArrivalTimes ();
336	SetCheckDeadPixels ();
337	SetCheckDeviatingBehavior();
338	SetCheckExtractionWindow ();
339	SetCheckHistOverflow ();
340	SetCheckOscillations ();
341
342	Clear();
343
344	}
345
346	// --------------------------------------------------------------------------
347	//
348	// Sets:
349	// - all variables to 0.,
350	// - all flags to kFALSE
351	// - all pointers to NULL
352	// - the pulser colour to kNONE
353	// - fBlindPixelFlags to 0
354	// - fPINDiodeFlags to 0
355	//
356	void MCalibrationChargeCalc::Clear(const Option_t *o)
357	{
358
359	fNumHiGainSamples = 0.;
360	fNumLoGainSamples = 0.;
361	fSqrtHiGainSamples = 0.;
362	fSqrtLoGainSamples = 0.;
363	fNumInnerFFactorMethodUsed = 0;
364
365	fNumProcessed = 0;
366
367	fBadPixels = NULL;
368	fCam = NULL;
369	fHCam = NULL;
370	fQECam = NULL;
371	fBlindCam = NULL;
372	fHBlindCam = NULL;
373	fPINDiode = NULL;
374	fPedestals = NULL;
375
376	SetPulserColor ( MCalibrationCam::kNONE );
377
378	fStrength = 0.;
379	fBlindPixelFlags.Set(0);
380	fPINDiodeFlags .Set(0);
381	fResultFlags .Set(0);
382	}
383
384
385	// -----------------------------------------------------------------------------------
386	//
387	// The following container are searched for and execution aborted if not in MParList:
388	// - MPedestalCam
389	// - MCalibrationPattern
390	// - MExtractedSignalCam
391	//
392	Int_t MCalibrationChargeCalc::PreProcess(MParList *pList)
393	{
394
395	/*
396	if (IsInterlaced())
397	{
398	fTrigPattern = (MTriggerPattern*)pList->FindObject("MTriggerPattern");
399	if (!fTrigPattern)
400	{
401	*fLog << err << "MTriggerPattern not found... abort." << endl;
402	return kFALSE;
403	}
404	}
405	*/
406
407	fCalibPattern = (MCalibrationPattern*)pList->FindObject("MCalibrationPattern");
408	if (!fCalibPattern)
409	{
410	*fLog << err << "MCalibrationPattern not found... abort." << endl;
411	return kFALSE;
412	}
413
414	//
415	// Containers that have to be there.
416	//
417	fSignal = (MExtractedSignalCam*)pList->FindObject("MExtractedSignalCam");
418	if (!fSignal)
419	{
420	*fLog << err << "MExtractedSignalCam not found... aborting" << endl;
421	return kFALSE;
422	}
423
424	if (fPedestals)
425	return kTRUE;
426
427	fPedestals = (MPedestalCam*)pList->FindObject(AddSerialNumber(fNamePedestalCam), "MPedestalCam");
428	if (!fPedestals)
429	{
430	*fLog << err << fNamePedestalCam << " [MPedestalCam] not found... aborting" << endl;
431	return kFALSE;
432	}
433
434	// Obsolete... it is already set in the constructor isn't it?
435	fPulserColor = MCalibrationCam::kNONE;
436
437	return kTRUE;
438	}
439
440
441	// --------------------------------------------------------------------------
442	//
443	// Search for the following input containers and abort if not existing:
444	// - MGeomCam
445	// - MCalibrationChargeCam
446	// - MCalibrationQECam
447	// - MBadPixelsCam
448	//
449	// Search for the following input containers and give a warning if not existing:
450	// - MCalibrationBlindPix
451	// - MCalibrationChargePINDiode
452	//
453	// It retrieves the following variables from MCalibrationChargeCam:
454	//
455	// - fNumHiGainSamples
456	// - fNumLoGainSamples
457	//
458	// It defines the PixId of every pixel in:
459	//
460	// - MCalibrationChargeCam
461	// - MCalibrationQECam
462	//
463	// It sets all pixels in excluded which have the flag fBadBixelsPix::IsBad() set in:
464	//
465	// - MCalibrationChargePix
466	// - MCalibrationQEPix
467	//
468	// Sets the pulser colour and tests if it has not changed w.r.t. fPulserColor in:
469	//
470	// - MCalibrationChargeCam
471	// - MCalibrationBlindPix (if existing)
472	// - MCalibrationChargePINDiode (if existing)
473	//
474	Bool_t MCalibrationChargeCalc::ReInit(MParList *pList )
475	{
476
477	//
478	// Geometry
479	//
480	fGeom = (MGeomCam*)pList->FindObject("MGeomCam");
481	if (!fGeom)
482	{
483	*fLog << err << "No MGeomCam found... aborting." << endl;
484	return kFALSE;
485	}
486
487	//
488	// Charge histogram
489	//
490	fHCam = (MHCalibrationChargeCam*)pList->FindObject(AddSerialNumber("MHCalibrationChargeCam"));
491	if (!fHCam)
492	{
493	*fLog << err << "Cannot find MHCalibrationChargeCam ... abort." << endl;
494	*fLog << "Maybe you forget to call an MFillH for the MHCalibrationChargeCam before..." << endl;
495	return kFALSE;
496	}
497
498	//
499	// MCalibrationChargeCam
500	//
501	fCam = (MCalibrationChargeCam*)pList->FindObject(AddSerialNumber("MCalibrationChargeCam"));
502	if (!fCam)
503	{
504	*fLog << err << "Cannot find MCalibrationChargeCam ... abort." << endl;
505	*fLog << "Maybe you forget to call an MFillH for the MHCalibrationChargeCam before..." << endl;
506	return kFALSE;
507	}
508
509	//
510	// Blind pixel calibration
511	//
512	fBlindCam = (MCalibrationBlindCam*)pList->FindObject(AddSerialNumber("MCalibrationBlindCam"));
513	if (!fBlindCam)
514	*fLog << inf << "No MCalibrationBlindCam found... no Blind Pixel method!" << endl;
515
516	//
517	// Required containers
518	//
519	fQECam = (MCalibrationQECam*)pList->FindObject(AddSerialNumber("MCalibrationQECam"));
520	if (!fQECam)
521	{
522	*fLog << err << "Cannot find MCalibrationQECam ... abort." << endl;
523	return kFALSE;
524	}
525
526	fBadPixels = (MBadPixelsCam*)pList->FindObject(AddSerialNumber("MBadPixelsCam"));
527	if (!fBadPixels)
528	{
529	*fLog << err << "Cannot find MBadPixelsCam ... abort." << endl;
530	return kFALSE;
531	}
532
533	//
534	// Optional Containers
535	//
536	fPINDiode = (MCalibrationChargePINDiode*)pList->FindObject("MCalibrationChargePINDiode");
537	if (!fPINDiode)
538	*fLog << inf << "No MCalibrationChargePINDiode found... no PIN Diode method!" << endl;
539
540	fHBlindCam = (MHCalibrationChargeBlindCam*)pList->FindObject(AddSerialNumber("MHCalibrationChargeBlindCam"));
541	if (!fHBlindCam)
542	*fLog << inf << "No MHCalibrationChargeBlindCam found... no Blind Pixel method!" << endl;
543
544
545	//
546	// Further initialization
547	//
548	if (IsDebug())
549	{
550	const UInt_t npixels = fGeom->GetNumPixels();
551	for (UInt_t i=0; i<npixels; i++)
552	(*fCam)[i].SetDebug();
553	}
554
555	fResultFlags.Set(fGeom->GetNumAreas());
556
557	return kTRUE;
558	}
559
560	// ----------------------------------------------------------------------------------
561	//
562	// Set the correct colour to the charge containers
563	//
564	Int_t MCalibrationChargeCalc::Process()
565	{
566
567	const MCalibrationCam::PulserColor_t col = fCalibPattern->GetPulserColor();
568
569	//
570	// If pulser color didn't change there is nothing to do
571	//
572	const Float_t strength = fCalibPattern->GetPulserStrength();
573	const Float_t strdiff = TMath::Abs(strength-fStrength);
574	if (col == fPulserColor && strdiff < 0.05 )
575	{
576	fNumProcessed++;
577	return kTRUE;
578	}
579
580	//
581	// If there is no color is nothing to do
582	//
583	if (col == MCalibrationCam::kNONE)
584	return kTRUE;
585
586	//
587	// Now retrieve the colour and check if not various colours have been used
588	//
589	if (!fContinousCalibration && fPulserColor != MCalibrationCam::kNONE)
590	{
591	*fLog << warn << "Multiple colours used simultaneously!" << flush;
592	fHCam->Finalize();
593	if (fHBlindCam)
594	fHBlindCam->Finalize();
595
596	Finalize();
597
598	fHCam->ResetHists();
599	if (fHBlindCam)
600	fHBlindCam->ResetHists();
601
602	*fLog << inf << "Starting next calibration... " << flush;
603
604	fHCam->SetColor(col);
605	if (fHBlindCam)
606	fHBlindCam->SetColor(col);
607
608	fCam->SetPulserColor(col);
609	if (fBlindCam)
610	fBlindCam->SetPulserColor(col);
611	}
612
613	//
614	// Keep pulser color and strength in mind and output some information
615	//
616	fPulserColor = col;
617	fStrength = strength;
618
619	*fLog << inf << "Found new colour ... " << flush;
620
621	switch (col)
622	{
623	case MCalibrationCam::kGREEN: *fLog << "Green"; break;
624	case MCalibrationCam::kBLUE: *fLog << "Blue"; break;
625	case MCalibrationCam::kUV: *fLog << "UV"; break;
626	case MCalibrationCam::kCT1: *fLog << "CT1"; break;
627	default: break;
628	}
629
630	*fLog << inf << " with strength: " << strength << endl;
631
632	//
633	// Distribute new color to all containers
634	//
635	fCam->SetPulserColor(col);
636	if (fBlindCam)
637	fBlindCam->SetPulserColor(col);
638
639	fHCam->SetColor(col);
640	if (fHBlindCam)
641	fHBlindCam->SetColor(col);
642	if (fPINDiode)
643	fPINDiode->SetColor(col);
644
645	//
646	// Reset number of processed events
647	//
648	fNumProcessed = 0;
649
650	return kTRUE;
651	}
652
653	// -----------------------------------------------------------------------
654	//
655	// Return if number of executions is null.
656	//
657	Int_t MCalibrationChargeCalc::PostProcess()
658	{
659
660	if (GetNumExecutions() < 1)
661	return kTRUE;
662
663	if (fPulserColor == MCalibrationCam::kNONE)
664	{
665	*fLog << err << "ERROR - No event was flagged with a pulser color... no calibration possible." << endl;
666	return kFALSE;
667	}
668
669	if (fNumProcessed == 0)
670	return kTRUE;
671
672	*fLog << endl;
673
674	return Finalize();
675	}
676
677	// ----------------------------------------------------------------------------------------------------
678	//
679	// Check for outliers. They are marked with
680	// MBadPixelsPix::kFluctuatingArrivalTimes
681	//
682	// see also MCalibrationRelTimeCalc::FinalizeRelTimes
683	//
684	void MCalibrationChargeCalc::FinalizeAbsTimes()
685	{
686	const Int_t npixels = fGeom->GetNumPixels();
687	const Int_t nareas = fGeom->GetNumAreas();
688
689	// Create an array capable of holding all pixels
690	TArrayF arr(npixels);
691
692	for (Int_t aidx=0; aidx<nareas; aidx++)
693	{
694	Int_t n = 0;
695	for (Int_t i=0; i<npixels; i++)
696	{
697	// Check for this aidx only
698	if ((*fGeom)[i].GetAidx()!=aidx)
699	continue;
700
701	// check if pixel may not contain a valid value
702	if ((*fBadPixels)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
703	continue;
704
705	// check if it was excluded for some reason
706	const MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
707	if (pix.IsExcluded())
708	continue;
709
710	// if TimePrecision is valid fill it into array
711	if (pix.GetAbsTimeRms()>0)
712	arr[n++] = pix.GetAbsTimeRms();
713	}
714
715	// Check the ratio of valid entries to the ratio of pixels
716	const Float_t ratio = 100*n/fGeom->GetNumPixWithAidx(aidx);
717	if (3*ratio<2)
718	*fLog << warn << "Area " << setw(4) << aidx << ": Only " << ratio << "% pixels with valid time resolution found." << endl;
719
720	// Calculate median and median deviation
721	Double_t med;
722	const Double_t dev = MMath::MedianDev(n, arr.GetArray(), med);
723
724	// Calculate upper and lower limit
725	const Float_t lolim = TMath::Max(med-fArrTimeRmsLimit*dev, 0.);
726	const Float_t hilim = TMath::Max(med+fArrTimeRmsLimit*dev, 0.);
727
728	// Now find the outliers
729	for (Int_t i=0; i<npixels; i++)
730	{
731	// Search only within this aidx
732	if ((*fGeom)[i].GetAidx()!=aidx)
733	continue;
734
735	// skip pixels already known to be unsuitable
736	if ((*fBadPixels)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
737	continue;
738
739	// check if a pixel has been excluded. This
740	const MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
741
742	// Check if time precision is valid (might be invalid
743	// for example in cae of empty histograms)
744	const Float_t res = pix.GetAbsTimeRms();
745	if (res<0) //FIXME!!! How does this happen?
746	{
747	*fLog << warn << "Pixel " << setw(4) << i << ": Abs-time rms could not be calculated." << endl;
748	(*fBadPixels)[i].SetUncalibrated(MBadPixelsPix::kDeviatingAbsTimeResolution);
749	continue;
750	}
751
752	if (res==0)
753	{
754	*fLog << warn << "Pixel " << setw(4) << i << ": Abs-time rms==0." << endl;
755	(*fBadPixels)[i].SetUncalibrated(MBadPixelsPix::kDeviatingAbsTimeResolution);
756	continue;
757	}
758
759	// Now compare to a lower and upper limit
760	if (res<=lolim \|\| res>=hilim)
761	{
762	*fLog << warn << "Pixel " << setw(4) << i << ": Deviation from abs-time rms: "
763	<< Form("%5.2f", res) << " out of range "
764	<< Form("[%4.2f,%4.2f]", lolim, hilim) << endl;
765
766	(*fBadPixels)[i].SetUncalibrated(MBadPixelsPix::kDeviatingAbsTimeResolution);
767	}
768	}
769	}
770	}
771
772	// -----------------------------------------------------------------------
773	//
774	// Return kTRUE if fPulserColor is kNONE
775	//
776	// First loop over pixels, average areas and sectors, call:
777	// - FinalizePedestals()
778	// - FinalizeCharges()
779	// for every entry. Count number of valid pixels in loop and return kFALSE
780	// if there are none (the "Michele check").
781	//
782	// Call FinalizeBadPixels()
783	//
784	// Call FinalizeFFactorMethod() (second and third loop over pixels and areas)
785	//
786	// Call FinalizeBlindCam()
787	// Call FinalizePINDiode()
788	//
789	// Call FinalizeFFactorQECam() (fourth loop over pixels and areas)
790	// Call FinalizeBlindPixelQECam() (fifth loop over pixels and areas)
791	// Call FinalizePINDiodeQECam() (sixth loop over pixels and areas)
792	//
793	// Call FinalizeUnsuitablePixels()
794	//
795	// Call MParContainer::SetReadyToSave() for fCam, fQECam, fBadPixels and
796	// fBlindCam and fPINDiode if they exist
797	//
798	// Print out some statistics
799	//
800	Int_t MCalibrationChargeCalc::Finalize()
801	{
802	// The number of used slices are just a mean value
803	// the real number might change from event to event.
804	// (up to 50%!)
805
806	fNumHiGainSamples = fSignal->GetNumUsedHiGainFADCSlices();
807	fNumLoGainSamples = fSignal->GetNumUsedLoGainFADCSlices();
808
809	fSqrtHiGainSamples = TMath::Sqrt(fNumHiGainSamples);
810	fSqrtLoGainSamples = TMath::Sqrt(fNumLoGainSamples);
811
812	if (fPINDiode)
813	if (!fPINDiode->IsValid())
814	{
815	*fLog << warn << GetDescriptor()
816	<< ": MCalibrationChargePINDiode is declared not valid... no PIN Diode method! " << endl;
817	fPINDiode = NULL;
818	}
819
820	//
821	// First loop over pixels, call FinalizePedestals and FinalizeCharges
822	//
823	Int_t nvalid = 0;
824	for (Int_t pixid=0; pixid<fPedestals->GetSize(); pixid++)
825	{
826	//
827	// Check if the pixel has been excluded from the fits
828	//
829	MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[pixid];
830	if (pix.IsExcluded())
831	continue;
832
833	FinalizePedestals((fPedestals)[pixid], pix, (fGeom)[pixid].GetAidx());
834
835	if (FinalizeCharges(pix, (*fBadPixels)[pixid], "Pixel "))
836	nvalid++;
837	}
838
839	FinalizeAbsTimes();
840
841	*fLog << endl;
842
843	//
844	// The Michele check ...
845	//
846	if (nvalid == 0)
847	{
848	if (!fContinousCalibration)
849	{
850	*fLog << warn << GetDescriptor() << ": All pixels have non-valid calibration. "
851	<< "Did you forget to fill the histograms "
852	<< "(filling MHCalibrationChargeCam from MExtractedSignalCam using MFillH) ? " << endl;
853	*fLog << warn << GetDescriptor() << ": Or, maybe, you have used a pedestal run "
854	<< "instead of a calibration run " << endl;
855	return kFALSE;
856	}
857	}
858
859	for (UInt_t aidx=0; aidx<fGeom->GetNumAreas(); aidx++)
860	{
861
862	const MPedestalPix &ped = fPedestals->GetAverageArea(aidx);
863	MCalibrationChargePix &pix = (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
864	const MArrayI &arr = fHCam->GetAverageAreaNum();
865
866	FinalizePedestals(ped,pix,aidx);
867
868	//
869	// Correct for sqrt(number of valid pixels) in the pedestal RMS
870	// (already done for calibration sigma in MHCalibrationCam::CalcAverageSigma()
871	//
872	const Double_t sqrtnum = TMath::Sqrt((Double_t)arr[aidx]);
873
874	pix.SetPedRMS(pix.GetPedRms()sqrtnum, pix.GetPedRmsErr()sqrtnum);
875	pix.SetSigma (pix.GetSigma()/pix.GetFFactorFADC2Phe());
876
877	FinalizeCharges(pix, fCam->GetAverageBadArea(aidx),"area id");
878	}
879
880	*fLog << endl;
881
882	for (UInt_t sector=0; sector<fGeom->GetNumSectors(); sector++)
883	{
884
885	const MPedestalPix &ped = fPedestals->GetAverageSector(sector);
886
887	MCalibrationChargePix &pix = (MCalibrationChargePix&)fCam->GetAverageSector(sector);
888	FinalizePedestals(ped,pix, 0);
889	}
890
891	*fLog << endl;
892
893	//
894	// Finalize Bad Pixels
895	//
896	FinalizeBadPixels();
897
898	//
899	// Finalize F-Factor method
900	//
901	if (FinalizeFFactorMethod())
902	fCam->SetFFactorMethodValid(kTRUE);
903	else
904	{
905	*fLog << warn << "Could not calculate the photons flux from the F-Factor method " << endl;
906	fCam->SetFFactorMethodValid(kFALSE);
907	if (!fContinousCalibration)
908	return kFALSE;
909	}
910
911	*fLog << endl;
912
913	//
914	// Finalize Blind Pixel
915	//
916	fQECam->SetBlindPixelMethodValid(FinalizeBlindCam());
917
918	//
919	// Finalize PIN Diode
920	//
921	fQECam->SetBlindPixelMethodValid(FinalizePINDiode());
922
923	//
924	// Finalize QE Cam
925	//
926	FinalizeFFactorQECam();
927	FinalizeBlindPixelQECam();
928	FinalizePINDiodeQECam();
929	FinalizeCombinedQECam();
930
931	//
932	// Re-direct the output to an ascii-file from now on:
933	//
934	*fLog << inf << endl;
935	*fLog << GetDescriptor() << ": Fatal errors statistics:" << endl;
936
937	PrintUncalibrated(MBadPixelsPix::kChargeIsPedestal,
938	Form("%s%2.1f%s","Signal less than ",fChargeLimit," Pedestal RMS: "));
939	PrintUncalibrated(MBadPixelsPix::kChargeRelErrNotValid,
940	Form("%s%2.1f%s","Signal Error bigger than ",fChargeRelErrLimit," times Mean Signal: "));
941	PrintUncalibrated(MBadPixelsPix::kLoGainSaturation,
942	"Low Gain Saturation: ");
943	// PrintUncalibrated(MBadPixelsPix::kMeanTimeInFirstBin,
944	// Form("%s%2.1f%s","Mean Abs. Arr. Time in First ",1.," Bin(s): "));
945	// PrintUncalibrated(MBadPixelsPix::kMeanTimeInLast2Bins,
946	// Form("%s%2.1f%s","Mean Abs. Arr. Time in Last ",2.," Bin(s): "));
947	PrintUncalibrated(MBadPixelsPix::kHiGainOverFlow,
948	"Pixels with High Gain Overflow: ");
949	PrintUncalibrated(MBadPixelsPix::kLoGainOverFlow,
950	"Pixels with Low Gain Overflow : ");
951	// PrintUncalibrated(MBadPixelsPix::kFluctuatingArrivalTimes,
952	// "Fluctuating Pulse Arrival Times: ");
953	PrintUncalibrated(MBadPixelsPix::kDeviatingAbsTimeResolution,
954	Form("%s%2.1f%s ","Abs.time rms more than ", fArrTimeRmsLimit, " dev from median: "));
955	PrintUncalibrated(MBadPixelsPix::kDeadPedestalRms,
956	"Presumably dead from Pedestal Rms: ");
957	PrintUncalibrated(MBadPixelsPix::kDeviatingNumPhes,
958	"Deviating number of phes: ");
959	PrintUncalibrated(MBadPixelsPix::kLoGainBlackout,
960	"Too many blackout events in low gain: ");
961	PrintUncalibrated(MBadPixelsPix::kPreviouslyExcluded,
962	"Previously excluded: ");
963
964	*fLog << inf << endl;
965	*fLog << GetDescriptor() << ": Unreliable errors statistics:" << endl;
966
967	PrintUncalibrated(MBadPixelsPix::kChargeSigmaNotValid,
968	"Signal Sigma smaller than Pedestal RMS: ");
969	PrintUncalibrated(MBadPixelsPix::kHiGainOscillating,
970	"Changing Hi Gain signal over time: ");
971	PrintUncalibrated(MBadPixelsPix::kLoGainOscillating,
972	"Changing Lo Gain signal over time: ");
973	PrintUncalibrated(MBadPixelsPix::kHiGainNotFitted,
974	"Unsuccesful Gauss fit to the Hi Gain: ");
975	PrintUncalibrated(MBadPixelsPix::kLoGainNotFitted,
976	"Unsuccesful Gauss fit to the Lo Gain: ");
977	PrintUncalibrated(MBadPixelsPix::kDeviatingFFactor,
978	"Deviating F-Factor: ");
979
980	fCam->SetReadyToSave();
981	fQECam->SetReadyToSave();
982	fBadPixels->SetReadyToSave();
983
984	if (fBlindCam)
985	fBlindCam->SetReadyToSave();
986	if (fPINDiode)
987	fPINDiode->SetReadyToSave();
988
989	//
990	// Finalize calibration statistics
991	//
992	return FinalizeUnsuitablePixels();
993	}
994
995	// ----------------------------------------------------------------------------------
996	//
997	// Retrieves pedestal and pedestal RMS from MPedestalPix
998	// Retrieves total entries from MPedestalCam
999	// Sets pedestalfNumHiGainSamples and pedestalfNumLoGainSamples in MCalibrationChargePix
1000	// Sets pedRMS fSqrtHiGainSamples and pedRMS fSqrtLoGainSamples in MCalibrationChargePix
1001	//
1002	// If the flag MCalibrationPix::IsHiGainSaturation() is set, call also:
1003	// - MCalibrationChargePix::CalcLoGainPedestal()
1004	//
1005	void MCalibrationChargeCalc::FinalizePedestals(const MPedestalPix &ped, MCalibrationChargePix &cal, const Int_t aidx)
1006	{
1007
1008	//
1009	// get the pedestals
1010	//
1011	const Float_t pedes = ped.GetPedestal();
1012	const Float_t prms = ped.GetPedestalRms();
1013	const Int_t num = fPedestals->GetNumSlices()*ped.GetNumEvents();
1014
1015	//
1016	// RMS error set by PedCalcFromLoGain, 0 in case MPedCalcPedRun was used.
1017	//
1018	const Float_t prmserr = num>0 ? prms/TMath::Sqrt(2.*num) : ped.GetPedestalRmsError();
1019
1020	//
1021	// set them in the calibration camera
1022	//
1023	if (cal.IsHiGainSaturation())
1024	{
1025	cal.SetPedestal(pedes * fNumLoGainSamples,
1026	prms * fSqrtLoGainSamples,
1027	prmserr * fSqrtLoGainSamples);
1028	cal.CalcLoGainPedestal(fNumLoGainSamples);
1029	}
1030	else
1031	{
1032
1033	cal.SetPedestal(pedes * fNumHiGainSamples,
1034	prms * fSqrtHiGainSamples,
1035	prmserr * fSqrtHiGainSamples);
1036	}
1037
1038	}
1039
1040	// ----------------------------------------------------------------------------------------------------
1041	//
1042	// Check fit results validity. Bad Pixels flags are set if:
1043	//
1044	// 1) Pixel has a mean smaller than fChargeLimit*PedRMS ( Flag: MBadPixelsPix::kChargeIsPedestal)
1045	// 2) Pixel has a mean error smaller than fChargeErrLimit ( Flag: MBadPixelsPix::kChargeErrNotValid)
1046	// 3) Pixel has mean smaller than fChargeRelVarLimit times its mean error
1047	// ( Flag: MBadPixelsPix::kChargeRelErrNotValid)
1048	// 4) Pixel has a sigma bigger than its Pedestal RMS ( Flag: MBadPixelsPix::kChargeSigmaNotValid )
1049	//
1050	// Further returns if flags: MBadPixelsPix::kUnsuitableRun is set
1051	//
1052	// Calls MCalibrationChargePix::CalcReducedSigma() and sets flag: MBadPixelsPix::kChargeIsPedestal
1053	// and returns kFALSE if not succesful.
1054	//
1055	// Calls MCalibrationChargePix::CalcFFactor() and sets flag: MBadPixelsPix::kDeviatingNumPhes)
1056	// and returns kFALSE if not succesful.
1057	//
1058	// Calls MCalibrationChargePix::CalcConvFFactor()and sets flag: MBadPixelsPix::kDeviatingNumPhes)
1059	// and returns kFALSE if not succesful.
1060	//
1061	Bool_t MCalibrationChargeCalc::FinalizeCharges(MCalibrationChargePix &cal, MBadPixelsPix &bad, const char* what)
1062	{
1063
1064	if (bad.IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
1065	return kFALSE;
1066
1067	const TString desc = Form("%7s%4d: ", what, cal.GetPixId());
1068
1069	if (cal.GetMean()<0)
1070	{
1071	*fLog << warn << desc << "Charge not fitted." << endl;
1072	bad.SetUncalibrated( MBadPixelsPix::kChargeIsPedestal);
1073	return kFALSE;
1074	}
1075
1076	if (cal.GetSigma()<0)
1077	{
1078	*fLog << warn << desc << "Charge Sigma invalid." << endl;
1079	bad.SetUncalibrated( MBadPixelsPix::kChargeIsPedestal);
1080	return kFALSE;
1081	}
1082
1083	if (cal.GetMean() < fChargeLimit*cal.GetPedRms())
1084	{
1085	*fLog << warn << desc
1086	<< Form("Fitted Charge: %5.2f < %2.1f",cal.GetMean(),fChargeLimit)
1087	<< Form(" * Pedestal RMS %5.2f",cal.GetPedRms()) << endl;
1088	bad.SetUncalibrated( MBadPixelsPix::kChargeIsPedestal);
1089	}
1090
1091	if (cal.GetMean() < fChargeRelErrLimit*cal.GetMeanErr())
1092	{
1093	*fLog << warn << desc
1094	<< Form("Fitted Charge: %4.2f < %2.1f",cal.GetMean(),fChargeRelErrLimit)
1095	<< Form(" * its error %4.2f",cal.GetMeanErr()) << endl;
1096	bad.SetUncalibrated( MBadPixelsPix::kChargeRelErrNotValid );
1097	}
1098
1099	if (cal.GetSigma() < cal.GetPedRms())
1100	{
1101	*fLog << warn << desc << "Sigma of Fitted Charge: "
1102	<< Form("%6.2f <",cal.GetSigma()) << " Ped. RMS="
1103	<< Form("%5.2f", cal.GetPedRms()) << endl;
1104	bad.SetUncalibrated( MBadPixelsPix::kChargeSigmaNotValid );
1105	return kFALSE;
1106	}
1107
1108	if (!cal.CalcReducedSigma())
1109	{
1110	*fLog << warn << desc << "Could not calculate the reduced sigma" << endl;
1111	bad.SetUncalibrated( MBadPixelsPix::kChargeSigmaNotValid );
1112	return kFALSE;
1113	}
1114
1115	if (!cal.CalcFFactor())
1116	{
1117	*fLog << warn << desc << "Could not calculate the F-Factor"<< endl;
1118	bad.SetUncalibrated(MBadPixelsPix::kDeviatingNumPhes);
1119	bad.SetUnsuitable(MBadPixelsPix::kUnsuitableRun);
1120	return kFALSE;
1121	}
1122
1123	if (cal.GetPheFFactorMethod() < 0.)
1124	{
1125	bad.SetUncalibrated(MBadPixelsPix::kDeviatingNumPhes);
1126	bad.SetUnsuitable(MBadPixelsPix::kUnsuitableRun);
1127	cal.SetFFactorMethodValid(kFALSE);
1128	return kFALSE;
1129	}
1130
1131	if (!cal.CalcConvFFactor())
1132	{
1133	*fLog << warn << desc << "Could not calculate the Conv. FADC counts to Phes"<< endl;
1134	bad.SetUncalibrated(MBadPixelsPix::kDeviatingNumPhes);
1135	return kFALSE;
1136	}
1137
1138	if (!IsUseExtractorRes())
1139	return kTRUE;
1140
1141	if (!fExtractor)
1142	{
1143	*fLog << err << "Extractor resolution has been chosen, but no extractor is set. Cannot calibrate." << endl;
1144	return kFALSE;
1145	}
1146
1147	const Float_t resinphes = cal.IsHiGainSaturation()
1148	? cal.GetPheFFactorMethod()*fExtractor->GetResolutionPerPheLoGain()
1149	: cal.GetPheFFactorMethod()*fExtractor->GetResolutionPerPheHiGain();
1150
1151	Float_t resinfadc = cal.IsHiGainSaturation()
1152	? resinphes/cal.GetMeanConvFADC2Phe()/cal.GetConversionHiLo()
1153	: resinphes/cal.GetMeanConvFADC2Phe();
1154
1155	if (resinfadc > 3.0*cal.GetPedRms() )
1156	{
1157	*fLog << warn << desc << "Extractor Resolution " << Form("%5.2f", resinfadc) << " bigger than 3 Pedestal RMS "
1158	<< Form("%4.2f", cal.GetPedRms()) << endl;
1159	resinfadc = 3.0*cal.GetPedRms();
1160	}
1161
1162	if (!cal.CalcReducedSigma(resinfadc))
1163	{
1164	*fLog << warn << desc << "Could not calculate the reduced sigma" << endl;
1165	bad.SetUncalibrated( MBadPixelsPix::kChargeSigmaNotValid );
1166	return kFALSE;
1167	}
1168
1169	if (!cal.CalcFFactor())
1170	{
1171	*fLog << warn << desc << "Could not calculate the F-Factor" << endl;
1172	bad.SetUncalibrated(MBadPixelsPix::kDeviatingNumPhes);
1173	bad.SetUnsuitable(MBadPixelsPix::kUnsuitableRun);
1174	return kFALSE;
1175	}
1176
1177	if (cal.GetPheFFactorMethod() < 0.)
1178	{
1179	bad.SetUncalibrated(MBadPixelsPix::kDeviatingNumPhes);
1180	bad.SetUnsuitable(MBadPixelsPix::kUnsuitableRun);
1181	cal.SetFFactorMethodValid(kFALSE);
1182	return kFALSE;
1183	}
1184
1185	if (!cal.CalcConvFFactor())
1186	{
1187	*fLog << warn << desc << "Could not calculate the conv. FADC cts to phes" << endl;
1188	bad.SetUncalibrated(MBadPixelsPix::kDeviatingNumPhes);
1189	return kFALSE;
1190	}
1191
1192	return kTRUE;
1193	}
1194
1195	// -----------------------------------------------------------------------------------
1196	//
1197	// Sets pixel to MBadPixelsPix::kUnsuitableRun, if one of the following flags is set:
1198	// - MBadPixelsPix::kChargeIsPedestal
1199	// - MBadPixelsPix::kChargeRelErrNotValid
1200	// - MBadPixelsPix::kMeanTimeInFirstBin
1201	// - MBadPixelsPix::kMeanTimeInLast2Bins
1202	// - MBadPixelsPix::kDeviatingNumPhes
1203	// - MBadPixelsPix::kHiGainOverFlow
1204	// - MBadPixelsPix::kLoGainOverFlow
1205	//
1206	// Sets pixel to MBadPixelsPix::kUnreliableRun, if one of the following flags is set:
1207	// - MBadPixelsPix::kChargeSigmaNotValid
1208	//
1209	void MCalibrationChargeCalc::FinalizeBadPixels()
1210	{
1211
1212	for (Int_t i=0; i<fBadPixels->GetSize(); i++)
1213	{
1214
1215	MBadPixelsPix &bad = (*fBadPixels)[i];
1216
1217	if (IsCheckDeadPixels())
1218	{
1219	if (bad.IsUncalibrated( MBadPixelsPix::kChargeIsPedestal))
1220	bad.SetUnsuitable( MBadPixelsPix::kUnsuitableRun );
1221	}
1222	/*
1223	if (IsCheckExtractionWindow())
1224	{
1225	if (bad.IsUncalibrated( MBadPixelsPix::kMeanTimeInFirstBin ))
1226	bad.SetUnsuitable( MBadPixelsPix::kUnsuitableRun );
1227
1228	if (bad.IsUncalibrated( MBadPixelsPix::kMeanTimeInLast2Bins ))
1229	bad.SetUnsuitable( MBadPixelsPix::kUnsuitableRun );
1230	}
1231	*/
1232	if (IsCheckDeviatingBehavior())
1233	{
1234	if (bad.IsUncalibrated( MBadPixelsPix::kDeviatingNumPhes ))
1235	bad.SetUnsuitable( MBadPixelsPix::kUnsuitableRun );
1236	}
1237
1238	if (IsCheckHistOverflow())
1239	{
1240	if (bad.IsUncalibrated( MBadPixelsPix::kHiGainOverFlow ))
1241	bad.SetUnsuitable( MBadPixelsPix::kUnsuitableRun );
1242
1243	if (bad.IsUncalibrated( MBadPixelsPix::kLoGainOverFlow ))
1244	bad.SetUnsuitable( MBadPixelsPix::kUnsuitableRun );
1245	}
1246
1247	if (IsCheckArrivalTimes())
1248	{
1249	if (bad.IsUncalibrated( MBadPixelsPix::kDeviatingAbsTimeResolution ))
1250	bad.SetUnsuitable( MBadPixelsPix::kUnsuitableRun );
1251	//if (bad.IsUncalibrated( MBadPixelsPix::kFluctuatingArrivalTimes ))
1252	// bad.SetUnsuitable( MBadPixelsPix::kUnsuitableRun );
1253	}
1254
1255	if (bad.IsUncalibrated( MBadPixelsPix::kChargeSigmaNotValid ))
1256	bad.SetUnsuitable( MBadPixelsPix::kUnreliableRun );
1257	}
1258	}
1259
1260	// ------------------------------------------------------------------------
1261	//
1262	//
1263	// First loop: Calculate a mean and mean RMS of photo-electrons per area index
1264	// Include only pixels which are not MBadPixelsPix::kUnsuitableRun nor
1265	// MBadPixelsPix::kChargeSigmaNotValid (see FinalizeBadPixels()) and set
1266	// MCalibrationChargePix::SetFFactorMethodValid(kFALSE) in that case.
1267	//
1268	// Second loop: Get mean number of photo-electrons and its RMS including
1269	// only pixels with flag MCalibrationChargePix::IsFFactorMethodValid()
1270	// and further exclude those deviating by more than fPheErrLimit mean
1271	// sigmas from the mean (obtained in first loop). Set
1272	// MBadPixelsPix::kDeviatingNumPhes if excluded.
1273	//
1274	// For the suitable pixels with flag MBadPixelsPix::kChargeSigmaNotValid
1275	// set the number of photo-electrons as the mean number of photo-electrons
1276	// calculated in that area index.
1277	//
1278	// Set weighted mean and variance of photo-electrons per area index in:
1279	// average area pixels of MCalibrationChargeCam (obtained from:
1280	// MCalibrationChargeCam::GetAverageArea() )
1281	//
1282	// Set weighted mean and variance of photo-electrons per sector in:
1283	// average sector pixels of MCalibrationChargeCam (obtained from:
1284	// MCalibrationChargeCam::GetAverageSector() )
1285	//
1286	//
1287	// Third loop: Set mean number of photo-electrons and its RMS in the pixels
1288	// only excluded as: MBadPixelsPix::kChargeSigmaNotValid
1289	//
1290	Bool_t MCalibrationChargeCalc::FinalizeFFactorMethod()
1291	{
1292	const Int_t npixels = fGeom->GetNumPixels();
1293	const Int_t nareas = fGeom->GetNumAreas();
1294	const Int_t nsectors = fGeom->GetNumSectors();
1295
1296	TArrayF lowlim (nareas);
1297	TArrayF upplim (nareas);
1298	TArrayD areavars (nareas);
1299	TArrayD areaweights (nareas);
1300	TArrayD sectorweights (nsectors);
1301	TArrayD areaphes (nareas);
1302	TArrayD sectorphes (nsectors);
1303	TArrayI numareavalid (nareas);
1304	TArrayI numsectorvalid(nsectors);
1305
1306	//
1307	// First loop: Get mean number of photo-electrons and the RMS
1308	// The loop is only to recognize later pixels with very deviating numbers
1309	//
1310	MHCamera camphes(*fGeom,"Camphes","Phes in Camera");
1311
1312	for (Int_t i=0; i<npixels; i++)
1313	{
1314	MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
1315
1316	MBadPixelsPix &bad = (*fBadPixels)[i];
1317
1318	if (!pix.IsFFactorMethodValid())
1319	continue;
1320
1321	if (bad.IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
1322	{
1323	pix.SetFFactorMethodValid(kFALSE);
1324	continue;
1325	}
1326
1327	if (bad.IsUncalibrated(MBadPixelsPix::kChargeSigmaNotValid))
1328	continue;
1329
1330	if (!IsUseUnreliables())
1331	if (bad.IsUnsuitable(MBadPixelsPix::kUnreliableRun))
1332	continue;
1333
1334	const Float_t nphe = pix.GetPheFFactorMethod();
1335	const Int_t aidx = (*fGeom)[i].GetAidx();
1336	camphes.Fill(i,nphe);
1337	camphes.SetUsed(i);
1338	areaphes [aidx] += nphe;
1339	areavars [aidx] += nphe*nphe;
1340	numareavalid[aidx] ++;
1341	}
1342
1343	for (Int_t i=0; i<nareas; i++)
1344	{
1345	if (numareavalid[i] == 0)
1346	{
1347	*fLog << warn << GetDescriptor() << ": No pixels with valid number of photo-electrons found "
1348	<< "in area index: " << i << endl;
1349	continue;
1350	}
1351
1352	if (numareavalid[i] == 1)
1353	areavars[i] = 0.;
1354	else
1355	{
1356	areavars[i] = (areavars[i] - areaphes[i]*areaphes[i]/numareavalid[i]) / (numareavalid[i]-1);
1357	areaphes[i] /= numareavalid[i];
1358	}
1359
1360	if (areavars[i] < 0.)
1361	{
1362	*fLog << warn << "Area " << setw(4) << i << ": No pixels with valid variance of photo-electrons found." << endl;
1363	continue;
1364	}
1365
1366	// FIXME: WHAT IS THIS FOR? It is overwritten!
1367	lowlim[i] = areaphes[i] - fPheErrLowerLimit*TMath::Sqrt(areavars[i]);
1368	upplim[i] = areaphes[i] + fPheErrUpperLimit*TMath::Sqrt(areavars[i]);
1369
1370
1371	TH1D *hist = camphes.ProjectionS(TArrayI(),TArrayI(1,&i),"_py",100);
1372	hist->Fit("gaus","Q0");
1373	const Float_t mean = hist->GetFunction("gaus")->GetParameter(1);
1374	const Float_t sigma = hist->GetFunction("gaus")->GetParameter(2);
1375	const Int_t ndf = hist->GetFunction("gaus")->GetNDF();
1376
1377	if (IsDebug())
1378	hist->DrawClone();
1379
1380	if (ndf < 5)
1381	{
1382	*fLog << warn << GetDescriptor() << ": Cannot use a Gauss fit to the number of photo-electrons " << endl;
1383	*fLog << " in the camera with area index: " << i << endl;
1384	*fLog << " Number of dof.: " << ndf << " is smaller than 5 " << endl;
1385	*fLog << " Will use the simple mean and rms " << endl;
1386	delete hist;
1387	SetPheFitOK(i,kFALSE);
1388	continue;
1389	}
1390
1391	const Double_t prob = hist->GetFunction("gaus")->GetProb();
1392
1393	if (prob < 0.001)
1394	{
1395	*fLog << warn << GetDescriptor() << ": Cannot use a Gauss fit to the number of photo-electrons " << endl;
1396	*fLog << " in the camera with area index: " << i << endl;
1397	*fLog << " Fit probability " << prob << " is smaller than 0.001 " << endl;
1398	*fLog << " Will use the simple mean and rms " << endl;
1399	delete hist;
1400	SetPheFitOK(i,kFALSE);
1401	continue;
1402	}
1403
1404	if (mean < 0.)
1405	{
1406	*fLog << inf << "Area " << setw(4) << i << ": Fitted mean number of phe smaller 0." << endl;
1407	*fLog << warn << "Area " << setw(4) << i << ": Will use the simple mean and rms " << endl;
1408	SetPheFitOK(i,kFALSE);
1409	delete hist;
1410	continue;
1411	}
1412
1413	*fLog << inf << "Area " << setw(4) << i << ": Mean number of phes: "
1414	<< Form("%7.2f+-%6.2f",mean,sigma) << endl;
1415
1416	lowlim[i] = mean - fPheErrLowerLimit*sigma;
1417	upplim[i] = mean + fPheErrUpperLimit*sigma;
1418
1419	if (lowlim[i]<1)
1420	lowlim[i] = 1;
1421
1422	delete hist;
1423
1424	SetPheFitOK(i,kTRUE);
1425	}
1426
1427	*fLog << endl;
1428
1429	numareavalid.Reset();
1430	areaphes .Reset();
1431	areavars .Reset();
1432	//
1433	// Second loop: Get mean number of photo-electrons and its RMS excluding
1434	// pixels deviating by more than fPheErrLimit sigma.
1435	// Set the conversion factor FADC counts to photo-electrons
1436	//
1437	for (Int_t i=0; i<npixels; i++)
1438	{
1439
1440	MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
1441
1442	if (!pix.IsFFactorMethodValid())
1443	continue;
1444
1445	MBadPixelsPix &bad = (*fBadPixels)[i];
1446
1447	if (bad.IsUncalibrated(MBadPixelsPix::kChargeSigmaNotValid))
1448	continue;
1449
1450	if (!IsUseUnreliables())
1451	if (bad.IsUnsuitable(MBadPixelsPix::kUnreliableRun))
1452	continue;
1453
1454	const Float_t nvar = pix.GetPheFFactorMethodVar();
1455	if (nvar <= 0.)
1456	{
1457	pix.SetFFactorMethodValid(kFALSE);
1458	continue;
1459	}
1460
1461	const Int_t aidx = (*fGeom)[i].GetAidx();
1462	const Int_t sector = (*fGeom)[i].GetSector();
1463	const Float_t area = (*fGeom)[i].GetA();
1464	const Float_t nphe = pix.GetPheFFactorMethod();
1465
1466	if ( nphe < lowlim[aidx] \|\| nphe > upplim[aidx] )
1467	{
1468	*fLog << warn << "Pixel " << setw(4) << i << ": Num of phe "
1469	<< Form("%7.2f out of +%3.1f-%3.1f sigma limit ",nphe,fPheErrUpperLimit,fPheErrLowerLimit)
1470	<< Form("[%7.2f,%7.2f]",lowlim[aidx],upplim[aidx]) << endl;
1471	bad.SetUncalibrated( MBadPixelsPix::kDeviatingNumPhes );
1472
1473	if (IsCheckDeviatingBehavior())
1474	bad.SetUnsuitable(MBadPixelsPix::kUnsuitableRun);
1475	continue;
1476	}
1477
1478	areaweights [aidx] += nphe*nphe;
1479	areaphes [aidx] += nphe;
1480	numareavalid [aidx] ++;
1481
1482	if (aidx == 0)
1483	fNumInnerFFactorMethodUsed++;
1484
1485	sectorweights [sector] += nphe*nphe/area/area;
1486	sectorphes [sector] += nphe/area;
1487	numsectorvalid[sector] ++;
1488	}
1489
1490	*fLog << endl;
1491
1492	for (Int_t aidx=0; aidx<nareas; aidx++)
1493	{
1494
1495	MCalibrationChargePix &apix = (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
1496
1497	if (numareavalid[aidx] == 1)
1498	areaweights[aidx] = 0.;
1499	else if (numareavalid[aidx] == 0)
1500	{
1501	areaphes[aidx] = -1.;
1502	areaweights[aidx] = -1.;
1503	}
1504	else
1505	{
1506	areaweights[aidx] = (areaweights[aidx] - areaphes[aidx]*areaphes[aidx]/numareavalid[aidx])
1507	/ (numareavalid[aidx]-1);
1508	areaphes[aidx] /= numareavalid[aidx];
1509	}
1510
1511	if (areaweights[aidx] < 0. \|\| areaphes[aidx] <= 0.)
1512	{
1513	*fLog << warn << "Area " << setw(4) << aidx << ": Mean number phes could not be calculated: "
1514	<< " Mean: " << areaphes[aidx]
1515	<< " Var: " << areaweights[aidx] << endl;
1516	apix.SetFFactorMethodValid(kFALSE);
1517	continue;
1518	}
1519
1520	*fLog << inf << "Area " << setw(4) << aidx << ": Average total phes: "
1521	<< Form("%7.2f +- %6.2f",areaphes[aidx],TMath::Sqrt(areaweights[aidx])) << endl;
1522
1523	apix.SetPheFFactorMethod ( areaphes[aidx] );
1524	apix.SetPheFFactorMethodVar( areaweights[aidx] / numareavalid[aidx] );
1525	apix.SetFFactorMethodValid ( kTRUE );
1526
1527	}
1528
1529	*fLog << endl;
1530
1531	for (Int_t sector=0; sector<nsectors; sector++)
1532	{
1533
1534	if (numsectorvalid[sector] == 1)
1535	sectorweights[sector] = 0.;
1536	else if (numsectorvalid[sector] == 0)
1537	{
1538	sectorphes[sector] = -1.;
1539	sectorweights[sector] = -1.;
1540	}
1541	else
1542	{
1543	sectorweights[sector] = (sectorweights[sector]
1544	- sectorphes[sector]*sectorphes[sector]/numsectorvalid[sector]
1545	)
1546	/ (numsectorvalid[sector]-1.);
1547	sectorphes[sector] /= numsectorvalid[sector];
1548	}
1549
1550	MCalibrationChargePix &spix = (MCalibrationChargePix&)fCam->GetAverageSector(sector);
1551
1552	if (sectorweights[sector] < 0. \|\| sectorphes[sector] <= 0.)
1553	{
1554	*fLog << warn << "Sector " << setw(4) << sector
1555	<<": Mean number phes/area could not be calculated:"
1556	<< " Mean: " << sectorphes[sector] << " Var: " << sectorweights[sector] << endl;
1557	spix.SetFFactorMethodValid(kFALSE);
1558	continue;
1559	}
1560
1561	*fLog << inf << "Sector " << setw(4) << sector
1562	<< ": Avg number phes/mm^2: "
1563	<< Form("%5.3f+-%4.3f",sectorphes[sector],TMath::Sqrt(sectorweights[sector]))
1564	<< endl;
1565
1566	spix.SetPheFFactorMethod ( sectorphes[sector] );
1567	spix.SetPheFFactorMethodVar( sectorweights[sector] / numsectorvalid[sector]);
1568	spix.SetFFactorMethodValid ( kTRUE );
1569
1570	}
1571
1572	//
1573	// Third loop: Set mean number of photo-electrons and its RMS in the pixels
1574	// only excluded as: MBadPixelsPix::kChargeSigmaNotValid
1575	//
1576	for (Int_t i=0; i<npixels; i++)
1577	{
1578
1579	MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
1580
1581	MBadPixelsPix &bad = (*fBadPixels)[i];
1582
1583	if (bad.IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
1584	continue;
1585
1586	if (bad.IsUncalibrated(MBadPixelsPix::kChargeSigmaNotValid))
1587	{
1588	const Int_t aidx = (*fGeom)[i].GetAidx();
1589	MCalibrationChargePix &apix = (MCalibrationChargePix&)fCam->GetAverageArea(aidx);
1590
1591	pix.SetPheFFactorMethod ( apix.GetPheFFactorMethod() );
1592	pix.SetPheFFactorMethodVar( apix.GetPheFFactorMethodVar() );
1593
1594	if (!pix.CalcConvFFactor())
1595	{
1596	*fLog << warn << GetDescriptor()
1597	<< "Pixel " << setw(4) << pix.GetPixId()
1598	<<": Could not calculate the Conv. FADC counts to Phes"
1599	<< endl;
1600	bad.SetUncalibrated( MBadPixelsPix::kDeviatingNumPhes );
1601	if (IsCheckDeviatingBehavior())
1602	bad.SetUnsuitable ( MBadPixelsPix::kUnsuitableRun );
1603	}
1604
1605	}
1606	}
1607
1608	return kTRUE;
1609	}
1610
1611
1612
1613	// ------------------------------------------------------------------------
1614	//
1615	// Returns kFALSE if pointer to MCalibrationBlindCam is NULL
1616	//
1617	// The check returns kFALSE if:
1618	//
1619	// 1) fLambda and fLambdaCheck are separated relatively to each other by more than fLambdaCheckLimit
1620	// 2) BlindPixel has an fLambdaErr greater than fLambdaErrLimit
1621	//
1622	// Calls:
1623	// - MCalibrationBlindPix::CalcFluxInsidePlexiglass()
1624	//
1625	Bool_t MCalibrationChargeCalc::FinalizeBlindCam()
1626	{
1627	if (!fBlindCam)
1628	return kFALSE;
1629
1630	Int_t nvalid = 0;
1631
1632	for (Int_t i=0; i<fBlindCam->GetSize(); i++)
1633	{
1634
1635	MCalibrationBlindPix &blindpix = (MCalibrationBlindPix&)(*fBlindCam)[i];
1636
1637	if (!blindpix.IsValid())
1638	continue;
1639
1640	const Float_t lambda = blindpix.GetLambda();
1641	const Float_t lambdaerr = blindpix.GetLambdaErr();
1642	const Float_t lambdacheck = blindpix.GetLambdaCheck();
1643
1644	if (2.*(lambdacheck-lambda)/(lambdacheck+lambda) > fLambdaCheckLimit)
1645	{
1646	*fLog << warn << "BlindPix " << i << ": Lambda="
1647	<< Form("%4.2f", lambda) << " and Lambda-Check="
1648	<< Form("%4.2f", lambdacheck) << " differ by more than "
1649	<< Form("%4.2f", fLambdaCheckLimit) << endl;
1650	blindpix.SetValid(kFALSE);
1651	continue;
1652	}
1653
1654	if (lambdaerr > fLambdaErrLimit)
1655	{
1656	*fLog << warn << "BlindPix " << i << ": Error of Fitted Lambda="
1657	<< Form("%4.2f", lambdaerr) << " is greater than "
1658	<< Form("%4.2f", fLambdaErrLimit) << endl;
1659	blindpix.SetValid(kFALSE);
1660	continue;
1661	}
1662
1663	if (!blindpix.CalcFluxInsidePlexiglass())
1664	{
1665	*fLog << warn << "Could not calculate the flux of photons from Blind Pixel Nr." << i << endl;
1666	blindpix.SetValid(kFALSE);
1667	continue;
1668	}
1669
1670	nvalid++;
1671	}
1672
1673	if (!nvalid)
1674	return kFALSE;
1675
1676	return kTRUE;
1677	}
1678
1679	// ------------------------------------------------------------------------
1680	//
1681	// Returns kFALSE if pointer to MCalibrationChargePINDiode is NULL
1682	//
1683	// The check returns kFALSE if:
1684	//
1685	// 1) PINDiode has a fitted charge smaller than fChargeLimit*PedRMS
1686	// 2) PINDiode has a fit error smaller than fChargeErrLimit
1687	// 3) PINDiode has a fitted charge smaller its fChargeRelErrLimit times its charge error
1688	// 4) PINDiode has a charge sigma smaller than its Pedestal RMS
1689	//
1690	// Calls:
1691	// - MCalibrationChargePINDiode::CalcFluxOutsidePlexiglass()
1692	//
1693	Bool_t MCalibrationChargeCalc::FinalizePINDiode()
1694	{
1695
1696	if (!fPINDiode)
1697	return kFALSE;
1698
1699	if (fPINDiode->GetMean() < fChargeLimit*fPINDiode->GetPedRms())
1700	{
1701	*fLog << warn << "PINDiode : Fitted Charge is smaller than "
1702	<< fChargeLimit << " Pedestal RMS." << endl;
1703	return kFALSE;
1704	}
1705
1706	if (fPINDiode->GetMeanErr() < fChargeErrLimit)
1707	{
1708	*fLog << warn << "PINDiode : Error of Fitted Charge is smaller than "
1709	<< fChargeErrLimit << endl;
1710	return kFALSE;
1711	}
1712
1713	if (fPINDiode->GetMean() < fChargeRelErrLimit*fPINDiode->GetMeanErr())
1714	{
1715	*fLog << warn << "PINDiode : Fitted Charge is smaller than "
1716	<< fChargeRelErrLimit << "* its error" << endl;
1717	return kFALSE;
1718	}
1719
1720	if (fPINDiode->GetSigma() < fPINDiode->GetPedRms())
1721	{
1722	*fLog << warn << "PINDiode : Sigma of Fitted Charge smaller than Pedestal RMS" << endl;
1723	return kFALSE;
1724	}
1725
1726
1727	if (!fPINDiode->CalcFluxOutsidePlexiglass())
1728	{
1729	*fLog << warn << "PINDiode : Could not calculate the flux of photons, "
1730	<< "will skip PIN Diode Calibration " << endl;
1731	return kFALSE;
1732	}
1733
1734	return kTRUE;
1735	}
1736
1737	// ------------------------------------------------------------------------
1738	//
1739	// Calculate the average number of photons outside the plexiglass with the
1740	// formula:
1741	//
1742	// av.Num.photons(area index) = av.Num.Phes(area index)
1743	// / MCalibrationQEPix::GetDefaultQE(fPulserColor)
1744	// / MCalibrationQEPix::GetPMTCollectionEff()
1745	// / MCalibrationQEPix::GetLightGuidesEff(fPulserColor)
1746	// / MCalibrationQECam::GetPlexiglassQE()
1747	//
1748	// Calculate the variance on the average number of photons assuming that the error on the
1749	// Quantum efficiency is reduced by the number of used inner pixels, but the rest of the
1750	// values keeps it ordinary error since it is systematic.
1751	//
1752	// Loop over pixels:
1753	//
1754	// - Continue, if not MCalibrationChargePix::IsFFactorMethodValid() and set:
1755	// MCalibrationQEPix::SetFFactorMethodValid(kFALSE,fPulserColor)
1756	//
1757	// - Call MCalibrationChargePix::CalcMeanFFactor(av.Num.photons) and set:
1758	// MCalibrationQEPix::SetFFactorMethodValid(kFALSE,fPulserColor) if not succesful
1759	//
1760	// - Calculate the quantum efficiency with the formula:
1761	//
1762	// QE = ( Num.Phes / av.Num.photons ) * MGeomCam::GetPixRatio()
1763	//
1764	// - Set QE in MCalibrationQEPix::SetQEFFactor ( QE, fPulserColor );
1765	//
1766	// - Set Variance of QE in MCalibrationQEPix::SetQEFFactorVar ( Variance, fPulserColor );
1767	// - Set bit MCalibrationQEPix::SetFFactorMethodValid(kTRUE,fPulserColor)
1768	//
1769	// - Call MCalibrationQEPix::UpdateFFactorMethod()
1770	//
1771	void MCalibrationChargeCalc::FinalizeFFactorQECam()
1772	{
1773
1774	if (fNumInnerFFactorMethodUsed < 2)
1775	{
1776	*fLog << warn << GetDescriptor()
1777	<< ": Could not calculate F-Factor Method: Less than 2 inner pixels valid! " << endl;
1778	return;
1779	}
1780
1781	MCalibrationChargePix &avpix = (MCalibrationChargePix&)fCam->GetAverageArea(0);
1782	MCalibrationQEPix &qepix = (MCalibrationQEPix&) fQECam->GetAverageArea(0);
1783
1784	if (IsDebug())
1785	*fLog << dbginf << "External Phes: " << fExternalNumPhes
1786	<< " Internal Phes: " << avpix.GetPheFFactorMethod() << endl;
1787
1788	const Float_t avphotons = ( IsUseExternalNumPhes()
1789	? fExternalNumPhes
1790	: avpix.GetPheFFactorMethod() )
1791	/ qepix.GetDefaultQE(fPulserColor)
1792	/ qepix.GetPMTCollectionEff()
1793	/ qepix.GetLightGuidesEff(fPulserColor)
1794	/ fQECam->GetPlexiglassQE();
1795
1796	const Float_t avphotrelvar = ( IsUseExternalNumPhes()
1797	? fExternalNumPhesRelVar
1798	: avpix.GetPheFFactorMethodRelVar() )
1799	+ qepix.GetDefaultQERelVar(fPulserColor) / fNumInnerFFactorMethodUsed
1800	+ qepix.GetPMTCollectionEffRelVar()
1801	+ qepix.GetLightGuidesEffRelVar(fPulserColor)
1802	+ fQECam->GetPlexiglassQERelVar();
1803
1804	const UInt_t nareas = fGeom->GetNumAreas();
1805
1806	//
1807	// Set the results in the MCalibrationChargeCam
1808	//
1809	fCam->SetNumPhotonsFFactorMethod (avphotons);
1810
1811	if (avphotrelvar > 0.)
1812	fCam->SetNumPhotonsFFactorMethodErr(TMath::Sqrt( avphotrelvar * avphotons * avphotons));
1813
1814	TArrayF lowlim (nareas);
1815	TArrayF upplim (nareas);
1816	TArrayD avffactorphotons (nareas);
1817	TArrayD avffactorphotvar (nareas);
1818	TArrayI numffactor (nareas);
1819
1820	const UInt_t npixels = fGeom->GetNumPixels();
1821
1822	MHCamera camffactor(*fGeom,"Camffactor","F-Factor in Camera");
1823
1824	for (UInt_t i=0; i<npixels; i++)
1825	{
1826
1827	MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
1828	MCalibrationQEPix &qpix = (MCalibrationQEPix&) (*fQECam)[i];
1829
1830	MBadPixelsPix &bad = (*fBadPixels)[i];
1831
1832	if (bad.IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
1833	continue;
1834
1835	const Float_t photons = avphotons / fGeom->GetPixRatio(i);
1836	const Float_t qe = pix.GetPheFFactorMethod() / photons ;
1837
1838	const Float_t qerelvar = avphotrelvar + pix.GetPheFFactorMethodRelVar();
1839
1840	qpix.SetQEFFactor ( qe , fPulserColor );
1841	qpix.SetQEFFactorVar ( qerelvarqeqe, fPulserColor );
1842	qpix.SetFFactorMethodValid( kTRUE , fPulserColor );
1843
1844	if (!qpix.UpdateFFactorMethod( fQECam->GetPlexiglassQE() ))
1845	*fLog << warn << GetDescriptor()
1846	<< ": Cannot update Quantum efficiencies with the F-Factor Method" << endl;
1847
1848	//
1849	// The following pixels are those with deviating sigma, but otherwise OK,
1850	// probably those with stars during the pedestal run, but not the cal. run.
1851	//
1852	if (!pix.CalcMeanFFactor( photons , avphotrelvar ))
1853	{
1854	bad.SetUncalibrated( MBadPixelsPix::kDeviatingFFactor );
1855	if (IsCheckDeviatingBehavior())
1856	bad.SetUnsuitable ( MBadPixelsPix::kUnreliableRun );
1857	continue;
1858	}
1859
1860	const Int_t aidx = (*fGeom)[i].GetAidx();
1861	const Float_t ffactor = pix.GetMeanFFactorFADC2Phot();
1862
1863	camffactor.Fill(i,ffactor);
1864	camffactor.SetUsed(i);
1865
1866	avffactorphotons[aidx] += ffactor;
1867	avffactorphotvar[aidx] += ffactor*ffactor;
1868	numffactor[aidx]++;
1869	}
1870
1871	for (UInt_t i=0; i<nareas; i++)
1872	{
1873
1874	if (numffactor[i] == 0)
1875	{
1876	*fLog << warn << GetDescriptor() << ": No pixels with valid total F-Factor found "
1877	<< "in area index: " << i << endl;
1878	continue;
1879	}
1880
1881	avffactorphotvar[i] = (avffactorphotvar[i] - avffactorphotons[i]*avffactorphotons[i]/numffactor[i])
1882	/ (numffactor[i]-1.);
1883	avffactorphotons[i] = avffactorphotons[i] / numffactor[i];
1884
1885	if (avffactorphotvar[i] < 0.)
1886	{
1887	*fLog << warn << GetDescriptor() << ": No pixels with valid variance of total F-Factor found "
1888	<< "in area index: " << i << endl;
1889	continue;
1890	}
1891
1892	lowlim [i] = 1.; // Lowest known F-Factor of a PMT
1893	upplim [i] = avffactorphotons[i] + fFFactorErrLimit*TMath::Sqrt(avffactorphotvar[i]);
1894
1895	TArrayI area(1);
1896	area[0] = i;
1897
1898	TH1D *hist = camffactor.ProjectionS(TArrayI(),area,"_py",100);
1899	hist->Fit("gaus","Q0");
1900	const Float_t mean = hist->GetFunction("gaus")->GetParameter(1);
1901	const Float_t sigma = hist->GetFunction("gaus")->GetParameter(2);
1902	const Int_t ndf = hist->GetFunction("gaus")->GetNDF();
1903
1904	if (IsDebug())
1905	camffactor.DrawClone();
1906
1907	if (ndf < 2)
1908	{
1909	*fLog << warn << GetDescriptor() << ": Cannot use a Gauss fit to the F-Factor " << endl;
1910	*fLog << " in the camera with area index: " << i << endl;
1911	*fLog << " Number of dof.: " << ndf << " is smaller than 2 " << endl;
1912	*fLog << " Will use the simple mean and rms." << endl;
1913	delete hist;
1914	SetFFactorFitOK(i,kFALSE);
1915	continue;
1916	}
1917
1918	const Double_t prob = hist->GetFunction("gaus")->GetProb();
1919
1920	if (prob < 0.001)
1921	{
1922	*fLog << warn << GetDescriptor() << ": Cannot use a Gauss fit to the F-Factor " << endl;
1923	*fLog << " in the camera with area index: " << i << endl;
1924	*fLog << " Fit probability " << prob << " is smaller than 0.001 " << endl;
1925	*fLog << " Will use the simple mean and rms." << endl;
1926	delete hist;
1927	SetFFactorFitOK(i,kFALSE);
1928	continue;
1929	}
1930
1931	*fLog << inf << "Area " << setw(4) << i <<": Mean F-Factor :"
1932	<< Form("%4.2f+-%4.2f",mean,sigma) << endl;
1933
1934	lowlim [i] = 1.;
1935	upplim [i] = mean + fFFactorErrLimit*sigma;
1936
1937	delete hist;
1938
1939	SetFFactorFitOK(i,kTRUE);
1940	}
1941
1942	*fLog << endl;
1943
1944	for (UInt_t i=0; i<npixels; i++)
1945	{
1946
1947	MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
1948	MBadPixelsPix &bad = (*fBadPixels)[i];
1949
1950	if (bad.IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
1951	continue;
1952
1953	const Float_t ffactor = pix.GetMeanFFactorFADC2Phot();
1954	const Int_t aidx = (*fGeom)[i].GetAidx();
1955
1956	if ( ffactor < lowlim[aidx] \|\| ffactor > upplim[aidx] )
1957	{
1958	*fLog << warn << "Pixel " << setw(4) << i<< ": Overall F-Factor "
1959	<< Form("%5.2f",ffactor) << " out of range ["
1960	<< Form("%5.2f,%5.2f",lowlim[aidx],upplim[aidx]) << "]" << endl;
1961
1962	bad.SetUncalibrated( MBadPixelsPix::kDeviatingFFactor );
1963	if (IsCheckDeviatingBehavior())
1964	bad.SetUnsuitable ( MBadPixelsPix::kUnreliableRun );
1965	}
1966	}
1967
1968	for (UInt_t i=0; i<npixels; i++)
1969	{
1970
1971	MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
1972	MCalibrationQEPix &qpix = (MCalibrationQEPix&)(*fQECam)[i];
1973
1974	if ((*fBadPixels)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
1975	{
1976	qpix.SetFFactorMethodValid(kFALSE,fPulserColor);
1977	pix.SetFFactorMethodValid(kFALSE);
1978	continue;
1979	}
1980	}
1981	}
1982
1983
1984	// ------------------------------------------------------------------------
1985	//
1986	// Loop over pixels:
1987	//
1988	// - Continue, if not MCalibrationBlindPix::IsFluxInsidePlexiglassAvailable() and set:
1989	// MCalibrationQEPix::SetBlindPixelMethodValid(kFALSE,fPulserColor)
1990	//
1991	// - Calculate the quantum efficiency with the formula:
1992	//
1993	// QE = Num.Phes / MCalibrationBlindPix::GetFluxInsidePlexiglass()
1994	// / MGeomPix::GetA() * MCalibrationQECam::GetPlexiglassQE()
1995	//
1996	// - Set QE in MCalibrationQEPix::SetQEBlindPixel ( QE, fPulserColor );
1997	// - Set Variance of QE in MCalibrationQEPix::SetQEBlindPixelVar ( Variance, fPulserColor );
1998	// - Set bit MCalibrationQEPix::SetBlindPixelMethodValid(kTRUE,fPulserColor)
1999	//
2000	// - Call MCalibrationQEPix::UpdateBlindPixelMethod()
2001	//
2002	void MCalibrationChargeCalc::FinalizeBlindPixelQECam()
2003	{
2004
2005	if (!fBlindCam)
2006	return;
2007
2008	//
2009	// Set the results in the MCalibrationChargeCam
2010	//
2011	if (!fBlindCam->IsFluxInsidePlexiglassAvailable())
2012	{
2013
2014	const Float_t photons = fBlindCam->GetFluxInsidePlexiglass() * (*fGeom)[0].GetA()
2015	/ fQECam->GetPlexiglassQE();
2016	fCam->SetNumPhotonsBlindPixelMethod(photons);
2017
2018	const Float_t photrelvar = fBlindCam->GetFluxInsidePlexiglassRelVar()
2019	+ fQECam->GetPlexiglassQERelVar();
2020
2021	if (photrelvar > 0.)
2022	fCam->SetNumPhotonsBlindPixelMethodErr(TMath::Sqrt( photrelvar * photons * photons));
2023	}
2024
2025	//
2026	// With the knowledge of the overall photon flux, calculate the
2027	// quantum efficiencies after the Blind Pixel and PIN Diode method
2028	//
2029	const UInt_t npixels = fGeom->GetNumPixels();
2030	for (UInt_t i=0; i<npixels; i++)
2031	{
2032
2033	MCalibrationQEPix &qepix = (MCalibrationQEPix&)(*fQECam)[i];
2034
2035	if (!fBlindCam->IsFluxInsidePlexiglassAvailable())
2036	{
2037	qepix.SetBlindPixelMethodValid(kFALSE, fPulserColor);
2038	continue;
2039	}
2040
2041	MBadPixelsPix &bad = (*fBadPixels)[i];
2042
2043	if (bad.IsUnsuitable (MBadPixelsPix::kUnsuitableRun))
2044	{
2045	qepix.SetBlindPixelMethodValid(kFALSE, fPulserColor);
2046	continue;
2047	}
2048
2049	MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
2050	MGeom &geo = (*fGeom)[i];
2051
2052	const Float_t qe = pix.GetPheFFactorMethod()
2053	/ fBlindCam->GetFluxInsidePlexiglass()
2054	/ geo.GetA()
2055	* fQECam->GetPlexiglassQE();
2056
2057	const Float_t qerelvar = fBlindCam->GetFluxInsidePlexiglassRelVar()
2058	+ fQECam->GetPlexiglassQERelVar()
2059	+ pix.GetPheFFactorMethodRelVar();
2060
2061	qepix.SetQEBlindPixel ( qe , fPulserColor );
2062	qepix.SetQEBlindPixelVar ( qerelvarqeqe, fPulserColor );
2063	qepix.SetBlindPixelMethodValid( kTRUE , fPulserColor );
2064
2065	if (!qepix.UpdateBlindPixelMethod( fQECam->GetPlexiglassQE()))
2066	*fLog << warn << GetDescriptor()
2067	<< ": Cannot update Quantum efficiencies with the Blind Pixel Method" << endl;
2068	}
2069	}
2070
2071	// ------------------------------------------------------------------------
2072	//
2073	// Loop over pixels:
2074	//
2075	// - Continue, if not MCalibrationChargePINDiode::IsFluxOutsidePlexiglassAvailable() and set:
2076	// MCalibrationQEPix::SetPINDiodeMethodValid(kFALSE,fPulserColor)
2077	//
2078	// - Calculate the quantum efficiency with the formula:
2079	//
2080	// QE = Num.Phes / MCalibrationChargePINDiode::GetFluxOutsidePlexiglass() / MGeomPix::GetA()
2081	//
2082	// - Set QE in MCalibrationQEPix::SetQEPINDiode ( QE, fPulserColor );
2083	// - Set Variance of QE in MCalibrationQEPix::SetQEPINDiodeVar ( Variance, fPulserColor );
2084	// - Set bit MCalibrationQEPix::SetPINDiodeMethodValid(kTRUE,fPulserColor)
2085	//
2086	// - Call MCalibrationQEPix::UpdatePINDiodeMethod()
2087	//
2088	void MCalibrationChargeCalc::FinalizePINDiodeQECam()
2089	{
2090
2091	const UInt_t npixels = fGeom->GetNumPixels();
2092
2093	if (!fPINDiode)
2094	return;
2095
2096	//
2097	// With the knowledge of the overall photon flux, calculate the
2098	// quantum efficiencies after the PIN Diode method
2099	//
2100	for (UInt_t i=0; i<npixels; i++)
2101	{
2102
2103	MCalibrationQEPix &qepix = (MCalibrationQEPix&)(*fQECam)[i];
2104
2105	if (!fPINDiode)
2106	{
2107	qepix.SetPINDiodeMethodValid(kFALSE, fPulserColor);
2108	continue;
2109	}
2110
2111	if (!fPINDiode->IsFluxOutsidePlexiglassAvailable())
2112	{
2113	qepix.SetPINDiodeMethodValid(kFALSE, fPulserColor);
2114	continue;
2115	}
2116
2117	MBadPixelsPix &bad = (*fBadPixels)[i];
2118
2119	if (!bad.IsUnsuitable (MBadPixelsPix::kUnsuitableRun))
2120	{
2121	qepix.SetPINDiodeMethodValid(kFALSE, fPulserColor);
2122	continue;
2123	}
2124
2125	MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
2126	MGeom &geo = (*fGeom)[i];
2127
2128	const Float_t qe = pix.GetPheFFactorMethod()
2129	/ fPINDiode->GetFluxOutsidePlexiglass()
2130	/ geo.GetA();
2131
2132	const Float_t qerelvar = fPINDiode->GetFluxOutsidePlexiglassRelVar() + pix.GetPheFFactorMethodRelVar();
2133
2134	qepix.SetQEPINDiode ( qe , fPulserColor );
2135	qepix.SetQEPINDiodeVar ( qerelvarqeqe, fPulserColor );
2136	qepix.SetPINDiodeMethodValid( kTRUE , fPulserColor );
2137
2138	if (!qepix.UpdatePINDiodeMethod())
2139	*fLog << warn << GetDescriptor()
2140	<< ": Cannot update Quantum efficiencies with the PIN Diode Method" << endl;
2141	}
2142	}
2143
2144	// ------------------------------------------------------------------------
2145	//
2146	// Loop over pixels:
2147	//
2148	// - Call MCalibrationQEPix::UpdateCombinedMethod()
2149	//
2150	void MCalibrationChargeCalc::FinalizeCombinedQECam()
2151	{
2152
2153	const UInt_t npixels = fGeom->GetNumPixels();
2154
2155	for (UInt_t i=0; i<npixels; i++)
2156	{
2157
2158	MCalibrationQEPix &qepix = (MCalibrationQEPix&)(*fQECam)[i];
2159
2160	if (!(*fBadPixels)[i].IsUnsuitable (MBadPixelsPix::kUnsuitableRun))
2161	{
2162	qepix.SetPINDiodeMethodValid(kFALSE, fPulserColor);
2163	continue;
2164	}
2165
2166	qepix.UpdateCombinedMethod();
2167	}
2168	}
2169
2170	// -----------------------------------------------------------------------------------------------
2171	//
2172	// - Print out statistics about BadPixels of type UnsuitableType_t
2173	// - store numbers of bad pixels of each type in fCam
2174	//
2175	Bool_t MCalibrationChargeCalc::FinalizeUnsuitablePixels()
2176	{
2177
2178	*fLog << inf << endl;
2179	*fLog << GetDescriptor() << ": Charge Calibration status:" << endl;
2180	*fLog << dec << setfill(' ');
2181
2182	const Int_t nareas = fGeom->GetNumAreas();
2183
2184	TArrayI suit(nareas);
2185	TArrayI unsuit(nareas);
2186	TArrayI unrel(nareas);
2187
2188	Int_t unsuitcnt=0;
2189	Int_t unrelcnt =0;
2190
2191	// Count number of succesfully calibrated pixels
2192	for (Int_t aidx=0; aidx<nareas; aidx++)
2193	{
2194	suit[aidx] = fBadPixels->GetNumSuitable(MBadPixelsPix::kUnsuitableRun, fGeom, aidx);
2195	unsuit[aidx] = fBadPixels->GetNumUnsuitable(MBadPixelsPix::kUnsuitableRun, fGeom, aidx);
2196	unrel[aidx] = fBadPixels->GetNumUnsuitable(MBadPixelsPix::kUnreliableRun, fGeom, aidx);
2197
2198	unsuitcnt += unsuit[aidx];
2199	unrelcnt += unrel[aidx];
2200
2201	fCam->SetNumUnsuitable(unsuit[aidx], aidx);
2202	fCam->SetNumUnreliable(unrel[aidx], aidx);
2203	}
2204
2205	TArrayI counts(nareas);
2206	for (Int_t i=0; i<fCam->GetSize(); i++)
2207	{
2208	const MCalibrationPix &pix = (*fCam)[i];
2209	if (pix.IsHiGainSaturation())
2210	{
2211	const Int_t aidx = (*fGeom)[i].GetAidx();
2212	counts[aidx]++;
2213	}
2214	}
2215
2216	if (fGeom->InheritsFrom("MGeomCamMagic"))
2217	{
2218	*fLog << " Successfully calibrated Pixels: Inner: "
2219	<< Form("%3i",suit[0]) << " Outer: " << Form("%3i",suit[1]) << endl;
2220	*fLog << " Uncalibrated Pixels: Inner: "
2221	<< Form("%3i",unsuit[0]) << " Outer: " << Form("%3i",unsuit[1]) << endl;
2222	*fLog << " Unreliable Pixels: Inner: "
2223	<< Form("%3i",unrel[0]) << " Outer: " << Form("%3i",unrel[1]) << endl;
2224	*fLog << " High-gain saturated Pixels: Inner: "
2225	<< Form("%3i",counts[0]) << " Outer: " << Form("%3i",counts[1]) << endl;
2226	*fLog << endl;
2227	}
2228
2229	if (unsuitcnt > fUnsuitablesLimit*fGeom->GetNumPixels())
2230	{
2231	fLog << err << "Number of unsuitable pixels: " << 100.unsuitcnt/fGeom->GetNumPixels()
2232	<< "% exceeds limit of " << fUnsuitablesLimit*100 << "%" << endl;
2233	return kFALSE;
2234	}
2235
2236	if (unrelcnt > fUnreliablesLimit*fGeom->GetNumPixels())
2237	{
2238	fLog << err << "Relative number of unreliable pixels: " << 100.unrelcnt/fGeom->GetNumPixels()
2239	<< "% exceeds limit of " << fUnreliablesLimit*100 << "%" << endl;
2240	return kFALSE;
2241	}
2242	return kTRUE;
2243	}
2244
2245	// -----------------------------------------------------------------------------------------------
2246	//
2247	// Print out statistics about BadPixels of type UncalibratedType_t
2248	//
2249	void MCalibrationChargeCalc::PrintUncalibrated(MBadPixelsPix::UncalibratedType_t typ, const char *text) const
2250	{
2251
2252	UInt_t countinner = 0;
2253	UInt_t countouter = 0;
2254
2255	for (Int_t i=0; i<fBadPixels->GetSize(); i++)
2256	{
2257	if ((*fBadPixels)[i].IsUncalibrated(typ))
2258	{
2259	if (fGeom->GetPixRatio(i) == 1.)
2260	countinner++;
2261	else
2262	countouter++;
2263	}
2264	}
2265
2266	*fLog << " " << setw(7) << text << "Inner: " << Form("%3i",countinner)
2267	<< " Outer: " << Form("%3i", countouter) << endl;
2268	}
2269
2270	// --------------------------------------------------------------------------
2271	//
2272	// Read the environment for the following data members:
2273	// - fChargeLimit
2274	// - fChargeErrLimit
2275	// - fChargeRelErrLimit
2276	// - fDebug
2277	// - fFFactorErrLimit
2278	// - fLambdaErrLimit
2279	// - fLambdaCheckErrLimit
2280	// - fPheErrLimit
2281	//
2282	Int_t MCalibrationChargeCalc::ReadEnv(const TEnv &env, TString prefix, Bool_t print)
2283	{
2284
2285	Bool_t rc = kFALSE;
2286	if (IsEnvDefined(env, prefix, "ChargeLimit", print))
2287	{
2288	SetChargeLimit(GetEnvValue(env, prefix, "ChargeLimit", fChargeLimit));
2289	rc = kTRUE;
2290	}
2291	if (IsEnvDefined(env, prefix, "ChargeErrLimit", print))
2292	{
2293	SetChargeErrLimit(GetEnvValue(env, prefix, "ChargeErrLimit", fChargeErrLimit));
2294	rc = kTRUE;
2295	}
2296	if (IsEnvDefined(env, prefix, "ChargeRelErrLimit", print))
2297	{
2298	SetChargeRelErrLimit(GetEnvValue(env, prefix, "ChargeRelErrLimit", fChargeRelErrLimit));
2299	rc = kTRUE;
2300	}
2301	if (IsEnvDefined(env, prefix, "Debug", print))
2302	{
2303	SetDebug(GetEnvValue(env, prefix, "Debug", IsDebug()));
2304	rc = kTRUE;
2305	}
2306	if (IsEnvDefined(env, prefix, "ArrTimeRmsLimit", print))
2307	{
2308	SetArrTimeRmsLimit(GetEnvValue(env, prefix, "ArrTimeRmsLimit", fArrTimeRmsLimit));
2309	rc = kTRUE;
2310	}
2311	if (IsEnvDefined(env, prefix, "FFactorErrLimit", print))
2312	{
2313	SetFFactorErrLimit(GetEnvValue(env, prefix, "FFactorErrLimit", fFFactorErrLimit));
2314	rc = kTRUE;
2315	}
2316	if (IsEnvDefined(env, prefix, "LambdaErrLimit", print))
2317	{
2318	SetLambdaErrLimit(GetEnvValue(env, prefix, "LambdaErrLimit", fLambdaErrLimit));
2319	rc = kTRUE;
2320	}
2321	if (IsEnvDefined(env, prefix, "LambdaCheckLimit", print))
2322	{
2323	SetLambdaCheckLimit(GetEnvValue(env, prefix, "LambdaCheckLimit", fLambdaCheckLimit));
2324	rc = kTRUE;
2325	}
2326	if (IsEnvDefined(env, prefix, "CheckDeadPixels", print))
2327	{
2328	SetCheckDeadPixels(GetEnvValue(env, prefix, "CheckDeadPixels", IsCheckDeadPixels()));
2329	rc = kTRUE;
2330	}
2331	if (IsEnvDefined(env, prefix, "CheckDeviatingBehavior", print))
2332	{
2333	SetCheckDeviatingBehavior(GetEnvValue(env, prefix, "CheckDeviatingBehavior", IsCheckDeviatingBehavior()));
2334	rc = kTRUE;
2335	}
2336	if (IsEnvDefined(env, prefix, "CheckExtractionWindow", print))
2337	{
2338	SetCheckExtractionWindow(GetEnvValue(env, prefix, "CheckExtractionWindow", IsCheckExtractionWindow()));
2339	rc = kTRUE;
2340	}
2341	if (IsEnvDefined(env, prefix, "CheckHistOverflow", print))
2342	{
2343	SetCheckHistOverflow(GetEnvValue(env, prefix, "CheckHistOverflow", IsCheckHistOverflow()));
2344	rc = kTRUE;
2345	}
2346	if (IsEnvDefined(env, prefix, "CheckOscillations", print))
2347	{
2348	SetCheckOscillations(GetEnvValue(env, prefix, "CheckOscillations", IsCheckOscillations()));
2349	rc = kTRUE;
2350	}
2351	if (IsEnvDefined(env, prefix, "CheckArrivalTimes", print))
2352	{
2353	SetCheckArrivalTimes(GetEnvValue(env, prefix, "CheckArrivalTimes", IsCheckArrivalTimes()));
2354	rc = kTRUE;
2355	}
2356	if (IsEnvDefined(env, prefix, "PheErrLowerLimit", print))
2357	{
2358	SetPheErrLowerLimit(GetEnvValue(env, prefix, "PheErrLowerLimit", fPheErrLowerLimit));
2359	rc = kTRUE;
2360	}
2361	if (IsEnvDefined(env, prefix, "PheErrUpperLimit", print))
2362	{
2363	SetPheErrUpperLimit(GetEnvValue(env, prefix, "PheErrUpperLimit", fPheErrUpperLimit));
2364	rc = kTRUE;
2365	}
2366	if (IsEnvDefined(env, prefix, "UseExtractorRes", print))
2367	{
2368	SetUseExtractorRes(GetEnvValue(env, prefix, "UseExtractorRes", IsUseExtractorRes()));
2369	rc = kTRUE;
2370	}
2371	if (IsEnvDefined(env, prefix, "UseUnreliables", print))
2372	{
2373	SetUseUnreliables(GetEnvValue(env, prefix, "UseUnreliables", IsUseUnreliables()));
2374	rc = kTRUE;
2375	}
2376
2377	if (IsEnvDefined(env, prefix, "UseExternalNumPhes", print))
2378	{
2379	SetUseExternalNumPhes(GetEnvValue(env, prefix, "UseExternalNumPhes", IsUseExternalNumPhes()));
2380	rc = kTRUE;
2381	}
2382
2383	if (IsEnvDefined(env, prefix, "UnsuitablesLimit", print))
2384	{
2385	SetUnsuitablesLimit(GetEnvValue(env, prefix, "UnsuitablesLimit", fUnsuitablesLimit));
2386	rc = kTRUE;
2387	}
2388
2389	if (IsEnvDefined(env, prefix, "UnreliablesLimit", print))
2390	{
2391	SetUnreliablesLimit(GetEnvValue(env, prefix, "UnreliablesLimit", fUnreliablesLimit));
2392	rc = kTRUE;
2393	}
2394
2395
2396	return rc;
2397	}

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

Context Navigation

source: releases/Mars.2014.05.26/mcalib/MCalibrationChargeCalc.cc

Download in other formats: