Context Navigation

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

Visit:

Last change on this file since 8898 was 8898, checked in by tbretz, 17 years ago
* empty log message *
File size: 33.5 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-2008
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 "MH3.h"
62	#include "MHCamEvent.h"
63	#include "MHVsTime.h"
64
65	// Calibration containers
66	#include "MCalibrationQECam.h"
67	#include "MCalibrationBlindCam.h"
68	#include "MCalibrationChargeCam.h"
69	#include "MCalibrationRelTimeCam.h"
70	#include "MCalibrationChargePINDiode.h"
71
72	// Calibration histograms
73	#include "MHCalibrationChargeCam.h"
74	#include "MHCalibrationChargeBlindCam.h"
75	#include "MHCalibrationChargePINDiode.h"
76	#include "MHCalibrationRelTimeCam.h"
77
78	// Tasks
79	#include "MReadMarsFile.h"
80	#include "MRawFileRead.h"
81	#include "MTaskEnv.h"
82	#include "MContinue.h"
83	#include "MFillH.h"
84	#include "MGeomApply.h"
85	#include "MExtractTimeAndCharge.h"
86	#include "MTriggerPatternDecode.h"
87	#include "MCalibrationPatternDecode.h"
88	#include "MCalibrationChargeCalc.h"
89	#include "MCalibrationRelTimeCalc.h"
90	#include "MCalibCalcFromPast.h"
91	#include "MPedestalSubtract.h"
92	#include "MPedCalcFromLoGain.h"
93	#include "MCalibrateData.h"
94	#include "MExtractPINDiode.h"
95	#include "MExtractBlindPixel.h"
96	#include "MCalibrateRelTimes.h"
97	#include "MBadPixelsCalc.h"
98	#include "MBadPixelsTreat.h"
99	#include "MWriteRootFile.h"
100
101	// Filter
102	#include "MFTriggerPattern.h"
103	#include "MFCosmics.h"
104	#include "MFilterList.h"
105	#include "MFDataPhrase.h"
106
107	// Classes for writing movies
108	#include "MFEvtNumber.h"
109	#include "MMoviePrepare.h"
110	#include "MMovieWrite.h"
111	#include "MImgCleanStd.h"
112
113
114	ClassImp(MJCalibrateSignal);
115
116	using namespace std;
117
118	// --------------------------------------------------------------------------
119	//
120	// Default constructor.
121	//
122	// Sets:
123	// - fIsInterlaced to kTRUE
124	// - fIsRelTimesUpdate to kFALSE
125	// - fIsHiLoCalibration to kFALSE
126	//
127	MJCalibrateSignal::MJCalibrateSignal(const char name, const char title)
128	: fExtractor(0), fIsInterlaced(kTRUE), fIsRelTimesUpdate(kTRUE), fIsMovieMode(kFALSE)
129	{
130	fName = name ? name : "MJCalibrateSignal";
131	fTitle = title ? title : "Tool to calibrate data";
132	}
133
134	MJCalibrateSignal::~MJCalibrateSignal()
135	{
136	if (fExtractor)
137	delete fExtractor;
138	}
139
140	void MJCalibrateSignal::SetExtractor(const MExtractor *ext)
141	{
142	if (fExtractor)
143	delete fExtractor;
144
145	fExtractor = ext ? (MExtractor*)ext->Clone() : NULL;
146	}
147
148	Bool_t MJCalibrateSignal::WriteResult() const
149	{
150	if (IsNoStorage() \|\| fIsMovieMode)
151	return kTRUE;
152
153	// FIXME: This is not nice because it will update the signal
154	// file always. Which might make the usage outside of
155	// callisto difficult.
156	TObjArray cont;
157	cont.Add(const_cast<TEnv*>(GetEnv()));
158	cont.Add(const_cast<MSequence*>(&fSequence));
159
160	if (fDisplay)
161	cont.Add(fDisplay);
162
163	const TString name(Form("signal%08d.root", fSequence.GetSequence()));
164	return WriteContainer(cont, name, "UPDATE");
165	}
166
167	Bool_t MJCalibrateSignal::ReadCalibration(TObjArray &l, MBadPixelsCam &cam, MExtractor* &ext2, MExtractor* &ext3, TString &geom) const
168	{
169	TString fname = Form("%s/calib%08d.root", fPathIn.Data(), fSequence.GetSequence());
170
171	*fLog << inf << "Reading from file: " << fname << endl;
172
173	TFile file(fname, "READ");
174	if (!file.IsOpen())
175	{
176	*fLog << err << dbginf << "ERROR - Could not open file " << fname << endl;
177	return kFALSE;
178	}
179
180	TObject *o = file.Get("ExtractSignal");
181	if (o && !o->InheritsFrom(MExtractor::Class()))
182	{
183	*fLog << err << dbginf << "ERROR - ExtractSignal read from " << fname << " doesn't inherit from MExtractor!" << endl;
184	return kFALSE;
185	}
186	ext3 = o ? (MExtractor*)o->Clone() : NULL;
187
188	o = file.Get("ExtractTime");
189	if (o && !o->InheritsFrom(MExtractor::Class()))
190	{
191	*fLog << err << dbginf << "ERROR - ExtractTime read from " << fname << " doesn't inherit from MExtractor!" << endl;
192	return kFALSE;
193	}
194	ext2 = o ? (MExtractor*)o->Clone() : NULL;
195	if (!ext3 && !ext2)
196	{
197	*fLog << err << dbginf << "ERROR - Neither ExtractSignal nor ExrtractTime found in " << fname << "!" << endl;
198	return kFALSE;
199	}
200
201	o = file.Get("MGeomCam");
202	if (o && !o->InheritsFrom(MGeomCam::Class()))
203	{
204	*fLog << err << dbginf << "ERROR - MGeomCam read from " << fname << " doesn't inherit from MGeomCam!" << endl;
205	return kFALSE;
206	}
207	geom = o ? o->ClassName() : "";
208
209	TObjArray cont(l);
210	cont.Add(&cam);
211	return ReadContainer(cont);
212	}
213
214	// --------------------------------------------------------------------------
215	//
216	// MJCalibration allows to setup several option by a resource file:
217	// MJCalibrateSignal.RawData: yes,no
218	//
219	// For more details see the class description and the corresponding Getters
220	//
221	Bool_t MJCalibrateSignal::CheckEnvLocal()
222	{
223	SetInterlaced(GetEnv("Interlaced", fIsInterlaced));
224	SetRelTimesUpdate(GetEnv("RelTimesUpdate", fIsRelTimesUpdate));
225	SetMovieMode(GetEnv("MovieMode", fIsMovieMode));
226
227	return MJCalib::CheckEnvLocal();
228	}
229
230	#include "MParameterCalc.h" // FIXME
231	Bool_t MJCalibrateSignal::Process(MPedestalCam &pedcamab, MPedestalCam &pedcambias,
232	MPedestalCam &pedcamextr)
233	{
234	if (!fSequence.IsValid())
235	{
236	*fLog << err << "ERROR - Sequence invalid..." << endl;
237	return kFALSE;
238	}
239
240	*fLog << inf;
241	fLog->Separator(GetDescriptor());
242	*fLog << "Calculate calibrated data from Sequence #";
243	*fLog << fSequence.GetSequence() << endl << endl;
244
245
246	//if (!CheckEnv())
247	// return kFALSE;
248
249	CheckEnv();
250
251	// --------------------------------------------------------------------------------
252
253	MDirIter iter;
254	if (fSequence.IsValid())
255	{
256	if (fSequence.SetupDatRuns(iter, 0, !fSequence.IsMonteCarlo())<=0)
257	return kFALSE;
258	}
259
260	// Read File
261	MHCalibrationChargeCam hchacam;
262	MHCalibrationChargeBlindCam hbndcam;
263	MHCalibrationChargePINDiode hpndiod;
264	MHCalibrationRelTimeCam hrelcam;
265	//MHCalibrationHiLoCam hilocam;
266	//MHCalibrationPulseTimeCam hpulcam;
267
268	hchacam.SetOscillations(kFALSE);
269	hbndcam.SetOscillations(kFALSE);
270	hrelcam.SetOscillations(kFALSE);
271
272	MCalibrationChargeCam calcam;
273	MCalibrationQECam qecam;
274	MCalibrationBlindCam bndcam;
275	MCalibrationChargePINDiode pind;
276	MCalibrationRelTimeCam tmcam;
277	//MCalibrationHiLoCam hilcam;
278	//MCalibrationPulseTimeCam pulcam;
279
280	MBadPixelsCam badpix;
281
282	TObjArray interlacedcont;
283	if (fIsInterlaced)
284	{
285	interlacedcont.Add(&hchacam);
286	if (IsUseBlindPixel())
287	interlacedcont.Add(&hbndcam);
288	if (IsUsePINDiode())
289	interlacedcont.Add(&hpndiod);
290	if (fIsRelTimesUpdate)
291	interlacedcont.Add(&hrelcam);
292	}
293
294	MExtractor *extractor1=fExtractor;
295	MExtractor *extractor2=0;
296	MExtractor *extractor3=0;
297	TString geom;
298
299	TObjArray calibcont;
300	calibcont.Add(&calcam);
301	calibcont.Add(&qecam);
302	calibcont.Add(&bndcam);
303	calibcont.Add(&tmcam);
304	if (IsUseBlindPixel())
305	calibcont.Add(&bndcam);
306
307	if (!ReadCalibration(calibcont, badpix, extractor2, extractor3, geom))
308	return kFALSE;
309
310	*fLog << all;
311	if (!geom.IsNull())
312	*fLog << inf << "Camera geometry found in file: " << geom << endl;
313	else
314	*fLog << inf << "No Camera geometry found using default <MGeomCamMagic>" << endl;
315
316	if (extractor3)
317	{
318	*fLog << underline << "Signal Extractor found in calibration file" << endl;
319	extractor3->Print();
320	*fLog << endl;
321	}
322	else
323	*fLog << inf << "No Signal Extractor: ExtractSignal in file." << endl;
324
325
326	if (extractor1)
327	{
328	*fLog << underline << "Modified Signal Extractor set by user." << endl;
329	extractor1->Print();
330	*fLog << endl;
331	}
332	else
333	{
334	*fLog << inf << "No modified Signal Extractor set by user... using ExtractSignal." << endl;
335	extractor1 = extractor3 ? (MExtractor*)extractor3->Clone() : 0;
336	}
337
338	if (extractor2)
339	{
340	*fLog << underline << "Time Extractor found in calibration file" << endl;
341	extractor2->Print();
342	*fLog << endl;
343	}
344	else
345	*fLog << inf << "No Time Extractor: ExtractTime in file." << endl;
346
347	// This is necessary for the case in which it is not in the files
348	MCalibConstCam constcam;
349
350	//MBadPixelsCam badcam;
351	constcam.SetBadPixels(&badpix);
352
353	// Setup Parlist
354	MParList plist;
355	plist.AddToList(this); // take care of fDisplay!
356	plist.AddToList(&badpix);
357	plist.AddToList(&constcam);
358	//plist.AddToList(&hilcam);
359	plist.AddToList(&calibcont); // Using AddToList(TObjArray *)
360	plist.AddToList(&interlacedcont); // Using AddToList(TObjArray *)
361	//plist.AddToList(&pulcam);
362
363	// Setup Tasklist
364	MTaskList tlist;
365	plist.AddToList(&tlist);
366
367	MReadMarsFile readmc("Events");
368	readmc.DisableAutoScheme();
369
370	MRawFileRead rawread(NULL);
371
372	MRead read = fSequence.IsMonteCarlo() ? (MRead)&readmc : (MRead*)&rawread;
373	read->AddFiles(iter);
374
375	const TString fname(Form("%s{s/_D_/_Y_}{s/\\.raw$/.root}{s/\\.raw\\.gz$/.root}", fPathOut.Data()));
376
377	// Skips MC which have no contents. This are precisely the
378	// events which fullfilled the MC Lvl1 trigger and an
379	// arbitrary cut (typically at 50phe) to speed up simulation
380	MContinue contmc("MRawEvtData.GetNumPixels<0.5", "ContEmptyMC");
381
382	//MPointingPosInterpolate pextr;
383	//pextr.AddFiles(&iter);
384
385	MGeomApply apply; // Only necessary to create geometry
386	if (!geom.IsNull())
387	apply.SetGeometry(geom);
388	//MBadPixelsMerge merge(&badpix);
389
390	// Make sure that pedcamab has the correct name
391	pedcamab.SetName("MPedestalFundamental");
392	pedcamextr.SetName("MPedestalFromExtractorRndm");
393	pedcambias.SetName("MPedestalFromExtractor");
394	plist.AddToList(&pedcamextr);
395	plist.AddToList(&pedcambias);
396	plist.AddToList(&pedcamab);
397
398	MArrivalTimeCam timecam;
399	plist.AddToList(&timecam);
400
401	// Check for interleaved events
402	MCalibrationPatternDecode caldec;
403	MTriggerPatternDecode decode;
404
405	MH3 hpat("MRawRunHeader.fRunNumber", "MTriggerPattern.GetUnprescaled");
406	hpat.SetWeight("1./MRawRunHeader.GetRunLength");
407	hpat.SetName("TrigPat");
408	hpat.SetTitle("Rate of the trigger pattern [Hz];Run Number;Trigger Pattern;Rate [Hz]");
409	hpat.InitLabels(MH3::kLabelsXY);
410	//hpat.DefineLabelsY("1=Lvl1;2=Cal;3=Cal;4=Lvl2;5=Cal;7=Cal;8=Ped;9=Ped+Trig;13=Ped+Trig;16=Pin;32=Sum");
411	hpat.DefaultLabelY("UNKNOWN");
412	hpat.DefineLabelY( 0, "0"); // 0: No pattern
413	hpat.DefineLabelY( 1, "Trig"); // Lvl1
414	hpat.DefineLabelY( 2, "Cal"); // Cal
415	hpat.DefineLabelY( 3, "Cal"); // Cal+Lvl1
416	hpat.DefineLabelY( 4, "Trig"); // Lvl2
417	hpat.DefineLabelY( 5, "Trig"); // Lvl1+Lvl2
418	hpat.DefineLabelY( 7, "Cal"); // Cal+Lvl1+Lvl2
419	hpat.DefineLabelY( 8, "Ped"); // Ped
420	hpat.DefineLabelY( 9, "Ped+Trig"); // Ped+Lvl1
421	hpat.DefineLabelY(13, "Ped+Trig"); // Ped+Lvl2
422	hpat.DefineLabelY(16, "Pin");
423	hpat.DefineLabelY(32, "Sum"); // Sum
424	hpat.DefineLabelY(33, "Sum"); // Sum+Lvl1
425	hpat.DefineLabelY(37, "Sum"); // Sum+Lvl1+Lvl2
426
427	MFillH fillpat(&hpat, "", "FillPattern");
428	fillpat.SetDrawOption("box");
429
430	// This will make that for data with version less than 5, where
431	// trigger patterns were not yet correct, all the events in the real
432	// data file will be processed. In any case there are no interleaved
433	// calibration events in such data, so this is fine.
434	// We allow only cosmics triggered events to pass (before prescaling)
435	MFTriggerPattern fcalped;
436	fcalped.SetInverted();
437	fcalped.SetDefault(kTRUE);
438	fcalped.DenyAll();
439	fcalped.AllowTriggerLvl1();
440	fcalped.AllowTriggerLvl2();
441	//fcalped.AllowSumTrigger();
442
443	// This will skip interleaved events with a cal- or ped-trigger
444	MContinue contcalped(&fcalped, "ContTrigPattern");
445
446	// Create the pedestal subtracted raw-data
447	MPedestalSubtract pedsub;
448	pedsub.SetPedestalCam(&pedcamab);
449
450	// Do signal and pedestal calculation
451	MPedCalcFromLoGain pedlo1("MPedCalcFundamental");
452	pedlo1.SetPedestalUpdate(kTRUE);
453	pedlo1.SetNamePedestalCamOut("MPedestalFundamental");
454
455	MPedCalcFromLoGain pedlo2("MPedCalcWithExtractorRndm");
456	pedlo2.SetPedestalUpdate(kTRUE);
457	pedlo2.SetRandomCalculation(kTRUE);
458	pedlo2.SetNamePedestalCamOut("MPedestalFromExtractorRndm");
459
460	MPedCalcFromLoGain pedlo3("MPedCalcWithExtractor");
461	pedlo3.SetPedestalUpdate(kTRUE);
462	pedlo3.SetRandomCalculation(kFALSE);
463	pedlo3.SetNamePedestalCamOut("MPedestalFromExtractor");
464
465	if (!extractor1)
466	{
467	*fLog << err << "ERROR - extractor1 == NULL" << endl;
468	return kFALSE;
469	}
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	//------------------------------
497	//
498	// this is the filter to find pedestal events. For the Siegen FADC
499	// these are all events which are not calibration events because
500	// the pedestal is extracted from the lo-gain signal. For MUX
501	// data this are artifiially triggered events with the pedestal
502	// trigger flag, and for safty without Lvl1 or Lvl2 flag)
503	//
504	// For the time "before" the trigger pattern all events (Siegen FADC)
505	// can be considered to be pedestal, because this was also the time
506	// without artifially calibration events
507	//
508	// Deny or allow is done before prescaling.
509	//
510	MFTriggerPattern fped;
511	fped.SetDefault(kTRUE);
512	fped.DenyCalibration();
513	if (!extractor1->HasLoGain())
514	{
515	fped.DenyAll();
516	fped.RequirePedestal();
517	}
518
519	//------------------------------
520	//
521	// Apply a filter against cosmics (this is to make sure that the
522	// trigger system was working properly and no empty events survive)
523	// For every event 5% of the pixel must not be empty. In PostProcess
524	// an error is raised if more than 50% of the events were skipped.
525	//
526	MFCosmics fcosmicscal;
527	fcosmicscal.SetNamePedestalCam("MPedestalFundamental"); //CORRECT?
528	fcosmicscal.SetMaxEmptyPixels(0.05);
529	fcosmicscal.SetMaxAcceptedFraction(0.5);
530
531	MContinue contcoscal(&fcosmicscal, "ContCosmicsCal");
532	contcoscal.SetInverted();
533
534	//------------------------------
535	/*
536	MFCosmics fcosmicsped; // Def=20% empty pixels
537	fcosmicsped.SetNamePedestalCam("MPedestalFundamental"); //CORRECT?
538	MContinue contcosped(&fcosmicsped, "ContCosmicsPed");
539	contcosped.SetInverted();
540	*/
541
542	//------------------------------
543	//
544	// Thie signal extractors
545	//
546	MTaskEnv taskenv1("ExtractSignal");
547	MTaskEnv taskenv2("ExtractTime");
548	MTaskEnv taskenv3("ExtractInterlaced");
549	taskenv1.SetDefault(extractor1);
550	taskenv2.SetDefault(extractor2);
551	taskenv3.SetDefault(extractor3);
552
553	//
554	// This is new calibration to photo-electrons, hard-coded
555	// as decided at the Wuerzburg software meeting 26.01.05
556	//
557	MCalibrateData calib;
558	calib.SetSignalType(MCalibrateData::kPhe);
559	//calib.AddPedestal("Fundamental");
560	calib.AddPedestal("FromExtractor");
561	calib.AddPedestal("FromExtractorRndm");
562	calib.SetPedestalFlag(MCalibrateData::kEvent);
563
564	//----------------------------------------------------------
565
566	MExtractPINDiode pinext;
567	MExtractBlindPixel bldext;
568
569	// Execute for all events with the calibration trigger. If no
570	// trigger pattern is available do not execute it
571	// The selection is done before prescaling.
572	MFTriggerPattern fcalib("CalibFilter");
573	fcalib.SetDefault(kFALSE);
574	fcalib.DenyAll();
575	fcalib.RequireCalibration();
576
577	MCalibrationChargeCalc chcalc;
578	chcalc.SetContinousCalibration();
579	chcalc.SetExtractor(extractor3);
580
581	MCalibrationRelTimeCalc recalc;
582	MCalibCalcFromPast pacalc;
583
584	chcalc.SetPedestals(&pedcamextr);
585
586	pacalc.SetChargeCalc(&chcalc);
587	if (fIsRelTimesUpdate)
588	pacalc.SetRelTimeCalc(&recalc);
589	pacalc.SetCalibrate(&calib);
590
591	//
592	// Calibration histogramming
593	//
594	MFillH filpin(&hpndiod, "MExtractedSignalPINDiode", "FillPINDiode");
595	MFillH filbnd(&hbndcam, "MExtractedSignalBlindPixel", "FillBlindCam");
596	MFillH filcam(&hchacam, "MExtractedSignalCam", "FillChargeCam");
597	MFillH filtme(&hrelcam, "MArrivalTimeCam", "FillRelTime");
598	//MFillH filhil(&hilocam, "MExtractedSignalCam", "FillHiLoRatio");
599	//MFillH filpul(&hpulcam, "MRawEvtData", "FillPulseTime");
600	filpin.SetBit(MFillH::kDoNotDisplay);
601	filbnd.SetBit(MFillH::kDoNotDisplay);
602	filcam.SetBit(MFillH::kDoNotDisplay);
603	filtme.SetBit(MFillH::kDoNotDisplay);
604	//filhil.SetBit(MFillH::kDoNotDisplay);
605	//filpul.SetBit(MFillH::kDoNotDisplay);
606
607	MCalibrateRelTimes caltm;
608	MBadPixelsCalc bpcal;
609	MBadPixelsTreat treat;
610
611	//bpcal.SetNamePedPhotCam("MPedPhotFromExtractor");
612	bpcal.SetNamePedPhotCam("MPedPhotFromExtractorRndm");
613
614	//treat.AddNamePedPhotCam("MPedPhotFundamental");
615	treat.AddNamePedPhotCam("MPedPhotFromExtractor");
616	treat.AddNamePedPhotCam("MPedPhotFromExtractorRndm");
617	if (!extractor2 && !extractor1->InheritsFrom("MExtractTimeAndCharge"))
618	treat.SetProcessTimes(kFALSE);
619
620	MHCamEvent evt0( 0, "PedFLG", "Fundamental Pedestal from Lo Gain;;P [cnts/sl]");
621	MHCamEvent evt1( 2, "PedRmsFLG", "RMS from Extractor applied to ped.;;\\sigma_{p} [cnts/sl]");
622	MHCamEvent evt2( 0, "Extra'd", "Extracted Signal;;S [cnts/sl]");
623	// MHCamEvent evt3(4, "PedPhot", "Calibrated Pedestal;;P [phe]");
624	MHCamEvent evt4( 5, "PedRMS", "Calibrated RMS from Extractor applied to ped.;;\\sigma_{p} [phe]");
625	MHCamEvent evt5( 0, "Interp'd", "Interpolated Signal scaled with A/A_{0};;S [phe]");
626	MHCamEvent evt6(102, "Unsuitable", "Fraction of unsuitable events per Pixel;;[1]");
627	// MHCamEvent evt7( 6, "Times", "Calibrated Arrival Time;;T [fadc sl]");
628	MHCamEvent evt8( 0, "Conv", "Calibration Conv. Factors;;[phe/cnts]");
629	MHCamEvent evt9( 7, "PulsePos", "Pulse Position of cosmics (>50phe);;T [ns]");
630	MHCamEvent evtR( 4, "HiLoCal", "Hi-/Lo-Gain ratio;;Ratio");
631	MHCamEvent evtO( 7, "HiLoOff", "Lo-/Hi-Gain Offset;;Offset");
632	evt2.SetErrorSpread(kFALSE);
633	evt5.SetErrorSpread(kFALSE);
634	evt6.SetErrorSpread(kFALSE);
635	evt6.SetThreshold();
636
637	MFillH fill0(&evt0, "MPedestalFundamental", "FillPedFLG");
638	MFillH fill1(&evt1, "MPedestalFromExtractorRndm", "FillPedRmsFLG");
639	MFillH fill2(&evt2, "MExtractedSignalCam", "FillExtracted");
640	// MFillH fill3(&evt3, "MPedPhotFundamental", "FillPedPhot");
641	MFillH fill4(&evt4, "MPedPhotFromExtractorRndm", "FillPedRMS");
642	MFillH fill5(&evt5, "MSignalCam", "FillInterpolated");
643	MFillH fill6(&evt6, "MBadPixelsCam", "FillUnsuitable");
644	// MFillH fill7(&evt7, "MSignalCam", "FillTimes");
645	MFillH fill8(&evt8, "MCalibConstCam", "FillConv");
646	MFillH fill9(&evt9, "MSignalCam", "FillPulse");
647	MFillH fillR(&evtR, "MExtractedSignalCam", "FillHiLoCal");
648	MFillH fillO(&evtO, "MArrivalTimeCam", "FillHiLoOff");
649
650	MHVsTime histbp("MBadPixelsCam.GetNumUnsuitable");
651	histbp.SetName("BadPixTm");
652	histbp.SetTitle("Number of unsuitable pixels;;N");
653	histbp.SetMinimum(0);
654
655	MHVsTime histdp("MSignalCam.GetNumPixelsUnmapped");
656	histdp.SetName("DeadPixTm");
657	histdp.SetTitle("Number of dead/unmapped pixels;;N");
658	histdp.SetMinimum(0);
659
660	// Task to fill the histogram
661	MFillH fillB(&histbp, "MTime", "FillBadPixTm");
662	MFillH fillD(&histdp, "MTime", "FillDeadPixTm");
663	fillB.SetNameTab("BadPixTm");
664	fillD.SetNameTab("DeadPixTm");
665
666	/*
667	MFillH fillP("MHPulseShape", "", "FillPulseShape");
668	fillP.SetNameTab("Pulse");
669	*/
670
671	/*
672	MHVsTime hbadpix("MBadPixelsCam.GetNumUnsuitable");
673	hbadpix.SetNumEvents(50);
674	MFillH fillB(&hbadpix, "MTime");
675	*/
676
677	MTaskEnv fillflorian("FinalFantasy");
678	fillflorian.SetDefault();
679
680	// The second rule is for the case reading raw-files!
681	MWriteRootFile write(2, fname, fOverwrite?"RECREATE":"NEW");
682	// Run Header
683	write.AddContainer("MRawRunHeader", "RunHeaders");
684	// write.AddContainer("MBadPixelsCam", "RunHeaders");
685	write.AddContainer("MGeomCam", "RunHeaders");
686	// Monte Carlo Headers
687	write.AddContainer("MMcRunHeader", "RunHeaders", kFALSE);
688	write.AddContainer("MMcFadcHeader", "RunHeaders", kFALSE);
689	write.AddContainer("MMcTrigHeader", "RunHeaders", kFALSE);
690	write.AddContainer("MMcConfigRunHeader", "RunHeaders", kFALSE);
691	write.AddContainer("MMcCorsikaRunHeader", "RunHeaders", kFALSE);
692	// Monte Carlo
693	write.AddContainer("MMcEvt", "Events", kFALSE);
694	write.AddContainer("MMcTrig", "Events", kFALSE);
695	// Data tree
696	write.AddContainer("MSignalCam", "Events");
697	// write.AddContainer("MPedPhotFundamental", "Events");
698	write.AddContainer("MPedPhotFromExtractor", "Events");
699	write.AddContainer("MPedPhotFromExtractorRndm", "Events");
700	write.AddContainer("MTime", "Events", kFALSE);
701	write.AddContainer("MRawEvtHeader", "Events");
702
703	// Slow-Control: Current-tree
704	write.AddContainer("MTimeCurrents", "Currents", kFALSE);
705	write.AddContainer("MCameraDC", "Currents", kFALSE);
706	write.AddContainer("MReportCurrents", "Currents", kFALSE);
707	// Slow-Control: Camera-tree
708	write.AddContainer("MReportCamera", "Camera", kFALSE);
709	write.AddContainer("MTimeCamera", "Camera", kFALSE);
710	write.AddContainer("MCameraAUX", "Camera", kFALSE);
711	write.AddContainer("MCameraCalibration", "Camera", kFALSE);
712	write.AddContainer("MCameraCooling", "Camera", kFALSE);
713	write.AddContainer("MCameraHV", "Camera", kFALSE);
714	write.AddContainer("MCameraLV", "Camera", kFALSE);
715	write.AddContainer("MCameraLids", "Camera", kFALSE);
716	// Slow-Control: Trigger-tree
717	write.AddContainer("MReportTrigger", "Trigger", kFALSE);
718	write.AddContainer("MTimeTrigger", "Trigger", kFALSE);
719	// Slow-Control: Drive-tree
720	write.AddContainer("MReportDrive", "Drive", kFALSE);
721	write.AddContainer("MTimeDrive", "Drive", kFALSE);
722	// Slow-Control: Central Control-tree
723	write.AddContainer("MReportCC", "CC", kFALSE);
724	write.AddContainer("MTimeCC", "CC", kFALSE);
725
726	// Write the special MC tree
727	MWriteRootFile writemc(2, fname, fOverwrite?"RECREATE":"NEW");
728	writemc.SetName("WriteMC");
729	writemc.AddContainer("MMcEvtBasic", "OriginalMC");
730
731	// Write the special calib tree
732	/*
733	MWriteRootFile writecal(2, fname, fOverwrite?"RECREATE":"NEW");
734	writecal.SetName("WriteCalib");
735	writecal.AddContainer("MBadPixelsCam", "Calib");
736	writecal.AddContainer("MCalibrationChargeCam", "Calib");
737	writecal.AddContainer("MCalibrationRelTimeCam", "Calib");
738	*/
739
740	//-----------------------------------------------------------
741	// Build tasklist
742
743	MTaskList tlist2;
744
745	tlist2.AddToList(&caldec);
746	tlist2.AddToList(&decode);
747	tlist2.AddToList(&fillpat);
748	tlist2.AddToList(&apply);
749	//tlist2.AddToList(&merge);
750	tlist2.AddToList(&pedsub);
751
752	//-----------------------------------------------------------
753	// Pedestal extraction
754
755	MTaskList tlist3;
756	tlist3.SetFilter(&fped); // Deny events with cal-trigger
757
758	tlist2.AddToList(&fped); // If no lo-gain require ped-trigger
759	tlist2.AddToList(&tlist3); // and deny cosmics (lvl1/2) trigger
760
761	tlist3.AddToList(&pedlo1); // extract pedestal events
762	tlist3.AddToList(&pedlo2); // extract pedestal events
763	tlist3.AddToList(&pedlo3); // extract pedestal events
764	tlist3.AddToList(&fill0); // fill pedestal events
765	tlist3.AddToList(&fill1); // fill pedestal events
766
767	//-----------------------------------------------------------
768	// Calibration
769
770	MTaskList tlist4;
771	tlist4.SetFilter(&fcalib); // process only events with cal-trigger
772
773	//MFDataPhrase filcalco("MCalibrationConstCam.IsReadyToSave>0.5", "CalibConstFilter");
774	if (fIsInterlaced)
775	{
776	// The task list is executed for all events with the calibration
777	// trigger
778	tlist2.AddToList(&fcalib); // MFTriggerPattern
779	tlist2.AddToList(&tlist4);
780
781	tlist4.AddToList(&taskenv3);
782	tlist4.AddToList(&contcoscal); // MContinue/ContCosmicsCal
783	if (IsUsePINDiode())
784	tlist4.AddToList(&pinext); // MExtractPINDiode
785	if (IsUseBlindPixel())
786	tlist4.AddToList(&bldext); // MExtractBlindPixel
787	tlist4.AddToList(&pacalc); // MCalibCalcFromPast
788	/*
789	tlist3.AddToList(&filcalco); // CalibConstFilter (IsReadyToSave)
790	fill8.SetFilter(&filcalco);
791	tlist3.AddToList(&fill8); // FillConvUpd
792	*/
793
794	tlist4.AddToList(&filcam); // FillChargeCam
795	if (fIsRelTimesUpdate)
796	tlist4.AddToList(&filtme); // FillRelTime
797	if (IsUseBlindPixel())
798	tlist4.AddToList(&filbnd); // FillBlindCam
799	if (IsUsePINDiode())
800	tlist4.AddToList(&filpin); // FillPINDiode
801	tlist4.AddToList(&chcalc); // MCalibrationChargeCalc
802	if (fIsRelTimesUpdate)
803	tlist4.AddToList(&recalc); // MCalibrationRelTimeCam
804
805	//tlist3.AddToList(&writecal); // MWriteRootFile
806	}
807
808	//-----------------------------------------------------------
809	// Cosmics extraction
810
811	// remove all events with a cal- or ped-trigger (no matter
812	// whether they have lvl1 or lvl2 or any other flag
813	tlist2.AddToList(&contcalped);
814
815	// Extract the signal
816	if (extractor1)
817	tlist2.AddToList(&taskenv1);
818
819	// remove all events which definitly don't have a signal
820	// using MFCosmics (ContCosmicsPed)
821	// tlist2.AddToList(&contcosped);
822
823	// Extract arrival time (if a dedicated extrator given)
824	if (extractor2)
825	tlist2.AddToList(&taskenv2);
826
827	/*
828	if (fIsHiLoCalibration)
829	{
830	plist.AddToList(&hilocam);
831	tlist2.AddToList(&filhil);
832	}
833
834	if (fIsPulsePosCheck)
835	{
836	plist.AddToList(&hpulcam);
837	tlist2.AddToList(&filpul);
838	}
839	*/
840
841	tlist2.AddToList(&fill2);
842	tlist2.AddToList(&fill8); // FillConv
843	tlist2.AddToList(&calib); // MCalibrateData
844	if (extractor2 \|\| extractor1->InheritsFrom("MExtractTimeAndCharge"))
845	tlist2.AddToList(&caltm);
846
847	tlist2.AddToList(&bpcal); // MBadPixelsCalc
848	tlist2.AddToList(&treat); // MBadPixelsTreat
849	tlist2.AddToList(&fill6);
850	// tlist2.AddToList(&fill3);
851	tlist2.AddToList(&fill4);
852	tlist2.AddToList(&fill5);
853	//if (extractor2 \|\| extractor1->InheritsFrom("MExtractTimeAndCharge"))
854	// tlist2.AddToList(&fill7);
855	tlist2.AddToList(&fill9);
856	if (!fSequence.IsMonteCarlo())
857	{
858	tlist2.AddToList(&fillB);
859	tlist2.AddToList(&fillD);
860	}
861	if (extractor1->HasLoGain())
862	{
863	tlist2.AddToList(&fillR);
864	tlist2.AddToList(&fillO);
865	}
866
867	/*
868	MFillH fillC("MHCleaning", "", "FillClean");
869	tlist2.AddToList(&fillC);
870
871	//tlist2.AddToList(&fillP);
872	*/
873
874	// ----- Start: Code for encoding movies -----
875
876	MMoviePrepare movprep;
877	MMovieWrite movwrite;
878	movprep.SetRangeFromExtractor(*extractor1);
879
880	//MFDataPhrase movfilt("MMovieData.fMax>150");
881	MFDataPhrase movfilt("MMovieData.fMax>5*MMovieData.fMedianPedestalRms", "MovieFilter");
882
883	MImgCleanStd movclean(8.5, 4.0);
884	movclean.SetMethod(MImgCleanStd::kAbsolute);
885
886	//movprep.SetFilter(&evtnum);
887	movclean.SetFilter(&movfilt);
888	movwrite.SetFilter(&movfilt);
889
890	MTaskList tlistmov("MovieEncoder");
891	tlistmov.AddToList(&movprep);
892	tlistmov.AddToList(&movfilt);
893	tlistmov.AddToList(&movclean);
894	tlistmov.AddToList(&movwrite);
895
896	MFEvtNumber evtnum;
897	//evtnum.SetSelector("ThetaSquared.fVal<0.04");
898	//evtnum.SetFileName("ganymed00000001.root");
899	tlistmov.SetFilter(&evtnum);
900
901	if (fIsMovieMode)
902	{
903	tlist2.AddToList(&evtnum);
904	tlist2.AddToList(&tlistmov);
905	}
906
907	// ----- End: Code for encoding movies -----
908
909	tlist2.AddToList(&fillflorian);
910
911	// Setup List for Drive-tree
912	//MPointingPosCalc pcalc;
913
914	// Now setup main tasklist
915	tlist.AddToList(read);
916
917	if (fSequence.IsMonteCarlo())
918	{
919	if (!fIsMovieMode)
920	tlist.AddToList(&writemc);
921	tlist.AddToList(&contmc);
922	}
923
924	//if (IsUseRootData())
925	// tlist2.AddToList(&pextr);
926	tlist.AddToList(&tlist2, fSequence.IsMonteCarlo() ? "Events" : "All");
927
928	//if (fSequence.IsMonteCarlo())
929	// tlist.AddToList(&pcalc, "Drive");
930
931	if (!fIsMovieMode)
932	tlist.AddToList(&write);
933
934	// Create and setup the eventloop
935	MEvtLoop evtloop(fName);
936	evtloop.SetParList(&plist);
937	evtloop.SetDisplay(fDisplay);
938	evtloop.SetLogStream(fLog);
939	if (!SetupEnv(evtloop))
940	return kFALSE;
941
942	// Execute first analysis
943	const Bool_t rc = evtloop.Eventloop(fMaxEvents);
944
945	// make sure owned object are deleted
946	if (extractor1 && extractor1!=fExtractor)
947	delete extractor1;
948	if (extractor2)
949	delete extractor2;
950	if (extractor3)
951	delete extractor3;
952
953	// return if job failed
954	if (!rc)
955	{
956	*fLog << err << GetDescriptor() << ": Failed." << endl;
957	return kFALSE;
958	}
959
960	// if everything went ok write and display result
961	DisplayResult(plist);
962
963	/*
964	if (fIsPixelCheck)
965	{
966	if (fIsPulsePosCheck)
967	hpulcam[fCheckedPixId].DrawClone("");
968
969	//if (fIsHiLoCalibration)
970	// hilocam[fCheckedPixId].DrawClone("");
971	}
972	interlacedcont.Add(&pulcam);
973	*/
974
975	//if (fIsHiLoCalibration)
976	// interlacedcont.Add(&hilcam);
977
978	//if (fIsPulsePosCheck)
979	// interlacedcont.Add(plist.FindObject("MHCalibrationPulseTimeCam"));
980
981	//if (fIsHiLoCalibration)
982	// interlacedcont.Add(plist.FindObject("MHCalibrationHiLoCam"));
983
984	if (!WriteResult())
985	return kFALSE;
986
987	// return if job went ok
988	*fLog << all << GetDescriptor() << ": Done." << endl;
989	*fLog << endl << endl;
990
991	return kTRUE;
992	}
993
994
995	void MJCalibrateSignal::DisplayResult(MParList &plist)
996	{
997	/*
998	if (!fDisplay \|\| !fIsHiLoCalibration)
999	return;
1000
1001	MCalibrationHiLoCam hcam = (MCalibrationHiLoCam)plist.FindObject("MCalibrationHiLoCam");
1002	MGeomCam geom = (MGeomCam)plist.FindObject("MGeomCam");
1003	if (!hcam \|\| !geom)
1004	return;
1005
1006	// Create histograms to display
1007	MHCamera disp1(*geom, "HiLoConv", "Ratio Amplification HiGain vs. LoGain (Charges)");
1008	MHCamera disp2(*geom, "HiLoDiff", "Arrival Time Diff. HiGain vs. LoGain (Times)");
1009
1010	disp1.SetCamContent(*hcam, 0);
1011	disp1.SetCamError( *hcam, 1);
1012	disp2.SetCamContent(*hcam, 5);
1013	disp2.SetCamError( *hcam, 6);
1014
1015	disp1.SetYTitle("R [1]");
1016	disp2.SetYTitle("\\Delta T [FADC sl.]");
1017
1018	TCanvas &c1 = fDisplay->AddTab("HiLoConv");
1019	c1.Divide(2,3);
1020
1021	disp1.CamDraw(c1, 1, 2, 1);
1022	disp2.CamDraw(c1, 2, 2, 1);
1023	*/
1024	}
1025

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

Download in other formats: