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

Last change on this file since 8888 was 8795, checked in by tbretz, 17 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// Core
43#include "MLog.h"
44#include "MLogManip.h"
45
46#include "MDirIter.h"
47#include "MTaskList.h"
48#include "MParList.h"
49#include "MEvtLoop.h"
50
51#include "MStatusDisplay.h"
52
53// General containers
54#include "MGeomCam.h"
55#include "MBadPixelsCam.h"
56#include "MCalibConstCam.h"
57#include "MPedestalCam.h"
58#include "MArrivalTimeCam.h"
59
60// General histograms
61#include "MHCamEvent.h"
62#include "MHVsTime.h"
63
64// Calibration containers
65#include "MCalibrationQECam.h"
66#include "MCalibrationBlindCam.h"
67#include "MCalibrationChargeCam.h"
68#include "MCalibrationRelTimeCam.h"
69#include "MCalibrationChargePINDiode.h"
70
71// Calibration histograms
72#include "MHCalibrationChargeCam.h"
73#include "MHCalibrationChargeBlindCam.h"
74#include "MHCalibrationChargePINDiode.h"
75#include "MHCalibrationRelTimeCam.h"
76
77// Tasks
78#include "MReadMarsFile.h"
79#include "MRawFileRead.h"
80#include "MTaskEnv.h"
81#include "MContinue.h"
82#include "MFillH.h"
83#include "MGeomApply.h"
84#include "MExtractTimeAndCharge.h"
85#include "MTriggerPatternDecode.h"
86#include "MCalibrationPatternDecode.h"
87#include "MCalibrationChargeCalc.h"
88#include "MCalibrationRelTimeCalc.h"
89#include "MCalibCalcFromPast.h"
90#include "MPedestalSubtract.h"
91#include "MPedCalcFromLoGain.h"
92#include "MCalibrateData.h"
93#include "MExtractPINDiode.h"
94#include "MExtractBlindPixel.h"
95#include "MCalibrateRelTimes.h"
96#include "MBadPixelsCalc.h"
97#include "MBadPixelsTreat.h"
98#include "MWriteRootFile.h"
99
100// Filter
101#include "MFTriggerPattern.h"
102#include "MFCosmics.h"
103#include "MFilterList.h"
104#include "MFDataPhrase.h"
105
106// Classes for writing movies
107#include "MFEvtNumber.h"
108#include "MMoviePrepare.h"
109#include "MMovieWrite.h"
110#include "MImgCleanStd.h"
111
112
113ClassImp(MJCalibrateSignal);
114
115using namespace std;
116
117// --------------------------------------------------------------------------
118//
119// Default constructor.
120//
121// Sets:
122// - fIsInterlaced to kTRUE
123// - fIsRelTimesUpdate to kFALSE
124// - fIsHiLoCalibration to kFALSE
125//
126MJCalibrateSignal::MJCalibrateSignal(const char *name, const char *title)
127 : fExtractor(0), fIsInterlaced(kTRUE), fIsRelTimesUpdate(kTRUE), fIsMovieMode(kFALSE)
128{
129 fName = name ? name : "MJCalibrateSignal";
130 fTitle = title ? title : "Tool to calibrate data";
131}
132
133MJCalibrateSignal::~MJCalibrateSignal()
134{
135 if (fExtractor)
136 delete fExtractor;
137}
138
139void MJCalibrateSignal::SetExtractor(const MExtractor *ext)
140{
141 if (fExtractor)
142 delete fExtractor;
143
144 fExtractor = ext ? (MExtractor*)ext->Clone() : NULL;
145}
146
147Bool_t MJCalibrateSignal::WriteResult() const
148{
149 if (IsNoStorage() || fIsMovieMode)
150 return kTRUE;
151
152 // FIXME: This is not nice because it will update the signal
153 // file always. Which might make the usage outside of
154 // callisto difficult.
155 TObjArray cont;
156 cont.Add(const_cast<TEnv*>(GetEnv()));
157 cont.Add(const_cast<MSequence*>(&fSequence));
158
159 if (fDisplay)
160 cont.Add(fDisplay);
161
162 const TString name(Form("signal%08d.root", fSequence.GetSequence()));
163 return WriteContainer(cont, name, "UPDATE");
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, !fSequence.IsMonteCarlo())<=0)
255 return kFALSE;
256 }
257
258 // Read File
259 MHCalibrationChargeCam hchacam;
260 MHCalibrationChargeBlindCam hbndcam;
261 MHCalibrationChargePINDiode hpndiod;
262 MHCalibrationRelTimeCam hrelcam;
263 //MHCalibrationHiLoCam hilocam;
264 //MHCalibrationPulseTimeCam hpulcam;
265
266 hchacam.SetOscillations(kFALSE);
267 hbndcam.SetOscillations(kFALSE);
268 hrelcam.SetOscillations(kFALSE);
269
270 MCalibrationChargeCam calcam;
271 MCalibrationQECam qecam;
272 MCalibrationBlindCam bndcam;
273 MCalibrationChargePINDiode pind;
274 MCalibrationRelTimeCam tmcam;
275 //MCalibrationHiLoCam hilcam;
276 //MCalibrationPulseTimeCam pulcam;
277
278 MBadPixelsCam badpix;
279
280 TObjArray interlacedcont;
281 if (fIsInterlaced)
282 {
283 interlacedcont.Add(&hchacam);
284 if (IsUseBlindPixel())
285 interlacedcont.Add(&hbndcam);
286 if (IsUsePINDiode())
287 interlacedcont.Add(&hpndiod);
288 if (fIsRelTimesUpdate)
289 interlacedcont.Add(&hrelcam);
290 }
291
292 MExtractor *extractor1=fExtractor;
293 MExtractor *extractor2=0;
294 MExtractor *extractor3=0;
295 TString geom;
296
297 TObjArray calibcont;
298 calibcont.Add(&calcam);
299 calibcont.Add(&qecam);
300 calibcont.Add(&bndcam);
301 calibcont.Add(&tmcam);
302 if (IsUseBlindPixel())
303 calibcont.Add(&bndcam);
304
305 if (!ReadCalibration(calibcont, badpix, extractor2, extractor3, geom))
306 return kFALSE;
307
308 *fLog << all;
309 if (!geom.IsNull())
310 *fLog << inf << "Camera geometry found in file: " << geom << endl;
311 else
312 *fLog << inf << "No Camera geometry found using default <MGeomCamMagic>" << endl;
313
314 if (extractor3)
315 {
316 *fLog << underline << "Signal Extractor found in calibration file" << endl;
317 extractor3->Print();
318 *fLog << endl;
319 }
320 else
321 *fLog << inf << "No Signal Extractor: ExtractSignal in file." << endl;
322
323
324 if (extractor1)
325 {
326 *fLog << underline << "Modified Signal Extractor set by user." << endl;
327 extractor1->Print();
328 *fLog << endl;
329 }
330 else
331 {
332 *fLog << inf << "No modified Signal Extractor set by user... using ExtractSignal." << endl;
333 extractor1 = extractor3 ? (MExtractor*)extractor3->Clone() : 0;
334 }
335
336 if (extractor2)
337 {
338 *fLog << underline << "Time Extractor found in calibration file" << endl;
339 extractor2->Print();
340 *fLog << endl;
341 }
342 else
343 *fLog << inf << "No Time Extractor: ExtractTime in file." << endl;
344
345 // This is necessary for the case in which it is not in the files
346 MCalibConstCam constcam;
347
348 //MBadPixelsCam badcam;
349 constcam.SetBadPixels(&badpix);
350
351 // Setup Parlist
352 MParList plist;
353 plist.AddToList(this); // take care of fDisplay!
354 plist.AddToList(&badpix);
355 plist.AddToList(&constcam);
356 //plist.AddToList(&hilcam);
357 plist.AddToList(&calibcont); // Using AddToList(TObjArray *)
358 plist.AddToList(&interlacedcont); // Using AddToList(TObjArray *)
359 //plist.AddToList(&pulcam);
360
361 // Setup Tasklist
362 MTaskList tlist;
363 plist.AddToList(&tlist);
364
365 MReadMarsFile readmc("Events");
366 readmc.DisableAutoScheme();
367
368 MRawFileRead rawread(NULL);
369
370 MRead *read = fSequence.IsMonteCarlo() ? (MRead*)&readmc : (MRead*)&rawread;
371 read->AddFiles(iter);
372
373 const TString fname(Form("%s{s/_D_/_Y_}{s/\\.raw$/.root}{s/\\.raw\\.gz$/.root}", fPathOut.Data()));
374
375 // Skips MC which have no contents. This are precisely the
376 // events which fullfilled the MC Lvl1 trigger and an
377 // arbitrary cut (typically at 50phe) to speed up simulation
378 MContinue contmc("MRawEvtData.GetNumPixels<0.5", "ContEmptyMC");
379
380 //MPointingPosInterpolate pextr;
381 //pextr.AddFiles(&iter);
382
383 MGeomApply apply; // Only necessary to create geometry
384 if (!geom.IsNull())
385 apply.SetGeometry(geom);
386 //MBadPixelsMerge merge(&badpix);
387
388 // Make sure that pedcamab has the correct name
389 pedcamab.SetName("MPedestalFundamental");
390 pedcamextr.SetName("MPedestalFromExtractorRndm");
391 pedcambias.SetName("MPedestalFromExtractor");
392 plist.AddToList(&pedcamextr);
393 plist.AddToList(&pedcambias);
394 plist.AddToList(&pedcamab);
395
396 MArrivalTimeCam timecam;
397 plist.AddToList(&timecam);
398
399 // Check for interleaved events
400 MCalibrationPatternDecode caldec;
401 MTriggerPatternDecode decode;
402
403 // This will make that for data with version less than 5, where
404 // trigger patterns were not yet correct, all the events in the real
405 // data file will be processed. In any case there are no interleaved
406 // calibration events in such data, so this is fine.
407 MFTriggerPattern ftp;
408 ftp.SetDefault(kTRUE);
409 // ftp.RequireCalibration();
410 ftp.DenyCalibration();
411 ftp.DenyPedestal();
412 // ftp.DenyPinDiode();
413 ftp.SetInverted();
414
415 // This will skip interleaved calibration events and pedestal events (if any)
416 // --> tlist2
417 MContinue conttp(&ftp, "ContTrigPattern");
418
419 // Create the pedestal subtracted raw-data
420 MPedestalSubtract pedsub;
421 pedsub.SetPedestalCam(&pedcamab);
422
423 // Do signal and pedestal calculation
424 MPedCalcFromLoGain pedlo1("MPedCalcFundamental");
425 pedlo1.SetPedestalUpdate(kTRUE);
426 pedlo1.SetNamePedestalCamOut("MPedestalFundamental");
427
428 MPedCalcFromLoGain pedlo2("MPedCalcWithExtractorRndm");
429 pedlo2.SetPedestalUpdate(kTRUE);
430 pedlo2.SetRandomCalculation(kTRUE);
431 pedlo2.SetNamePedestalCamOut("MPedestalFromExtractorRndm");
432
433 MPedCalcFromLoGain pedlo3("MPedCalcWithExtractor");
434 pedlo3.SetPedestalUpdate(kTRUE);
435 pedlo3.SetRandomCalculation(kFALSE);
436 pedlo3.SetNamePedestalCamOut("MPedestalFromExtractor");
437
438 if (!extractor1)
439 {
440 *fLog << err << "ERROR - extractor1 == NULL" << endl;
441 return kFALSE;
442 }
443
444 // Setup to use the hi-gain extraction window in the lo-gain
445 // range (the start of the lo-gain range is added automatically
446 // by MPedCalcFromLoGain)
447 //
448 // The window size of the extractor is not yet initialized,
449 // so we have to stick to the extraction range
450 //
451 // Even if we would like to use a range comparable to the
452 // hi-gain extraction we use the lo-gain range to make
453 // sure that exclusions (eg. due to switching noise)
454 // are correctly handled.
455 //
456 pedlo1.SetRangeFromExtractor(*extractor1);
457
458 if (extractor1->InheritsFrom("MExtractTimeAndCharge"))
459 {
460 pedlo2.SetExtractor((MExtractTimeAndCharge*)extractor1);
461 pedlo3.SetExtractor((MExtractTimeAndCharge*)extractor1);
462 }
463 else
464 {
465 pedlo2.SetRangeFromExtractor(*extractor1);
466 pedlo3.SetRangeFromExtractor(*extractor1);
467 }
468
469 //------------------------------
470 MFTriggerPattern ftp2;
471 ftp2.SetDefault(kTRUE);
472 ftp2.DenyCalibration();
473 if (!extractor1->HasLoGain())
474 ftp2.RequirePedestal();
475
476 pedlo1.SetFilter(&ftp2);
477 pedlo2.SetFilter(&ftp2);
478 pedlo3.SetFilter(&ftp2);
479
480 MContinue contftp2(&ftp2, "ContPedestal");
481 //------------------------------
482
483 MFCosmics fcosmics;
484 fcosmics.SetNamePedestalCam("MPedestalFundamental");
485 MContinue contcos(&fcosmics, "ContTrigEvts");
486 contcos.SetInverted();
487
488 //MMcPedestalCopy pcopy;
489 MTaskEnv taskenv1("ExtractSignal");
490 MTaskEnv taskenv2("ExtractTime");
491 MTaskEnv taskenv3("ExtractInterlaced");
492 taskenv1.SetDefault(extractor1);
493 taskenv2.SetDefault(extractor2);
494 taskenv3.SetDefault(extractor3);
495
496 MFilterList flistftp2("PedestalFilter");
497 flistftp2.SetInverted();
498 flistftp2.AddToList(&ftp2);
499
500 if (!extractor1->HasLoGain())
501 {
502 taskenv1.SetFilter(&flistftp2);
503 taskenv2.SetFilter(&flistftp2);
504 taskenv3.SetFilter(&flistftp2);
505 }
506
507 //
508 // This is new calibration to photo-electrons, hard-coded
509 // as decided at the Wuerzburg software meeting 26.01.05
510 //
511 MCalibrateData calib;
512 calib.SetSignalType(MCalibrateData::kPhe);
513 //calib.AddPedestal("Fundamental");
514 calib.AddPedestal("FromExtractor");
515 calib.AddPedestal("FromExtractorRndm");
516 calib.SetPedestalFlag(MCalibrateData::kEvent);
517 //----------------------------------------------------------
518
519 MExtractPINDiode pinext;
520 MExtractBlindPixel bldext;
521
522 MFTriggerPattern fcalib("CalibFilter");
523 fcalib.SetDefault(kFALSE);
524 fcalib.RequireCalibration();
525
526 MCalibrationChargeCalc chcalc;
527 chcalc.SetContinousCalibration();
528 chcalc.SetExtractor(extractor3);
529
530 MCalibrationRelTimeCalc recalc;
531 MCalibCalcFromPast pacalc;
532
533 chcalc.SetPedestals(&pedcamextr);
534
535 pacalc.SetChargeCalc(&chcalc);
536 if (fIsRelTimesUpdate)
537 pacalc.SetRelTimeCalc(&recalc);
538 pacalc.SetCalibrate(&calib);
539
540 //
541 // Calibration histogramming
542 //
543 MFillH filpin(&hpndiod, "MExtractedSignalPINDiode", "FillPINDiode");
544 MFillH filbnd(&hbndcam, "MExtractedSignalBlindPixel", "FillBlindCam");
545 MFillH filcam(&hchacam, "MExtractedSignalCam", "FillChargeCam");
546 MFillH filtme(&hrelcam, "MArrivalTimeCam", "FillRelTime");
547 //MFillH filhil(&hilocam, "MExtractedSignalCam", "FillHiLoRatio");
548 //MFillH filpul(&hpulcam, "MRawEvtData", "FillPulseTime");
549 filpin.SetBit(MFillH::kDoNotDisplay);
550 filbnd.SetBit(MFillH::kDoNotDisplay);
551 filcam.SetBit(MFillH::kDoNotDisplay);
552 filtme.SetBit(MFillH::kDoNotDisplay);
553 //filhil.SetBit(MFillH::kDoNotDisplay);
554 //filpul.SetBit(MFillH::kDoNotDisplay);
555
556 MCalibrateRelTimes caltm;
557 MBadPixelsCalc bpcal;
558 MBadPixelsTreat treat;
559
560 //bpcal.SetNamePedPhotCam("MPedPhotFromExtractor");
561 bpcal.SetNamePedPhotCam("MPedPhotFromExtractorRndm");
562
563 //treat.AddNamePedPhotCam("MPedPhotFundamental");
564 treat.AddNamePedPhotCam("MPedPhotFromExtractor");
565 treat.AddNamePedPhotCam("MPedPhotFromExtractorRndm");
566 if (!extractor2 && !extractor1->InheritsFrom("MExtractTimeAndCharge"))
567 treat.SetProcessTimes(kFALSE);
568
569 MHCamEvent evt0( 0, "PedFLG", "Fundamental Pedestal from Lo Gain;;P [cnts/sl]");
570 MHCamEvent evt1( 2, "PedRmsFLG", "RMS from Extractor applied to ped.;;\\sigma_{p} [cnts/sl]");
571 MHCamEvent evt2( 0, "Extra'd", "Extracted Signal;;S [cnts/sl]");
572 // MHCamEvent evt3(4, "PedPhot", "Calibrated Pedestal;;P [phe]");
573 MHCamEvent evt4( 5, "PedRMS", "Calibrated RMS from Extractor applied to ped.;;\\sigma_{p} [phe]");
574 MHCamEvent evt5( 0, "Interp'd", "Interpolated Signal scaled with A/A_{0};;S [phe]");
575 MHCamEvent evt6(102, "Unsuitable", "Fraction of unsuitable events per Pixel;;[1]");
576 // MHCamEvent evt7( 6, "Times", "Calibrated Arrival Time;;T [fadc sl]");
577 MHCamEvent evt8( 0, "Conv", "Calibration Conv. Factors;;[phe/cnts]");
578 MHCamEvent evt9( 7, "PulsePos", "Pulse Position of cosmics (>50phe);;T [ns]");
579 MHCamEvent evtR( 4, "HiLoCal", "Hi-/Lo-Gain ratio;;Ratio");
580 MHCamEvent evtO( 7, "HiLoOff", "Lo-/Hi-Gain Offset;;Offset");
581 evt2.SetErrorSpread(kFALSE);
582 evt5.SetErrorSpread(kFALSE);
583 evt6.SetErrorSpread(kFALSE);
584 evt6.SetThreshold();
585
586 MFillH fill0(&evt0, "MPedestalFundamental", "FillPedFLG");
587 MFillH fill1(&evt1, "MPedestalFromExtractorRndm", "FillPedRmsFLG");
588 MFillH fill2(&evt2, "MExtractedSignalCam", "FillExtracted");
589 // MFillH fill3(&evt3, "MPedPhotFundamental", "FillPedPhot");
590 MFillH fill4(&evt4, "MPedPhotFromExtractorRndm", "FillPedRMS");
591 MFillH fill5(&evt5, "MSignalCam", "FillInterpolated");
592 MFillH fill6(&evt6, "MBadPixelsCam", "FillUnsuitable");
593 // MFillH fill7(&evt7, "MSignalCam", "FillTimes");
594 MFillH fill8(&evt8, "MCalibConstCam", "FillConv");
595 MFillH fill9(&evt9, "MSignalCam", "FillPulse");
596 MFillH fillR(&evtR, "MExtractedSignalCam", "FillHiLoCal");
597 MFillH fillO(&evtO, "MArrivalTimeCam", "FillHiLoOff");
598
599 MHVsTime histbp("MBadPixelsCam.GetNumUnsuitable");
600 histbp.SetName("BadPixTm");
601 histbp.SetTitle("Number of unsuitable pixels;;N");
602 histbp.SetMinimum(0);
603
604 MHVsTime histdp("MSignalCam.GetNumPixelsUnmapped");
605 histdp.SetName("DeadPixTm");
606 histdp.SetTitle("Number of dead/unmapped pixels;;N");
607 histdp.SetMinimum(0);
608
609 // Task to fill the histogram
610 MFillH fillB(&histbp, "MTime", "FillBadPixTm");
611 MFillH fillD(&histdp, "MTime", "FillDeadPixTm");
612 fillB.SetNameTab("BadPixTm");
613 fillD.SetNameTab("DeadPixTm");
614
615 /*
616 MFillH fillP("MHPulseShape", "", "FillPulseShape");
617 fillP.SetNameTab("Pulse");
618 */
619
620 if (!extractor1->HasLoGain())
621 {
622 fill0.SetFilter(&ftp2);
623 fill1.SetFilter(&ftp2);
624 }
625
626 /*
627 MHVsTime hbadpix("MBadPixelsCam.GetNumUnsuitable");
628 hbadpix.SetNumEvents(50);
629 MFillH fillB(&hbadpix, "MTime");
630 */
631
632 MTaskEnv fillflorian("FinalFantasy");
633 fillflorian.SetDefault();
634
635 // The second rule is for the case reading raw-files!
636 MWriteRootFile write(2, fname, fOverwrite?"RECREATE":"NEW");
637 // Run Header
638 write.AddContainer("MRawRunHeader", "RunHeaders");
639// write.AddContainer("MBadPixelsCam", "RunHeaders");
640 write.AddContainer("MGeomCam", "RunHeaders");
641 // Monte Carlo Headers
642 write.AddContainer("MMcRunHeader", "RunHeaders", kFALSE);
643 write.AddContainer("MMcFadcHeader", "RunHeaders", kFALSE);
644 write.AddContainer("MMcTrigHeader", "RunHeaders", kFALSE);
645 write.AddContainer("MMcConfigRunHeader", "RunHeaders", kFALSE);
646 write.AddContainer("MMcCorsikaRunHeader", "RunHeaders", kFALSE);
647 // Monte Carlo
648 write.AddContainer("MMcEvt", "Events", kFALSE);
649 write.AddContainer("MMcTrig", "Events", kFALSE);
650 // Data tree
651 write.AddContainer("MSignalCam", "Events");
652 // write.AddContainer("MPedPhotFundamental", "Events");
653 write.AddContainer("MPedPhotFromExtractor", "Events");
654 write.AddContainer("MPedPhotFromExtractorRndm", "Events");
655 write.AddContainer("MTime", "Events", kFALSE);
656 write.AddContainer("MRawEvtHeader", "Events");
657
658 // Slow-Control: Current-tree
659 write.AddContainer("MTimeCurrents", "Currents", kFALSE);
660 write.AddContainer("MCameraDC", "Currents", kFALSE);
661 write.AddContainer("MReportCurrents", "Currents", kFALSE);
662 // Slow-Control: Camera-tree
663 write.AddContainer("MReportCamera", "Camera", kFALSE);
664 write.AddContainer("MTimeCamera", "Camera", kFALSE);
665 write.AddContainer("MCameraAUX", "Camera", kFALSE);
666 write.AddContainer("MCameraCalibration", "Camera", kFALSE);
667 write.AddContainer("MCameraCooling", "Camera", kFALSE);
668 write.AddContainer("MCameraHV", "Camera", kFALSE);
669 write.AddContainer("MCameraLV", "Camera", kFALSE);
670 write.AddContainer("MCameraLids", "Camera", kFALSE);
671 // Slow-Control: Trigger-tree
672 write.AddContainer("MReportTrigger", "Trigger", kFALSE);
673 write.AddContainer("MTimeTrigger", "Trigger", kFALSE);
674 // Slow-Control: Drive-tree
675 write.AddContainer("MReportDrive", "Drive", kFALSE);
676 write.AddContainer("MTimeDrive", "Drive", kFALSE);
677 // Slow-Control: Central Control-tree
678 write.AddContainer("MReportCC", "CC", kFALSE);
679 write.AddContainer("MTimeCC", "CC", kFALSE);
680
681 // Write the special MC tree
682 MWriteRootFile writemc(2, fname, fOverwrite?"RECREATE":"NEW");
683 writemc.SetName("WriteMC");
684 writemc.AddContainer("MMcEvtBasic", "OriginalMC");
685
686 // Write the special calib tree
687 /*
688 MWriteRootFile writecal(2, fname, fOverwrite?"RECREATE":"NEW");
689 writecal.SetName("WriteCalib");
690 writecal.AddContainer("MBadPixelsCam", "Calib");
691 writecal.AddContainer("MCalibrationChargeCam", "Calib");
692 writecal.AddContainer("MCalibrationRelTimeCam", "Calib");
693 */
694
695 // Now setup tasklist for events
696 MTaskList tlist2;
697
698 tlist2.AddToList(&caldec);
699 tlist2.AddToList(&decode);
700 tlist2.AddToList(&apply);
701 //tlist2.AddToList(&merge);
702 tlist2.AddToList(&pedsub);
703 tlist2.AddToList(&ftp2);
704 tlist2.AddToList(&pedlo1);
705 tlist2.AddToList(&pedlo2);
706 tlist2.AddToList(&pedlo3);
707 tlist2.AddToList(&fill0); // fill pedestal events
708 tlist2.AddToList(&fill1); // fill pedestal events
709
710 //-----------------------------------------------------------
711
712 MTaskList tlist3;
713 tlist3.SetFilter(&fcalib);
714
715 //MFDataPhrase filcalco("MCalibrationConstCam.IsReadyToSave>0.5", "CalibConstFilter");
716 if (fIsInterlaced)
717 {
718 tlist2.AddToList(&fcalib); // MFTriggerPattern
719 tlist2.AddToList(&tlist3);
720 if (IsUsePINDiode())
721 tlist3.AddToList(&pinext); // MExtractPINDiode
722 if (IsUseBlindPixel())
723 tlist3.AddToList(&bldext); // MExtractBlindPixel
724 tlist3.AddToList(&taskenv3);
725 tlist3.AddToList(&pacalc); // MCalibCalcFromPast
726 /*
727 tlist3.AddToList(&filcalco); // CalibConstFilter (IsReadyToSave)
728 fill8.SetFilter(&filcalco);
729 tlist3.AddToList(&fill8); // FillConvUpd
730 */
731
732 tlist3.AddToList(&filcam); // FillChargeCam
733 if (fIsRelTimesUpdate)
734 tlist3.AddToList(&filtme); // FillRelTime
735 if (IsUseBlindPixel())
736 tlist3.AddToList(&filbnd); // FillBlindCam
737 if (IsUsePINDiode())
738 tlist3.AddToList(&filpin); // FillPINDiode
739 tlist3.AddToList(&chcalc); // MCalibrationChargeCalc
740 if (fIsRelTimesUpdate)
741 tlist3.AddToList(&recalc); // MCalibrationRelTimeCam
742
743 //tlist3.AddToList(&writecal); // MWriteRootFile
744 }
745
746 // Continue for all non-cosmic events
747 if (!extractor1->HasLoGain())
748 tlist2.AddToList(&contftp2); // remove pedestal events from processing
749 tlist2.AddToList(&conttp); // remove calib events from processing
750 if (extractor1)
751 tlist2.AddToList(&taskenv1);
752 if (extractor2)
753 tlist2.AddToList(&taskenv2);
754 tlist2.AddToList(&contcos); // MFCosmics (ContTrigEvts)
755 /*
756 if (fIsHiLoCalibration)
757 {
758 plist.AddToList(&hilocam);
759 tlist2.AddToList(&filhil);
760 }
761
762 if (fIsPulsePosCheck)
763 {
764 plist.AddToList(&hpulcam);
765 tlist2.AddToList(&filpul);
766 }
767 */
768 tlist2.AddToList(&fill2);
769 tlist2.AddToList(&fill8); // FillConv
770 tlist2.AddToList(&calib); // MCalibrateData
771 if (extractor2 || extractor1->InheritsFrom("MExtractTimeAndCharge"))
772 tlist2.AddToList(&caltm);
773
774 tlist2.AddToList(&bpcal); // MBadPixelsCalc
775 tlist2.AddToList(&treat); // MBadPixelsTreat
776 tlist2.AddToList(&fill6);
777 // tlist2.AddToList(&fill3);
778 tlist2.AddToList(&fill4);
779 tlist2.AddToList(&fill5);
780 //if (extractor2 || extractor1->InheritsFrom("MExtractTimeAndCharge"))
781 // tlist2.AddToList(&fill7);
782 tlist2.AddToList(&fill9);
783 if (!fSequence.IsMonteCarlo())
784 {
785 tlist2.AddToList(&fillB);
786 tlist2.AddToList(&fillD);
787 }
788 if (extractor1->HasLoGain())
789 {
790 tlist2.AddToList(&fillR);
791 tlist2.AddToList(&fillO);
792 }
793
794 /*
795 MFillH fillC("MHCleaning", "", "FillClean");
796 tlist2.AddToList(&fillC);
797
798 //tlist2.AddToList(&fillP);
799 */
800
801 // ----- Start: Code for encoding movies -----
802
803 MMoviePrepare movprep;
804 MMovieWrite movwrite;
805 movprep.SetRangeFromExtractor(*extractor1);
806
807 //MFDataPhrase movfilt("MMovieData.fMax>150");
808 MFDataPhrase movfilt("MMovieData.fMax>5*MMovieData.fMedianPedestalRms", "MovieFilter");
809
810 MImgCleanStd movclean(8.5, 4.0);
811 movclean.SetMethod(MImgCleanStd::kAbsolute);
812
813 //movprep.SetFilter(&evtnum);
814 movclean.SetFilter(&movfilt);
815 movwrite.SetFilter(&movfilt);
816
817 MTaskList tlistmov("MovieEncoder");
818 tlistmov.AddToList(&movprep);
819 tlistmov.AddToList(&movfilt);
820 tlistmov.AddToList(&movclean);
821 tlistmov.AddToList(&movwrite);
822
823 MFEvtNumber evtnum;
824 //evtnum.SetSelector("ThetaSquared.fVal<0.04");
825 //evtnum.SetFileName("ganymed00000001.root");
826 tlistmov.SetFilter(&evtnum);
827
828 if (fIsMovieMode)
829 {
830 tlist2.AddToList(&evtnum);
831 tlist2.AddToList(&tlistmov);
832 }
833
834 // ----- End: Code for encoding movies -----
835
836 tlist2.AddToList(&fillflorian);
837
838 // Setup List for Drive-tree
839 //MPointingPosCalc pcalc;
840
841 // Now setup main tasklist
842 tlist.AddToList(read);
843
844 if (fSequence.IsMonteCarlo())
845 {
846 if (!fIsMovieMode)
847 tlist.AddToList(&writemc);
848 tlist.AddToList(&contmc);
849 }
850
851 //if (IsUseRootData())
852 // tlist2.AddToList(&pextr);
853 tlist.AddToList(&tlist2, fSequence.IsMonteCarlo() ? "Events" : "All");
854
855 //if (fSequence.IsMonteCarlo())
856 // tlist.AddToList(&pcalc, "Drive");
857
858 if (!fIsMovieMode)
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 interlacedcont.Add(&pulcam);
900 */
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())
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.