Context Navigation

source: trunk/MagicSoft/Mars/mcalib/MCalibrationChargeCam.cc@ 8212

Visit:

Last change on this file since 8212 was 8106, checked in by tbretz, 18 years ago
* empty log message *
File size: 36.6 KB

Line
1	/* ======================================================================== *\
2	! $Name: not supported by cvs2svn $:$Id: MCalibrationChargeCam.cc,v 1.69 2006-10-17 17:18:40 tbretz Exp $
3	! --------------------------------------------------------------------------
4	!
5	! *
6	! * This file is part of MARS, the MAGIC Analysis and Reconstruction
7	! * Software. It is distributed to you in the hope that it can be a useful
8	! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
9	! * It is distributed WITHOUT ANY WARRANTY.
10	! *
11	! * Permission to use, copy, modify and distribute this software and its
12	! * documentation for any purpose is hereby granted without fee,
13	! * provided that the above copyright notice appear in all copies and
14	! * that both that copyright notice and this permission notice appear
15	! * in supporting documentation. It is provided "as is" without express
16	! * or implied warranty.
17	! *
18	!
19	!
20	! Author(s): Markus Gaug 11/2003 <mailto:markus@ifae.es>
21	!
22	! Copyright: MAGIC Software Development, 2000-2004
23	!
24	!
25	\* ======================================================================== */
26	/////////////////////////////////////////////////////////////////////////////
27	//
28	// MCalibrationChargeCam
29	//
30	// Storage container for charge calibration results from the signal distribution
31	// fits (see MHCalibrationChargeCam and MHCalibrationChargePix), the calculation
32	// of reduced sigmas and number of photo-electrons (this class) and conversion
33	// factors sum FADC slices to photo-electrons (see MCalibrationChargeCalc)
34	//
35	// Individual pixels have to be cast when retrieved e.g.:
36	// MCalibrationChargePix &avpix = (MCalibrationChargePix&)(*fChargeCam)[i]
37	//
38	// Averaged values over one whole area index (e.g. inner or outer pixels for
39	// the MAGIC camera), can be retrieved via:
40	// MCalibrationChargePix &avpix = (MCalibrationChargePix&)fChargeCam->GetAverageArea(i)
41	//
42	// Averaged values over one whole camera sector can be retrieved via:
43	// MCalibrationChargePix &avpix = (MCalibrationChargePix&)fChargeCam->GetAverageSector(i)
44	//
45	// Note the averageing has been done on an event-by-event basis. Resulting
46	// Sigma's of the Gauss fit have been multiplied with the square root of the number
47	// of involved pixels in order to make a direct comparison possible with the mean of
48	// sigmas.
49	//
50	// Final numbers of uncalibrated or unreliable pixels can be retrieved via the commands:
51	// GetNumUncalibrated(aidx) and GetNumUnreliable(aidx) where aidx is the area index (0 for
52	// inner and 1 for outer pixels in the MAGIC camera).
53	//
54	// The following "calibration" constants are used for the calibration of each pixel
55	// (see MCalibrate):
56	//
57	// - MCalibrationQEPix::GetMeanConvFADC2Phe(): The mean conversion factor from the
58	// summed FADC slices to the number of photo-electrons (in first order independent
59	// on colour and intensity)
60	// - MCalibrationQEPix::GetMeanFFactorFADC2Phot(): The mean F-Factor of the total
61	// readout chain dividing the signal to noise of the incoming number of photons
62	// (= sqrt(number photons)) by the signal to noise of the outgoing summed FADC slices
63	// signal (= MCalibrationPix::GetMean() / MCalibrationChargePix::GetRSigma() )
64	//
65	// The following calibration constants can be retrieved directly from this class:
66	//
67	// - GetConversionFactorFFactor ( Int_t idx, Float_t &mean, Float_t &err, Float_t &sigma );
68	//
69	// where:
70	// - idx is the pixel software ID
71	// - "mean" is the mean conversion constant, to be multiplied with the retrieved signal
72	// in order to get a calibrated number of PHOTONS.
73	// - "err" is the pure statistical uncertainty about the MEAN
74	// - "sigma", if mulitplied with the square root of signal, gives the approximate sigma of the
75	// retrieved mean number of incident Cherenkov photons.
76	//
77	// Note, Conversion is ALWAYS (included the F-Factor method!) from summed FADC slices to PHOTONS.
78	//
79	// See also: MCalibrationChargePix, MCalibrationChargeCalc, MCalibrationQECam
80	// MHCalibrationChargePix, MHCalibrationChargeCam
81	// MCalibrationBlindPix, MCalibrationChargePINDiode
82	//
83	/////////////////////////////////////////////////////////////////////////////
84	#include "MCalibrationChargeCam.h"
85	#include "MCalibrationChargePix.h"
86
87	#include <TOrdCollection.h>
88	#include <TH1D.h>
89	#include <TF1.h>
90
91	#include "MLog.h"
92	#include "MLogManip.h"
93
94	#include "MGeomCam.h"
95	#include "MGeomPix.h"
96
97	#include "MBadPixelsCam.h"
98	#include "MBadPixelsPix.h"
99
100	#include "MCalibrationQECam.h"
101	#include "MCalibrationQEPix.h"
102
103	#include "MHCamera.h"
104
105	ClassImp(MCalibrationChargeCam);
106
107	using namespace std;
108	// --------------------------------------------------------------------------
109	//
110	// Default constructor.
111	//
112	// Calls:
113	// - Clear()
114	//
115	MCalibrationChargeCam::MCalibrationChargeCam(const char name, const char title)
116	{
117	fName = name ? name : "MCalibrationChargeCam";
118	fTitle = title ? title : "Storage container for the Calibration Information in the camera";
119
120	Clear();
121	}
122
123	/*
124	// --------------------------------------------------------------------------
125	//
126	// Creates new MCalibrationCam only for the averaged areas:
127	// the rest has to be retrieved directly, e.g. via:
128	//
129	TObject MCalibrationChargeCam::Clone(const char ) const
130	{
131
132	//
133	// FIXME, this might be done faster and more elegant, by direct copy.
134	//
135	MCalibrationChargeCam *cam = new MCalibrationChargeCam(fName,fTitle);
136
137	cam->fNumUnsuitable = fNumUnsuitable;
138	cam->fNumUnreliable = fNumUnreliable;
139	cam->fNumHiGainFADCSlices = fNumHiGainFADCSlices;
140	cam->fNumLoGainFADCSlices = fNumLoGainFADCSlices;
141	cam->fPulserColor = fPulserColor;
142
143	cam->fFlags = fFlags;
144
145	cam->fNumPhotonsBlindPixelMethod = fNumPhotonsBlindPixelMethod;
146	cam->fNumPhotonsFFactorMethod = fNumPhotonsFFactorMethod;
147	cam->fNumPhotonsPINDiodeMethod = fNumPhotonsPINDiodeMethod;
148	cam->fNumPhotonsBlindPixelMethodErr = fNumPhotonsBlindPixelMethodErr;
149	cam->fNumPhotonsFFactorMethodErr = fNumPhotonsFFactorMethodErr;
150	cam->fNumPhotonsPINDiodeMethodErr = fNumPhotonsPINDiodeMethodErr;
151
152	for (Int_t i=0; i<GetSize(); i++)
153	cam->fPixels->AddAt((*this)[i].Clone(),i);
154
155	for (Int_t i=0; i<GetAverageAreas(); i++)
156	{
157	cam->fAverageAreas->AddAt(GetAverageArea(i).Clone(),i);
158	cam->fAverageBadAreas->AddAt(GetAverageBadArea(i).Clone(),i);
159	}
160	for (Int_t i=0; i<GetAverageSectors(); i++)
161	{
162	cam->fAverageSectors->AddAt(GetAverageSector(i).Clone(),i);
163	cam->fAverageBadSectors->AddAt(GetAverageBadSector(i).Clone(),i);
164	}
165
166	return cam;
167	}
168	*/
169
170	// -------------------------------------------------------------------
171	//
172	// Add MCalibrationChargePix's in the ranges from - to to fPixels
173	//
174	void MCalibrationChargeCam::Add(const UInt_t a, const UInt_t b)
175	{
176	for (UInt_t i=a; i<b; i++)
177	{
178	fPixels->AddAt(new MCalibrationChargePix,i);
179	(*this)[i].SetPixId(i);
180	}
181	}
182
183	// -------------------------------------------------------------------
184	//
185	// Add MCalibrationChargePix's in the ranges from - to to fAverageAreas
186	//
187	void MCalibrationChargeCam::AddArea(const UInt_t a, const UInt_t b)
188	{
189	for (UInt_t i=a; i<b; i++)
190	{
191	fAverageAreas->AddAt(new MCalibrationChargePix,i);
192	GetAverageArea(i).SetPixId(i);
193	}
194	}
195
196	// -------------------------------------------------------------------
197	//
198	// Add MCalibrationChargePix's in the ranges from - to to fAverageSectors
199	//
200	void MCalibrationChargeCam::AddSector(const UInt_t a, const UInt_t b)
201	{
202	for (UInt_t i=a; i<b; i++)
203	{
204	fAverageSectors->AddAt(new MCalibrationChargePix,i);
205	GetAverageSector(i).SetPixId(i);
206	}
207	}
208
209
210	// --------------------------------------
211	//
212	// Sets all variable to 0.
213	// Sets all flags to kFALSE
214	// Calls MCalibrationCam::Clear()
215	//
216	void MCalibrationChargeCam::Clear(Option_t *o)
217	{
218
219	SetFFactorMethodValid ( kFALSE );
220
221	fNumPhotonsBlindPixelMethod = 0.;
222	fNumPhotonsFFactorMethod = 0.;
223	fNumPhotonsPINDiodeMethod = 0.;
224	fNumPhotonsBlindPixelMethodErr = 0.;
225	fNumPhotonsFFactorMethodErr = 0.;
226	fNumPhotonsPINDiodeMethodErr = 0.;
227
228	MCalibrationCam::Clear();
229
230	return;
231	}
232
233	// -----------------------------------------------
234	//
235	// Sets the kFFactorMethodValid bit from outside
236	//
237	void MCalibrationChargeCam::SetFFactorMethodValid(const Bool_t b)
238	{
239	b ? SETBIT(fFlags, kFFactorMethodValid) : CLRBIT(fFlags, kFFactorMethodValid);
240	}
241
242
243	// --------------------------------------------------------------------------
244	//
245	// Test bit kFFactorMethodValid
246	//
247	Bool_t MCalibrationChargeCam::IsFFactorMethodValid() const
248	{
249	return TESTBIT(fFlags,kFFactorMethodValid);
250	}
251
252	// --------------------------------------------------------------------------
253	//
254	// Copy High-gain vs. low-gain conversion factors from cam to this.
255	//
256	Bool_t MCalibrationChargeCam::MergeHiLoConversionFactors(const MCalibrationChargeCam &cam) const
257	{
258
259	if (GetSize() != cam.GetSize())
260	{
261	*fLog << warn << "Sizes mismatch! Cannot merge high-gain vs. low-gain convertion factors" << endl;
262	return kFALSE;
263	}
264
265	for (Int_t i=0; i<GetSize(); i++)
266	{
267	((MCalibrationChargePix&)(*this)[i]).SetConversionHiLo (((MCalibrationChargePix&)cam[i]).GetConversionHiLo());
268	((MCalibrationChargePix&)(*this)[i]).SetConversionHiLoErr(((MCalibrationChargePix&)cam[i]).GetConversionHiLoErr());
269	}
270
271	return kTRUE;
272	}
273
274	// --------------------------------------------------------------------------
275	//
276	// Print first the well fitted pixels
277	// and then the ones which are not FitValid
278	//
279	void MCalibrationChargeCam::Print(Option_t *o) const
280	{
281
282	*fLog << all << GetDescriptor() << ":" << endl;
283	int id = 0;
284
285	*fLog << all << "Calibrated pixels:" << endl;
286	*fLog << all << endl;
287
288	TIter Next(fPixels);
289	MCalibrationChargePix *pix;
290	while ((pix=(MCalibrationChargePix*)Next()))
291	{
292
293	if (pix->IsFFactorMethodValid())
294	{
295
296	*fLog << all
297	<< Form("%s%3i","Pixel: ",pix->GetPixId())
298	<< Form("%s%4.2f%s%4.2f"," Ped.Rms: ",pix->GetPedRms(),"+-",pix->GetPedRmsErr())
299	<< Form("%s%4.2f%s%4.2f"," Charge: " ,pix->GetConvertedMean(),"+-",pix->GetConvertedSigma())
300	<< Form("%s%4.2f%s%4.2f"," Red.Sigma: ",pix->GetConvertedRSigma(),"+-",pix->GetConvertedRSigmaErr())
301	<< Form("%s%4.2f%s%4.2f"," Num.Phes: ",pix->GetPheFFactorMethod(),"+-",pix->GetPheFFactorMethodErr())
302	<< Form("%s%4.2f%s%4.2f"," Conv.FADC2Phe: ",pix->GetMeanConvFADC2Phe(),"+-",pix->GetMeanConvFADC2PheErr())
303	<< " Saturated? :" << pix->IsHiGainSaturation()
304	<< Form("%s%4.2f%s%4.2f"," Conv.HiLo: ",pix->GetConversionHiLo(),"+-",pix->GetConversionHiLoErr())
305	<< endl;
306	id++;
307	}
308	}
309
310	*fLog << all << id << " pixels" << endl;
311	id = 0;
312
313
314	*fLog << all << endl;
315	*fLog << all << "Previously Excluded pixels:" << endl;
316	*fLog << all << endl;
317
318	id = 0;
319
320	TIter Next4(fPixels);
321	while ((pix=(MCalibrationChargePix*)Next4()))
322	{
323	if (pix->IsExcluded())
324	{
325	*fLog << all << pix->GetPixId() << " ";
326	id++;
327
328	if (!(id % 25))
329	*fLog << endl;
330	}
331	}
332
333	*fLog << all << endl;
334	*fLog << all << "New Excluded pixels:" << endl;
335	*fLog << all << endl;
336
337	TIter Next5(fPixels);
338	while ((pix=(MCalibrationChargePix*)Next5()))
339	{
340	if (!pix->IsFFactorMethodValid() && !pix->IsExcluded())
341	{
342	*fLog << all << pix->GetPixId() << " ";
343	id++;
344
345	if (!(id % 25))
346	*fLog << endl;
347	}
348	}
349
350	*fLog << endl;
351	*fLog << all << id << " Excluded pixels " << endl;
352	*fLog << endl;
353
354	*fLog << all << endl;
355	*fLog << all << "Averaged Areas:" << endl;
356	*fLog << all << endl;
357
358	TIter Next6(fAverageAreas);
359	while ((pix=(MCalibrationChargePix*)Next6()))
360	{
361	*fLog << all << Form("%s%3i","Area Idx: ",pix->GetPixId())
362	<< " Ped. Rms: " << pix->GetPedRms() << " +- " << pix->GetPedRmsErr()
363	<< " Mean signal: " << pix->GetMean() << " +- " << pix->GetMeanErr()
364	<< " Sigma signal: " << pix->GetSigma() << " +- "<< pix->GetSigmaErr()
365	<< " Reduced Sigma: " << pix->GetRSigma()
366	<< " Nr Phe's: " << pix->GetPheFFactorMethod()
367	<< endl;
368	}
369
370	*fLog << all << endl;
371	*fLog << all << "Averaged Sectors:" << endl;
372	*fLog << all << endl;
373
374	TIter Next7(fAverageSectors);
375	while ((pix=(MCalibrationChargePix*)Next7()))
376	{
377	*fLog << all << Form("%s%3i","Sector: ",pix->GetPixId())
378	<< " Ped. Rms: " << pix->GetPedRms() << " +- " << pix->GetPedRmsErr()
379	<< " Mean signal: " << pix->GetMean() << " +- " << pix->GetMeanErr()
380	<< " Sigma signal: " << pix->GetSigma() << " +- "<< pix->GetSigmaErr()
381	<< " Reduced Sigma: " << pix->GetRSigma()
382	<< " Nr Phe's: " << pix->GetPheFFactorMethod()
383	<< endl;
384	}
385	*fLog << all << endl;
386	}
387
388
389	// --------------------------------------------------------------------------
390	//
391	// The types are as follows:
392	//
393	// Fitted values:
394	// ==============
395	//
396	// 0: Fitted Charge (see MCalibrationPix::GetMean())
397	// 1: Error of fitted Charge (see MCalibrationPix::GetMeanErr())
398	// 2: Sigma of fitted Charge (see MCalibrationPix::GetSigma())
399	// 3: Error of Sigma of fitted Charge (see MCalibrationPix::GetSigmaErr())
400	//
401	// Useful variables derived from the fit results:
402	// =============================================
403	//
404	// 4: Probability Gauss fit Charge distribution (see MCalibrationPix::GetProb())
405	// 5: Reduced Sigma of fitted Charge (see MCalibrationChargePix::GetRSigma())
406	// 6: Error Reduced Sigma of fitted Charge (see MCalibrationChargePix::GetRSigmaErr())
407	// 7: Reduced Sigma per Charge (see MCalibrationChargePix::GetRSigmaPerCharge())
408	// 8: Error of Reduced Sigma per Charge (see MCalibrationChargePix::GetRSigmaPerChargeErr())
409	//
410	// Results of the F-Factor calibration Method:
411	// ===========================================
412	//
413	// 9: Nr. Photo-electrons from F-Factor Method (see MCalibrationChargePix::GetPheFFactorMethod())
414	// 10: Error Nr. Photo-el. from F-Factor Method (see MCalibrationChargePix::GetPheFFactorMethodErr())
415	// 11: Conversion factor from F-Factor Method (see MCalibrationChargePix::GetMeanConvFADC2Phe()
416	// 12: Error conv. factor from F-Factor Method (see MCalibrationChargePix::GetMeanConvFADC2PheErr()
417	// 13: Overall F-Factor from F-Factor Method (see MCalibrationChargePix::GetMeanFFactorFADC2Phot()
418	// 14: Error F-Factor from F-Factor Method (see MCalibrationChargePix::GetMeanFFactorFADC2PhotErr()
419	// 15: Pixels valid calibration F-Factor-Method (see MCalibrationChargePix::IsFFactorMethodValid())
420	//
421	// Results of the Low-Gain vs. High-Gain Conversion:
422	// =================================================
423	//
424	// 16: Mean Signal Hi-Gain / Mean Signal Lo-Gain (see MCalibrationPix::GetHiLoMeansDivided())
425	// 17: Error Signal High-Gain / Signal Low Gain (see MCalibrationPix::GetHiLoMeansDividedErr())
426	// 18: Sigma High-Gain / Sigma Low Gain (see MCalibrationPix::GetHiLoSigmasDivided())
427	// 19: Error Sigma High-Gain / Sigma Low Gain (see MCalibrationPix::GetHiLoSigmasDividedErr())
428	//
429	// Localized defects:
430	// ==================
431	//
432	// 20: Excluded Pixels
433	// 21: Number of pickup events in the Hi Gain (see MCalibrationPix::GetHiGainNumPickup())
434	// 22: Number of pickup events in the Lo Gain (see MCalibrationPix::GetLoGainNumPickup())
435	// 23: Number of blackout events in the Hi Gain (see MCalibrationPix::GetHiGainNumBlackout())
436	// 24: Number of blackout events in the Lo Gain (see MCalibrationPix::GetLoGainNumBlackout())
437	//
438	// Other classifications of pixels:
439	// ================================
440	//
441	// 25: Pixels with saturated High-Gain (see MCalibrationPix::IsHiGainSaturation())
442	//
443	// Calculated absolute arrival times (very low precision!):
444	// ========================================================
445	//
446	// 26: Absolute Arrival time of the signal (see MCalibrationChargePix::GetAbsTimeMean())
447	// 27: RMS Ab. Arrival time of the signal (see MCalibrationChargePix::GetAbsTimeRms())
448	//
449	// Used Pedestals:
450	// ===============
451	//
452	// 28: Pedestal for entire signal extr. range (see MCalibrationChargePix::Ped())
453	// 29: Error Pedestal entire signal extr. range (see MCalibrationChargePix::PedErr())
454	// 30: Ped. RMS entire signal extraction range (see MCalibrationChargePix::PedRms())
455	// 31: Error Ped. RMS entire signal extr. range (see MCalibrationChargePix::PedRmsErr())
456	//
457	// Special variables (for data check):
458	// ====================================
459	//
460	// 32: HiGain RMS divided by Mean for every pixel (with inclusion of the excluded pixels)
461	//
462	Bool_t MCalibrationChargeCam::GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type) const
463	{
464
465	if (idx > GetSize())
466	return kFALSE;
467
468	Float_t area = cam[idx].GetA();
469
470	if (area == 0)
471	return kFALSE;
472
473	MCalibrationChargePix &pix = (MCalibrationChargePix&)(*this)[idx];
474
475	switch (type)
476	{
477	case 0:
478	if (pix.IsExcluded())
479	return kFALSE;
480	val = pix.GetConvertedMean();
481	break;
482	case 1:
483	if (pix.IsExcluded())
484	return kFALSE;
485	val = pix.GetConvertedMeanErr();
486	break;
487	case 2:
488	if (pix.IsExcluded())
489	return kFALSE;
490	val = pix.GetConvertedSigma();
491	break;
492	case 3:
493	if (pix.IsExcluded())
494	return kFALSE;
495	val = pix.GetConvertedSigmaErr();
496	break;
497	case 4:
498	if (pix.IsExcluded())
499	return kFALSE;
500	val = pix.GetProb();
501	break;
502	case 5:
503	if (!pix.IsFFactorMethodValid())
504	return kFALSE;
505	if (pix.GetRSigma() == -1.)
506	return kFALSE;
507	val = pix.GetConvertedRSigma();
508	break;
509	case 6:
510	if (!pix.IsFFactorMethodValid())
511	return kFALSE;
512	if (pix.GetRSigma() == -1.)
513	return kFALSE;
514	val = pix.GetConvertedRSigmaErr();
515	break;
516	case 7:
517	if (!pix.IsFFactorMethodValid())
518	return kFALSE;
519	val = pix.GetRSigmaPerCharge();
520	break;
521	case 8:
522	if (!pix.IsFFactorMethodValid())
523	return kFALSE;
524	val = pix.GetRSigmaPerChargeErr();
525	break;
526	case 9:
527	// if (!pix.IsFFactorMethodValid())
528	// return kFALSE;
529	if (pix.IsExcluded())
530	return kFALSE;
531	val = pix.GetPheFFactorMethod();
532	break;
533	case 10:
534	// if (!pix.IsFFactorMethodValid())
535	// return kFALSE;
536	if (pix.IsExcluded())
537	return kFALSE;
538	val = pix.GetPheFFactorMethodErr();
539	if (val < 0.)
540	val = 0.00001;
541	break;
542	case 11:
543	// if (!pix.IsFFactorMethodValid())
544	// return kFALSE;
545	if (pix.IsExcluded())
546	return kFALSE;
547	val = pix.GetMeanConvFADC2Phe();
548	break;
549	case 12:
550	// if (!pix.IsFFactorMethodValid())
551	// return kFALSE;
552	if (pix.IsExcluded())
553	return kFALSE;
554	val = pix.GetMeanConvFADC2PheErr();
555	if (val < 0.)
556	val = 0.00001;
557	break;
558	case 13:
559	// if (!pix.IsFFactorMethodValid())
560	// return kFALSE;
561	if (pix.IsExcluded())
562	return kFALSE;
563	val = pix.GetMeanFFactorFADC2Phot();
564	break;
565	case 14:
566	// if (!pix.IsFFactorMethodValid())
567	// return kFALSE;
568	if (pix.IsExcluded())
569	return kFALSE;
570	val = pix.GetMeanFFactorFADC2PhotErr();
571	if (val < 0.)
572	val = 0.00001;
573	break;
574	case 15:
575	if (pix.IsExcluded())
576	return kFALSE;
577	if (pix.IsFFactorMethodValid())
578	val = 1;
579	else
580	return kFALSE;
581	break;
582	case 16:
583	if (pix.IsExcluded())
584	return kFALSE;
585	val = pix.GetHiLoMeansDivided();
586	break;
587	case 17:
588	if (pix.IsExcluded())
589	return kFALSE;
590	val = pix.GetHiLoMeansDividedErr();
591	break;
592	case 18:
593	if (pix.IsExcluded())
594	return kFALSE;
595	val = pix.GetHiLoSigmasDivided();
596	break;
597	case 19:
598	if (pix.IsExcluded())
599	return kFALSE;
600	val = pix.GetHiLoSigmasDividedErr();
601	break;
602	case 20:
603	if (pix.IsExcluded())
604	val = 1.;
605	else
606	return kFALSE;
607	break;
608	case 21:
609	if (pix.IsExcluded())
610	return kFALSE;
611	val = pix.GetHiGainNumPickup();
612	break;
613	case 22:
614	if (pix.IsExcluded())
615	return kFALSE;
616	val = pix.GetLoGainNumPickup();
617	break;
618	case 23:
619	if (pix.IsExcluded())
620	return kFALSE;
621	val = pix.GetHiGainNumBlackout();
622	break;
623	case 24:
624	if (pix.IsExcluded())
625	return kFALSE;
626	val = pix.GetLoGainNumBlackout();
627	break;
628	case 25:
629	if (pix.IsExcluded())
630	return kFALSE;
631	val = pix.IsHiGainSaturation();
632	break;
633	case 26:
634	if (pix.IsExcluded())
635	return kFALSE;
636	val = pix.GetAbsTimeMean();
637	break;
638	case 27:
639	if (pix.IsExcluded())
640	return kFALSE;
641	val = pix.GetAbsTimeRms();
642	break;
643	case 28:
644	if (pix.IsExcluded())
645	return kFALSE;
646	val = pix.GetPed();
647	break;
648	case 29:
649	if (pix.IsExcluded())
650	return kFALSE;
651	val = pix.GetPedErr();
652	break;
653	case 30:
654	if (pix.IsExcluded())
655	return kFALSE;
656	val = pix.GetPedRms();
657	break;
658	case 31:
659	if (pix.IsExcluded())
660	return kFALSE;
661	val = pix.GetPedErr()/2.;
662	break;
663	case 32:
664	if (pix.IsExcluded())
665	return kFALSE;
666	val = pix.GetMean() == 0. ? 0. : pix.GetRms()/pix.GetMean();
667	break;
668	case 33:
669	if (pix.IsExcluded())
670	return kFALSE;
671	if (pix.GetMean() == 0.)
672	val = 0.;
673	else
674	val = pix.GetSigmaErr()/pix.GetMean() + pix.GetRms()/pix.GetMean()/pix.GetMean()*pix.GetMeanErr();
675	break;
676	default:
677	return kFALSE;
678	}
679
680	return val!=-1.;
681	}
682
683
684	Bool_t MCalibrationChargeCam::GetConversionFactorFFactor(Int_t ipx, Float_t &mean, Float_t &ferr, Float_t &ffactor)
685	{
686
687	MCalibrationChargePix &pix = (MCalibrationChargePix&)(*this)[ipx];
688
689	Float_t conv = pix.GetMeanConvFADC2Phe();
690
691	if (conv < 0.)
692	return kFALSE;
693
694	mean = conv;
695	ferr = pix.GetMeanConvFADC2PheErr();
696	ffactor = pix.GetMeanFFactorFADC2Phot();
697
698	return kTRUE;
699	}
700
701
702	// --------------------------------------------------------------------------
703	//
704	// Calculates the average conversion factor FADC counts to photons for pixel sizes.
705	// The geometry container is used to get the necessary
706	// geometry information (area index). The MCalibrationQECam container is necessary for
707	// the quantum efficiency information.
708	// If the bad pixel container is given all pixels which have the flag 'kUnsuitableRun' are ignored
709	// in the calculation of the size average.
710	//
711	// Returns a TArrayF of dimension 2:
712	// arr[0]: averaged conversion factors (default: -1.)
713	// arr[1]: Error (rms) of averaged conversion factors (default: 0.)
714	//
715	TArrayF MCalibrationChargeCam::GetAveragedConvFADC2PhotPerArea ( const MGeomCam &geom, const MCalibrationQECam &qecam,
716	const UInt_t ai, MBadPixelsCam *bad)
717	{
718
719	const Int_t np = GetSize();
720
721	Double_t mean = 0.;
722	Double_t mean2 = 0.;
723	Int_t nr = 0;
724
725	MHCamera convcam(geom,"ConvFactors","Conversion Factors;Conv Factor [phot/FADC cnts];channels");
726
727	for (int i=0; i<np; i++)
728	{
729	if (bad && (*bad)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
730	continue;
731
732	if (bad && (*bad)[i].IsUncalibrated(MBadPixelsPix::kDeviatingNumPhes))
733	continue;
734
735	const UInt_t aidx = geom[i].GetAidx();
736
737	if (ai != aidx)
738	continue;
739
740	const MCalibrationQEPix &qepix = (MCalibrationQEPix&)qecam[i];
741	if (!qepix.IsAverageQEFFactorAvailable())
742	continue;
743
744	const MCalibrationChargePix &pix = (MCalibrationChargePix&)(*this)[i];
745	const Float_t conv = pix.GetMeanConvFADC2Phe()/qepix.GetQECascadesFFactor();
746
747	mean += conv;
748	mean2 += conv*conv;
749	nr ++;
750
751	convcam.Fill(i,conv);
752	convcam.SetUsed(i);
753	}
754
755	Float_t mn = nr ? mean/nr : -1.;
756	Float_t sg = nr>1 ? TMath::Sqrt((mean2 - mean*mean/nr)/(nr-1)) : 0.;
757
758	const Int_t aidx = (Int_t)ai;
759
760	TH1D *h = convcam.ProjectionS(TArrayI(),TArrayI(1,&aidx),"_py",750);
761	h->SetDirectory(NULL);
762
763	TF1 *fit = NULL;
764
765	if (geom.InheritsFrom("MGeomCamMagic"))
766	{
767
768	fit = new TF1("fit","gaus",0.4,5.);
769
770	// Fix the ranges, as found by Nadia
771	if(aidx == 0)
772	h->Fit(fit, "REQ0", "",0.4,1.5);
773	else
774	h->Fit(fit ,"REQ0", "",1.,5.);
775	}
776	else
777	{
778	h->Fit("gaus","Q0");
779	fit = h->GetFunction("gaus");
780	}
781
782	Float_t ci2 = fit->GetChisquare();
783	Float_t sigma = fit->GetParameter(2);
784
785	if (ci2 > 500. \|\| sigma > sg)
786	{
787	if (geom.InheritsFrom("MGeomCamMagic"))
788	{
789	// Fix the ranges, as found by Nadia
790	if(aidx == 0)
791	h->Fit(fit, "REQ0", "",0.4,1.5);
792	else
793	h->Fit(fit, "REQ0", "",1.,5.);
794	}
795	else
796	{
797	h->Fit("gaus","MREQ0");
798	fit = h->GetFunction("gaus");
799	}
800
801	ci2 = fit->GetChisquare();
802	sigma = fit->GetParameter(2);
803	}
804
805	const Int_t ndf = fit->GetNDF();
806
807	if (ci2 < 500. && sigma < sg && ndf > 2)
808	{
809	mn = fit->GetParameter(1);
810	sg = sigma;
811	}
812
813	*fLog << inf << "Conversion Factors to photons area idx: " << aidx << ":" << endl;
814	*fLog << inf << "Mean: " << Form("%4.3f",mn)
815	<< "+-" << Form("%4.3f",fit->GetParError(1))
816	<< " Sigma: " << Form("%4.3f",sg) << "+-" << Form("%4.3f",fit->GetParError(2))
817	<< " Chisquare: " << Form("%4.3f",fit->GetChisquare()) << " NDF : " << ndf << endl;
818
819	delete fit;
820	delete h;
821	gROOT->GetListOfFunctions()->Remove(fit);
822
823	TArrayF arr(2);
824	arr[0] = mn;
825	arr[1] = sg;
826
827	return arr;
828	}
829
830	// --------------------------------------------------------------------------
831	//
832	// Calculates the average conversion factor FADC counts to equiv. photo-electrons for pixel sizes.
833	// The geometry container is used to get the necessary
834	// geometry information (area index). The MCalibrationQECam container is necessary for
835	// the quantum efficiency information.
836	// If the bad pixel container is given all pixels which have the flag 'kUnsuitableRun' are ignored
837	// in the calculation of the size average.
838	//
839	// Returns a TArrayF of dimension 2:
840	// arr[0]: averaged conversion factors (default: -1.)
841	// arr[1]: Error (rms) of averaged conversion factors (default: 0.)
842	//
843	TArrayF MCalibrationChargeCam::GetAveragedConvFADC2PhePerArea ( const MGeomCam &geom, const MCalibrationQECam &qecam,
844	const UInt_t ai, MBadPixelsCam *bad)
845	{
846
847	const Int_t np = GetSize();
848
849	Double_t mean = 0.;
850	Double_t mean2 = 0.;
851	Int_t nr = 0;
852
853	MHCamera convcam(geom,"ConvFactors","Conversion Factors;Conv Factor [phe/FADC cnts];channels");
854
855	for (int i=0; i<np; i++)
856	{
857	if (bad && (*bad)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
858	continue;
859
860	if (bad && (*bad)[i].IsUncalibrated(MBadPixelsPix::kDeviatingNumPhes))
861	continue;
862
863	const UInt_t aidx = geom[i].GetAidx();
864
865	if (ai != aidx)
866	continue;
867
868	const MCalibrationQEPix &qepix = (MCalibrationQEPix&)qecam[i];
869	if (!qepix.IsAverageQEFFactorAvailable())
870	continue;
871
872	const MCalibrationChargePix &pix = (MCalibrationChargePix&)(*this)[i];
873	const Float_t conv = pix.GetMeanConvFADC2Phe()/qepix.GetQECascadesFFactor()*MCalibrationQEPix::gkDefaultAverageQE;
874
875	mean += conv;
876	mean2 += conv*conv;
877	nr ++;
878
879	convcam.Fill(i,conv);
880	convcam.SetUsed(i);
881	}
882
883	Float_t mn = nr ? mean/nr : -1.;
884	Float_t sg = nr>1 ? TMath::Sqrt((mean2 - mean*mean/nr)/(nr-1)) : 0.;
885
886	const Int_t aidx = (Int_t)ai;
887
888	TH1D *h = convcam.ProjectionS(TArrayI(),TArrayI(1,&aidx),"_py",750);
889	h->SetDirectory(NULL);
890
891	TF1 *fit = NULL;
892
893	if (geom.InheritsFrom("MGeomCamMagic"))
894	{
895
896	fit = new TF1("fit","gaus",0.01,1.);
897
898	// Fix the ranges, as found by Nadia
899	if(aidx == 0)
900	{h->Fit("fit","REQ0", "",0.07,0.3);}
901	else
902	{h->Fit("fit","REQ0", "",0.15,1.0);}
903	}
904	else
905	{
906	h->Fit("gaus","Q0");
907	fit = h->GetFunction("gaus");
908	}
909
910	Float_t ci2 = fit->GetChisquare();
911	Float_t sigma = fit->GetParameter(2);
912
913	if (ci2 > 500. \|\| sigma > sg)
914	{
915	if (geom.InheritsFrom("MGeomCamMagic"))
916	{
917	// Fix the ranges, as found by Nadia
918	if(aidx == 0)
919	{h->Fit("fit","REQ0", "",0.07,0.3);}
920	else
921	{h->Fit("fit","REQ0", "",0.15,1.0);}
922	}
923	else
924	{
925	h->Fit("gaus","MREQ0");
926	fit = h->GetFunction("gaus");
927	}
928
929	ci2 = fit->GetChisquare();
930	sigma = fit->GetParameter(2);
931	}
932
933	const Int_t ndf = fit->GetNDF();
934
935	if (ci2 < 500. && sigma < sg && ndf > 2)
936	{
937	mn = fit->GetParameter(1);
938	sg = sigma;
939	}
940
941	*fLog << inf << "Conversion Factors to equiv. photo-electrons area idx: " << aidx << ":" << endl;
942	*fLog << inf << "Mean: " << Form("%4.3f",mn)
943	<< "+-" << Form("%4.3f",fit->GetParError(1))
944	<< " Sigma: " << Form("%4.3f",sg) << "+-" << Form("%4.3f",fit->GetParError(2))
945	<< " Chisquare: " << Form("%4.3f",fit->GetChisquare()) << " NDF : " << ndf << endl;
946
947	delete fit;
948	delete h;
949	gROOT->GetListOfFunctions()->Remove(fit);
950
951	TArrayF arr(2);
952	arr[0] = mn;
953	arr[1] = sg;
954
955	return arr;
956	}
957
958	// --------------------------------------------------------------------------
959	//
960	// Calculates the average conversion factor FADC counts to photons for camera sectors.
961	// The geometry container is used to get the necessary
962	// geometry information (area index). The MCalibrationQECam container is necessary for
963	// the quantum efficiency information.
964	// If the bad pixel container is given all pixels which have the flag 'kUnsuitableRun' are ignored
965	// in the calculation of the size average.
966	//
967	// Returns a TArrayF of dimension 2:
968	// arr[0]: averaged conversion factors (default: -1.)
969	// arr[1]: Error (rms) of averaged conversion factors (default: 0.)
970	//
971	TArrayF MCalibrationChargeCam::GetAveragedConvFADC2PhotPerSector( const MGeomCam &geom, const MCalibrationQECam &qecam,
972	const UInt_t sec, MBadPixelsCam *bad)
973	{
974	const Int_t np = GetSize();
975
976	Double_t mean = 0.;
977	Double_t mean2 = 0.;
978	Int_t nr = 0;
979
980	for (int i=0; i<np; i++)
981	{
982	if (bad && (*bad)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
983	continue;
984
985	const UInt_t sector = geom[i].GetSector();
986
987	if (sector != sec)
988	continue;
989
990	const MCalibrationQEPix &qepix = (MCalibrationQEPix&)qecam[i];
991	if (!qepix.IsAverageQEFFactorAvailable())
992	continue;
993
994	const MCalibrationChargePix &pix = (MCalibrationChargePix&)(*this)[i];
995	const Float_t conv = pix.GetMeanConvFADC2Phe();
996	const Float_t qe = qepix.GetQECascadesFFactor();
997
998	mean += conv/qe;
999	mean2 += conv*conv/qe/qe;
1000	nr ++;
1001
1002	}
1003
1004	TArrayF arr(2);
1005	arr[0] = nr ? mean/nr : -1;
1006	arr[1] = nr>1 ? TMath::Sqrt((mean2 - mean*mean/nr)/(nr-1)) : 0;
1007	return arr;
1008	}
1009
1010	// --------------------------------------------------------------------------
1011	//
1012	// Calculates the average mean arrival times for pixel sizes.
1013	// The geometry container is used to get the necessary
1014	// geometry information (area index).
1015	// If the bad pixel container is given all pixels which have the flag 'kUnsuitableRun' are ignored
1016	// in the calculation of the size average.
1017	//
1018	// Returns a TArrayF of dimension 2:
1019	// arr[0]: averaged mean arrival times (default: -1.)
1020	// arr[1]: Error (rms) of averaged mean arrival times (default: 0.)
1021	//
1022	TArrayF MCalibrationChargeCam::GetAveragedArrivalTimeMeanPerArea(const MGeomCam &geom,
1023	const UInt_t ai, MBadPixelsCam *bad)
1024	{
1025
1026	const Int_t np = GetSize();
1027
1028	Double_t mean = 0.;
1029	Double_t mean2 = 0.;
1030	Int_t nr = 0;
1031
1032	for (int i=0; i<np; i++)
1033	{
1034	if (bad && (*bad)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
1035	continue;
1036
1037	const UInt_t aidx = geom[i].GetAidx();
1038
1039	if (ai != aidx)
1040	continue;
1041
1042	const MCalibrationChargePix &pix = (MCalibrationChargePix&)(*this)[i];
1043	const Float_t time = pix.GetAbsTimeMean();
1044
1045	mean += time ;
1046	mean2 += time*time;
1047	nr ++;
1048
1049	}
1050
1051	TArrayF arr(2);
1052	arr[0] = nr ? mean/nr : -1;
1053	arr[1] = nr>1 ? TMath::Sqrt((mean2 - mean*mean/nr)/(nr-1)) : 0;
1054	return arr;
1055	}
1056
1057	// --------------------------------------------------------------------------
1058	//
1059	// Calculates the average mean arrival times for camera sectors.
1060	// The geometry container is used to get the necessary
1061	// geometry information (area index).
1062	// If the bad pixel container is given all pixels which have the flag 'kUnsuitableRun' are ignored
1063	// in the calculation of the size average.
1064	//
1065	// Returns a TArrayF of dimension 2:
1066	// arr[0]: averaged mean arrival times (default: -1.)
1067	// arr[1]: Error (rms) of averaged mean arrival times (default: 0.)
1068	//
1069	TArrayF MCalibrationChargeCam::GetAveragedArrivalTimeMeanPerSector(const MGeomCam &geom,
1070	const UInt_t sec, MBadPixelsCam *bad)
1071	{
1072	const Int_t np = GetSize();
1073
1074	Double_t mean = 0.;
1075	Double_t mean2 = 0.;
1076	Int_t nr = 0;
1077
1078	for (int i=0; i<np; i++)
1079	{
1080	if (bad && (*bad)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
1081	continue;
1082
1083	const UInt_t sector = geom[i].GetSector();
1084
1085	if (sector != sec)
1086	continue;
1087
1088	const MCalibrationChargePix &pix = (MCalibrationChargePix&)(*this)[i];
1089	const Float_t time = pix.GetAbsTimeMean();
1090
1091	mean += time;
1092	mean2 += time*time;
1093	nr ++;
1094
1095	}
1096
1097	TArrayF arr(2);
1098	arr[0] = nr ? mean/nr : -1;
1099	arr[1] = nr>1 ? TMath::Sqrt((mean2 - mean*mean/nr)/(nr-1)) : 0;
1100	return arr;
1101	}
1102
1103	// --------------------------------------------------------------------------
1104	//
1105	// Calculates the average arrival time RMSs for pixel sizes.
1106	// The geometry container is used to get the necessary
1107	// geometry information (area index).
1108	// If the bad pixel container is given all pixels which have the flag 'kUnsuitableRun' are ignored
1109	// in the calculation of the size average.
1110	//
1111	// Returns a TArrayF of dimension 2:
1112	// arr[0]: averaged arrival time RMSs (default: -1.)
1113	// arr[1]: Error (rms) of averaged arrival time RMSs (default: 0.)
1114	//
1115	TArrayF MCalibrationChargeCam::GetAveragedArrivalTimeRmsPerArea ( const MGeomCam &geom,
1116	const UInt_t ai, MBadPixelsCam *bad)
1117	{
1118
1119	const Int_t np = GetSize();
1120
1121	Double_t mean = 0.;
1122	Double_t mean2 = 0.;
1123	Int_t nr = 0;
1124
1125	for (int i=0; i<np; i++)
1126	{
1127	if (bad && (*bad)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
1128	continue;
1129
1130	const UInt_t aidx = geom[i].GetAidx();
1131
1132	if (ai != aidx)
1133	continue;
1134
1135	const MCalibrationChargePix &pix = (MCalibrationChargePix&)(*this)[i];
1136	const Float_t rms = pix.GetAbsTimeRms();
1137
1138	mean += rms;
1139	mean2 += rms*rms;
1140	nr ++;
1141
1142	}
1143
1144	TArrayF arr(2);
1145	arr[0] = nr ? mean/nr : -1;
1146	arr[1] = nr>1 ? TMath::Sqrt((mean2 - mean*mean/nr)/(nr-1)) : 0;
1147	return arr;
1148	}
1149
1150	// --------------------------------------------------------------------------
1151	//
1152	// Calculates the average arrival time RMSs for camera sectors.
1153	// The geometry container is used to get the necessary
1154	// geometry information (area index).
1155	// If the bad pixel container is given all pixels which have the flag 'kUnsuitableRun' are ignored
1156	// in the calculation of the size average.
1157	//
1158	// Returns a TArrayF of dimension 2:
1159	// arr[0]: averaged arrival time RMSs (default: -1.)
1160	// arr[1]: Error (rms) of averaged arrival time RMSs (default: 0.)
1161	//
1162	TArrayF MCalibrationChargeCam::GetAveragedArrivalTimeRmsPerSector( const MGeomCam &geom, const UInt_t sec, MBadPixelsCam *bad)
1163	{
1164	const Int_t np = GetSize();
1165
1166	Double_t mean = 0.;
1167	Double_t mean2 = 0.;
1168	Int_t nr = 0;
1169
1170	for (int i=0; i<np; i++)
1171	{
1172	if (bad && (*bad)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
1173	continue;
1174
1175	const UInt_t sector = geom[i].GetSector();
1176
1177	if (sector != sec)
1178	continue;
1179
1180	const MCalibrationChargePix &pix = (MCalibrationChargePix&)(*this)[i];
1181	const Float_t rms = pix.GetAbsTimeRms();
1182
1183	mean += rms;
1184	mean2 += rms*rms;
1185	nr ++;
1186	}
1187
1188	TArrayF arr(2);
1189	arr[0] = nr ? mean/nr : -1;
1190	arr[1] = nr>1 ? TMath::Sqrt((mean2 - mean*mean/nr)/(nr-1)) : 0;
1191
1192	return arr;
1193	}

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

Download in other formats: