source: trunk/MagicSoft/Mars/mjobs/MJCalibrateSignal.cc@ 8418

Last change on this file since 8418 was 8418, checked in by tbretz, 17 years ago
*** empty log message ***
File size: 30.2 KB
Line 
1/* ======================================================================== *\
2!
3! *
4! * This file is part of MARS, the MAGIC Analysis and Reconstruction
5! * Software. It is distributed to you in the hope that it can be a useful
6! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
7! * It is distributed WITHOUT ANY WARRANTY.
8! *
9! * Permission to use, copy, modify and distribute this software and its
10! * documentation for any purpose is hereby granted without fee,
11! * provided that the above copyright notice appear in all copies and
12! * that both that copyright notice and this permission notice appear
13! * in supporting documentation. It is provided "as is" without express
14! * or implied warranty.
15! *
16!
17!
18! Author(s): Thomas Bretz, 1/2004 <mailto:tbretz@astro.uni-wuerzburg.de>
19!
20! Copyright: MAGIC Software Development, 2000-2007
21!
22!
23\* ======================================================================== */
24
25/////////////////////////////////////////////////////////////////////////////
26//
27// MJCalibrateSignal
28//
29// This class is reading the output written by callisto. It calibrates
30// signal and time.
31//
32// The signal and time extractors are read from the callisto-output. In
33// pricipal you could overwrite these default using the resource file,
34// but this is NOT recommended!
35//
36/////////////////////////////////////////////////////////////////////////////
37#include "MJCalibrateSignal.h"
38
39#include <TEnv.h>
40#include <TFile.h>
41
42#include "MLog.h"
43#include "MLogManip.h"
44
45#include "MDirIter.h"
46#include "MRunIter.h"
47#include "MParList.h"
48#include "MTaskList.h"
49#include "MEvtLoop.h"
50
51#include "MStatusDisplay.h"
52
53#include "MGeomCam.h"
54#include "MHCamEvent.h"
55#include "MPedestalCam.h"
56#include "MBadPixelsCam.h"
57#include "MArrivalTimeCam.h"
58
59#include "MCalibrationQECam.h"
60#include "MCalibrationBlindCam.h"
61#include "MCalibrationChargeCam.h"
62#include "MCalibrationRelTimeCam.h"
63#include "MCalibrationChargePINDiode.h"
64#include "MCalibrationPulseTimeCam.h"
65#include "MCalibrationPatternDecode.h"
66
67#include "MCalibrationChargeCalc.h"
68#include "MCalibrationRelTimeCalc.h"
69
70#include "MCalibConstCam.h"
71#include "MCalibrationIntensityChargeCam.h"
72#include "MCalibrationIntensityBlindCam.h"
73#include "MCalibrationIntensityRelTimeCam.h"
74#include "MCalibrationIntensityQECam.h"
75
76#include "MHCalibrationChargeCam.h"
77#include "MHCalibrationChargeBlindCam.h"
78#include "MHCalibrationChargePINDiode.h"
79#include "MHCalibrationRelTimeCam.h"
80#include "MHCalibrationPulseTimeCam.h"
81#include "MHCamera.h"
82
83#include "MCalibCalcFromPast.h"
84
85#include "MReadReports.h"
86#include "MReadMarsFile.h"
87#include "MRawFileRead.h"
88#include "MContinue.h"
89#include "MTriggerPatternDecode.h"
90#include "MFTriggerPattern.h"
91#include "MFDataPhrase.h"
92#include "MFilterList.h"
93#include "MGeomApply.h"
94#include "MPedestalSubtract.h"
95//#include "MMcPedestalCopy.h"
96#include "MPointingPosCalc.h"
97#include "MPedCalcFromLoGain.h"
98#include "MPedestalSubtract.h"
99#include "MExtractor.h"
100#include "MExtractTimeAndCharge.h"
101#include "MExtractPINDiode.h"
102#include "MExtractBlindPixel.h"
103#include "MFCosmics.h"
104#include "MTaskEnv.h"
105#include "MCalibrateData.h"
106#include "MCalibrateRelTimes.h"
107//#include "MBadPixelsMerge.h"
108#include "MBadPixelsCalc.h"
109#include "MBadPixelsTreat.h"
110#include "MFillH.h"
111#include "MWriteRootFile.h"
112
113#include "MFEvtNumber.h"
114#include "MMoviePrepare.h"
115#include "MMovieWrite.h"
116#include "MImgCleanStd.h"
117
118ClassImp(MJCalibrateSignal);
119
120using namespace std;
121
122// --------------------------------------------------------------------------
123//
124// Default constructor.
125//
126// Sets:
127// - fIsInterlaced to kTRUE
128// - fIsRelTimesUpdate to kFALSE
129// - fIsHiLoCalibration to kFALSE
130// - fPulsePosCheck to kTRUE
131//
132MJCalibrateSignal::MJCalibrateSignal(const char *name, const char *title)
133 : fExtractor(0), fIsInterlaced(kTRUE), fIsRelTimesUpdate(kFALSE), fIsMovieMode(kFALSE)
134{
135 fName = name ? name : "MJCalibrateSignal";
136 fTitle = title ? title : "Tool to calibrate data";
137
138 SetPulsePosCheck();
139 //fCruns = NULL;
140}
141
142MJCalibrateSignal::~MJCalibrateSignal()
143{
144 if (fExtractor)
145 delete fExtractor;
146}
147
148void MJCalibrateSignal::SetExtractor(const MExtractor *ext)
149{
150 if (fExtractor)
151 delete fExtractor;
152
153 fExtractor = ext ? (MExtractor*)ext->Clone() : NULL;
154}
155
156Bool_t MJCalibrateSignal::WriteResult(TObjArray &cont)
157{
158 if (IsNoStorage())
159 return kTRUE;
160
161 const TString name(Form("signal%08d.root", fSequence.GetSequence()));
162 return WriteContainer(cont, name);
163}
164
165Bool_t MJCalibrateSignal::ReadCalibration(TObjArray &l, MBadPixelsCam &cam, MExtractor* &ext2, MExtractor* &ext3, TString &geom) const
166{
167 TString fname = Form("%s/calib%08d.root", fPathIn.Data(), fSequence.GetSequence());
168
169 *fLog << inf << "Reading from file: " << fname << endl;
170
171 TFile file(fname, "READ");
172 if (!file.IsOpen())
173 {
174 *fLog << err << dbginf << "ERROR - Could not open file " << fname << endl;
175 return kFALSE;
176 }
177
178 TObject *o = file.Get("ExtractSignal");
179 if (o && !o->InheritsFrom(MExtractor::Class()))
180 {
181 *fLog << err << dbginf << "ERROR - ExtractSignal read from " << fname << " doesn't inherit from MExtractor!" << endl;
182 return kFALSE;
183 }
184 ext3 = o ? (MExtractor*)o->Clone() : NULL;
185
186 o = file.Get("ExtractTime");
187 if (o && !o->InheritsFrom(MExtractor::Class()))
188 {
189 *fLog << err << dbginf << "ERROR - ExtractTime read from " << fname << " doesn't inherit from MExtractor!" << endl;
190 return kFALSE;
191 }
192 ext2 = o ? (MExtractor*)o->Clone() : NULL;
193 if (!ext3 && !ext2)
194 {
195 *fLog << err << dbginf << "ERROR - Neither ExtractSignal nor ExrtractTime found in " << fname << "!" << endl;
196 return kFALSE;
197 }
198
199 o = file.Get("MGeomCam");
200 if (o && !o->InheritsFrom(MGeomCam::Class()))
201 {
202 *fLog << err << dbginf << "ERROR - MGeomCam read from " << fname << " doesn't inherit from MGeomCam!" << endl;
203 return kFALSE;
204 }
205 geom = o ? o->ClassName() : "";
206
207 TObjArray cont(l);
208 cont.Add(&cam);
209 return ReadContainer(cont);
210}
211
212// --------------------------------------------------------------------------
213//
214// MJCalibration allows to setup several option by a resource file:
215// MJCalibrateSignal.RawData: yes,no
216//
217// For more details see the class description and the corresponding Getters
218//
219Bool_t MJCalibrateSignal::CheckEnvLocal()
220{
221 SetInterlaced(GetEnv("Interlaced", fIsInterlaced));
222 SetRelTimesUpdate(GetEnv("RelTimesUpdate", fIsRelTimesUpdate));
223 SetMovieMode(GetEnv("MovieMode", fIsMovieMode));
224
225 return MJCalib::CheckEnvLocal();
226}
227
228Bool_t MJCalibrateSignal::Process(MPedestalCam &pedcamab, MPedestalCam &pedcambias,
229 MPedestalCam &pedcamextr)
230{
231 if (!fSequence.IsValid())
232 {
233 *fLog << err << "ERROR - Sequence invalid..." << endl;
234 return kFALSE;
235 }
236
237 *fLog << inf;
238 fLog->Separator(GetDescriptor());
239 *fLog << "Calculate calibrated data from Sequence #";
240 *fLog << fSequence.GetSequence() << endl << endl;
241
242
243 //if (!CheckEnv())
244 // return kFALSE;
245
246 CheckEnv();
247
248 // --------------------------------------------------------------------------------
249
250 MDirIter iter;
251 if (fSequence.IsValid())
252 {
253 if (fSequence.SetupDatRuns(iter, 0, IsUseRawData())<=0)
254 return kFALSE;
255 }
256
257 // Read File
258 MCalibrationIntensityChargeCam ichcam;
259 MCalibrationIntensityQECam iqecam;
260 MCalibrationIntensityBlindCam iblcam;
261 MCalibrationIntensityRelTimeCam itmcam;
262
263 MHCalibrationChargeCam hchacam;
264 MHCalibrationChargeBlindCam hbndcam;
265 MHCalibrationChargePINDiode hpndiod;
266 MHCalibrationRelTimeCam hrelcam;
267 //MHCalibrationHiLoCam hilocam;
268 //MHCalibrationPulseTimeCam hpulcam;
269
270 hchacam.SetOscillations(kFALSE);
271 hbndcam.SetOscillations(kFALSE);
272 hrelcam.SetOscillations(kFALSE);
273
274 MCalibrationChargeCam calcam;
275 MCalibrationQECam qecam;
276 MCalibrationBlindCam bndcam;
277 MCalibrationChargePINDiode pind;
278 MCalibrationRelTimeCam tmcam;
279 //MCalibrationHiLoCam hilcam;
280 MCalibrationPulseTimeCam pulcam;
281
282 MBadPixelsCam badpix;
283
284 TObjArray interlacedcont;
285 if (fIsInterlaced)
286 {
287 interlacedcont.Add(&ichcam);
288 interlacedcont.Add(&iqecam);
289 interlacedcont.Add(&iblcam);
290 interlacedcont.Add(&itmcam);
291 interlacedcont.Add(&hchacam);
292 if (IsUseBlindPixel())
293 interlacedcont.Add(&hbndcam);
294 if (IsUsePINDiode())
295 interlacedcont.Add(&hpndiod);
296 if (fIsRelTimesUpdate)
297 interlacedcont.Add(&hrelcam);
298 }
299
300 MExtractor *extractor1=fExtractor;
301 MExtractor *extractor2=0;
302 MExtractor *extractor3=0;
303 TString geom;
304
305 TObjArray calibcont;
306 calibcont.Add(&calcam);
307 calibcont.Add(&qecam);
308 calibcont.Add(&bndcam);
309 calibcont.Add(&tmcam);
310 if (IsUseBlindPixel())
311 calibcont.Add(&bndcam);
312
313 if (!ReadCalibration(calibcont, badpix, extractor2, extractor3, geom))
314 return kFALSE;
315
316 *fLog << all;
317 if (!geom.IsNull())
318 *fLog << inf << "Camera geometry found in file: " << geom << endl;
319 else
320 *fLog << inf << "No Camera geometry found using default <MGeomCamMagic>" << endl;
321
322 if (extractor3)
323 {
324 *fLog << underline << "Signal Extractor found in calibration file" << endl;
325 extractor3->Print();
326 *fLog << endl;
327 }
328 else
329 *fLog << inf << "No Signal Extractor: ExtractSignal in file." << endl;
330
331
332 if (extractor1)
333 {
334 *fLog << underline << "Modified Signal Extractor set by user." << endl;
335 extractor1->Print();
336 *fLog << endl;
337 }
338 else
339 {
340 *fLog << inf << "No modified Signal Extractor set by user... using ExtractSignal." << endl;
341 extractor1 = extractor3 ? (MExtractor*)extractor3->Clone() : 0;
342 }
343
344 if (extractor2)
345 {
346 *fLog << underline << "Time Extractor found in calibration file" << endl;
347 extractor2->Print();
348 *fLog << endl;
349 }
350 else
351 *fLog << inf << "No Time Extractor: ExtractTime in file." << endl;
352
353 // This is necessary for the case in which it is not in the files
354 MCalibConstCam constcam;
355
356 //MBadPixelsCam badcam;
357 constcam.SetBadPixels(&badpix);
358
359 // Setup Parlist
360 MParList plist;
361 plist.AddToList(this); // take care of fDisplay!
362 plist.AddToList(&badpix);
363 plist.AddToList(&constcam);
364 //plist.AddToList(&hilcam);
365 plist.AddToList(&calibcont); // Using AddToList(TObjArray *)
366 plist.AddToList(&interlacedcont); // Using AddToList(TObjArray *)
367 plist.AddToList(&pulcam);
368
369 // Setup Tasklist
370 MTaskList tlist;
371 plist.AddToList(&tlist);
372
373 MReadReports readreal;
374 readreal.AddTree("Events", "MTime.", MReadReports::kMaster);
375 readreal.AddTree("Trigger");
376 readreal.AddTree("Camera");
377 readreal.AddTree("Drive");
378 readreal.AddTree("CC");
379 readreal.AddTree("Currents");
380
381 MReadMarsFile readmc("Events");
382 readmc.DisableAutoScheme();
383
384 MRawFileRead rawread(NULL);
385
386 MRead *read = 0;
387 switch (GetDataFlag())
388 {
389 case kIsUseRawData: read = &rawread; break;
390 case kIsUseMC: read = &readmc; break;
391 case kIsUseRootData: read = &readreal; break;
392 }
393 read->AddFiles(iter);
394
395 const TString fname(Form("%s{s/_D_/_Y_}{s/\\.raw$/.root}{s/\\.raw\\.gz$/.root}", fPathOut.Data()));
396
397
398 // Skips MC which have no contents. This are precisely the
399 // events which fullfilled the MC Lvl1 trigger and an
400 // arbitrary cut (typically at 50phe) to speed up simulation
401 MContinue contmc("MRawEvtData.GetNumPixels<0.5", "ContEmptyMC");
402
403 //MPointingPosInterpolate pextr;
404 //pextr.AddFiles(&iter);
405
406 MGeomApply apply; // Only necessary to create geometry
407 if (!geom.IsNull())
408 apply.SetGeometry(geom);
409 //MBadPixelsMerge merge(&badpix);
410
411 // Make sure that pedcamab has the correct name
412 pedcamab.SetName("MPedestalFundamental");
413 pedcamextr.SetName("MPedestalFromExtractorRndm");
414 pedcambias.SetName("MPedestalFromExtractor");
415 plist.AddToList(&pedcamextr);
416 plist.AddToList(&pedcambias);
417 plist.AddToList(&pedcamab);
418
419 MArrivalTimeCam timecam;
420 plist.AddToList(&timecam);
421
422 // Check for interleaved events
423 MCalibrationPatternDecode caldec;
424 MTriggerPatternDecode decode;
425
426 // This will make that for data with version less than 5, where
427 // trigger patterns were not yet correct, all the events in the real
428 // data file will be processed. In any case there are no interleaved
429 // calibration events in such data, so this is fine.
430 MFTriggerPattern ftp;
431 ftp.SetDefault(kTRUE);
432 // ftp.RequireCalibration();
433 ftp.DenyCalibration();
434 ftp.DenyPedestal();
435 // ftp.DenyPinDiode();
436 ftp.SetInverted();
437
438 // This will skip interleaved calibration events and pedestal events (if any)
439 // --> tlist2
440 MContinue conttp(&ftp, "ContTrigPattern");
441
442 // Create the pedestal subtracted raw-data
443 MPedestalSubtract pedsub;
444 pedsub.SetPedestalCam(&pedcamab);
445
446 // Do signal and pedestal calculation
447 MPedCalcFromLoGain pedlo1("MPedCalcFundamental");
448 pedlo1.SetPedestalUpdate(kTRUE);
449 pedlo1.SetNamePedestalCamOut("MPedestalFundamental");
450
451 MPedCalcFromLoGain pedlo2("MPedCalcWithExtractorRndm");
452 pedlo2.SetPedestalUpdate(kTRUE);
453 pedlo2.SetRandomCalculation(kTRUE);
454 pedlo2.SetNamePedestalCamIn("MPedestalFundamental");
455 pedlo2.SetNamePedestalCamOut("MPedestalFromExtractorRndm");
456
457 MPedCalcFromLoGain pedlo3("MPedCalcWithExtractor");
458 pedlo3.SetPedestalUpdate(kTRUE);
459 pedlo3.SetRandomCalculation(kFALSE);
460 pedlo3.SetNamePedestalCamIn("MPedestalFundamental");
461 pedlo3.SetNamePedestalCamOut("MPedestalFromExtractor");
462
463 if (!extractor1)
464 {
465 *fLog << err << "ERROR - extractor1 == NULL" << endl;
466 return kFALSE;
467 }
468
469 extractor1->SetPedestals(&pedcamab);
470
471 // Setup to use the hi-gain extraction window in the lo-gain
472 // range (the start of the lo-gain range is added automatically
473 // by MPedCalcFromLoGain)
474 //
475 // The window size of the extractor is not yet initialized,
476 // so we have to stick to the extraction range
477 //
478 // Even if we would like to use a range comparable to the
479 // hi-gain extraction we use the lo-gain range to make
480 // sure that exclusions (eg. due to switching noise)
481 // are correctly handled.
482 //
483 pedlo1.SetRangeFromExtractor(*extractor1);
484
485 if (extractor1->InheritsFrom("MExtractTimeAndCharge"))
486 {
487 pedlo2.SetExtractor((MExtractTimeAndCharge*)extractor1);
488 pedlo3.SetExtractor((MExtractTimeAndCharge*)extractor1);
489 }
490 else
491 {
492 pedlo2.SetRangeFromExtractor(*extractor1);
493 pedlo3.SetRangeFromExtractor(*extractor1);
494 }
495
496 if (extractor2)
497 extractor2->SetPedestals(&pedcamab);
498
499 if (extractor3)
500 extractor3->SetPedestals(&pedcamab);
501
502 //------------------------------
503 MFTriggerPattern ftp2;
504 ftp2.SetDefault(kTRUE);
505 ftp2.DenyCalibration();
506 if (!extractor1->HasLoGain())
507 ftp2.RequirePedestal();
508
509 pedlo1.SetFilter(&ftp2);
510 pedlo2.SetFilter(&ftp2);
511 pedlo3.SetFilter(&ftp2);
512
513 MContinue contftp2(&ftp2, "ContPedestal");
514 //------------------------------
515
516 MFCosmics fcosmics;
517 fcosmics.SetNamePedestalCam("MPedestalFundamental");
518 MContinue contcos(&fcosmics, "ContTrigEvts");
519 contcos.SetInverted();
520
521 //MMcPedestalCopy pcopy;
522 MTaskEnv taskenv1("ExtractSignal");
523 MTaskEnv taskenv2("ExtractTime");
524 MTaskEnv taskenv3("ExtractInterlaced");
525 taskenv1.SetDefault(extractor1);
526 taskenv2.SetDefault(extractor2);
527 taskenv3.SetDefault(extractor3);
528
529 MFilterList flistftp2("PedestalFilter");
530 flistftp2.SetInverted();
531 flistftp2.AddToList(&ftp2);
532
533 if (!extractor1->HasLoGain())
534 {
535 taskenv1.SetFilter(&flistftp2);
536 taskenv2.SetFilter(&flistftp2);
537 taskenv3.SetFilter(&flistftp2);
538 }
539
540 //
541 // This is new calibration to photo-electrons, hard-coded
542 // as decided at the Wuerzburg software meeting 26.01.05
543 //
544 MCalibrateData calib;
545 calib.SetSignalType(MCalibrateData::kPhe);
546 //calib.AddPedestal("Fundamental");
547 calib.AddPedestal("FromExtractor");
548 calib.AddPedestal("FromExtractorRndm");
549 calib.SetPedestalFlag(MCalibrateData::kEvent);
550 //----------------------------------------------------------
551
552 MExtractPINDiode pinext;
553 MExtractBlindPixel bldext;
554
555 MFTriggerPattern fcalib("CalibFilter");
556 fcalib.SetDefault(kFALSE);
557 fcalib.RequireCalibration();
558
559 MCalibrationChargeCalc chcalc;
560 chcalc.SetExtractor(extractor3);
561
562 MCalibrationRelTimeCalc recalc;
563 MCalibCalcFromPast pacalc;
564
565 pinext.SetPedestals(&pedcamab);
566 bldext.SetPedestals(&pedcamab);
567 chcalc.SetPedestals(&pedcamextr);
568
569 pacalc.SetChargeCalc(&chcalc);
570 if (fIsRelTimesUpdate)
571 pacalc.SetRelTimeCalc(&recalc);
572 pacalc.SetCalibrate(&calib);
573
574 //
575 // Intensity Calibration histogramming
576 //
577 MFillH filpin(&hpndiod, "MExtractedSignalPINDiode", "FillPINDiode");
578 MFillH filbnd(&hbndcam, "MExtractedSignalBlindPixel", "FillBlindCam");
579 MFillH filcam(&hchacam, "MExtractedSignalCam", "FillChargeCam");
580 MFillH filtme(&hrelcam, "MArrivalTimeCam", "FillRelTime");
581 //MFillH filhil(&hilocam, "MExtractedSignalCam", "FillHiLoRatio");
582 //MFillH filpul(&hpulcam, "MRawEvtData", "FillPulseTime");
583 filpin.SetBit(MFillH::kDoNotDisplay);
584 filbnd.SetBit(MFillH::kDoNotDisplay);
585 filcam.SetBit(MFillH::kDoNotDisplay);
586 filtme.SetBit(MFillH::kDoNotDisplay);
587 //filhil.SetBit(MFillH::kDoNotDisplay);
588 //filpul.SetBit(MFillH::kDoNotDisplay);
589
590 MCalibrateRelTimes caltm;
591 MBadPixelsCalc bpcal;
592 MBadPixelsTreat treat;
593
594 //bpcal.SetNamePedPhotCam("MPedPhotFromExtractor");
595 bpcal.SetNamePedPhotCam("MPedPhotFromExtractorRndm");
596
597 //treat.AddNamePedPhotCam("MPedPhotFundamental");
598 treat.AddNamePedPhotCam("MPedPhotFromExtractor");
599 treat.AddNamePedPhotCam("MPedPhotFromExtractorRndm");
600 if (!extractor2 && !extractor1->InheritsFrom("MExtractTimeAndCharge"))
601 treat.SetProcessTimes(kFALSE);
602
603 MHCamEvent evt0( 0, "PedFLG", "Fundamental Pedestal from Lo Gain;;P [cnts/sl]");
604 MHCamEvent evt1( 2, "PedRmsFLG", "RMS from Extractor applied to ped.;;\\sigma_{p} [cnts/sl]");
605 MHCamEvent evt2( 0, "Extra'd", "Extracted Signal;;S [cnts/sl]");
606 // MHCamEvent evt3(4, "PedPhot", "Calibrated Pedestal;;P [phe]");
607 MHCamEvent evt4( 5, "PedRMS", "Calibrated RMS from Extractor applied to ped.;;\\sigma_{p} [phe]");
608 MHCamEvent evt5( 0, "Interp'd", "Interpolated Signal scaled with A/A_{0};;S [phe]");
609 MHCamEvent evt6(102, "Unsuitable", "Fraction of unsuitable events per Pixel;;[1]");
610 // MHCamEvent evt7( 6, "Times", "Calibrated Arrival Time;;T [fadc sl]");
611 MHCamEvent evt8( 0, "Conv", "Calibration Conv. Factors;;[phe/cnts]");
612 MHCamEvent evt9( 7, "PulsePos", "Pulse Position of cosmics (>50phe);;T");
613 MHCamEvent evtR( 4, "HiLoCal", "Hi-/Lo-Gain ratio;;Ratio");
614 MHCamEvent evtO( 7, "HiLoOff", "Lo-/Hi-Gain Offset;;Offset");
615 evt2.SetErrorSpread(kFALSE);
616 evt5.SetErrorSpread(kFALSE);
617 evt6.SetErrorSpread(kFALSE);
618 evt6.SetThreshold();
619
620 MFillH fill0(&evt0, "MPedestalFundamental", "FillPedFLG");
621 MFillH fill1(&evt1, "MPedestalFromExtractorRndm", "FillPedRmsFLG");
622 MFillH fill2(&evt2, "MExtractedSignalCam", "FillExtracted");
623 // MFillH fill3(&evt3, "MPedPhotFundamental", "FillPedPhot");
624 MFillH fill4(&evt4, "MPedPhotFromExtractorRndm", "FillPedRMS");
625 MFillH fill5(&evt5, "MSignalCam", "FillInterpolated");
626 MFillH fill6(&evt6, "MBadPixelsCam", "FillUnsuitable");
627 // MFillH fill7(&evt7, "MSignalCam", "FillTimes");
628 MFillH fill8(&evt8, "MCalibConstCam", "FillConv");
629 MFillH fill9(&evt9, "MSignalCam", "FillPulse");
630 MFillH fillR(&evtR, "MExtractedSignalCam", "FillHiLoCal");
631 MFillH fillO(&evtO, "MArrivalTimeCam", "FillHiLoOff");
632
633 /*
634 MFillH fillP("MHPulseShape", "", "FillPulseShape");
635 fillP.SetNameTab("Pulse");
636 */
637
638 if (!extractor1->HasLoGain())
639 {
640 fill0.SetFilter(&ftp2);
641 fill1.SetFilter(&ftp2);
642 }
643
644 /*
645 MHVsTime hbadpix("MBadPixelsCam.GetNumUnsuitable");
646 hbadpix.SetNumEvents(50);
647 MFillH fillB(&hbadpix, "MTime");
648 */
649
650 MTaskEnv fillflorian("FinalFantasy");
651 fillflorian.SetDefault();
652
653 // The second rule is for the case reading raw-files!
654 MWriteRootFile write(2, fname, fOverwrite?"RECREATE":"NEW");
655 // Run Header
656 write.AddContainer("MRawRunHeader", "RunHeaders");
657 write.AddContainer("MBadPixelsCam", "RunHeaders");
658 write.AddContainer("MGeomCam", "RunHeaders");
659 // Monte Carlo Headers
660 write.AddContainer("MMcRunHeader", "RunHeaders", kFALSE);
661 write.AddContainer("MMcFadcHeader", "RunHeaders", kFALSE);
662 write.AddContainer("MMcTrigHeader", "RunHeaders", kFALSE);
663 write.AddContainer("MMcConfigRunHeader", "RunHeaders", kFALSE);
664 write.AddContainer("MMcCorsikaRunHeader", "RunHeaders", kFALSE);
665 // Monte Carlo
666 write.AddContainer("MMcEvt", "Events", kFALSE);
667 write.AddContainer("MMcTrig", "Events", kFALSE);
668 // Data tree
669 write.AddContainer("MSignalCam", "Events");
670 // write.AddContainer("MPedPhotFundamental", "Events");
671 write.AddContainer("MPedPhotFromExtractor", "Events");
672 write.AddContainer("MPedPhotFromExtractorRndm", "Events");
673 write.AddContainer("MTime", "Events", kFALSE);
674 write.AddContainer("MRawEvtHeader", "Events");
675
676 // Slow-Control: Current-tree
677 write.AddContainer("MTimeCurrents", "Currents", kFALSE);
678 write.AddContainer("MCameraDC", "Currents", kFALSE);
679 write.AddContainer("MReportCurrents", "Currents", kFALSE);
680 // Slow-Control: Camera-tree
681 write.AddContainer("MReportCamera", "Camera", kFALSE);
682 write.AddContainer("MTimeCamera", "Camera", kFALSE);
683 write.AddContainer("MCameraAUX", "Camera", kFALSE);
684 write.AddContainer("MCameraCalibration", "Camera", kFALSE);
685 write.AddContainer("MCameraCooling", "Camera", kFALSE);
686 write.AddContainer("MCameraHV", "Camera", kFALSE);
687 write.AddContainer("MCameraLV", "Camera", kFALSE);
688 write.AddContainer("MCameraLids", "Camera", kFALSE);
689 // Slow-Control: Trigger-tree
690 write.AddContainer("MReportTrigger", "Trigger", kFALSE);
691 write.AddContainer("MTimeTrigger", "Trigger", kFALSE);
692 // Slow-Control: Drive-tree
693 write.AddContainer("MReportDrive", "Drive", kFALSE);
694 write.AddContainer("MTimeDrive", "Drive", kFALSE);
695 // Slow-Control: Central Control-tree
696 write.AddContainer("MReportCC", "CC", kFALSE);
697 write.AddContainer("MTimeCC", "CC", kFALSE);
698
699 // Write the special MC tree
700 MWriteRootFile writemc(2, fname, fOverwrite?"RECREATE":"NEW");
701 writemc.SetName("WriteMC");
702 writemc.AddContainer("MMcEvtBasic", "OriginalMC");
703
704 // Now setup tasklist for events
705 MTaskList tlist2;
706
707 tlist2.AddToList(&caldec);
708 tlist2.AddToList(&decode);
709 tlist2.AddToList(&apply);
710 //tlist2.AddToList(&merge);
711 tlist2.AddToList(&pedsub);
712 tlist2.AddToList(&ftp2);
713 tlist2.AddToList(&pedlo1);
714 tlist2.AddToList(&pedlo2);
715 tlist2.AddToList(&pedlo3);
716 tlist2.AddToList(&fill0); // fill pedestal events
717 tlist2.AddToList(&fill1); // fill pedestal events
718
719 //-----------------------------------------------------------
720
721 MTaskList tlist3;
722 tlist3.SetFilter(&fcalib);
723
724 //MFDataPhrase filcalco("MCalibrationIntensityConstCam.IsReadyToSave>0.5", "CalibConstFilter");
725 if (fIsInterlaced)
726 {
727 tlist2.AddToList(&fcalib); // MFTriggerPattern
728 tlist2.AddToList(&tlist3);
729 if (IsUsePINDiode())
730 tlist3.AddToList(&pinext); // MExtractPINDiode
731 if (IsUseBlindPixel())
732 tlist3.AddToList(&bldext); // MExtractBlindPixel
733 tlist3.AddToList(&taskenv3);
734 tlist3.AddToList(&pacalc); // MCalibCalcFromPast
735 /*
736 tlist3.AddToList(&filcalco); // CalibConstFilter (IsReadyToSave)
737 fill8.SetFilter(&filcalco);
738 tlist3.AddToList(&fill8); // FillConvUpd
739 */
740
741 tlist3.AddToList(&filcam); // FillChargeCam
742 if (fIsRelTimesUpdate)
743 tlist3.AddToList(&filtme); // FillRelTime
744 if (IsUseBlindPixel())
745 tlist3.AddToList(&filbnd); // FillBlindCam
746 if (IsUsePINDiode())
747 tlist3.AddToList(&filpin); // FillPINDiode
748 tlist3.AddToList(&chcalc); // MCalibrationChargeCalc
749 if (fIsRelTimesUpdate)
750 tlist3.AddToList(&recalc); // MCalibrationRelTimeCam
751 }
752
753 // Continue for all non-cosmic events
754 if (!extractor1->HasLoGain())
755 tlist2.AddToList(&contftp2); // remove pedestal events from processing
756 tlist2.AddToList(&conttp); // remove calib events from processing
757 if (extractor1)
758 tlist2.AddToList(&taskenv1);
759 if (extractor2)
760 tlist2.AddToList(&taskenv2);
761 tlist2.AddToList(&contcos); // MFCosmics (ContTrigEvts)
762 /*
763 if (fIsHiLoCalibration)
764 {
765 plist.AddToList(&hilocam);
766 tlist2.AddToList(&filhil);
767 }
768
769 if (fIsPulsePosCheck)
770 {
771 plist.AddToList(&hpulcam);
772 tlist2.AddToList(&filpul);
773 }
774 */
775 tlist2.AddToList(&fill2);
776 tlist2.AddToList(&fill8); // FillConv
777 tlist2.AddToList(&calib); // MCalibrateData
778 if (extractor2 || extractor1->InheritsFrom("MExtractTimeAndCharge"))
779 tlist2.AddToList(&caltm);
780
781 tlist2.AddToList(&bpcal); // MBadPixelsCalc
782 tlist2.AddToList(&treat); // MBadPixelsTreat
783 tlist2.AddToList(&fill6);
784 // tlist2.AddToList(&fill3);
785 tlist2.AddToList(&fill4);
786 tlist2.AddToList(&fill5);
787 //if (extractor2 || extractor1->InheritsFrom("MExtractTimeAndCharge"))
788 // tlist2.AddToList(&fill7);
789 tlist2.AddToList(&fill9);
790 if (extractor1->HasLoGain())
791 {
792 tlist2.AddToList(&fillR);
793 tlist2.AddToList(&fillO);
794 }
795
796 /*
797 MFillH fillC("MHCleaning", "", "FillClean");
798 tlist2.AddToList(&fillC);
799
800 //tlist2.AddToList(&fillP);
801 */
802
803 // ----- Start: Code for encoding movies -----
804
805 MMoviePrepare movprep;
806 MMovieWrite movwrite;
807 movprep.SetRangeFromExtractor(*extractor1);
808
809 //MFDataPhrase movfilt("MMovieData.fMax>150");
810 MFDataPhrase movfilt("MMovieData.fMax>5*MMovieData.fMedianPedestalRms", "MovieFilter");
811
812 MImgCleanStd movclean(8.5, 4.0);
813 movclean.SetMethod(MImgCleanStd::kAbsolute);
814
815 //movprep.SetFilter(&evtnum);
816 movclean.SetFilter(&movfilt);
817 movwrite.SetFilter(&movfilt);
818
819 MTaskList tlistmov;
820 tlistmov.AddToList(&movprep);
821 tlistmov.AddToList(&movfilt);
822 tlistmov.AddToList(&movclean);
823 tlistmov.AddToList(&movwrite);
824
825 MFEvtNumber evtnum;
826 //evtnum.SetSelector("ThetaSquared.fVal<0.04");
827 //evtnum.SetFileName("ganymed00000001.root");
828 tlistmov.SetFilter(&evtnum);
829
830 if (fIsMovieMode)
831 {
832 tlist2.AddToList(&evtnum);
833 tlist2.AddToList(&tlistmov);
834 }
835
836 // ----- End: Code for encoding movies -----
837
838 tlist2.AddToList(&fillflorian);
839
840 // Setup List for Drive-tree
841 //MPointingPosCalc pcalc;
842
843 // Now setup main tasklist
844 tlist.AddToList(read);
845
846 if (IsUseMC())
847 {
848 tlist.AddToList(&writemc);
849 tlist.AddToList(&contmc);
850 }
851
852 //if (IsUseRootData())
853 // tlist2.AddToList(&pextr);
854 tlist.AddToList(&tlist2, IsUseRootData() ? "Events" : "All");
855
856 //if (IsUseMC())
857 // tlist.AddToList(&pcalc, "Drive");
858
859 tlist.AddToList(&write);
860
861 // Create and setup the eventloop
862 MEvtLoop evtloop(fName);
863 evtloop.SetParList(&plist);
864 evtloop.SetDisplay(fDisplay);
865 evtloop.SetLogStream(fLog);
866 if (!SetupEnv(evtloop))
867 return kFALSE;
868
869 // Execute first analysis
870 const Bool_t rc = evtloop.Eventloop(fMaxEvents);
871
872 // make sure owned object are deleted
873 if (extractor1 && extractor1!=fExtractor)
874 delete extractor1;
875 if (extractor2)
876 delete extractor2;
877 if (extractor3)
878 delete extractor3;
879
880 // return if job failed
881 if (!rc)
882 {
883 *fLog << err << GetDescriptor() << ": Failed." << endl;
884 return kFALSE;
885 }
886
887 // if everything went ok write and display result
888 DisplayResult(plist);
889
890 /*
891 if (fIsPixelCheck)
892 {
893 if (fIsPulsePosCheck)
894 hpulcam[fCheckedPixId].DrawClone("");
895
896 //if (fIsHiLoCalibration)
897 // hilocam[fCheckedPixId].DrawClone("");
898 }
899 */
900 interlacedcont.Add(&pulcam);
901
902 //if (fIsHiLoCalibration)
903 // interlacedcont.Add(&hilcam);
904
905 //if (fIsPulsePosCheck)
906 // interlacedcont.Add(plist.FindObject("MHCalibrationPulseTimeCam"));
907
908 //if (fIsHiLoCalibration)
909 // interlacedcont.Add(plist.FindObject("MHCalibrationHiLoCam"));
910
911 if (!WriteResult(interlacedcont))
912 return kFALSE;
913
914 // return if job went ok
915 *fLog << all << GetDescriptor() << ": Done." << endl;
916 *fLog << endl << endl;
917
918 return kTRUE;
919}
920
921
922void MJCalibrateSignal::DisplayResult(MParList &plist)
923{
924 /*
925 if (!fDisplay || !fIsHiLoCalibration)
926 return;
927
928 MCalibrationHiLoCam *hcam = (MCalibrationHiLoCam*)plist.FindObject("MCalibrationHiLoCam");
929 MGeomCam *geom = (MGeomCam*)plist.FindObject("MGeomCam");
930 if (!hcam || !geom)
931 return;
932
933 // Create histograms to display
934 MHCamera disp1(*geom, "HiLoConv", "Ratio Amplification HiGain vs. LoGain (Charges)");
935 MHCamera disp2(*geom, "HiLoDiff", "Arrival Time Diff. HiGain vs. LoGain (Times)");
936
937 disp1.SetCamContent(*hcam, 0);
938 disp1.SetCamError( *hcam, 1);
939 disp2.SetCamContent(*hcam, 5);
940 disp2.SetCamError( *hcam, 6);
941
942 disp1.SetYTitle("R [1]");
943 disp2.SetYTitle("\\Delta T [FADC sl.]");
944
945 TCanvas &c1 = fDisplay->AddTab("HiLoConv");
946 c1.Divide(2,3);
947
948 disp1.CamDraw(c1, 1, 2, 1);
949 disp2.CamDraw(c1, 2, 2, 1);
950*/
951}
952
Note: See TracBrowser for help on using the repository browser.