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

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