source: trunk/MagicSoft/Mars/mcalib/MCalibrateData.cc@ 6921

Last change on this file since 6921 was 6913, checked in by tbretz, 20 years ago
*** empty log message ***
File size: 28.7 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): Javier Lopez 12/2003 <mailto:jlopez@ifae.es>
19! Author(s): Javier Rico 01/2004 <mailto:jrico@ifae.es>
20! Author(s): Wolfgang Wittek 02/2004 <mailto:wittek@mppmu.mpg.de>
21! Author(s): Markus Gaug 04/2004 <mailto:markus@ifae.es>
22! Author(s): Hendrik Bartko 08/2004 <mailto:hbartko@mppmu.mpg.de>
23! Author(s): Thomas Bretz 08/2004 <mailto:tbretz@astro.uni-wuerzburg.de>
24!
25! Copyright: MAGIC Software Development, 2000-2004
26!
27!
28\* ======================================================================== */
29
30///////////////////////////////////////////////////////////////////////////////////
31//
32// MCalibrateData
33//
34// This task takes the integrated charge from MExtractedSignal and applies
35// the calibration constants from MCalibrationCam to convert the summed FADC
36// slices into photons. The number of photons obtained is stored in MSignalCam.
37// Optionally, the calibration of pedestals from an MPedestalCam container into
38// an MPedPhotCam container can be chosen with the member functions
39// SetPedestalType(). Default is 'kRun', i.e. calibration of pedestals from a
40// dedicated pedestal run.
41// In case, the chosen pedestal type is kRun or kEvent, in ReInit() the MPedPhotCam
42// container is filled using the information from MPedestalCam, MExtractedSignalCam,
43// MCalibrationChargeCam and MCalibrationQECam
44//
45// Selection of different calibration methods is allowed through the
46// SetCalibrationMode() member function (default: kFfactor)
47//
48// The calibration modes which exclude non-valid pixels are the following:
49//
50// kFfactor: calibrates using the F-Factor method
51// kBlindpixel: calibrates using the BlindPixel method
52// kBlindpixel: calibrates using the BlindPixel method
53// kFlatCharge: perform a charge flat-flatfielding. Outer pixels are area-corrected.
54// kDummy: calibrates with fixed conversion factors of 1 and errors of 0.
55//
56// The calibration modes which include all pixels regardless of their validity is:
57//
58// kNone: calibrates with fixed conversion factors of 1 and errors of 0.
59//
60// Use the kDummy and kNone methods ONLY FOR DEBUGGING!
61//
62//
63// This class can calibrate data and/or pedestals. To switch off calibration of data
64// set the Calibration Mode to kSkip. To switch on pedestal calibration call either
65// SetPedestalFlag(MCalibrateData::kRun) (calibration is done once in ReInit)
66// SetPedestalFlag(MCalibrateData::kEvent) (calibration is done for each event)
67//
68// By calling AddPedestal() you can control the name of the
69// MPedestalCam and/or MPedPhotCam container which is used.
70//
71// Assume you want to calibrate "MPedestalCam" once and "MPedestalFromLoGain" [MPedestalCam]
72// event-by-event, so:
73// MCalibrateData cal1;
74// cal1.SetCalibrationMode(MCalibrateData::kSkip);
75// cal1.SetPedestalFlag(MCalibrateData::kRun);
76// MCalibrateData cal2;
77// cal2.SetCalibrationMode(MCalibrateData::kSkip);
78// cal2.AddPedestal("FromLoGain");
79// cal2.SetPedestalFlag(MCalibrateData::kEvent);
80//
81//
82// Input Containers:
83// [MPedestalCam]
84// [MExtractedSignalCam]
85// [MCalibrationChargeCam]
86// [MCalibrationQECam]
87// MBadPixelsCam
88//
89// Output Containers:
90// [MPedPhotCam]
91// [MSignalCam]
92//
93// See also: MJCalibration, MJPedestal, MJExtractSignal, MJExtractCalibTest
94//
95//////////////////////////////////////////////////////////////////////////////
96#include "MCalibrateData.h"
97
98#include <fstream>
99
100#include <TEnv.h>
101
102#include "MLog.h"
103#include "MLogManip.h"
104
105#include "MParList.h"
106#include "MH.h"
107
108#include "MGeomCam.h"
109
110#include "MPedestalCam.h"
111#include "MPedestalPix.h"
112
113#include "MCalibrationChargeCam.h"
114#include "MCalibrationChargePix.h"
115
116#include "MCalibrationQECam.h"
117#include "MCalibrationQEPix.h"
118
119#include "MCalibConstCam.h"
120#include "MCalibConstPix.h"
121
122#include "MExtractedSignalCam.h"
123#include "MExtractedSignalPix.h"
124
125#include "MPedPhotCam.h"
126#include "MPedPhotPix.h"
127
128#include "MBadPixelsCam.h"
129#include "MBadPixelsPix.h"
130
131#include "MSignalCam.h"
132
133ClassImp(MCalibrateData);
134
135using namespace std;
136
137const Float_t MCalibrateData::fgCalibConvMinLimit = 0.01;
138const Float_t MCalibrateData::fgCalibConvMaxLimit = 5.;
139// --------------------------------------------------------------------------
140//
141// Default constructor.
142//
143// Sets all pointers to NULL
144//
145// Initializes:
146// - fCalibrationMode to kDefault
147// - fPedestalFlag to kNo
148//
149MCalibrateData::MCalibrateData(CalibrationMode_t calmode,const char *name, const char *title)
150 : fGeomCam(NULL), fBadPixels(NULL), fCalibrations(NULL),
151 fQEs(NULL), fSignals(NULL), fCerPhotEvt(NULL), fCalibConstCam(NULL),
152 fPedestalFlag(kNo), fSignalType(kPhot), fRenormFactor(1.)
153{
154
155 fName = name ? name : "MCalibrateData";
156 fTitle = title ? title : "Task to calculate the number of photons in one event";
157
158 SetCalibrationMode(calmode);
159
160 SetCalibConvMinLimit();
161 SetCalibConvMaxLimit();
162
163 fNamesPedestal.SetOwner();
164}
165
166void MCalibrateData::AddPedestal(const char *name)
167{
168 TString ped(name);
169 TString pho(name);
170 ped.Prepend("MPedestal");
171 pho.Prepend("MPedPhot");
172
173 fNamesPedestal.Add(new TNamed(ped, pho));
174}
175
176void MCalibrateData::AddPedestal(const char *pedestal, const char *pedphot)
177{
178 fNamesPedestal.Add(new TNamed(pedestal, pedphot));
179}
180
181// --------------------------------------------------------------------------
182//
183// The PreProcess searches for the following input containers:
184//
185// - MGeomCam
186// - MPedestalCam
187// - MCalibrationChargeCam
188// - MCalibrationQECam
189// - MExtractedSignalCam
190// - MBadPixelsCam
191//
192// The following output containers are also searched and created if
193// they were not found:
194//
195// - MPedPhotCam
196// - MSignalCam
197//
198Int_t MCalibrateData::PreProcess(MParList *pList)
199{
200 // input containers
201
202 fBadPixels = (MBadPixelsCam*)pList->FindObject(AddSerialNumber("MBadPixelsCam"));
203 if (!fBadPixels)
204 {
205 *fLog << err << AddSerialNumber("MBadPixelsCam") << " not found ... aborting" << endl;
206 return kFALSE;
207 }
208
209 fSignals = 0;
210 fCerPhotEvt = 0;
211 if (fCalibrationMode>kSkip)
212 {
213 fSignals = (MExtractedSignalCam*)pList->FindObject(AddSerialNumber("MExtractedSignalCam"));
214 if (!fSignals)
215 {
216 *fLog << err << AddSerialNumber("MExtractedSignalCam") << " not found ... aborting" << endl;
217 return kFALSE;
218 }
219
220 fCerPhotEvt = (MSignalCam*)pList->FindCreateObj(AddSerialNumber("MSignalCam"));
221 if (!fCerPhotEvt)
222 return kFALSE;
223
224 fCalibConstCam = (MCalibConstCam*)pList->FindCreateObj(AddSerialNumber("MCalibConstCam"));
225 if (!fCalibConstCam)
226 return kFALSE;
227 }
228
229 fCalibrations = 0;
230 fQEs = 0;
231 if (fCalibrationMode>kNone)
232 {
233 fCalibrations = (MCalibrationChargeCam*)pList->FindObject(AddSerialNumber("MCalibrationChargeCam"));
234 if (!fCalibrations)
235 {
236 *fLog << err << AddSerialNumber("MCalibrationChargeCam") << " not found ... aborting." << endl;
237 return kFALSE;
238 }
239
240 fQEs = (MCalibrationQECam*)pList->FindObject(AddSerialNumber("MCalibrationQECam"));
241 if (!fQEs)
242 {
243 *fLog << err << AddSerialNumber("MCalibrationQECam") << " not found ... aborting." << endl;
244 return kFALSE;
245 }
246
247 }
248
249 if (fNamesPedestal.GetSize()>0 && fPedestalFlag==kNo)
250 {
251 *fLog << warn << "Pedestal list contains entries, but mode is set to kNo... setting to kEvent." << endl;
252 fPedestalFlag = kEvent;
253 }
254
255 if (fPedestalFlag)
256 {
257 if (fNamesPedestal.GetSize()==0)
258 {
259 *fLog << inf << "No container names specified... using default: MPedestalCam and MPedPhotCam." << endl;
260 AddPedestal();
261 }
262
263 fPedestalCams.Clear();
264 fPedPhotCams.Clear();
265
266 TIter Next(&fNamesPedestal);
267 TObject *o=0;
268 while ((o=Next()))
269 {
270 TObject *pedcam = pList->FindObject(AddSerialNumber(o->GetName()), "MPedestalCam");
271 if (!pedcam)
272 {
273 *fLog << err << AddSerialNumber(o->GetName()) << " [MPedestalCam] not found ... aborting" << endl;
274 return kFALSE;
275 }
276 TObject *pedphot = pList->FindCreateObj("MPedPhotCam", AddSerialNumber(o->GetTitle()));
277 if (!pedphot)
278 return kFALSE;
279
280 fPedestalCams.Add(pedcam);
281 fPedPhotCams.Add(pedphot);
282 }
283 }
284
285 switch (fSignalType)
286 {
287 case kPhe:
288 fRenormFactor = MCalibrationQEPix::gkDefaultAverageQE;
289 break;
290 case kPhot:
291 fRenormFactor = 1.;
292 break;
293 }
294
295 fCalibConsts.Reset();
296 fCalibFFactors.Reset();
297 fHiLoConv.Reset();
298 fHiLoConvErr.Reset();
299
300 return kTRUE;
301}
302
303// --------------------------------------------------------------------------
304//
305// The ReInit searches for the following input containers:
306//
307// - MGeomCam
308//
309// Check for validity of the selected calibration method, switch to a
310// different one in case of need
311//
312// Fill the MPedPhotCam container using the information from MPedestalCam,
313// MExtractedSignalCam and MCalibrationCam
314//
315Bool_t MCalibrateData::ReInit(MParList *pList)
316{
317 fGeomCam = (MGeomCam*)pList->FindObject(AddSerialNumber("MGeomCam"));
318 if (!fGeomCam)
319 {
320 *fLog << err << "No MGeomCam found... aborting." << endl;
321 return kFALSE;
322 }
323
324 // Sizes might have changed
325 if (fPedestalFlag)
326 {
327 TIter Next(&fPedestalCams);
328 MPedestalCam *cam=0;
329 while ((cam=(MPedestalCam*)Next()))
330 if ((Int_t)cam->GetSize() != fSignals->GetSize())
331 {
332 *fLog << err << "Size mismatch of " << cam->GetDescriptor() << " and MCalibrationCam... abort." << endl;
333 return kFALSE;
334 }
335 }
336
337 if(fCalibrationMode == kBlindPixel && !fQEs->IsBlindPixelMethodValid())
338 {
339 *fLog << warn << "Blind pixel calibration method not valid, switching to F-factor method" << endl;
340 fCalibrationMode = kFfactor;
341 }
342
343 if(fCalibrationMode == kPinDiode && !fQEs->IsPINDiodeMethodValid())
344 {
345 *fLog << warn << "PIN diode calibration method not valid, switching to F-factor method" << endl;
346 fCalibrationMode = kFfactor;
347 }
348
349 if(fCalibrationMode == kCombined && !fQEs->IsCombinedMethodValid())
350 {
351 *fLog << warn << "Combined calibration method not valid, switching to F-factor method" << endl;
352 fCalibrationMode = kFfactor;
353 }
354
355 //
356 // output information or warnings:
357 //
358 switch(fCalibrationMode)
359 {
360 case kBlindPixel:
361 break;
362 case kFfactor:
363 break;
364 case kPinDiode:
365 *fLog << err << "PIN Diode Calibration mode not yet available!" << endl;
366 return kFALSE;
367 break;
368 case kCombined:
369 *fLog << err << "Combined Calibration mode not yet available!" << endl;
370 return kFALSE;
371 break;
372 case kFlatCharge:
373 *fLog << warn << "WARNING - Flat-fielding charges - only for muon calibration!" << endl;
374 break;
375 case kDummy:
376 *fLog << warn << "WARNING - Dummy calibration, no calibration applied!" << endl;
377 break;
378 case kNone:
379 *fLog << warn << "WARNING - No calibration applied!" << endl;
380 break;
381 default:
382 *fLog << warn << "WARNING - Calibration mode value (" << fCalibrationMode << ") not known" << endl;
383 return kFALSE;
384 }
385
386 //
387 // output information or warnings:
388 //
389 switch(fSignalType)
390 {
391 case kPhe:
392 *fLog << warn << "WARNING - Renormalization to photo-electrons applied!" << endl;
393 break;
394 case kPhot:
395 break;
396 }
397
398 const Int_t npixels = fGeomCam->GetNumPixels();
399
400 if (fCalibrationMode > kNone)
401 {
402
403 if (fCalibrations->GetSize() != npixels)
404 {
405 *fLog << err << GetDescriptor()
406 << ": Size mismatch between MGeomCam and MCalibrationChargeCam ... abort!" << endl;
407 return kFALSE;
408 }
409
410 if (fBadPixels->GetSize() != npixels)
411 {
412 *fLog << err << GetDescriptor()
413 << ": Size mismatch between MGeomCam and MBadPixelsCam ... abort!" << endl;
414 return kFALSE;
415 }
416
417 if (fBadPixels->GetSize() != npixels)
418 {
419 *fLog << err << GetDescriptor()
420 << ": Size mismatch between MGeomCam and MBadPixelsCam ... abort!" << endl;
421 return kFALSE;
422 }
423 }
424
425 fCalibConsts .Set(npixels);
426 fCalibFFactors.Set(npixels);
427 fHiLoConv .Set(npixels);
428 fHiLoConvErr .Set(npixels);
429
430 if (!UpdateConversionFactors())
431 return kFALSE;
432
433 if (TestPedestalFlag(kRun))
434 Calibrate(kFALSE, kTRUE);
435
436 return kTRUE;
437}
438
439// --------------------------------------------------------------------------
440//
441// Update the conversion factors and F-Factors from MCalibrationCams into
442// the arrays. Later, the here pre-calcualted conversion factors get simply
443// copied from memory.
444//
445// This function can be called from outside in case that the MCalibrationCams
446// have been updated...
447//
448Bool_t MCalibrateData::UpdateConversionFactors( const MCalibrationChargeCam *updatecam)
449{
450
451 *fLog << inf << GetDescriptor()
452 << ": Updating Conversion Factors... " << endl;
453
454 fCalibConsts.Reset();
455 fCalibFFactors.Reset();
456 fHiLoConv.Reset();
457 fHiLoConvErr.Reset();
458
459 //
460 // For the moment, we use only a dummy zenith for the calibration:
461 //
462 const Float_t zenith = -1.;
463
464 UInt_t skip = 0;
465
466 for (UInt_t pixidx=0; pixidx<fGeomCam->GetNumPixels(); pixidx++)
467 {
468
469 Float_t hiloconv = 1.;
470 Float_t hiloconverr = 0.;
471 Float_t calibConv = 1.;
472 Float_t calibConvVar = 0.;
473 Float_t calibFFactor = 0.;
474
475 Float_t calibQE = 1.;
476 Float_t calibQEVar = 0.;
477
478 Float_t calibUpdate = 1.;
479
480 MCalibConstPix &cpix = (*fCalibConstCam)[pixidx];
481
482 if(fCalibrationMode!=kNone)
483 {
484 if ((*fBadPixels)[pixidx].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
485 {
486 skip++;
487 calibConv = -1.;
488 continue;
489 }
490
491 MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCalibrations)[pixidx];
492 MCalibrationChargePix &avpix = (MCalibrationChargePix&)fCalibrations->GetAverageArea(0);
493
494 hiloconv = pix.GetConversionHiLo ();
495 hiloconverr= pix.GetConversionHiLoErr();
496
497 calibConv = pix.GetMeanConvFADC2Phe();
498 calibConvVar = pix.GetMeanConvFADC2PheVar();
499 calibFFactor = pix.GetMeanFFactorFADC2Phot();
500
501 MCalibrationQEPix &qe = (MCalibrationQEPix&) (*fQEs)[pixidx];
502
503 if (updatecam)
504 {
505 MCalibrationChargePix &upix = (MCalibrationChargePix&)(*updatecam)[pixidx];
506 //
507 // Correct for the possible change in amplification of the individual pixels chain
508 //
509 const Float_t pixmean = upix.GetConvertedMean();
510 calibUpdate = (pixmean == 0.) ? 1. : pix.GetConvertedMean() / pixmean;
511 //
512 // Correct for global shifts in light emission
513 //
514 MCalibrationChargePix &ugpix = (MCalibrationChargePix&)updatecam->GetAverageArea(0);
515
516 const Float_t globmean = avpix.GetConvertedMean();
517 calibUpdate = (globmean == 0.) ? 1. : ugpix.GetConvertedMean() / globmean;
518
519 MBadPixelsPix &ubad = (MBadPixelsPix&) updatecam->GetAverageBadArea(0);
520 if (ubad.IsUncalibrated(MBadPixelsPix::kChargeIsPedestal))
521 {
522 *fLog << warn << GetDescriptor() << ": Mean charge in inner pixels is smaller than 3 ped. RMS." << endl;
523 *fLog << "Maybe calibration pulses have been lost!" << endl;
524 calibUpdate = 1.;
525
526 }
527 }
528
529 switch(fCalibrationMode)
530 {
531 case kFlatCharge:
532 {
533 calibConv = avpix.GetConvertedMean()
534 / (pix.GetConvertedMean() * fGeomCam->GetPixRatio(pixidx));
535 calibConvVar = (avpix.GetMeanRelVar() + pix.GetMeanRelVar()) * calibConv * calibConv;
536 if (pix.IsFFactorMethodValid())
537 {
538 const Float_t convmin1 = qe.GetQECascadesFFactor(zenith)/pix.GetMeanConvFADC2Phe();
539 if (convmin1 > 0)
540 calibFFactor *= TMath::Sqrt(convmin1);
541 else
542 calibFFactor = -1.;
543 }
544 break;
545 }
546 case kBlindPixel:
547 if (!qe.IsBlindPixelMethodValid())
548 {
549 skip++;
550 continue;
551 }
552 calibQE = qe.GetQECascadesBlindPixel ( zenith );
553 calibQEVar = qe.GetQECascadesBlindPixelVar( zenith );
554 break;
555
556 case kPinDiode:
557 if (!qe.IsPINDiodeMethodValid())
558 {
559 skip++;
560 continue;
561 }
562 calibQE = qe.GetQECascadesPINDiode ( zenith );
563 calibQEVar = qe.GetQECascadesPINDiodeVar( zenith );
564 break;
565
566 case kFfactor:
567 if (!pix.IsFFactorMethodValid())
568 {
569 skip++;
570 continue;
571 }
572 calibQE = qe.GetQECascadesFFactor ( zenith );
573 calibQEVar = qe.GetQECascadesFFactorVar( zenith );
574 break;
575
576 case kCombined:
577 if (!qe.IsCombinedMethodValid())
578 {
579 skip++;
580 continue;
581 }
582 calibQE = qe.GetQECascadesCombined ( zenith );
583 calibQEVar = qe.GetQECascadesCombinedVar( zenith );
584 break;
585
586 case kDummy:
587 hiloconv = 1.;
588 hiloconverr = 0.;
589 calibUpdate = 1.;
590 break;
591 } /* switch calibration mode */
592 } /* if(fCalibrationMode!=kNone) */
593 else
594 {
595 calibConv = 1./fGeomCam->GetPixRatio(pixidx);
596 }
597
598 calibConv /= calibQE;
599
600 if (calibConv != 0. && calibQE != 0.)
601 {
602 // Now doing:
603 calibConvVar = calibConvVar/(calibConv*calibConv) + calibQEVar/(calibQE*calibQE);
604 calibConvVar *= (calibConv*calibConv);
605 // The above two lines had been commented by TB and replaced by the following line
606 // (without notice to me!) but it is simply wrong!
607 // calibConvVar += calibQEVar*(calibConv*calibConv)/(calibQE*calibQE);
608 }
609
610 calibConv *= fRenormFactor * calibUpdate;
611 calibFFactor *= TMath::Sqrt(fRenormFactor);
612
613 fHiLoConv [pixidx] = hiloconv;
614 fHiLoConvErr [pixidx] = hiloconverr;
615 fCalibConsts [pixidx] = calibConv;
616 fCalibFFactors[pixidx] = calibFFactor;
617
618 if (calibConv < fCalibConvMinLimit || calibConv > fCalibConvMaxLimit)
619 {
620 (*fBadPixels)[pixidx].SetUnsuitable(MBadPixelsPix::kUnsuitableRun);
621 calibConv = -1.;
622 calibFFactor = -1.;
623 }
624 cpix.SetCalibConst(calibConv);
625 cpix.SetCalibFFactor(calibFFactor);
626
627 } /* for (Int_t pixidx=0; pixidx<fGeomCam->GetNumPixels(); pixidx++) */
628
629 if (skip>fGeomCam->GetNumPixels()*0.9)
630 {
631 *fLog << warn << GetDescriptor()
632 << ": WARNING - GetConversionFactor has skipped more than 90% of the pixels... abort." << endl;
633 return kFALSE;
634 }
635
636
637
638 // Print();
639
640 return kTRUE;
641}
642
643
644// --------------------------------------------------------------------------
645//
646// Apply the conversion factors and F-Factors from the arrays to the data.
647//
648// The flags 'data' and 'pedestal' decide whether the signal and/or the pedetals
649// shall be calibrated, respectively.
650//
651Int_t MCalibrateData::Calibrate(Bool_t data, Bool_t pedestal) const
652{
653 if (!data && !pedestal)
654 return kTRUE;
655
656 const UInt_t npix = fSignals->GetSize();
657 const Float_t slices = fSignals->GetNumUsedHiGainFADCSlices();
658 const Float_t sqrtslices = TMath::Sqrt(slices);
659
660 Int_t numsatlo=0;
661 Int_t numsathi=0;
662
663 for (UInt_t pixidx=0; pixidx<npix; pixidx++)
664 {
665
666 if (data)
667 {
668 const MExtractedSignalPix &sig = (*fSignals)[pixidx];
669
670 Float_t signal = 0.;
671 Float_t signalErr = 0.;
672
673 if (sig.IsLoGainUsed())
674 {
675 if (fHiLoConv[pixidx] < 0.5)
676 {
677 signal = sig.GetExtractedSignalHiGain()*1.5;
678 signalErr = sig.GetExtractedSignalHiGain()*0.5;
679 }
680 else
681 {
682 const Float_t siglo = sig.GetExtractedSignalLoGain();
683
684 if (siglo > 0.1) // low-gain signal has been extracted successfully
685 {
686 signal = siglo*fHiLoConv [pixidx];
687 signalErr = siglo*fHiLoConvErr[pixidx];
688 }
689 else // low-gain signal has not been extracted successfully, get a rough estimate from the high-gain
690 {
691 signal = sig.GetExtractedSignalHiGain()*1.5;
692 signalErr = sig.GetExtractedSignalHiGain()*0.5;
693 }
694 }
695 }
696 else
697 {
698 if (sig.GetExtractedSignalHiGain() <= 9999.)
699 signal = sig.GetExtractedSignalHiGain();
700 }
701
702 const Float_t nphot = signal * fCalibConsts [pixidx];
703 const Float_t nphotErr = TMath::Sqrt(TMath::Abs(nphot)) * fCalibFFactors[pixidx];
704
705 fCerPhotEvt->AddPixel(pixidx, nphot, nphotErr);
706
707 if (sig.GetNumHiGainSaturated() > 0)
708 numsathi++;
709
710 if (sig.GetNumLoGainSaturated() > 0)
711 numsatlo++;
712 } /* if (data) */
713
714
715 if (pedestal)
716 {
717 TIter NextPed(&fPedestalCams);
718 TIter NextPhot(&fPedPhotCams);
719
720 MPedestalCam *pedestal = 0;
721 MPedPhotCam *pedphot = 0;
722
723 const Float_t pedmeancalib = slices *fCalibConsts[pixidx];
724 const Float_t pedrmscalib = sqrtslices*fCalibConsts[pixidx];
725
726 while ((pedestal=(MPedestalCam*)NextPed()) &&
727 (pedphot =(MPedPhotCam*)NextPhot()))
728 {
729 // pedestals/(used FADC slices) in [number of photons]
730 const Float_t mean = (*pedestal)[pixidx].GetPedestal() *pedmeancalib;
731 const Float_t rms = (*pedestal)[pixidx].GetPedestalRms()*pedrmscalib;
732
733 (*pedphot)[pixidx].Set(mean, rms);
734 pedphot->SetReadyToSave();
735 }
736 } /* if (pedestal) */
737 }
738
739 if (data)
740 {
741 fCerPhotEvt->SetNumPixelsSaturated(numsathi, numsatlo);
742 fCerPhotEvt->SetReadyToSave();
743 }
744 return kTRUE;
745}
746
747// --------------------------------------------------------------------------
748//
749// Apply the calibration factors to the extracted signal according to the
750// selected calibration method
751//
752Int_t MCalibrateData::Process()
753{
754 return Calibrate(fCalibrationMode!=kSkip, TestPedestalFlag(kEvent));
755}
756
757// --------------------------------------------------------------------------
758//
759// Implementation of SavePrimitive. Used to write the call to a constructor
760// to a macro. In the original root implementation it is used to write
761// gui elements to a macro-file.
762//
763void MCalibrateData::StreamPrimitive(ofstream &out) const
764{
765 out << " " << ClassName() << " " << GetUniqueName() << "(\"";
766 out << "\"" << fName << "\", \"" << fTitle << "\");" << endl;
767
768 if (TestPedestalFlag(kEvent))
769 out << " " << GetUniqueName() << ".EnablePedestalType(MCalibrateData::kEvent)" << endl;
770 if (TestPedestalFlag(kRun))
771 out << " " << GetUniqueName() << ".EnablePedestalType(MCalibrateData::kRun)" << endl;
772
773 if (fCalibrationMode != kDefault)
774 {
775 out << " " << GetUniqueName() << ".SetCalibrationMode(MCalibrateData::";
776 switch (fCalibrationMode)
777 {
778 case kSkip: out << "kSkip"; break;
779 case kNone: out << "kNone"; break;
780 case kFlatCharge: out << "kFlatCharge"; break;
781 case kBlindPixel: out << "kBlindPixel"; break;
782 case kFfactor: out << "kFfactor"; break;
783 case kPinDiode: out << "kPinDiode"; break;
784 case kCombined: out << "kCombined"; break;
785 case kDummy: out << "kDummy"; break;
786 default: out << (int)fCalibrationMode; break;
787 }
788 out << ")" << endl;
789 }
790
791 TIter Next(&fNamesPedestal);
792 TObject *o=0;
793 while ((o=Next()))
794 {
795 out << " " << GetUniqueName() << ".AddPedestal(\"";
796 out << o->GetName() << "\", \"" << o->GetTitle() << "\");" << endl;
797 }
798}
799
800// --------------------------------------------------------------------------
801//
802// Read the setup from a TEnv, eg:
803// MJPedestal.MCalibrateDate.PedestalFlag: no,run,event
804// MJPedestal.MCalibrateDate.CalibrationMode: skip,none,flatcharge,blindpixel,ffactor,pindiode,combined,dummy,default
805//
806Int_t MCalibrateData::ReadEnv(const TEnv &env, TString prefix, Bool_t print)
807{
808 Bool_t rc = kFALSE;
809 if (IsEnvDefined(env, prefix, "PedestalFlag", print))
810 {
811 rc = kTRUE;
812 TString s = GetEnvValue(env, prefix, "PedestalFlag", "");
813 s.ToLower();
814 if (s.BeginsWith("no"))
815 SetPedestalFlag(kNo);
816 if (s.BeginsWith("run"))
817 SetPedestalFlag(kRun);
818 if (s.BeginsWith("event"))
819 SetPedestalFlag(kEvent);
820 }
821
822 if (IsEnvDefined(env, prefix, "CalibrationMode", print))
823 {
824 rc = kTRUE;
825 TString s = GetEnvValue(env, prefix, "CalibrationMode", "");
826 s.ToLower();
827 if (s.BeginsWith("skip"))
828 SetCalibrationMode(kSkip);
829 if (s.BeginsWith("none"))
830 SetCalibrationMode(kNone);
831 if (s.BeginsWith("flatcharge"))
832 SetCalibrationMode(kFlatCharge);
833 if (s.BeginsWith("blindpixel"))
834 SetCalibrationMode(kBlindPixel);
835 if (s.BeginsWith("ffactor"))
836 SetCalibrationMode(kFfactor);
837 if (s.BeginsWith("pindiode"))
838 SetCalibrationMode(kPinDiode);
839 if (s.BeginsWith("combined"))
840 SetCalibrationMode(kCombined);
841 if (s.BeginsWith("dummy"))
842 SetCalibrationMode(kDummy);
843 if (s.BeginsWith("default"))
844 SetCalibrationMode();
845 }
846
847 if (IsEnvDefined(env, prefix, "SignalType", print))
848 {
849 rc = kTRUE;
850 TString s = GetEnvValue(env, prefix, "SignalType", "");
851 s.ToLower();
852 if (s.BeginsWith("phot"))
853 SetSignalType(kPhot);
854 if (s.BeginsWith("phe"))
855 SetSignalType(kPhe);
856 if (s.BeginsWith("default"))
857 SetSignalType();
858 }
859
860 if (IsEnvDefined(env, prefix, "CalibConvMinLimit", print))
861 {
862 fCalibConvMinLimit = GetEnvValue(env, prefix, "CalibConvMinLimit", fCalibConvMinLimit);
863 rc = kTRUE;
864 }
865
866 if (IsEnvDefined(env, prefix, "CalibConvMaxLimit", print))
867 {
868 fCalibConvMaxLimit = GetEnvValue(env, prefix, "CalibConvMaxLimit", fCalibConvMaxLimit);
869 rc = kTRUE;
870 }
871
872 return rc;
873}
874
875void MCalibrateData::Print(Option_t *o) const
876{
877
878 *fLog << all << GetDescriptor() << ":" << endl;
879
880 for (UInt_t pixidx=0; pixidx<fGeomCam->GetNumPixels(); pixidx++)
881 {
882 *fLog << all
883 << Form("%s%3i","Pixel: ",pixidx)
884 << Form("%s%4.2f"," CalibConst: ",fCalibConsts[pixidx])
885 << Form("%s%4.2f"," F-Factor: ",fCalibFFactors[pixidx])
886 << Form("%s%4.2f"," HiLoConv: ",fHiLoConv[pixidx])
887 << endl;
888 }
889}
890
Note: See TracBrowser for help on using the repository browser.