Context Navigation

source: trunk/MagicSoft/Mars/mcalib/MCalibrationCalc.cc@ 3007

Visit:

Last change on this file since 3007 was 3007, checked in by gaug, 21 years ago
* empty log message *
File size: 23.1 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 09/2003 <mailto:markus@ifae.es>
19	!
20	! Copyright: MAGIC Software Development, 2000-2001
21	!
22	!
23	\* ======================================================================== */
24
25	//////////////////////////////////////////////////////////////////////////////
26	//
27	// MCalibrationCalc
28	//
29	// Task to calculate the calibration conversion factors from the FADC
30	// time slices. The integrated time slices have to be delivered by an
31	// MExtractedSignalCam. The pedestals by an MPedestalCam and possibly
32	// arrival times from MArrivalTime
33	//
34	// The output container MCalibrationCam holds one entry of type MCalibrationPix
35	// for every pixel. It is filled in the following way:
36	//
37	// ProProcess: Search for MPedestalCam, MExtractedSignalCam
38	// Initialize MCalibrationCam
39	// Initialize MArrivalTime if exists
40	// Initialize pulser light wavelength
41	//
42	// ReInit: MCalibrationCam::InitSize(NumPixels) is called which allocates
43	// memory in a TClonesArray of type MCalibrationPix
44	// Initialize number of used FADC slices
45	// Optionally exclude pixels from calibration
46	//
47	// Process: Optionally, a cut on cosmics can be performed
48	//
49	// Every MCalibrationPix holds a histogram class,
50	// MHCalibrationPixel which itself hold histograms of type:
51	// HCharge(npix) (distribution of summed FADC time slice
52	// entries)
53	// HTime(npix) (distribution of position of maximum)
54	// HChargevsN(npix) (distribution of charges vs. event number.
55	//
56	// PostProcess: All histograms HCharge(npix) are fitted to a Gaussian
57	// All histograms HTime(npix) are fitted to a Gaussian
58	// The histogram HBlindPixelCharge (blind pixel) is fitted to
59	// a single PhE fit
60	//
61	// The histograms of the PIN Diode are fitted to Gaussians
62	//
63	// Fits can be excluded via the commands:
64	// MalibrationCam::SkipTimeFits() (skip all time fits)
65	// MalibrationCam::SkipBlindPixelFits() (skip all blind
66	// pixel fits)
67	// MalibrationCam::SkipPinDiodeFits() (skip all PIN Diode
68	// fits)
69	//
70	// Input Containers:
71	// MRawEvtData
72	// MPedestalCam
73	// MExtractedSignalCam
74	//
75	// Output Containers:
76	// MCalibrationCam
77	//
78	//////////////////////////////////////////////////////////////////////////////
79	#include "MCalibrationCalc.h"
80
81	// FXIME: Usage of fstream is a preliminary workaround!
82	#include <fstream>
83
84	// FXIME: This has to be removed!!!! (YES, WHEN WE HAVE ACCESS TO THE DATABASE!!!!!)
85	#include "MCalibrationConfig.h"
86
87	#include <TSystem.h>
88
89	#include "MLog.h"
90	#include "MLogManip.h"
91
92	#include "MParList.h"
93
94	#include "MGeomCam.h"
95	#include "MRawRunHeader.h"
96	#include "MRawEvtPixelIter.h"
97
98	#include "MPedestalCam.h"
99	#include "MPedestalPix.h"
100
101	#include "MCalibrationCam.h"
102	#include "MCalibrationPix.h"
103
104	#include "MExtractedSignalCam.h"
105	#include "MExtractedSignalPix.h"
106
107	#include "MCalibrationBlindPix.h"
108	#include "MCalibrationPINDiode.h"
109
110	#include "MArrivalTime.h"
111
112	ClassImp(MCalibrationCalc);
113
114	using namespace std;
115
116	const Int_t MCalibrationCalc::fBlindPixelId = 559;
117	const Int_t MCalibrationCalc::fPINDiodeId = 9999;
118
119	// --------------------------------------------------------------------------
120	//
121	// Default constructor.
122	//
123	MCalibrationCalc::MCalibrationCalc(const char name, const char title)
124	: fPedestals(NULL), fCalibrations(NULL), fSignals(NULL),
125	fRawEvt(NULL), fRunHeader(NULL), fArrivalTime(NULL), fEvtTime(NULL)
126	{
127
128	fName = name ? name : "MCalibrationCalc";
129	fTitle = title ? title : "Task to calculate the calibration constants and MCalibrationCam ";
130
131	AddToBranchList("MRawEvtData.fHiGainPixId");
132	AddToBranchList("MRawEvtData.fLoGainPixId");
133	AddToBranchList("MRawEvtData.fHiGainFadcSamples");
134	AddToBranchList("MRawEvtData.fLoGainFadcSamples");
135
136	Clear();
137	}
138
139	void MCalibrationCalc::Clear(const Option_t *o)
140	{
141
142	SETBIT(fFlags, kUseTimes);
143	SETBIT(fFlags, kUseBlindPixelFit);
144	SETBIT(fFlags, kUseCosmicsRejection);
145	SETBIT(fFlags, kUseQualityChecks);
146
147	// As long as we don't have the PIN Diode:
148	CLRBIT(fFlags, kUsePinDiodeFit);
149
150	fEvents = 0;
151	fCosmics = 0;
152	fNumHiGainSamples = 0;
153	fNumLoGainSamples = 0;
154	fConversionHiLo = 0;
155	fNumExcludedPixels = 0;
156
157	fColor = kECT1;
158	}
159
160
161	MCalibrationBlindPix *MCalibrationCalc::GetBlindPixel() const
162	{
163	return fCalibrations->GetBlindPixel();
164	}
165
166	MCalibrationPINDiode *MCalibrationCalc::GetPINDiode() const
167	{
168	return fCalibrations->GetPINDiode();
169	}
170
171	// --------------------------------------------------------------------------
172	//
173	// The PreProcess searches for the following input containers:
174	// - MRawEvtData
175	// - MPedestalCam
176	//
177	// The following output containers are also searched and created if
178	// they were not found:
179	//
180	// - MHCalibrationBlindPixel
181	// - MCalibrationCam
182	//
183	// The following output containers are only searched, but not created
184	//
185	// - MArrivaltime
186	// - MTime
187	//
188	Int_t MCalibrationCalc::PreProcess(MParList *pList)
189	{
190
191	fRawEvt = (MRawEvtData*)pList->FindObject("MRawEvtData");
192	if (!fRawEvt)
193	{
194	*fLog << err << dbginf << "MRawEvtData not found... aborting." << endl;
195	return kFALSE;
196	}
197
198	const MRawRunHeader runheader = (MRawRunHeader)pList->FindObject("MRawRunHeader");
199	if (!runheader)
200	*fLog << warn << dbginf << "Warning - cannot check file type, MRawRunHeader not found." << endl;
201	else
202	if (runheader->GetRunType() == kRTMonteCarlo)
203	{
204	return kTRUE;
205	}
206
207	fCalibrations = (MCalibrationCam*)pList->FindCreateObj("MCalibrationCam");
208	if (!fCalibrations)
209	{
210	*fLog << err << dbginf << "MCalibrationCam could not be created ... aborting." << endl;
211	return kFALSE;
212	}
213
214	fArrivalTime = (MArrivalTime*)pList->FindObject("MArrivalTime");
215
216	fEvtTime = (MTime*)pList->FindObject("MTime");
217
218	switch (fColor)
219	{
220	case kEBlue:
221	fCalibrations->SetColor(MCalibrationCam::kECBlue);
222	break;
223	case kEGreen:
224	fCalibrations->SetColor(MCalibrationCam::kECGreen);
225	break;
226	case kEUV:
227	fCalibrations->SetColor(MCalibrationCam::kECUV);
228	break;
229	case kECT1:
230	fCalibrations->SetColor(MCalibrationCam::kECCT1);
231	break;
232	default:
233	fCalibrations->SetColor(MCalibrationCam::kECCT1);
234	}
235
236	fPedestals = (MPedestalCam*)pList->FindObject("MPedestalCam");
237	if (!fPedestals)
238	{
239	*fLog << err << dbginf << "Cannot find MPedestalCam ... aborting" << endl;
240	return kFALSE;
241	}
242
243
244	fSignals = (MExtractedSignalCam*)pList->FindObject("MExtractedSignalCam");
245	if (!fSignals)
246	{
247	*fLog << err << dbginf << "Cannot find MExtractedSignalCam ... aborting" << endl;
248	return kFALSE;
249	}
250
251	return kTRUE;
252	}
253
254
255	// --------------------------------------------------------------------------
256	//
257	// The ReInit searches for the following input containers:
258	// - MRawRunHeader
259	//
260	Bool_t MCalibrationCalc::ReInit(MParList *pList )
261	{
262
263	fRunHeader = (MRawRunHeader*)pList->FindObject("MRawRunHeader");
264	if (!fRunHeader)
265	{
266	*fLog << err << dbginf << ": MRawRunHeader not found... aborting." << endl;
267	return kFALSE;
268	}
269
270
271	MGeomCam cam = (MGeomCam)pList->FindObject("MGeomCam");
272	if (!cam)
273	{
274	*fLog << err << GetDescriptor() << ": No MGeomCam found... aborting." << endl;
275	return kFALSE;
276	}
277
278	fNumHiGainSamples = fSignals->GetNumUsedHiGainFADCSlices();
279	fNumLoGainSamples = fSignals->GetNumUsedLoGainFADCSlices();
280	fSqrtHiGainSamples = TMath::Sqrt((Float_t)fNumHiGainSamples);
281
282	UInt_t npixels = cam->GetNumPixels();
283
284	for (UInt_t i=0; i<npixels; i++)
285	{
286
287	MCalibrationPix &pix = (*fCalibrations)[i];
288	pix.DefinePixId(i);
289
290	pix.SetAbsTimeBordersHiGain(fSignals->GetFirstUsedSliceHiGain(),
291	fSignals->GetLastUsedSliceHiGain());
292	pix.SetAbsTimeBordersLoGain(fSignals->GetFirstUsedSliceLoGain(),
293	fSignals->GetLastUsedSliceLoGain());
294
295	if (!TESTBIT(fFlags,kUseQualityChecks))
296	pix.SetExcludeQualityCheck();
297
298	}
299
300	//
301	// Look for file to exclude pixels from analysis
302	//
303	if (!fExcludedPixelsFile.IsNull())
304	{
305
306	fExcludedPixelsFile = gSystem->ExpandPathName(fExcludedPixelsFile.Data());
307
308	//
309	// Initialize reading the file
310	//
311	ifstream in(fExcludedPixelsFile.Data(),ios::in);
312
313	if (in)
314	{
315	*fLog << inf << "Use excluded pixels from file: '" << fExcludedPixelsFile.Data() << "'" << endl;
316	//
317	// Read the file and count the number of entries
318	//
319	UInt_t pixel = 0;
320
321	while (++fNumExcludedPixels)
322	{
323
324	in >> pixel;
325
326	if (!in.good())
327	break;
328	//
329	// Check for out of range
330	//
331	if (pixel > npixels)
332	{
333	*fLog << warn << "WARNING: To be excluded pixel: " << pixel
334	<< " is out of range " << endl;
335	continue;
336	}
337	//
338	// Exclude pixel
339	//
340	MCalibrationPix &pix = (*fCalibrations)[pixel];
341	pix.SetExcluded();
342
343	*fLog << GetDescriptor() << inf << ": Exclude Pixel: " << pixel << endl;
344
345	}
346
347	if (--fNumExcludedPixels == 0)
348	*fLog << warn << "WARNING: File '" << fExcludedPixelsFile.Data()
349	<< "'" << " is empty " << endl;
350	else
351	fCalibrations->SetNumPixelsExcluded(fNumExcludedPixels);
352
353	}
354	else
355	*fLog << warn << dbginf << "Cannot open file '" << fExcludedPixelsFile.Data() << "'" << endl;
356	}
357
358	return kTRUE;
359	}
360
361
362	// --------------------------------------------------------------------------
363	//
364	// Calculate the integral of the FADC time slices and store them as a new
365	// pixel in the MCerPhotEvt container.
366	//
367	Int_t MCalibrationCalc::Process()
368	{
369
370	//
371	// Initialize pointers to blind pixel, PIN Diode and individual pixels
372	//
373	MCalibrationBlindPix &blindpixel = *(fCalibrations->GetBlindPixel());
374	MCalibrationPINDiode &pindiode = *(fCalibrations->GetPINDiode());
375
376	MRawEvtPixelIter pixel(fRawEvt);
377
378	//
379	// Perform cosmics cut
380	//
381	if (TESTBIT(fFlags,kUseCosmicsRejection))
382	{
383
384	Int_t cosmicpix = 0;
385
386	//
387	// Create a first loop to sort out the cosmics ...
388	//
389	// This is a very primitive check for the number of cosmicpixs
390	// The cut will be applied in the fit, but for the blind pixel,
391	// we need to remove this event
392	//
393	// FIXME: In the future need a much more sophisticated one!!!
394	//
395
396	while (pixel.Next())
397	{
398
399	const UInt_t pixid = pixel.GetPixelId();
400
401	MExtractedSignalPix &sig = (*fSignals)[pixid];
402	MPedestalPix &ped = (*fPedestals)[pixid];
403	Float_t pedrms = ped.GetPedestalRms()*fSqrtHiGainSamples;
404	Float_t sumhi = sig.GetExtractedSignalHiGain();
405
406	//
407	// We consider a pixel as presumably due to cosmics
408	// if its sum of FADC slices is lower than 3 pedestal RMS
409	//
410	if (sumhi < 3.*pedrms )
411	cosmicpix++;
412	}
413
414	//
415	// If the camera contains more than 230
416	// (this is the number of outer pixels plus about 50 inner ones)
417	// presumed pixels due to cosmics, then the event is discarted.
418	// This procedure is more or less equivalent to keeping only events
419	// with at least 350 pixels with high signals.
420	//
421	if (cosmicpix > 230.)
422	{
423	fCosmics++;
424	return kCONTINUE;
425	}
426
427	pixel.Reset();
428	}
429
430	fEvents++;
431
432	Int_t overflow = 0;
433	Float_t referencetime = 0.;
434
435	//
436	// Create a (second) loop to do fill the calibration histograms
437	// Search for: a signal in MExtractedSignalCam
438	// a time in MArrivalTime.
439	// Fill histograms with:
440	// charge
441	// charge vs. event nr.
442	// relative arrival time w.r.t. pixel 1
443	//
444	while (pixel.Next())
445	{
446
447	const UInt_t pixid = pixel.GetPixelId();
448
449	MCalibrationPix &pix = (*fCalibrations)[pixid];
450
451	if (pix.IsExcluded())
452	continue;
453
454	MExtractedSignalPix &sig = (*fSignals)[pixid];
455
456	const Float_t sumhi = sig.GetExtractedSignalHiGain();
457	const Float_t sumlo = sig.GetExtractedSignalLoGain();
458
459	Float_t abstime = 0.;
460	Float_t reltime = 0.;
461
462	if (TESTBIT(fFlags,kUseTimes))
463	{
464
465	//
466	// Have a look in MArrivalTime,
467	// otherwise search the position of maximum bin
468	// in MRawEvtData
469	//
470	if (fArrivalTime)
471	{
472	abstime = (*fArrivalTime)[pixid];
473	reltime = abstime - (*fArrivalTime)[1];
474	}
475
476	else
477	{
478	if (pixid == 1)
479	referencetime = (Float_t)pixel.GetIdxMaxHiGainSample();
480
481	if (sig.IsLoGainUsed())
482	{
483	abstime = (Float_t)pixel.GetIdxMaxLoGainSample();
484	reltime = abstime - referencetime;
485	}
486	else
487	{
488	abstime = (Float_t)pixel.GetIdxMaxHiGainSample();
489	reltime = abstime - referencetime;
490	}
491	}
492	}
493
494	switch(pixid)
495	{
496
497	case fBlindPixelId:
498
499	if (!blindpixel.FillCharge(sumhi))
500	*fLog << warn <<
501	"Overflow or Underflow occurred filling Blind Pixel sum = " << sumhi << endl;
502
503	if (TESTBIT(fFlags,kUseTimes))
504	{
505	if (!blindpixel.FillTime(reltime))
506	*fLog << warn <<
507	"Overflow or Underflow occurred filling Blind Pixel time = " << reltime << endl;
508	}
509
510	if (!blindpixel.FillRChargevsTime(sumhi,fEvents))
511	*fLog << warn <<
512	"Overflow or Underflow occurred filling Blind Pixel eventnr = " << fEvents << endl;
513	break;
514
515	case fPINDiodeId:
516
517	if (!pindiode.FillCharge(sumhi))
518	*fLog << warn <<
519	"Overflow or Underflow occurred filling PINDiode: sum = " << sumhi << endl;
520
521	if (TESTBIT(fFlags,kUseTimes))
522	{
523	if (!pindiode.FillAbsTime(abstime))
524	*fLog << warn <<
525	"Overflow or Underflow occurred filling PINDiode abs. time = " << abstime << endl;
526	if (!pindiode.FillRelTime(reltime))
527	*fLog << warn <<
528	"Overflow or Underflow occurred filling PINDiode rel. time = " << reltime << endl;
529	}
530
531	if (!pindiode.FillRChargevsTime(sumhi,fEvents))
532	*fLog << warn <<
533	"Overflow or Underflow occurred filling PINDiode: eventnr = " << fEvents << endl;
534	break;
535
536	default:
537
538	pix.FillChargesInGraph(sumhi,sumlo);
539
540	if (!pix.FillRChargevsTimeLoGain(sumlo,fEvents))
541	overflow++;
542
543	if (!pix.FillRChargevsTimeHiGain(sumhi,fEvents))
544	overflow++;
545
546	if (sig.IsLoGainUsed())
547	{
548
549	if (!pix.FillChargeLoGain(sumlo))
550	*fLog << warn << "Could not fill Lo Gain Charge of pixel: " << pixid
551	<< " signal = " << sumlo << endl;
552
553	if (TESTBIT(fFlags,kUseTimes))
554	{
555	if (!pix.FillAbsTimeLoGain(abstime))
556	*fLog << warn << "Could not fill Lo Gain Abs. Time of pixel: "
557	<< pixid << " time = " << abstime << endl;
558	if (!pix.FillRelTimeLoGain(reltime))
559	*fLog << warn << "Could not fill Lo Gain Rel. Time of pixel: "
560	<< pixid << " time = " << reltime << endl;
561	}
562	} /* if (sig.IsLoGainUsed()) */
563	else
564	{
565	if (!pix.FillChargeHiGain(sumhi))
566	*fLog << warn << "Could not fill Hi Gain Charge of pixel: " << pixid
567	<< " signal = " << sumhi << endl;
568
569	if (TESTBIT(fFlags,kUseTimes))
570	{
571	if (!pix.FillAbsTimeHiGain(abstime))
572	*fLog << warn << "Could not fill Hi Gain Abs. Time of pixel: "
573	<< pixid << " time = " << abstime << endl;
574	if (!pix.FillRelTimeHiGain(reltime))
575	*fLog << warn << "Could not fill Hi Gain Rel. Time of pixel: "
576	<< pixid << " time = " << reltime << endl;
577	}
578	} /* else (sig.IsLoGainUsed()) */
579	break;
580
581	} /* switch(pixid) */
582
583	} /* while (pixel.Next()) */
584
585	if (overflow)
586	*fLog << warn << "Overflow occurred filling Charges vs. EvtNr " << overflow << " times" << endl;
587
588	return kTRUE;
589	}
590
591	Int_t MCalibrationCalc::PostProcess()
592	{
593
594	*fLog << inf << endl;
595
596	if (fEvents == 0)
597	{
598	*fLog << err << GetDescriptor()
599	<< ": This run contains only cosmics or pedestals, "
600	<< "cannot find events with more than 350 illuminated pixels. " << endl;
601	return kFALSE;
602	}
603
604	if (fEvents < fCosmics)
605	*fLog << warn << GetDescriptor()
606	<< ": WARNING: Run contains more cosmics or pedestals than calibration events " << endl;
607
608
609	*fLog << inf << GetDescriptor() << ": Cut Histogram Edges" << endl;
610
611	//
612	// Cut edges to make fits and viewing of the hists easier
613	//
614	fCalibrations->CutEdges();
615
616	//
617	// Fit the blind pixel
618	//
619	if (TESTBIT(fFlags,kUseBlindPixelFit))
620	{
621	//
622	// Get pointer to blind pixel
623	//
624	MCalibrationBlindPix &blindpixel = *(fCalibrations->GetBlindPixel());
625
626	*fLog << inf << GetDescriptor() << ": Fitting the Blind Pixel" << endl;
627
628	//
629	// retrieve mean and sigma of the blind pixel pedestal,
630	// so that we can use it for the fit
631	//
632	if (fPedestals->IsUseHists())
633	{
634	//
635	// retrieve the pedestal pix of the blind pixel
636	//
637	MPedestalPix &ped = (*fPedestals)[fBlindPixelId];
638	//
639	// retrieve the histogram containers
640	//
641	MHCalibrationBlindPixel *hist = blindpixel.GetHist();
642	MHPedestalPixel *pedhist = ped.GetHist();
643	//
644	// Set the corresponding values
645	//
646	const Float_t nslices = (Float_t)fSignals->GetNumUsedFADCSlices();
647	const Int_t nentries = pedhist->GetTotalEntries();
648
649	const Float_t peddiff = ped.GetMean() - ped.GetPedestal()*nslices;
650
651	Float_t pederr = ped.GetMeanErr()*ped.GetMeanErr();
652	pederr += ped.GetPedestalRms()ped.GetPedestalRms()nslices*nslices/nentries/nentries;
653	pederr = TMath::Sqrt(pederr);
654
655	const Float_t pedsigma = ped.GetSigma();
656	const Float_t pedsigmaerr = ped.GetSigmaErr();
657
658	hist->SetMeanPedestal(peddiff);
659	hist->SetMeanPedestalErr(pederr);
660	hist->SetSigmaPedestal(pedsigma);
661	hist->SetSigmaPedestalErr(pedsigmaerr);
662	}
663
664	if (!blindpixel.FitCharge())
665	{
666	*fLog << warn << "Could not fit the blind pixel! " << endl;
667	*fLog << warn << "Setting bit kBlindPixelMethodValid to FALSE in MCalibrationCam" << endl;
668	fCalibrations->SetBlindPixelMethodValid(kFALSE);
669	}
670
671	fCalibrations->SetBlindPixelMethodValid(kTRUE);
672	blindpixel.DrawClone();
673	}
674	else
675	*fLog << inf << GetDescriptor() << ": Skipping Blind Pixel Fit " << endl;
676
677
678	*fLog << inf << GetDescriptor() << ": Fitting the Normal Pixels" << endl;
679
680	//
681	// loop over the pedestal events and check if we have calibration
682	//
683	for (Int_t pixid=0; pixid<fPedestals->GetSize(); pixid++)
684	{
685
686	MCalibrationPix &pix = (*fCalibrations)[pixid];
687
688	//
689	// get the pedestals
690	//
691	const Float_t ped = (fPedestals)[pixid].GetPedestal() fNumHiGainSamples;
692	const Float_t prms = (fPedestals)[pixid].GetPedestalRms() fSqrtHiGainSamples;
693
694	//
695	// set them in the calibration camera
696	//
697	pix.SetPedestal(ped,prms);
698
699
700	//
701	// Check if the pixel has been excluded from the fits
702	//
703	if (pix.IsExcluded())
704	continue;
705
706	//
707	// perform the Gauss fits to the charges
708	//
709	pix.FitCharge();
710
711	//
712	// Perform the Gauss fits to the arrival times
713	//
714	if (TESTBIT(fFlags,kUseTimes))
715	pix.FitTime();
716
717	}
718
719	if (TESTBIT(fFlags,kUseBlindPixelFit) && fCalibrations->IsBlindPixelMethodValid())
720	{
721
722	if (!fCalibrations->CalcNumPhotInsidePlexiglass())
723	{
724	*fLog << err
725	<< "Could not calculate the number of photons from the blind pixel " << endl;
726	*fLog << err
727	<< "You can try to calibrate using the MCalibrationCalc::SkipBlindPixelFit()" << endl;
728	fCalibrations->SetBlindPixelMethodValid(kFALSE);
729	}
730	}
731	else
732	*fLog << inf << GetDescriptor() << ": Skipping Blind Pixel Calibration! " << endl;
733
734
735	if (TESTBIT(fFlags,kUsePinDiodeFit) && fCalibrations->IsPINDiodeMethodValid())
736	{
737
738	if (!fCalibrations->CalcNumPhotInsidePlexiglass())
739	{
740	*fLog << err
741	<< "Could not calculate the number of photons from the blind pixel " << endl;
742	*fLog << err
743	<< "You can try to calibrate using the MCalibrationCalc::SkipPINDiodeFit()" << endl;
744	fCalibrations->SetPINDiodeMethodValid(kFALSE);
745	}
746	}
747	else
748	*fLog << inf << GetDescriptor() << ": Skipping PIN Diode Calibration! " << endl;
749
750	fCalibrations->SetReadyToSave();
751
752	if (GetNumExecutions()==0)
753	return kTRUE;
754
755	*fLog << inf << endl;
756	*fLog << dec << setfill(' ') << fCosmics << " Events presumably cosmics" << endl;
757
758	return kTRUE;
759	}
760

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

Download in other formats: