source: trunk/MagicSoft/Mars/macros/calibration.C@ 5595

Last change on this file since 5595 was 5532, checked in by gaug, 21 years ago
*** empty log message ***
File size: 17.7 KB
Line 
1/* ======================================================================== *\
2!
3! *
4! * This file is part of MARS, the MAGIC Analysis and Reconstruction
5! * Software. It is distributed to you in the hope that it can be a useful
6! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
7! * It is distributed WITHOUT ANY WARRANTY.
8! *
9! * Permission to use, copy, modify and distribute this software and its
10! * documentation for any purpose is hereby granted without fee,
11! * provided that the above copyright notice appear in all copies and
12! * that both that copyright notice and this permission notice appear
13! * in supporting documentation. It is provided "as is" without express
14! * or implied warranty.
15! *
16!
17!
18! Author(s): Markus Gaug, 11/2003 <mailto:markus@ifae.es>
19!
20! Copyright: MAGIC Software Development, 2000-2004
21!
22!
23\* ======================================================================== */
24/////////////////////////////////////////////////////////////////////////////
25//
26// calibration.C
27//
28// Needs as arguments the run number of a calibration file ("*_C_*.root") and
29// the run number of the corresponding pedestal file ("*_P_*.root").
30//
31// The TString inpath has to be set correctly.
32//
33// The macro searches for the pulser colour which corresponds to the calibration
34// run number. If the run number is smaller than 20000, pulser colour "CT1"
35// is assumed, otherwise, it searches for the strings "green", "blue", "uv" or
36// "ct1" in the filenames. If no colour or multiple colours are found, the
37// execution is aborted.
38//
39// The container MBadPixelsCam is created and followed during the execution of the
40// rest of the macro.
41//
42// A first loop over the pedestal file is performed using the class MJPedestal
43//
44// The container MCalibrationQECam is created and followed during the execution of the
45// rest of the macro.
46//
47// A loop over the calibration files is performed using the class MJCalibration.
48// The results are displayed using the MJCalibration::SetNormalDisplay() facility,
49// but other displays can easily be uncommented.
50// The call to MJCalibration skips the relative time calibration, which can be
51// uncommented as well.
52//
53// Last, a third loop is performed over the calibration file again in order to
54// "calibrate" it and test the resulting outcome.
55//
56//////////////////////////////////////////////////////////////////////////////////////////
57#include "getExtractor.C"
58
59#include "MJPedestal.h"
60#include "MJCalibration.h"
61#include "MJExtractSignal.h"
62#include "MJExtractCalibTest.h"
63#include "MRunIter.h"
64#include "MStatusDisplay.h"
65#include "MCalibrationQECamMagic.h"
66#include "MCalibrationQECam.h"
67#include "MBadPixelsCam.h"
68#include "MArgs.h"
69#include "MArray.h"
70#include "MParContainer.h"
71
72#include "TStyle.h"
73#include "TObject.h"
74#include "TObjectTable.h"
75#include "TCanvas.h"
76#include "TPad.h"
77#include "TH1.h"
78#include "TPaveStats.h"
79
80using namespace std;
81
82static TString outpath = "./";
83static TString inpath = "/home/rootdata/Calib/2004_09_22";
84//static TString badfile = "";
85static TString badfile = "badpixels_only0_388_559.dat";
86//
87// the default pedestal run for the calibration
88//
89static const Int_t pedrun = 38995;
90//
91// the default start calibration run
92//
93static const Int_t calrun1 = 38997;
94//
95// the default last calibration run (if 0, only one run is taken, otherwise consecutive runs
96// between calrun1 and calrun2)
97//
98static const Int_t calrun2 = 0;
99//
100// A switch to output debugging information about Objects use
101//
102static Bool_t debug = kFALSE;
103//
104// A switch to use the Blind Pixel
105//
106static Bool_t blindpix = kTRUE;
107//
108// A switch to use the PIN Diode
109//
110static Bool_t pindiode = kTRUE;
111//
112// Tell if you want to use the display:
113//
114static Bool_t useDisplay = kTRUE;
115//
116// Tell if you want to test the result afterwards
117//
118static Bool_t useTest = kFALSE;
119//
120// Tell if you want to test the intensity calibration
121//
122static Bool_t useIntensity = kFALSE;
123//
124// Tell if you want to store and read the F0 and F1- files
125//
126static Bool_t usestorage = kFALSE;
127//
128// Tell which extractor you want to use. The flags are counted according
129// to the extractor-TDAS
130//
131static Int_t extractorflag = 1;
132//
133Int_t calibration(const UInt_t extflag=extractorflag, const Int_t prun=pedrun,
134 const Int_t crun1=calrun1, const Int_t crun2=calrun2)
135{
136
137 MExtractor *extractor = getExtractor(extflag);
138
139 if (!extractor)
140 return 99;
141
142 extractor->SetName(Form("%s_Run_%05d",extractor->GetName(),prun));
143 const Bool_t timeandcharge = extractor->InheritsFrom("MExtractTimeAndCharge");
144
145 gStyle->SetOptStat(1111);
146 gStyle->SetOptFit();
147 gStyle->SetTitleSize(0.35,"u");
148 gStyle->SetTitleFontSize(0.9);
149 gStyle->SetTitleH(0.12);
150 gStyle->SetTitleW(0.95);
151 gStyle->SetLineWidth(1);
152
153 if (debug)
154 TObject::SetObjectStat(kTRUE);
155
156 MRunIter pruns;
157 MRunIter cruns;
158
159 pruns.AddRun(prun,inpath);
160
161 if (crun2==0)
162 cruns.AddRun(crun1,inpath);
163 else
164 cruns.AddRuns(crun1,crun2,inpath);
165
166 MStatusDisplay *display = NULL;
167
168 if (useDisplay)
169 {
170 display = new MStatusDisplay;
171 display->SetUpdateTime(3000);
172 display->Resize(850,700);
173 }
174
175 /*****************************************/
176 /* FIRST LOOP: PURE PEDESTAL COMPUTATION */
177 /*****************************************/
178 //
179 // Hand over to the jobs a QE Cam with Cornings initialized
180 //
181 MCalibrationQECamMagic qecam;
182 MBadPixelsCam badcam;
183 //
184 // If you want to exclude pixels from the beginning, read
185 // an ascii-file with the corr. pixel numbers (see MBadPixelsCam)
186 //
187 if (!badfile.IsNull())
188 {
189 ifstream f(badfile.Data());
190 badcam.AsciiRead((istream&)f);
191 f.close();
192 }
193
194 MJPedestal pedloop1;
195 pedloop1.SetNoStorage(!usestorage);
196 pedloop1.SetEnvDebug(debug);
197 pedloop1.SetExtractor(extractor);
198 pedloop1.SetInput(&pruns);
199 pedloop1.SetPathOut(outpath.Data());
200 if (useDisplay)
201 {
202 pedloop1.SetDisplay(display);
203 pedloop1.SetDataCheckDisplay();
204 }
205 pedloop1.SetBadPixels(badcam);
206
207 if (!pedloop1.Process())
208 return 1;
209
210 /****************************************/
211 /* SECOND LOOP: CALIBRATION COMPUTATION */
212 /****************************************/
213
214 MJPedestal pedloop2;
215 MJCalibration calloop;
216
217 if (timeandcharge)
218 {
219 /***********************************************************/
220 /* NEEDE FOR SECOND LOOP: EXTRACTOR RESOLUTION COMPUTATION */
221 /***********************************************************/
222
223 pedloop2.SetUseData();
224 pedloop2.SetNoStorage(!usestorage);
225 pedloop2.SetEnvDebug(debug);
226 pedloop2.SetExtractor(extractor);
227 pedloop2.SetExtractorResolution();
228 pedloop2.SetPedestals(pedloop1.GetPedestalCam());
229 pedloop2.SetInput(&pruns);
230 pedloop2.SetPathOut(outpath.Data());
231 if (useDisplay)
232 {
233 pedloop2.SetDisplay(display);
234 pedloop2.SetDataCheckDisplay();
235 }
236 pedloop2.SetBadPixels(badcam);
237
238 if (!pedloop2.Process())
239 return 1;
240
241 extractor->SetNoiseCalculation(kFALSE);
242 calloop.SetExtractorCam(pedloop2.GetPedestalCam());
243 }
244
245 MPedestalCam &pedcam = pedloop1.GetPedestalCam();
246
247 if (debug)
248 calloop.SetDebug();
249 calloop.SetEnvDebug(debug);
250 if (useIntensity)
251 calloop.SetIntensity();
252 // calloop.SetHistsStorage();
253 calloop.SetNoStorage(!usestorage);
254 //
255 // If you want to set a colour explicitely from outside (not recommanded!)
256 // calloop.SetColor(MCalibrationCam::kUV);
257 //
258 // If you want to run the data-check on RAW DATA!!!, choose:
259 // calloop.SetDataCheck();
260 //
261 // If you want to see the data-check plots only, choose:
262 calloop.SetDataCheckDisplay();
263 //calloop.SetNormalDisplay();
264 //
265 // For everything, you have ever dreamed of, choose:
266 // calloop.SetFullDisplay();
267
268 //
269 // If you want to calibrate the times as well, choose:
270 //
271 calloop.SetExtractor(extractor);
272 calloop.SetInput(&cruns);
273 calloop.SetPathOut(outpath.Data());
274 if (useDisplay)
275 calloop.SetDisplay(display);
276 calloop.SetUseBlindPixel(blindpix);
277 calloop.SetUsePINDiode(pindiode);
278 calloop.SetQECam(qecam);
279 calloop.SetBadPixels(pedloop1.GetBadPixels());
280
281 if (!calloop.Process(pedcam))
282 return 2;
283
284 //
285 // The next lines are the use the Print() function and have
286 // all the results as ascii-tables:
287 //
288 if (debug)
289 {
290 MCalibrationChargeCam &chargecam = calloop.GetCalibrationCam();
291 MCalibrationQECam &nqecam = calloop.GetQECam();
292 MBadPixelsCam &badbad = calloop.GetBadPixels();
293 chargecam.Print();
294 nqecam.Print();
295 badbad.Print();
296 }
297
298 /********************************************************************/
299 /* THIRD LOOP: APPLY CALIBRATION TO THE CALIBRATION FILES FOR TESTS */
300 /********************************************************************/
301
302 if (useTest)
303 {
304
305 MJExtractCalibTest testloop;
306
307 // If you want to see the data-check plots only, choose:
308 testloop.SetDataCheckDisplay();
309
310 testloop.SetExtractor(extractor);
311 testloop.SetInput(&cruns);
312 testloop.SetPathOut(outpath);
313 if (useDisplay)
314 testloop.SetDisplay(display);
315 testloop.SetBadPixels(calloop.GetBadPixels());
316
317 if (!testloop.ProcessD(pedloop1.GetPedestalCam(),calloop.GetCalibrationCam(),calloop.GetQECam()))
318 return 3;
319
320 return 4;
321
322 }
323
324 /********************************************************************/
325 /* FOURTH LOOP: APPLY CALIBRATION TO THE PEDESTAL FILES */
326 /********************************************************************/
327
328 MJExtractSignal pedphotloop;
329
330 pedphotloop.SetExtractor(extractor);
331 pedphotloop.SetInput(&pruns);
332 pedphotloop.SetOutputPath(outpath);
333 if (useDisplay)
334 pedphotloop.SetDisplay(display);
335 pedphotloop.SetBadPixels(calloop.GetBadPixels());
336
337 if (!pedphotloop.ProcessP(pedloop1.GetPedestalCam(),calloop.GetCalibrationCam(),calloop.GetQECam()))
338 return 5;
339
340 if (debug)
341 TObject::SetObjectStat(kFALSE);
342
343 //
344 // Debugging at the end:
345 //
346 if (debug)
347 gObjectTable->Print();
348
349 return 0;
350}
351
352static void Usage()
353{
354 gLog << endl;
355 gLog << "Usage:" << endl;
356 gLog << endl;
357 gLog << " calibration [ped.run nr.] [first cal.run nr.] [last cal.run nr.]" << endl ;
358 gLog << endl;
359 gLog << " ped.run.nr: Run number of the pedestal file." << endl;
360 gLog << " first cal.run nr.: Run number of the first calibration file." << endl;
361 gLog << " last cal.run nr.: Run number of the last calibration file." << endl;
362 gLog << endl;
363 gLog << "All calibration runs between (first cal.run nr.) and (last cal.run nr.) will be used" << endl;
364 gLog << "If last.cal.run.nr is 0 (default), only one calibration run is taken" << endl;
365 gLog << endl;
366 gLog << "Additional Options: " << endl;
367 gLog << " --extractor=# Choose one of the following possible extractors (integer)" << endl;
368 gLog << endl;
369 gLog << " Nr. Extractor Parameters " << endl;
370 gLog << endl;
371 gLog << " MExtractFixedWindow: " << endl;
372 gLog << " with the following parameters, if 'maxbin' defines the mean position" << endl;
373 gLog << " of the High-Gain FADC slice carrying the pulse maximum: " << endl;
374 gLog << " 1: SetRange('maxbin}}-1,'maxbin}}+2,'maxbin}}+0.5,'maxbin}}+3.5) " << endl;
375 gLog << " 2: SetRange('maxbin'-1,'maxbin'+2,'maxbin'-0.5,'maxbin'+4.5)" << endl;
376 gLog << " 3: SetRange('maxbin'-2,'maxbin'+3,'maxbin'-0.5,'maxbin'+4.5)" << endl;
377 gLog << " 4: SetRange('maxbin'-3,'maxbin'+4,'maxbin'-1.5,'maxbin'+5.5)" << endl;
378 gLog << " 5: SetRange('maxbin'-5,'maxbin'+8,'maxbin'-1.5,'maxbin'+7.5)" << endl;
379 gLog << " MExtractFixedWindowSpline: " << endl;
380 gLog << " 6: SetRange('maxbin'-1,'maxbin'+2,'maxbin'+0.5,'maxbin'+3.5)" << endl;
381 gLog << " 7: SetRange('maxbin'-1,'maxbin'+2,'maxbin'-0.5,'maxbin'+4.5)" << endl;
382 gLog << " 8: SetRange('maxbin'-2,'maxbin'+3,'maxbin'-0.5,'maxbin'+4.5)" << endl;
383 gLog << " 9: SetRange('maxbin'-3,'maxbin'+4,'maxbin'-1.5,'maxbin'+5.5)" << endl;
384 gLog << " 10: SetRange('maxbin'-5,'maxbin'+8,'maxbin'-1.5,'maxbin'+7.5)" << endl;
385 gLog << " MExtractFixedWindowPeakSearch: " << endl;
386 gLog << " SetRange(0,18,2,14) and the following parameters:" << endl;
387 gLog << " 11: SetWindows(2,2,2)" << endl;
388 gLog << " 12: SetWindows(4,4,2)" << endl;
389 gLog << " 13: SetWindows(6,6,4)" << endl;
390 gLog << " 14: SetWindows(4,6,4)" << endl;
391 gLog << " 15: SetWindows(8,8,4)" << endl;
392 gLog << " 16: SetWindows(14,10,4)" << endl;
393 gLog << " MExtractTimeAndChargeSlidingWindow:" << endl;
394 gLog << " SetRange(0,18,2,14) and the following parameters:" << endl;
395 gLog << " 17: SetWindowSize(2,2)" << endl;
396 gLog << " 18: SetWindowSize(4,4)" << endl;
397 gLog << " 19: SetWindowSize(6,6)" << endl;
398 gLog << " 20: SetWindowSize(4,6)" << endl;
399 gLog << " 21: SetWindowSize(8,8)" << endl;
400 gLog << " 22: SetWindowSize(14,10)" << endl;
401 gLog << " MExtractTimeAndChargeSpline: " << endl;
402 gLog << " SetChargeType(MExtractTimeAndChargeSpline::kIntegral) and:" << endl;
403 gLog << " SetRange(0,18,2,14) and the following parameters:" << endl;
404 gLog << " 23: SetRiseTime(1.5); SetFallTime(4.5)" << endl;
405 gLog << " 24: SetRiseTime(0.5); SetFallTime(2.5)" << endl;
406 gLog << " 25: SetRiseTime(0.5); SetFallTime(1.5)" << endl;
407 gLog << " 26: SetRiseTime(0.5); SetFallTime(0.5)" << endl;
408 gLog << " 27: SetChargeType(MExtractTimeAndChargeSpline::kAmplitude" << endl;
409 gLog << " SetRange(0,10,4,11)" << endl;
410 gLog << " MExtractTimeAndChargeDigitalFilter" << endl;
411 gLog << " SetRange(0,18,2,14) and the following parameters:" << endl;
412 gLog << " 28: SetNameWeightsFile('msignal/cosmics_weights.dat')" << endl;
413 gLog << " 29: SetNameWeightsFile('msignal/cosmics_weights4.dat')" << endl;
414 gLog << " 30: SetNameWeightsFile('msignal/cosmics_weights_logain6.dat')" << endl;
415 gLog << " 31: SetNameWeightsFile('msignal/cosmics_weights_logain4.dat')" << endl;
416 gLog << " 32: SetNameWeightsFile('msignal/calibration_weights_UV.dat')" << endl;
417 gLog << " 33: SetNameWeightsFile('msignal/calibration_weights_UV4.dat')" << endl;
418 gLog << " 34: SetNameWeightsFile('msignal/calibration_weights_UV_logain6.dat')" << endl;
419 gLog << " 35: SetNameWeightsFile('msignal/calibration_weights_UV_logain4.dat')" << endl;
420 gLog << " 36: Real Fit: (not yet implemented)" << endl;
421 gLog << endl;
422 gLog << " --inpath=# Find the data in inpath" << endl;
423 gLog << " --outpath=# Write the output containers to outpath" << endl;
424 gLog << " --badfile=# Use the file # to exclude pixels from the beginning" << endl;
425 gLog << " --debug Use the TObjectTable for debugging " << endl;
426 gLog << " and write out the pixels as ascii tables" << endl;
427 gLog << " --useTest Use the class MJExtractCalibTest to test the calibration on itself" << endl;
428 gLog << " --skipBlindPix Skip the blind pixel calibration" << endl;
429 gLog << " --skipPINDiode Skip the PIN Diode calibration" << endl;
430}
431
432
433int main(int argc, char **argv)
434{
435 //
436 // Evaluate arguments
437 //
438 MArgs arg(argc, argv);
439
440 if (arg.HasOnly("-?") || arg.HasOnly("-h") || arg.HasOnly("--help"))
441 {
442 Usage();
443 return -1;
444 }
445
446 debug = arg.HasOnlyAndRemove("--debug") || arg.HasOnlyAndRemove("-d");
447 useTest = arg.HasOnlyAndRemove("--useTest") || arg.HasOnlyAndRemove("-e");
448 blindpix = !(arg.HasOnlyAndRemove("--skipBlindPix"));
449 pindiode = !(arg.HasOnlyAndRemove("--skipPINDiode"));
450
451 if (arg.HasOption("--extractor="))
452 extractorflag = arg.GetIntAndRemove("--extractor=");
453
454 if (arg.HasOption("--inpath="))
455 inpath = arg.GetStringAndRemove("--inpath=");
456
457 if (arg.HasOption("--outpath="))
458 outpath = arg.GetStringAndRemove("--outpath=");
459
460 if (arg.HasOption("--badfile="))
461 badfile = arg.GetStringAndRemove("--badfile=");
462
463 if (gSystem->AccessPathName(badfile,kFileExists))
464 {
465 gLog << "WARNING: the bad pixels file '" << badfile.Data() << "' doesn't exist." << endl;
466 badfile = "";
467 }
468
469 // check for the right usage of the program
470 //
471 if (arg.GetNumArguments()>4)
472 {
473 Usage();
474 return -1;
475 }
476
477 //
478 // Initialize Non-GUI (batch) mode
479 //
480 gROOT->SetBatch();
481
482 //
483 // Switch off the display
484 //
485 useDisplay = kTRUE;
486 //
487 // check for the arguments
488 //
489 Int_t pedr = 0;
490 Int_t calr1 = 0;
491 Int_t calr2 = 0;
492
493 const Int_t nargs = arg.GetNumArguments();
494
495 if (nargs>=3)
496 {
497 pedr = arg.GetArgumentInt(0);
498 calr1 = arg.GetArgumentInt(1);
499 calr2 = arg.GetArgumentInt(2);
500 return calibration(pedr,calr1,calr2);
501 }
502
503 if (nargs>=2)
504 {
505 pedr = arg.GetArgumentInt(0);
506 calr1 = arg.GetArgumentInt(1);
507 gLog << "PEDR: " << pedr << " CALR1: " << calr1 << " CALR2 " << calr2 << endl;
508 gLog << "inpath: " << inpath << endl;
509 gLog << "extractor: " << extractorflag << endl;
510 return calibration();
511 }
512
513 if (nargs>=1)
514 {
515 pedr = arg.GetArgumentInt(0);
516 return calibration(pedr,calr1,calr2);
517 }
518
519 return calibration(pedr,calr1,calr2);
520}
521
Note: See TracBrowser for help on using the repository browser.