1 | /* ======================================================================== *\
|
---|
2 | ! $Name: not supported by cvs2svn $:$Id: MHCalibrationChargeCam.cc,v 1.58 2007-04-27 10:04:47 tbretz Exp $
|
---|
3 | ! --------------------------------------------------------------------------
|
---|
4 | !
|
---|
5 | ! *
|
---|
6 | ! * This file is part of MARS, the MAGIC Analysis and Reconstruction
|
---|
7 | ! * Software. It is distributed to you in the hope that it can be a useful
|
---|
8 | ! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
|
---|
9 | ! * It is distributed WITHOUT ANY WARRANTY.
|
---|
10 | ! *
|
---|
11 | ! * Permission to use, copy, modify and distribute this software and its
|
---|
12 | ! * documentation for any purpose is hereby granted without fee,
|
---|
13 | ! * provided that the above copyright notice appear in all copies and
|
---|
14 | ! * that both that copyright notice and this permission notice appear
|
---|
15 | ! * in supporting documentation. It is provided "as is" without express
|
---|
16 | ! * or implied warranty.
|
---|
17 | ! *
|
---|
18 | !
|
---|
19 | !
|
---|
20 | ! Author(s): Markus Gaug 02/2004 <mailto:markus@ifae.es>
|
---|
21 | ! Author(s): Thomas Bretz <mailto:tbretz@astro.uni-wuerzburg.de>
|
---|
22 | !
|
---|
23 | ! Copyright: MAGIC Software Development, 2000-2007
|
---|
24 | !
|
---|
25 | !
|
---|
26 | \* ======================================================================== */
|
---|
27 | /////////////////////////////////////////////////////////////////////////////
|
---|
28 | //
|
---|
29 | // MHCalibrationChargeCam
|
---|
30 | //
|
---|
31 | // Fills the extracted signals of MExtractedSignalCam into the MHCalibrationPix-classes
|
---|
32 | // MHCalibrationChargeHiGainPix and MHCalibrationChargeLoGainPix for every:
|
---|
33 | //
|
---|
34 | // - Pixel, stored in the TOrdCollection's MHCalibrationCam::fHiGainArray and
|
---|
35 | // MHCalibrationCam::fLoGainArray
|
---|
36 | //
|
---|
37 | // - Average pixel per AREA index (e.g. inner and outer for the MAGIC camera),
|
---|
38 | // stored in the TOrdCollection's MHCalibrationCam::fAverageHiGainAreas and
|
---|
39 | // MHCalibrationCam::fAverageLoGainAreas
|
---|
40 | //
|
---|
41 | // - Average pixel per camera SECTOR (e.g. sectors 1-6 for the MAGIC camera),
|
---|
42 | // stored in the TOrdCollection's MHCalibrationCam::fAverageHiGainSectors and
|
---|
43 | // MHCalibrationCam::fAverageLoGainSectors
|
---|
44 | //
|
---|
45 | // Every signal is taken from MExtractedSignalCam and filled into a histogram and
|
---|
46 | // an array, in order to perform a Fourier analysis (see MHGausEvents).
|
---|
47 | // The signals are moreover averaged on an event-by-event basis and written into
|
---|
48 | // the corresponding average pixels.
|
---|
49 | //
|
---|
50 | // Additionally, the (FADC slice) position of the maximum is stored in an Absolute
|
---|
51 | // Arrival Time histogram. This histogram serves for a rough cross-check if the
|
---|
52 | // signal does not lie at or outside the edges of the extraction window.
|
---|
53 | //
|
---|
54 | // The Charge histograms are fitted to a Gaussian, mean and sigma with its errors
|
---|
55 | // and the fit probability are extracted. If none of these values are NaN's and
|
---|
56 | // if the probability is bigger than MHGausEvents::fProbLimit (default: 0.5%),
|
---|
57 | // the fit is declared valid.
|
---|
58 | // Otherwise, the fit is repeated within ranges of the previous mean
|
---|
59 | // +- MHCalibrationPix::fPickupLimit (default: 5) sigma (see MHCalibrationPix::RepeatFit())
|
---|
60 | // In case this does not make the fit valid, the histogram means and RMS's are
|
---|
61 | // taken directly (see MHCalibrationPix::BypassFit()) and the following flags are set:
|
---|
62 | // - MBadPixelsPix::SetUncalibrated( MBadPixelsPix::kHiGainNotFitted ) or
|
---|
63 | // - MBadPixelsPix::SetUncalibrated( MBadPixelsPix::kLoGainNotFitted ) and
|
---|
64 | // - MBadPixelsPix::SetUnsuitable( MBadPixelsPix::kUnreliableRun )
|
---|
65 | //
|
---|
66 | // Outliers of more than MHCalibrationPix::fPickupLimit (default: 5) sigmas
|
---|
67 | // from the mean are counted as Pickup events (stored in MHCalibrationPix::fPickup)
|
---|
68 | //
|
---|
69 | // If more than fNumHiGainSaturationLimit (default: 15%) of the overall FADC
|
---|
70 | // slices show saturation, the following flag is set:
|
---|
71 | // - MCalibrationChargePix::SetHiGainSaturation();
|
---|
72 | // In that case, the calibration constants are derived from the low-gain results.
|
---|
73 | //
|
---|
74 | // If more than fNumLoGainSaturationLimit (default: 1%) of the overall
|
---|
75 | // low-gain FADC slices saturate, the following flags are set:
|
---|
76 | // - MBadPixelsPix::SetUncalibrated( MBadPixelsPix::kLoGainSaturation ) and
|
---|
77 | // - MBadPixelsPix::SetUnsuitable( MBadPixelsPix::kUnsuitableRun )
|
---|
78 | //
|
---|
79 | // The class also fills arrays with the signal vs. event number, creates a fourier
|
---|
80 | // spectrum and investigates if the projected fourier components follow an exponential
|
---|
81 | // distribution. In case that the probability of the exponential fit is less than
|
---|
82 | // MHGausEvents::fProbLimit (default: 0.5%), the following flags are set:
|
---|
83 | // - MBadPixelsPix::SetUncalibrated( MBadPixelsPix::kHiGainOscillating ) or
|
---|
84 | // - MBadPixelsPix::SetUncalibrated( MBadPixelsPix::kLoGainOscillating ) and
|
---|
85 | // - MBadPixelsPix::SetUnsuitable( MBadPixelsPix::kUnreliableRun )
|
---|
86 | //
|
---|
87 | // This same procedure is performed for the average pixels.
|
---|
88 | //
|
---|
89 | // The following results are written into MCalibrationChargeCam:
|
---|
90 | //
|
---|
91 | // - MCalibrationPix::SetHiGainSaturation()
|
---|
92 | // - MCalibrationPix::SetHiGainMean()
|
---|
93 | // - MCalibrationPix::SetHiGainMeanErr()
|
---|
94 | // - MCalibrationPix::SetHiGainSigma()
|
---|
95 | // - MCalibrationPix::SetHiGainSigmaErr()
|
---|
96 | // - MCalibrationPix::SetHiGainProb()
|
---|
97 | // - MCalibrationPix::SetHiGainNumPickup()
|
---|
98 | //
|
---|
99 | // - MCalibrationPix::SetLoGainMean()
|
---|
100 | // - MCalibrationPix::SetLoGainMeanErr()
|
---|
101 | // - MCalibrationPix::SetLoGainSigma()
|
---|
102 | // - MCalibrationPix::SetLoGainSigmaErr()
|
---|
103 | // - MCalibrationPix::SetLoGainProb()
|
---|
104 | // - MCalibrationPix::SetLoGainNumPickup()
|
---|
105 | //
|
---|
106 | // - MCalibrationChargePix::SetAbsTimeMean()
|
---|
107 | // - MCalibrationChargePix::SetAbsTimeRms()
|
---|
108 | //
|
---|
109 | // For all averaged areas, the fitted sigma is multiplied with the square root of
|
---|
110 | // the number involved pixels in order to be able to compare it to the average of
|
---|
111 | // sigmas in the camera.
|
---|
112 | //
|
---|
113 | // Class Version 2:
|
---|
114 | // + Float_t fNumLoGainBlackoutLimit; // Rel. amount blackout logain events until pixel is declared unsuitable
|
---|
115 | //
|
---|
116 | // Class Version 3:
|
---|
117 | // - Byte_t fFirstHiGain; // First used slice High Gain
|
---|
118 | // - Byte_t fLastHiGain; // Last used slice High Gain
|
---|
119 | // - Byte_t fFirstLoGain; // First used slice Low Gain
|
---|
120 | // - Byte_t fLastLoGain; // Last used slice Low Gain
|
---|
121 | //
|
---|
122 | /////////////////////////////////////////////////////////////////////////////
|
---|
123 | #include "MHCalibrationChargeCam.h"
|
---|
124 |
|
---|
125 | #include <TOrdCollection.h>
|
---|
126 | #include <TPad.h>
|
---|
127 | #include <TVirtualPad.h>
|
---|
128 | #include <TCanvas.h>
|
---|
129 | #include <TStyle.h>
|
---|
130 | #include <TF1.h>
|
---|
131 | #include <TLine.h>
|
---|
132 | #include <TLatex.h>
|
---|
133 | #include <TLegend.h>
|
---|
134 | #include <TGraph.h>
|
---|
135 | #include <TEnv.h>
|
---|
136 |
|
---|
137 | #include "MLog.h"
|
---|
138 | #include "MLogManip.h"
|
---|
139 |
|
---|
140 | #include "MParList.h"
|
---|
141 |
|
---|
142 | #include "MHCalibrationChargePix.h"
|
---|
143 | #include "MHCalibrationPix.h"
|
---|
144 |
|
---|
145 | #include "MCalibrationChargeCam.h"
|
---|
146 | #include "MCalibrationChargePix.h"
|
---|
147 |
|
---|
148 | #include "MGeomCam.h"
|
---|
149 | #include "MGeomPix.h"
|
---|
150 |
|
---|
151 | #include "MBadPixelsCam.h"
|
---|
152 | #include "MBadPixelsPix.h"
|
---|
153 |
|
---|
154 | #include "MRawRunHeader.h"
|
---|
155 | #include "MRawEvtPixelIter.h"
|
---|
156 |
|
---|
157 | #include "MPedestalSubtractedEvt.h"
|
---|
158 |
|
---|
159 | #include "MExtractedSignalCam.h"
|
---|
160 | #include "MExtractedSignalPix.h"
|
---|
161 |
|
---|
162 | ClassImp(MHCalibrationChargeCam);
|
---|
163 |
|
---|
164 | using namespace std;
|
---|
165 |
|
---|
166 | const Int_t MHCalibrationChargeCam::fgChargeHiGainNbins = 500;
|
---|
167 | const Axis_t MHCalibrationChargeCam::fgChargeHiGainFirst = -98.;
|
---|
168 | const Axis_t MHCalibrationChargeCam::fgChargeHiGainLast = 1902.;
|
---|
169 | const Int_t MHCalibrationChargeCam::fgChargeLoGainNbins = 500;
|
---|
170 | const Axis_t MHCalibrationChargeCam::fgChargeLoGainFirst = -99.;
|
---|
171 | const Axis_t MHCalibrationChargeCam::fgChargeLoGainLast = 901.;
|
---|
172 | const Float_t MHCalibrationChargeCam::fgProbLimit = 0.00000001;
|
---|
173 | const TString MHCalibrationChargeCam::gsHistName = "Charge";
|
---|
174 | const TString MHCalibrationChargeCam::gsHistTitle = "Signals";
|
---|
175 | const TString MHCalibrationChargeCam::gsHistXTitle = "Signal [FADC counts]";
|
---|
176 | const TString MHCalibrationChargeCam::gsHistYTitle = "Nr. events";
|
---|
177 | const TString MHCalibrationChargeCam::gsAbsHistName = "AbsTime";
|
---|
178 | const TString MHCalibrationChargeCam::gsAbsHistTitle = "Abs. Arr. Times";
|
---|
179 | const TString MHCalibrationChargeCam::gsAbsHistXTitle = "Time [FADC slices]";
|
---|
180 | const TString MHCalibrationChargeCam::gsAbsHistYTitle = "Nr. events";
|
---|
181 | const Float_t MHCalibrationChargeCam::fgNumHiGainSaturationLimit = 0.15;
|
---|
182 | const Float_t MHCalibrationChargeCam::fgNumLoGainSaturationLimit = 0.005;
|
---|
183 | const Float_t MHCalibrationChargeCam::fgNumLoGainBlackoutLimit = 0.05;
|
---|
184 | const Float_t MHCalibrationChargeCam::fgLoGainBlackoutLimit = 3.5;
|
---|
185 | const Float_t MHCalibrationChargeCam::fgLoGainPickupLimit = 3.5;
|
---|
186 | const Float_t MHCalibrationChargeCam::fgTimeLowerLimit = 1.;
|
---|
187 | const Float_t MHCalibrationChargeCam::fgTimeUpperLimit = 3.;
|
---|
188 | const TString MHCalibrationChargeCam::fgReferenceFile = "mjobs/calibrationref.rc";
|
---|
189 |
|
---|
190 | // --------------------------------------------------------------------------
|
---|
191 | //
|
---|
192 | // Default Constructor.
|
---|
193 | //
|
---|
194 | // Sets:
|
---|
195 | // - all pointers to NULL
|
---|
196 | //
|
---|
197 | // Initializes:
|
---|
198 | // - fNumHiGainSaturationLimit to fgNumHiGainSaturationLimit
|
---|
199 | // - fNumLoGainSaturationLimit to fgNumLoGainSaturationLimit
|
---|
200 | // - fTimeLowerLimit to fgTimeLowerLimit
|
---|
201 | // - fTimeUpperLimit to fgTimeUpperLimit
|
---|
202 | // - fNumLoGainBlackoutLimit to fgNumLoGainBlackoutLimit
|
---|
203 | //
|
---|
204 | // - fNbins to fgChargeHiGainNbins
|
---|
205 | // - fFirst to fgChargeHiGainFirst
|
---|
206 | // - fLast to fgChargeHiGainLast
|
---|
207 | //
|
---|
208 | // - fLoGainNbins to fgChargeLoGainNbins
|
---|
209 | // - fLoGainFirst to fgChargeLoGainFirst
|
---|
210 | // - fLoGainLast to fgChargeLoGainLast
|
---|
211 | //
|
---|
212 | // - fHistName to gsHistName
|
---|
213 | // - fHistTitle to gsHistTitle
|
---|
214 | // - fHistXTitle to gsHistXTitle
|
---|
215 | // - fHistYTitle to gsHistYTitle
|
---|
216 | //
|
---|
217 | // - fAbsHistName to gsAbsHistName
|
---|
218 | // - fAbsHistTitle to gsAbsHistTitle
|
---|
219 | // - fAbsHistXTitle to gsAbsHistXTitle
|
---|
220 | // - fAbsHistYTitle to gsAbsHistYTitle
|
---|
221 | //
|
---|
222 | MHCalibrationChargeCam::MHCalibrationChargeCam(const char *name, const char *title)
|
---|
223 | : fRawEvt(NULL), fSignal(NULL)
|
---|
224 | {
|
---|
225 |
|
---|
226 | fName = name ? name : "MHCalibrationChargeCam";
|
---|
227 | fTitle = title ? title : "Class to fill the calibration histograms ";
|
---|
228 |
|
---|
229 | SetNumHiGainSaturationLimit(fgNumHiGainSaturationLimit);
|
---|
230 | SetNumLoGainSaturationLimit(fgNumLoGainSaturationLimit);
|
---|
231 |
|
---|
232 | SetNumLoGainBlackoutLimit (fgNumLoGainBlackoutLimit);
|
---|
233 |
|
---|
234 | SetTimeLowerLimit();
|
---|
235 | SetTimeUpperLimit();
|
---|
236 |
|
---|
237 | SetBinning(fgChargeHiGainNbins, fgChargeHiGainFirst, fgChargeHiGainLast );
|
---|
238 | SetBinningLoGain(fgChargeLoGainNbins, fgChargeLoGainFirst, fgChargeLoGainLast );
|
---|
239 |
|
---|
240 | SetProbLimit(fgProbLimit);
|
---|
241 |
|
---|
242 | SetHistName (gsHistName .Data());
|
---|
243 | SetHistTitle (gsHistTitle .Data());
|
---|
244 | SetHistXTitle(gsHistXTitle.Data());
|
---|
245 | SetHistYTitle(gsHistYTitle.Data());
|
---|
246 |
|
---|
247 | SetAbsHistName (gsAbsHistName .Data());
|
---|
248 | SetAbsHistTitle (gsAbsHistTitle .Data());
|
---|
249 | SetAbsHistXTitle(gsAbsHistXTitle.Data());
|
---|
250 | SetAbsHistYTitle(gsAbsHistYTitle.Data());
|
---|
251 |
|
---|
252 | SetReferenceFile();
|
---|
253 |
|
---|
254 | fInnerRefCharge = 278.;
|
---|
255 | fOuterRefCharge = 282.;
|
---|
256 | }
|
---|
257 |
|
---|
258 | // --------------------------------------------------------------------------
|
---|
259 | //
|
---|
260 | // Creates new MHCalibrationChargeCam only with the averaged areas:
|
---|
261 | // the rest has to be retrieved directly, e.g. via:
|
---|
262 | // MHCalibrationChargeCam *cam = MParList::FindObject("MHCalibrationChargeCam");
|
---|
263 | // - cam->GetAverageSector(5).DrawClone();
|
---|
264 | // - (*cam)[100].DrawClone()
|
---|
265 | //
|
---|
266 | TObject *MHCalibrationChargeCam::Clone(const char *) const
|
---|
267 | {
|
---|
268 |
|
---|
269 | MHCalibrationChargeCam *cam = new MHCalibrationChargeCam();
|
---|
270 |
|
---|
271 | //
|
---|
272 | // Copy the data members
|
---|
273 | //
|
---|
274 | cam->fColor = fColor;
|
---|
275 | cam->fRunNumbers = fRunNumbers;
|
---|
276 | cam->fPulserFrequency = fPulserFrequency;
|
---|
277 | cam->fFlags = fFlags;
|
---|
278 | cam->fNbins = fNbins;
|
---|
279 | cam->fFirst = fFirst;
|
---|
280 | cam->fLast = fLast;
|
---|
281 | cam->fLoGainNbins = fLoGainNbins;
|
---|
282 | cam->fLoGainFirst = fLoGainFirst;
|
---|
283 | cam->fLoGainLast = fLoGainLast;
|
---|
284 | cam->fReferenceFile = fReferenceFile;
|
---|
285 | cam->fInnerRefCharge = fInnerRefCharge;
|
---|
286 | cam->fOuterRefCharge = fOuterRefCharge;
|
---|
287 |
|
---|
288 | //
|
---|
289 | // Copy the MArrays
|
---|
290 | //
|
---|
291 | cam->fAverageAreaRelSigma = fAverageAreaRelSigma;
|
---|
292 | cam->fAverageAreaRelSigmaVar = fAverageAreaRelSigmaVar;
|
---|
293 | cam->fAverageAreaSat = fAverageAreaSat;
|
---|
294 | cam->fAverageAreaSigma = fAverageAreaSigma;
|
---|
295 | cam->fAverageAreaSigmaVar = fAverageAreaSigmaVar;
|
---|
296 | cam->fAverageAreaNum = fAverageAreaNum;
|
---|
297 | cam->fAverageSectorNum = fAverageSectorNum;
|
---|
298 |
|
---|
299 | if (!IsAverageing())
|
---|
300 | return cam;
|
---|
301 |
|
---|
302 | const Int_t navhi = fAverageHiGainAreas->GetSize();
|
---|
303 |
|
---|
304 | for (int i=0; i<navhi; i++)
|
---|
305 | cam->fAverageHiGainAreas->AddAt(GetAverageHiGainArea(i).Clone(),i);
|
---|
306 |
|
---|
307 | if (IsLoGain())
|
---|
308 | {
|
---|
309 |
|
---|
310 | const Int_t navlo = fAverageLoGainAreas->GetSize();
|
---|
311 | for (int i=0; i<navlo; i++)
|
---|
312 | cam->fAverageLoGainAreas->AddAt(GetAverageLoGainArea(i).Clone(),i);
|
---|
313 |
|
---|
314 | }
|
---|
315 |
|
---|
316 | return cam;
|
---|
317 | }
|
---|
318 |
|
---|
319 | // --------------------------------------------------------------------------
|
---|
320 | //
|
---|
321 | // Gets the pointers to:
|
---|
322 | // - MRawEvtData
|
---|
323 | //
|
---|
324 | Bool_t MHCalibrationChargeCam::SetupHists(const MParList *pList)
|
---|
325 | {
|
---|
326 | fRawEvt = (MPedestalSubtractedEvt*)pList->FindObject("MPedestalSubtractedEvt");
|
---|
327 | if (!fRawEvt)
|
---|
328 | {
|
---|
329 | *fLog << err << dbginf << "MPedestalSubtractedEvt not found... aborting." << endl;
|
---|
330 | return kFALSE;
|
---|
331 | }
|
---|
332 |
|
---|
333 | return kTRUE;
|
---|
334 | }
|
---|
335 |
|
---|
336 | // --------------------------------------------------------------------------
|
---|
337 | //
|
---|
338 | // Gets or creates the pointers to:
|
---|
339 | // - MExtractedSignalCam
|
---|
340 | // - MCalibrationChargeCam
|
---|
341 | // - MBadPixelsCam
|
---|
342 | //
|
---|
343 | // Initializes the number of used FADC slices from MExtractedSignalCam
|
---|
344 | // into MCalibrationChargeCam and test for changes in that variable
|
---|
345 | //
|
---|
346 | // Calls:
|
---|
347 | // - InitHiGainArrays()
|
---|
348 | // - InitLoGainArrays()
|
---|
349 | //
|
---|
350 | // Sets:
|
---|
351 | // - fSumhiarea to nareas
|
---|
352 | // - fSumloarea to nareas
|
---|
353 | // - fTimehiarea to nareas
|
---|
354 | // - fTimeloarea to nareas
|
---|
355 | // - fSumhisector to nsectors
|
---|
356 | // - fSumlosector to nsectors
|
---|
357 | // - fTimehisector to nsectors
|
---|
358 | // - fTimelosector to nsectors
|
---|
359 | // - fSathiarea to nareas
|
---|
360 | // - fSatloarea to nareas
|
---|
361 | // - fSathisector to nsectors
|
---|
362 | // - fSatlosector to nsectors
|
---|
363 | //
|
---|
364 | Bool_t MHCalibrationChargeCam::ReInitHists(MParList *pList)
|
---|
365 | {
|
---|
366 |
|
---|
367 | fSignal = (MExtractedSignalCam*)pList->FindObject(AddSerialNumber("MExtractedSignalCam"));
|
---|
368 | if (!fSignal)
|
---|
369 | {
|
---|
370 | *fLog << err << "MExtractedSignalCam not found... abort." << endl;
|
---|
371 | return kFALSE;
|
---|
372 | }
|
---|
373 |
|
---|
374 | if (!InitCams(pList,"Charge"))
|
---|
375 | return kFALSE;
|
---|
376 |
|
---|
377 | const Int_t npixels = fGeom->GetNumPixels();
|
---|
378 | const Int_t nsectors = fGeom->GetNumSectors();
|
---|
379 | const Int_t nareas = fGeom->GetNumAreas();
|
---|
380 |
|
---|
381 | //
|
---|
382 | // In case of the intense blue, double the range
|
---|
383 | //
|
---|
384 | if (fGeom->InheritsFrom("MGeomCamMagic"))
|
---|
385 | if ( fColor == MCalibrationCam::kBLUE)
|
---|
386 | SetBinning(fLoGainNbins, fLoGainFirst, 2.*fLoGainLast - fLoGainFirst);
|
---|
387 |
|
---|
388 | InitHiGainArrays(npixels,nareas,nsectors);
|
---|
389 | InitLoGainArrays(npixels,nareas,nsectors);
|
---|
390 |
|
---|
391 | fSumhiarea .Set(nareas);
|
---|
392 | fSumloarea .Set(nareas);
|
---|
393 | fTimehiarea .Set(nareas);
|
---|
394 | fTimeloarea .Set(nareas);
|
---|
395 | fSumhisector.Set(nsectors);
|
---|
396 | fSumlosector.Set(nsectors);
|
---|
397 | fTimehisector.Set(nsectors);
|
---|
398 | fTimelosector.Set(nsectors);
|
---|
399 |
|
---|
400 | fSathiarea .Set(nareas);
|
---|
401 | fSatloarea .Set(nareas);
|
---|
402 | fSathisector.Set(nsectors);
|
---|
403 | fSatlosector.Set(nsectors);
|
---|
404 |
|
---|
405 | return kTRUE;
|
---|
406 | }
|
---|
407 |
|
---|
408 | // --------------------------------------------------------------------------
|
---|
409 | //
|
---|
410 | // Retrieve:
|
---|
411 | // - fRunHeader->GetNumSamplesHiGain();
|
---|
412 | //
|
---|
413 | // Initializes the High Gain Arrays:
|
---|
414 | //
|
---|
415 | // - For every entry in the expanded arrays:
|
---|
416 | // * Initialize an MHCalibrationChargePix
|
---|
417 | // * Set Binning from fNbins, fFirst and fLast
|
---|
418 | // * Set Binning of Abs Times histogram from fAbsNbins, fAbsFirst and fAbsLast
|
---|
419 | // * Set Histgram names and titles from fHistName and fHistTitle
|
---|
420 | // * Set Abs Times Histgram names and titles from fAbsHistName and fAbsHistTitle
|
---|
421 | // * Set X-axis and Y-axis titles from fHistXTitle and fHistYTitle
|
---|
422 | // * Set X-axis and Y-axis titles of Abs Times Histogram from fAbsHistXTitle and fAbsHistYTitle
|
---|
423 | // * Call InitHists
|
---|
424 | //
|
---|
425 | //
|
---|
426 | void MHCalibrationChargeCam::InitHiGainArrays(const Int_t npixels, const Int_t nareas, const Int_t nsectors)
|
---|
427 | {
|
---|
428 |
|
---|
429 | TH1F *h;
|
---|
430 |
|
---|
431 | const Int_t higainsamples = fRunHeader->GetNumSamplesHiGain();
|
---|
432 |
|
---|
433 | if (fHiGainArray->GetSize()==0)
|
---|
434 | {
|
---|
435 | for (Int_t i=0; i<npixels; i++)
|
---|
436 | {
|
---|
437 | fHiGainArray->AddAt(new MHCalibrationChargePix(Form("%sHiGainPix%04d",fHistName.Data(),i),
|
---|
438 | Form("%s High Gain Pixel%04d",fHistTitle.Data(),i)),i);
|
---|
439 |
|
---|
440 | MHCalibrationChargePix &pix = (MHCalibrationChargePix&)(*this)[i];
|
---|
441 |
|
---|
442 | pix.SetBinning(fNbins, fFirst, fLast);
|
---|
443 | pix.SetProbLimit(fProbLimit);
|
---|
444 |
|
---|
445 | pix.SetBinningAbsTime(higainsamples, -0.5, higainsamples-0.5);
|
---|
446 |
|
---|
447 | InitHists(pix,(*fBadPixels)[i], i);
|
---|
448 |
|
---|
449 | h = pix.GetHAbsTime();
|
---|
450 |
|
---|
451 | h->SetName (Form("H%sHiGainPix%04d",fAbsHistName.Data(),i));
|
---|
452 | h->SetTitle(Form("%s High Gain Pixel %04d",fAbsHistTitle.Data(),i));
|
---|
453 | h->SetXTitle(fAbsHistXTitle.Data());
|
---|
454 | h->SetYTitle(fAbsHistYTitle.Data());
|
---|
455 | }
|
---|
456 | }
|
---|
457 |
|
---|
458 |
|
---|
459 | if (fAverageHiGainAreas->GetSize()==0)
|
---|
460 | {
|
---|
461 | for (Int_t j=0; j<nareas; j++)
|
---|
462 | {
|
---|
463 | fAverageHiGainAreas->AddAt(new MHCalibrationChargePix(Form("%sHiGainArea%d",fHistName.Data(),j),
|
---|
464 | Form("%s High Gain Area Idx %d",fHistTitle.Data(),j)),j);
|
---|
465 |
|
---|
466 | MHCalibrationChargePix &pix = (MHCalibrationChargePix&)GetAverageHiGainArea(j);
|
---|
467 |
|
---|
468 | pix.SetBinning(fNbins*(Int_t)TMath::Sqrt((Float_t)npixels/nareas),
|
---|
469 | fFirst, fLast);
|
---|
470 |
|
---|
471 | pix.SetBinningAbsTime(higainsamples, -0.5, higainsamples-0.5);
|
---|
472 |
|
---|
473 | InitHists(pix, fCam->GetAverageBadArea(j),j);
|
---|
474 |
|
---|
475 | h = pix.GetHAbsTime();
|
---|
476 |
|
---|
477 | h->SetName (Form("H%sHiGainArea%d",fAbsHistName.Data(),j));
|
---|
478 | h->SetTitle(Form("%s%s%d",fAbsHistTitle.Data(),
|
---|
479 | " averaged on event-by-event basis High Gain Area Idx ",j));
|
---|
480 | h->SetXTitle(fAbsHistXTitle.Data());
|
---|
481 | h->SetYTitle(fAbsHistYTitle.Data());
|
---|
482 | }
|
---|
483 | }
|
---|
484 |
|
---|
485 | if (fAverageHiGainSectors->GetSize()==0)
|
---|
486 | {
|
---|
487 | for (Int_t j=0; j<nsectors; j++)
|
---|
488 | {
|
---|
489 | fAverageHiGainSectors->AddAt(new MHCalibrationChargePix(Form("%sHiGainSector%02d",fHistName.Data(),j),
|
---|
490 | Form("%s High Gain Sector %02d",fHistTitle.Data(),j)),j);
|
---|
491 |
|
---|
492 | MHCalibrationChargePix &pix = (MHCalibrationChargePix&)GetAverageHiGainSector(j);
|
---|
493 |
|
---|
494 | pix.SetBinning(fNbins*(Int_t)TMath::Sqrt((Float_t)npixels/nareas),
|
---|
495 | fFirst, fLast);
|
---|
496 |
|
---|
497 | pix.SetBinningAbsTime(higainsamples, -0.5, higainsamples-0.5);
|
---|
498 |
|
---|
499 | InitHists(pix, fCam->GetAverageBadSector(j),j);
|
---|
500 |
|
---|
501 | h = pix.GetHAbsTime();
|
---|
502 |
|
---|
503 | h->SetName (Form("H%sHiGainSector%02d",fAbsHistName.Data(),j));
|
---|
504 | h->SetTitle(Form("%s%s%02d",fAbsHistTitle.Data(),
|
---|
505 | " averaged on event-by-event basis High Gain Area Sector ",j));
|
---|
506 | h->SetXTitle(fAbsHistXTitle.Data());
|
---|
507 | h->SetYTitle(fAbsHistYTitle.Data());
|
---|
508 | }
|
---|
509 | }
|
---|
510 | }
|
---|
511 |
|
---|
512 | //--------------------------------------------------------------------------------------
|
---|
513 | //
|
---|
514 | // Return, if IsLoGain() is kFALSE
|
---|
515 | //
|
---|
516 | // Retrieve:
|
---|
517 | // - fRunHeader->GetNumSamplesHiGain();
|
---|
518 | //
|
---|
519 | // Initializes the Low Gain Arrays:
|
---|
520 | //
|
---|
521 | // - For every entry in the expanded arrays:
|
---|
522 | // * Initialize an MHCalibrationChargePix
|
---|
523 | // * Set Binning from fNbins, fFirst and fLast
|
---|
524 | // * Set Binning of Abs Times histogram from fAbsNbins, fAbsFirst and fAbsLast
|
---|
525 | // * Set Histgram names and titles from fHistName and fHistTitle
|
---|
526 | // * Set Abs Times Histgram names and titles from fAbsHistName and fAbsHistTitle
|
---|
527 | // * Set X-axis and Y-axis titles from fHistXTitle and fHistYTitle
|
---|
528 | // * Set X-axis and Y-axis titles of Abs Times Histogram from fAbsHistXTitle and fAbsHistYTitle
|
---|
529 | // * Call InitHists
|
---|
530 | //
|
---|
531 | void MHCalibrationChargeCam::InitLoGainArrays(const Int_t npixels, const Int_t nareas, const Int_t nsectors)
|
---|
532 | {
|
---|
533 |
|
---|
534 | if (!IsLoGain())
|
---|
535 | return;
|
---|
536 |
|
---|
537 |
|
---|
538 | const Int_t logainsamples = fRunHeader->GetNumSamplesLoGain();
|
---|
539 |
|
---|
540 | TH1F *h;
|
---|
541 |
|
---|
542 | if (fLoGainArray->GetSize()==0 )
|
---|
543 | {
|
---|
544 | for (Int_t i=0; i<npixels; i++)
|
---|
545 | {
|
---|
546 | fLoGainArray->AddAt(new MHCalibrationChargePix(Form("%sLoGainPix%04d",fHistName.Data(),i),
|
---|
547 | Form("%s Low Gain Pixel %04d",fHistTitle.Data(),i)),i);
|
---|
548 |
|
---|
549 | MHCalibrationChargePix &pix = (MHCalibrationChargePix&)(*this)(i);
|
---|
550 |
|
---|
551 | pix.SetBinning(fLoGainNbins, fLoGainFirst, fLoGainLast);
|
---|
552 | pix.SetProbLimit(fProbLimit);
|
---|
553 |
|
---|
554 | pix.SetBinningAbsTime(logainsamples, -0.5, logainsamples-0.5);
|
---|
555 | pix.SetPickupLimit(fgLoGainPickupLimit);
|
---|
556 | pix.SetBlackoutLimit(fgLoGainBlackoutLimit);
|
---|
557 |
|
---|
558 | InitHists(pix,(*fBadPixels)[i], i);
|
---|
559 |
|
---|
560 | h = pix.GetHAbsTime();
|
---|
561 |
|
---|
562 | h->SetName (Form("H%sLoGainPix%04d",fAbsHistName.Data(),i));
|
---|
563 | h->SetTitle(Form("%s Low Gain Pixel %04d",fAbsHistTitle.Data(),i));
|
---|
564 | h->SetXTitle(fAbsHistXTitle.Data());
|
---|
565 | h->SetYTitle(fAbsHistYTitle.Data());
|
---|
566 | }
|
---|
567 | }
|
---|
568 |
|
---|
569 | if (fAverageLoGainAreas->GetSize()==0)
|
---|
570 | {
|
---|
571 | for (Int_t j=0; j<nareas; j++)
|
---|
572 | {
|
---|
573 | fAverageLoGainAreas->AddAt(new MHCalibrationChargePix(Form("%sLoGainArea%d",fHistName.Data(),j),
|
---|
574 | Form("%s Low Gain Area Idx %d",fHistTitle.Data(),j)),j);
|
---|
575 |
|
---|
576 | MHCalibrationChargePix &pix = (MHCalibrationChargePix&)GetAverageLoGainArea(j);
|
---|
577 |
|
---|
578 | pix.SetBinning(fLoGainNbins*(Int_t)TMath::Sqrt((Float_t)npixels/nareas),
|
---|
579 | fLoGainFirst, fLoGainLast);
|
---|
580 |
|
---|
581 | pix.SetBinningAbsTime(logainsamples, -0.5, logainsamples-0.5);
|
---|
582 |
|
---|
583 | InitHists(pix, fCam->GetAverageBadArea(j),j);
|
---|
584 |
|
---|
585 | h = pix.GetHAbsTime();
|
---|
586 |
|
---|
587 | h->SetName (Form("H%sLoGainArea%02d",fAbsHistName.Data(),j));
|
---|
588 | h->SetTitle(Form("%s%s%02d",fAbsHistTitle.Data(),
|
---|
589 | " averaged on event-by-event basis Low Gain Area Idx ",j));
|
---|
590 | h->SetXTitle(fAbsHistXTitle.Data());
|
---|
591 | h->SetYTitle(fAbsHistYTitle.Data());
|
---|
592 | }
|
---|
593 | }
|
---|
594 |
|
---|
595 |
|
---|
596 | if (fAverageLoGainSectors->GetSize()==0 && IsLoGain())
|
---|
597 | {
|
---|
598 | for (Int_t j=0; j<nsectors; j++)
|
---|
599 | {
|
---|
600 | fAverageLoGainSectors->AddAt(new MHCalibrationChargePix(Form("%sLoGainSector%02d",fHistName.Data(),j),
|
---|
601 | Form("%s Low Gain Sector %02d",fHistTitle.Data(),j)),j);
|
---|
602 |
|
---|
603 | MHCalibrationChargePix &pix = (MHCalibrationChargePix&)GetAverageLoGainSector(j);
|
---|
604 |
|
---|
605 | pix.SetBinning(fLoGainNbins*(Int_t)TMath::Sqrt((Float_t)npixels/nareas),
|
---|
606 | fLoGainFirst, fLoGainLast);
|
---|
607 |
|
---|
608 | pix.SetBinningAbsTime(logainsamples, -0.5, logainsamples-0.5);
|
---|
609 |
|
---|
610 | InitHists(pix, fCam->GetAverageBadSector(j),j);
|
---|
611 |
|
---|
612 | h = pix.GetHAbsTime();
|
---|
613 |
|
---|
614 | h->SetName (Form("H%sLoGainSector%02d",fAbsHistName.Data(),j));
|
---|
615 | h->SetTitle(Form("%s%s%02d",fAbsHistTitle.Data(),
|
---|
616 | " averaged on event-by-event basis Low Gain Area Sector ",j));
|
---|
617 | h->SetXTitle(fAbsHistXTitle.Data());
|
---|
618 | h->SetYTitle(fAbsHistYTitle.Data());
|
---|
619 | }
|
---|
620 | }
|
---|
621 | }
|
---|
622 |
|
---|
623 |
|
---|
624 | // --------------------------------------------------------------------------
|
---|
625 | //
|
---|
626 | // Retrieves from MExtractedSignalCam:
|
---|
627 | // - first used LoGain FADC slice
|
---|
628 | //
|
---|
629 | // Retrieves from MGeomCam:
|
---|
630 | // - number of pixels
|
---|
631 | // - number of pixel areas
|
---|
632 | // - number of sectors
|
---|
633 | //
|
---|
634 | // For all TOrdCollection's (including the averaged ones), the following steps are performed:
|
---|
635 | //
|
---|
636 | // 1) Fill Charges histograms (MHGausEvents::FillHistAndArray()) with:
|
---|
637 | // - MExtractedSignalPix::GetExtractedSignalHiGain();
|
---|
638 | // - MExtractedSignalPix::GetExtractedSignalLoGain();
|
---|
639 | //
|
---|
640 | // 2) Set number of saturated slices (MHCalibrationChargePix::AddSaturated()) with:
|
---|
641 | // - MExtractedSignalPix::IsHiGainSaturated();
|
---|
642 | // - MExtractedSignalPix::GetNumLoGainSaturated();
|
---|
643 | //
|
---|
644 | // 3) Fill AbsTime histograms (MHCalibrationChargePix::FillAbsTime()) with:
|
---|
645 | // - MRawEvtPixelIter::GetIdxMaxHiGainSample();
|
---|
646 | // - MRawEvtPixelIter::GetIdxMaxLoGainSample(first slice);
|
---|
647 | //
|
---|
648 | Bool_t MHCalibrationChargeCam::FillHists(const MParContainer *par, const Stat_t w)
|
---|
649 | {
|
---|
650 |
|
---|
651 | MExtractedSignalCam *signal = (MExtractedSignalCam*)par;
|
---|
652 | if (!signal)
|
---|
653 | {
|
---|
654 | *fLog << err << "No argument in MExtractedSignalCam::Fill... abort." << endl;
|
---|
655 | return kFALSE;
|
---|
656 | }
|
---|
657 |
|
---|
658 | const UInt_t npixels = fGeom->GetNumPixels();
|
---|
659 | const UInt_t nareas = fGeom->GetNumAreas();
|
---|
660 | const UInt_t nsectors = fGeom->GetNumSectors();
|
---|
661 |
|
---|
662 | const Int_t hifirst = fSignal->GetFirstUsedSliceHiGain();
|
---|
663 | const Int_t hilast = fSignal->GetLastUsedSliceHiGain();
|
---|
664 | const Int_t lofirst = fSignal->GetFirstUsedSliceLoGain();
|
---|
665 | const Int_t lolast = fSignal->GetLastUsedSliceLoGain();
|
---|
666 |
|
---|
667 | fSumhiarea .Reset();
|
---|
668 | fSumloarea .Reset();
|
---|
669 | fTimehiarea .Reset();
|
---|
670 | fTimeloarea .Reset();
|
---|
671 | fSumhisector.Reset();
|
---|
672 | fSumlosector.Reset();
|
---|
673 | fTimehisector.Reset();
|
---|
674 | fTimelosector.Reset();
|
---|
675 |
|
---|
676 | fSathiarea .Reset();
|
---|
677 | fSatloarea .Reset();
|
---|
678 | fSathisector.Reset();
|
---|
679 | fSatlosector.Reset();
|
---|
680 |
|
---|
681 | for (UInt_t i=0; i<npixels; i++)
|
---|
682 | {
|
---|
683 | MHCalibrationChargePix &histhi = (MHCalibrationChargePix&)(*this)[i];
|
---|
684 | if (histhi.IsExcluded())
|
---|
685 | continue;
|
---|
686 |
|
---|
687 | const Int_t aidx = (*fGeom)[i].GetAidx();
|
---|
688 | const Int_t sector = (*fGeom)[i].GetSector();
|
---|
689 |
|
---|
690 | const MExtractedSignalPix &pix = (*signal)[i];
|
---|
691 |
|
---|
692 | const Int_t sathi = pix.IsHiGainSaturated() ? 1 : 0;
|
---|
693 | histhi.AddSaturated(sathi);
|
---|
694 | if (sathi)
|
---|
695 | {
|
---|
696 | fSathiarea[aidx]++;
|
---|
697 | fSathisector[sector]++;
|
---|
698 | }
|
---|
699 |
|
---|
700 | if (pix.IsHiGainValid())
|
---|
701 | {
|
---|
702 | const Float_t sumhi = pix.GetExtractedSignalHiGain();
|
---|
703 | if (IsOscillations())
|
---|
704 | histhi.FillHistAndArray(sumhi);
|
---|
705 | else
|
---|
706 | histhi.FillHist(sumhi);
|
---|
707 |
|
---|
708 | fSumhiarea[aidx] += sumhi;
|
---|
709 | fSumhisector[sector] += sumhi;
|
---|
710 | }
|
---|
711 |
|
---|
712 | if (!IsLoGain())
|
---|
713 | continue;
|
---|
714 |
|
---|
715 | MHCalibrationChargePix &histlo = (MHCalibrationChargePix&)(*this)(i);
|
---|
716 |
|
---|
717 | const Int_t satlo = pix.IsLoGainSaturated() ? 1 : 0;
|
---|
718 | histlo.AddSaturated(satlo);
|
---|
719 | if (satlo)
|
---|
720 | {
|
---|
721 | fSatloarea[aidx]++;
|
---|
722 | fSatlosector[sector]++;
|
---|
723 | }
|
---|
724 |
|
---|
725 | /*
|
---|
726 | // Previously:
|
---|
727 | fSatloarea[aidx] += pix.GetNumHiGainSaturated();
|
---|
728 | fSatlosector[sector] += pix.GetNumHiGainSaturated();
|
---|
729 | */
|
---|
730 |
|
---|
731 | if (pix.IsLoGainValid())
|
---|
732 | {
|
---|
733 | const Float_t sumlo = pix.GetExtractedSignalLoGain();
|
---|
734 |
|
---|
735 | if (IsOscillations())
|
---|
736 | histlo.FillHistAndArray(sumlo);
|
---|
737 | else
|
---|
738 | histlo.FillHist(sumlo);
|
---|
739 |
|
---|
740 | fSumloarea[aidx] += sumlo;
|
---|
741 | fSumlosector[sector] += sumlo;
|
---|
742 | }
|
---|
743 | }
|
---|
744 |
|
---|
745 | const Int_t npix = fRawEvt->GetNumPixels();
|
---|
746 | const Int_t nhi = fRunHeader->GetNumSamplesHiGain();
|
---|
747 | for (int pixid=0; pixid<npix; pixid++)
|
---|
748 | {
|
---|
749 | MHCalibrationChargePix &histhi = (MHCalibrationChargePix&)(*this)[pixid];
|
---|
750 | if (histhi.IsExcluded())
|
---|
751 | continue;
|
---|
752 |
|
---|
753 | const Float_t timehi = fRawEvt->GetMax(pixid, hifirst, hilast)+hifirst;
|
---|
754 | histhi.FillAbsTime(timehi);
|
---|
755 |
|
---|
756 | const Int_t aidx = (*fGeom)[pixid].GetAidx();
|
---|
757 | const Int_t sector = (*fGeom)[pixid].GetSector();
|
---|
758 |
|
---|
759 | fTimehiarea [aidx] += timehi;
|
---|
760 | fTimehisector[sector] += timehi;
|
---|
761 |
|
---|
762 | if (IsLoGain())
|
---|
763 | {
|
---|
764 | MHCalibrationChargePix &histlo = (MHCalibrationChargePix&)(*this)(pixid);
|
---|
765 |
|
---|
766 | const Float_t timelo = fRawEvt->GetMax(pixid, nhi+lofirst, nhi+lolast)+lofirst;
|
---|
767 | histlo.FillAbsTime(timelo);
|
---|
768 |
|
---|
769 | fTimeloarea[aidx] += timelo;
|
---|
770 | fTimelosector[sector] += timelo;
|
---|
771 | }
|
---|
772 | }
|
---|
773 |
|
---|
774 | for (UInt_t j=0; j<nareas; j++)
|
---|
775 | {
|
---|
776 |
|
---|
777 | const Int_t npix = fAverageAreaNum[j];
|
---|
778 |
|
---|
779 | if (npix == 0)
|
---|
780 | continue;
|
---|
781 |
|
---|
782 | MHCalibrationChargePix &hipix = (MHCalibrationChargePix&)GetAverageHiGainArea(j);
|
---|
783 |
|
---|
784 | if (IsOscillations())
|
---|
785 | hipix.FillHistAndArray(fSumhiarea [j]/npix);
|
---|
786 | else
|
---|
787 | hipix.FillHist(fSumhiarea[j]/npix);
|
---|
788 |
|
---|
789 | hipix.AddSaturated ((Float_t)fSathiarea [j]/npix > 0.5 ? 1 : 0);
|
---|
790 | hipix.FillAbsTime (fTimehiarea[j]/npix);
|
---|
791 |
|
---|
792 | if (IsLoGain())
|
---|
793 | {
|
---|
794 | MHCalibrationChargePix &lopix = (MHCalibrationChargePix&)GetAverageLoGainArea(j);
|
---|
795 | if (IsOscillations())
|
---|
796 | lopix.FillHistAndArray(fSumloarea [j]/npix);
|
---|
797 | else
|
---|
798 | lopix.FillHist(fSumloarea [j]/npix);
|
---|
799 | lopix.AddSaturated ((Float_t)fSatloarea [j]/npix > 0.5 ? 1 : 0);
|
---|
800 | lopix.FillAbsTime (fTimeloarea[j]/npix);
|
---|
801 | }
|
---|
802 | }
|
---|
803 |
|
---|
804 | for (UInt_t j=0; j<nsectors; j++)
|
---|
805 | {
|
---|
806 |
|
---|
807 | const Int_t npix = fAverageSectorNum[j];
|
---|
808 |
|
---|
809 | if (npix == 0)
|
---|
810 | continue;
|
---|
811 |
|
---|
812 | MHCalibrationChargePix &hipix = (MHCalibrationChargePix&)GetAverageHiGainSector(j);
|
---|
813 |
|
---|
814 | if (IsOscillations())
|
---|
815 | hipix.FillHistAndArray(fSumhisector [j]/npix);
|
---|
816 | else
|
---|
817 | hipix.FillHist(fSumhisector [j]/npix);
|
---|
818 |
|
---|
819 | hipix.AddSaturated ((Float_t)fSathisector[j]/npix > 0.5 ? 1 : 0);
|
---|
820 | hipix.FillAbsTime (fTimehisector[j]/npix);
|
---|
821 |
|
---|
822 | if (IsLoGain())
|
---|
823 | {
|
---|
824 | MHCalibrationChargePix &lopix = (MHCalibrationChargePix&)GetAverageLoGainSector(j);
|
---|
825 |
|
---|
826 | if (IsOscillations())
|
---|
827 | lopix.FillHistAndArray(fSumlosector [j]/npix);
|
---|
828 | else
|
---|
829 | lopix.FillHist(fSumlosector [j]/npix);
|
---|
830 |
|
---|
831 | lopix.AddSaturated ((Float_t)fSatlosector[j]/npix > 0.5 ? 1 : 0);
|
---|
832 | lopix.FillAbsTime (fTimelosector[j]/npix);
|
---|
833 | }
|
---|
834 | }
|
---|
835 |
|
---|
836 | return kTRUE;
|
---|
837 | }
|
---|
838 |
|
---|
839 | // --------------------------------------------------------------------------
|
---|
840 | //
|
---|
841 | // For all TOrdCollection's (including the averaged ones), the following steps are performed:
|
---|
842 | //
|
---|
843 | // 1) Returns if the pixel is excluded.
|
---|
844 | // 2) Tests saturation. In case yes, set the flag: MCalibrationPix::SetHiGainSaturation()
|
---|
845 | // or the flag: MBadPixelsPix::SetUncalibrated( MBadPixelsPix::kLoGainSaturated )
|
---|
846 | // 3) Store the absolute arrival times in the MCalibrationChargePix's. If flag
|
---|
847 | // MCalibrationPix::IsHiGainSaturation() is set, the Low-Gain arrival times are stored,
|
---|
848 | // otherwise the Hi-Gain ones.
|
---|
849 | // 4) Calls to MHCalibrationCam::FitHiGainArrays() and MCalibrationCam::FitLoGainArrays()
|
---|
850 | // with the flags:
|
---|
851 | // - MBadPixelsPix::SetUncalibrated( MBadPixelsPix::kHiGainNotFitted )
|
---|
852 | // - MBadPixelsPix::SetUncalibrated( MBadPixelsPix::kLoGainNotFitted )
|
---|
853 | // - MBadPixelsPix::SetUncalibrated( MBadPixelsPix::kHiGainOscillating )
|
---|
854 | // - MBadPixelsPix::SetUncalibrated( MBadPixelsPix::kLoGainOscillating )
|
---|
855 | //
|
---|
856 | Bool_t MHCalibrationChargeCam::FinalizeHists()
|
---|
857 | {
|
---|
858 |
|
---|
859 | *fLog << endl;
|
---|
860 |
|
---|
861 | TH1F *h = NULL;
|
---|
862 |
|
---|
863 | const Int_t hifirst = fSignal->GetFirstUsedSliceHiGain();
|
---|
864 | const Int_t hilast = fSignal->GetLastUsedSliceHiGain();
|
---|
865 | const Int_t lofirst = fSignal->GetFirstUsedSliceLoGain();
|
---|
866 | const Int_t lolast = fSignal->GetLastUsedSliceLoGain();
|
---|
867 |
|
---|
868 | for (Int_t i=0; i<fHiGainArray->GetSize(); i++)
|
---|
869 | {
|
---|
870 |
|
---|
871 | MHCalibrationChargePix &histhi = (MHCalibrationChargePix&)(*this)[i];
|
---|
872 | if (histhi.IsExcluded())
|
---|
873 | continue;
|
---|
874 |
|
---|
875 | MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
|
---|
876 |
|
---|
877 | const Int_t numsat = histhi.GetSaturated();
|
---|
878 |
|
---|
879 | pix.SetNumSaturated(numsat);
|
---|
880 |
|
---|
881 | if (numsat > fNumHiGainSaturationLimit*histhi.GetHGausHist()->GetEntries())
|
---|
882 | {
|
---|
883 | pix.SetHiGainSaturation();
|
---|
884 | if (IsOscillations())
|
---|
885 | histhi.CreateFourierSpectrum();
|
---|
886 | continue;
|
---|
887 | }
|
---|
888 |
|
---|
889 | MBadPixelsPix &bad = (*fBadPixels)[i];
|
---|
890 |
|
---|
891 | h = histhi.GetHGausHist();
|
---|
892 |
|
---|
893 | Stat_t overflow = h->GetBinContent(h->GetNbinsX()+1);
|
---|
894 | if (overflow > fOverflowLimit*histhi.GetHGausHist()->GetEntries())
|
---|
895 | {
|
---|
896 | *fLog << warn
|
---|
897 | << "HiGain Hist-overflow " << overflow
|
---|
898 | << " times in: " << histhi.GetName() << " (w/o saturation!) " << endl;
|
---|
899 | bad.SetUncalibrated( MBadPixelsPix::kHiGainOverFlow );
|
---|
900 | }
|
---|
901 |
|
---|
902 | overflow = h->GetBinContent(0);
|
---|
903 | if (overflow > fOverflowLimit*histhi.GetHGausHist()->GetEntries())
|
---|
904 | {
|
---|
905 | *fLog << warn
|
---|
906 | << "HiGain Hist-underflow " << overflow
|
---|
907 | << " times in pix: " << histhi.GetName() << " (w/o saturation!) " << endl;
|
---|
908 | bad.SetUncalibrated( MBadPixelsPix::kHiGainOverFlow );
|
---|
909 | }
|
---|
910 |
|
---|
911 | FinalizeAbsTimes(histhi, pix, bad, hifirst, hilast);
|
---|
912 | }
|
---|
913 |
|
---|
914 | if (IsLoGain())
|
---|
915 | for (Int_t i=0; i<fLoGainArray->GetSize(); i++)
|
---|
916 | {
|
---|
917 |
|
---|
918 | MHCalibrationChargePix &histlo = (MHCalibrationChargePix&)(*this)(i);
|
---|
919 |
|
---|
920 | if (histlo.IsExcluded())
|
---|
921 | continue;
|
---|
922 |
|
---|
923 | MBadPixelsPix &bad = (*fBadPixels)[i];
|
---|
924 | if (histlo.GetSaturated() > fNumLoGainSaturationLimit*histlo.GetHGausHist()->GetEntries())
|
---|
925 | {
|
---|
926 | *fLog << warn << "Pixel " << setw(4) << i << ": More than " << Form("%.1f%%", fNumLoGainSaturationLimit*100) << " lo-gains saturated." << endl;
|
---|
927 | bad.SetUncalibrated( MBadPixelsPix::kLoGainSaturation );
|
---|
928 | if (IsOscillations())
|
---|
929 | histlo.CreateFourierSpectrum();
|
---|
930 | continue;
|
---|
931 | }
|
---|
932 |
|
---|
933 | MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i] ;
|
---|
934 | if (!pix.IsHiGainSaturation())
|
---|
935 | continue;
|
---|
936 |
|
---|
937 | h = histlo.GetHGausHist();
|
---|
938 |
|
---|
939 | Stat_t overflow = h->GetBinContent(h->GetNbinsX()+1);
|
---|
940 | if (overflow > fOverflowLimit*histlo.GetHGausHist()->GetEntries())
|
---|
941 | {
|
---|
942 | *fLog << warn
|
---|
943 | << "LoGain Hist-overflow " << overflow
|
---|
944 | << " times in: " << histlo.GetName() << " (w/o saturation!) " << endl;
|
---|
945 | bad.SetUncalibrated( MBadPixelsPix::kLoGainOverFlow );
|
---|
946 | }
|
---|
947 |
|
---|
948 | overflow = h->GetBinContent(0);
|
---|
949 | if (overflow > fOverflowLimit*histlo.GetHGausHist()->GetEntries())
|
---|
950 | {
|
---|
951 | *fLog << warn
|
---|
952 | << "LoGain Hist-underflow " << overflow
|
---|
953 | << " times in: " << histlo.GetName() << " (w/o saturation!) " << endl;
|
---|
954 | bad.SetUncalibrated( MBadPixelsPix::kLoGainOverFlow );
|
---|
955 | }
|
---|
956 |
|
---|
957 | FinalizeAbsTimes(histlo, pix, bad, lofirst, lolast);
|
---|
958 | }
|
---|
959 |
|
---|
960 | for (Int_t j=0; j<fAverageHiGainAreas->GetSize(); j++)
|
---|
961 | {
|
---|
962 |
|
---|
963 | MHCalibrationChargePix &histhi = (MHCalibrationChargePix&)GetAverageHiGainArea(j);
|
---|
964 | MCalibrationChargePix &pix = (MCalibrationChargePix&)fCam->GetAverageArea(j);
|
---|
965 |
|
---|
966 | if (histhi.GetSaturated() > fNumHiGainSaturationLimit*histhi.GetHGausHist()->GetEntries())
|
---|
967 | {
|
---|
968 | pix.SetHiGainSaturation();
|
---|
969 | if (IsOscillations())
|
---|
970 | histhi.CreateFourierSpectrum();
|
---|
971 | continue;
|
---|
972 | }
|
---|
973 |
|
---|
974 | MBadPixelsPix &bad = fCam->GetAverageBadArea(j);
|
---|
975 | FinalizeAbsTimes(histhi, pix, bad, hifirst, hilast);
|
---|
976 | }
|
---|
977 |
|
---|
978 | if (IsLoGain())
|
---|
979 | for (Int_t j=0; j<fAverageLoGainAreas->GetSize(); j++)
|
---|
980 | {
|
---|
981 |
|
---|
982 | MHCalibrationChargePix &histlo = (MHCalibrationChargePix&)GetAverageLoGainArea(j);
|
---|
983 |
|
---|
984 | if (histlo.GetSaturated() > fNumLoGainSaturationLimit*histlo.GetHGausHist()->GetEntries())
|
---|
985 | {
|
---|
986 | *fLog << warn << "Area " << setw(4) << j << ": More than " << Form("%.1f%%", fNumLoGainSaturationLimit*100) << " lo-gains saturated." << endl;
|
---|
987 | if (IsOscillations())
|
---|
988 | histlo.CreateFourierSpectrum();
|
---|
989 | continue;
|
---|
990 | }
|
---|
991 |
|
---|
992 | MCalibrationChargePix &pix = (MCalibrationChargePix&)fCam->GetAverageArea(j);
|
---|
993 | if (pix.IsHiGainSaturation())
|
---|
994 | {
|
---|
995 | MBadPixelsPix &bad = fCam->GetAverageBadArea(j);
|
---|
996 | FinalizeAbsTimes(histlo, pix, bad, lofirst, lolast);
|
---|
997 | }
|
---|
998 |
|
---|
999 | }
|
---|
1000 |
|
---|
1001 | for (Int_t j=0; j<fAverageHiGainSectors->GetSize(); j++)
|
---|
1002 | {
|
---|
1003 |
|
---|
1004 | MHCalibrationChargePix &histhi = (MHCalibrationChargePix&)GetAverageHiGainSector(j);
|
---|
1005 | MCalibrationChargePix &pix = (MCalibrationChargePix&)fCam->GetAverageSector(j);
|
---|
1006 |
|
---|
1007 | if (histhi.GetSaturated() > fNumHiGainSaturationLimit*histhi.GetHGausHist()->GetEntries())
|
---|
1008 | {
|
---|
1009 | pix.SetHiGainSaturation();
|
---|
1010 | if (IsOscillations())
|
---|
1011 | histhi.CreateFourierSpectrum();
|
---|
1012 | continue;
|
---|
1013 | }
|
---|
1014 |
|
---|
1015 | MBadPixelsPix &bad = fCam->GetAverageBadSector(j);
|
---|
1016 | FinalizeAbsTimes(histhi, pix, bad, hifirst, hilast);
|
---|
1017 | }
|
---|
1018 |
|
---|
1019 | if (IsLoGain())
|
---|
1020 | for (Int_t j=0; j<fAverageLoGainSectors->GetSize(); j++)
|
---|
1021 | {
|
---|
1022 |
|
---|
1023 | MHCalibrationChargePix &histlo = (MHCalibrationChargePix&)GetAverageLoGainSector(j);
|
---|
1024 | MBadPixelsPix &bad = fCam->GetAverageBadSector(j);
|
---|
1025 |
|
---|
1026 | if (histlo.GetSaturated() > fNumLoGainSaturationLimit*histlo.GetHGausHist()->GetEntries())
|
---|
1027 | {
|
---|
1028 | *fLog << warn << "Sector " << setw(4) << j << ": More than " << Form("%.1f%%", fNumLoGainSaturationLimit*100) << " lo-gains saturated." << endl;
|
---|
1029 | bad.SetUncalibrated( MBadPixelsPix::kLoGainSaturation );
|
---|
1030 | if (IsOscillations())
|
---|
1031 | histlo.CreateFourierSpectrum();
|
---|
1032 | continue;
|
---|
1033 | }
|
---|
1034 |
|
---|
1035 | MCalibrationChargePix &pix = (MCalibrationChargePix&)fCam->GetAverageSector(j);
|
---|
1036 | if (pix.IsHiGainSaturation())
|
---|
1037 | FinalizeAbsTimes(histlo, pix, bad, lofirst, lolast);
|
---|
1038 | }
|
---|
1039 |
|
---|
1040 | //
|
---|
1041 | // Perform the fitting for the High Gain (done in MHCalibrationCam)
|
---|
1042 | //
|
---|
1043 | FitHiGainArrays(*fCam, *fBadPixels,
|
---|
1044 | MBadPixelsPix::kHiGainNotFitted,
|
---|
1045 | MBadPixelsPix::kHiGainOscillating);
|
---|
1046 |
|
---|
1047 | //
|
---|
1048 | // Perform the fitting for the Low Gain (done in MHCalibrationCam)
|
---|
1049 | //
|
---|
1050 | if (IsLoGain())
|
---|
1051 | FitLoGainArrays(*fCam, *fBadPixels,
|
---|
1052 | MBadPixelsPix::kLoGainNotFitted,
|
---|
1053 | MBadPixelsPix::kLoGainOscillating);
|
---|
1054 |
|
---|
1055 | //
|
---|
1056 | // Check for pixels which have the high-gain saturated, but the low-gain
|
---|
1057 | // switch not applied in sufficient cases. Have to exclude these pixels,
|
---|
1058 | // although they not abnormal. They simply cannot be calibrated...
|
---|
1059 | //
|
---|
1060 | for (Int_t i=0; i<fLoGainArray->GetSize(); i++)
|
---|
1061 | {
|
---|
1062 |
|
---|
1063 | MHCalibrationChargePix &histlo = (MHCalibrationChargePix&)(*this)(i);
|
---|
1064 | if (histlo.IsExcluded())
|
---|
1065 | continue;
|
---|
1066 |
|
---|
1067 | MCalibrationChargePix &pix = (MCalibrationChargePix&)(*fCam)[i];
|
---|
1068 | if (!pix.IsHiGainSaturation())
|
---|
1069 | continue;
|
---|
1070 |
|
---|
1071 | //
|
---|
1072 | // Now,treat only low-gain calibrated pixels:
|
---|
1073 | //
|
---|
1074 | const Double_t lim = fNumLoGainBlackoutLimit*histlo.GetHGausHist()->GetEntries();
|
---|
1075 | if (histlo.GetBlackout() <= lim)
|
---|
1076 | continue;
|
---|
1077 |
|
---|
1078 | MBadPixelsPix &bad = (*fBadPixels)[i];
|
---|
1079 | bad.SetUnsuitable(MBadPixelsPix::kUnsuitableRun);
|
---|
1080 | bad.SetUncalibrated(MBadPixelsPix::kLoGainBlackout);
|
---|
1081 | }
|
---|
1082 |
|
---|
1083 | return kTRUE;
|
---|
1084 | }
|
---|
1085 |
|
---|
1086 | // --------------------------------------------------------------------------------
|
---|
1087 | //
|
---|
1088 | // Fill the absolute time results into MCalibrationChargePix
|
---|
1089 | //
|
---|
1090 | // Check absolute time validity:
|
---|
1091 | // - Mean arrival time is at least fTimeLowerLimit slices from the lower edge
|
---|
1092 | // - Mean arrival time is at least fUpperLimit slices from the upper edge
|
---|
1093 | //
|
---|
1094 | void MHCalibrationChargeCam::FinalizeAbsTimes(MHCalibrationChargePix &hist, MCalibrationChargePix &pix, MBadPixelsPix &bad,
|
---|
1095 | Int_t first, Int_t last)
|
---|
1096 | {
|
---|
1097 | const Float_t mean = hist.GetAbsTimeMean();
|
---|
1098 | const Float_t rms = hist.GetAbsTimeRms();
|
---|
1099 |
|
---|
1100 | pix.SetAbsTimeMean(mean);
|
---|
1101 | pix.SetAbsTimeRms(rms);
|
---|
1102 |
|
---|
1103 | const Float_t lowerlimit = (Float_t)first+1;// + fTimeLowerLimit;
|
---|
1104 | const Float_t upperlimit = (Float_t)last -1;// - fTimeUpperLimit;
|
---|
1105 |
|
---|
1106 | // FIXME: instead of checking whether the maximum is in the first or
|
---|
1107 | // last extracted slice we should check whether the extractor
|
---|
1108 | // was able to properly extract the signal!!!
|
---|
1109 |
|
---|
1110 | if (mean<lowerlimit)
|
---|
1111 | {
|
---|
1112 | *fLog << warn << hist.GetName() << ": Mean Arr.Time: "
|
---|
1113 | << Form("%4.1f < %4.1f (first used fadc sl+1)", mean, lowerlimit) << endl;
|
---|
1114 | bad.SetUncalibrated(MBadPixelsPix::kMeanTimeInFirstBin);
|
---|
1115 | }
|
---|
1116 |
|
---|
1117 | if (mean>upperlimit)
|
---|
1118 | {
|
---|
1119 | *fLog << warn << hist.GetName() << ": Mean Arr.Time: "
|
---|
1120 | << Form("%4.1f > %4.1f (last used fadc sl-1)", mean, upperlimit) << endl;
|
---|
1121 | bad.SetUncalibrated(MBadPixelsPix::kMeanTimeInLast2Bins);
|
---|
1122 | }
|
---|
1123 | }
|
---|
1124 |
|
---|
1125 | // --------------------------------------------------------------------------
|
---|
1126 | //
|
---|
1127 | // Sets all pixels to MBadPixelsPix::kUnsuitableRun, if following flags are set:
|
---|
1128 | // - MBadPixelsPix::kLoGainSaturation
|
---|
1129 | //
|
---|
1130 | // Sets all pixels to MBadPixelsPix::kUnreliableRun, if following flags are set:
|
---|
1131 | // - if MBadPixelsPix::kHiGainNotFitted and !MCalibrationPix::IsHiGainSaturation()
|
---|
1132 | // - if MBadPixelsPix::kHiGainOscillating and !MCalibrationPix::IsHiGainSaturation()
|
---|
1133 | // - if MBadPixelsPix::kLoGainNotFitted and MCalibrationPix::IsLoGainSaturation()
|
---|
1134 | // - if MBadPixelsPix::kLoGainOscillating and MCalibrationPix::IsLoGainSaturation()
|
---|
1135 | //
|
---|
1136 | void MHCalibrationChargeCam::FinalizeBadPixels()
|
---|
1137 | {
|
---|
1138 |
|
---|
1139 | for (Int_t i=0; i<fBadPixels->GetSize(); i++)
|
---|
1140 | {
|
---|
1141 |
|
---|
1142 | MBadPixelsPix &bad = (*fBadPixels)[i];
|
---|
1143 | MCalibrationPix &pix = (*fCam)[i];
|
---|
1144 |
|
---|
1145 | if (bad.IsUncalibrated(MBadPixelsPix::kHiGainNotFitted))
|
---|
1146 | if (!pix.IsHiGainSaturation())
|
---|
1147 | bad.SetUnsuitable(MBadPixelsPix::kUnreliableRun);
|
---|
1148 |
|
---|
1149 | if (bad.IsUncalibrated(MBadPixelsPix::kLoGainNotFitted))
|
---|
1150 | if (pix.IsHiGainSaturation())
|
---|
1151 | bad.SetUnsuitable(MBadPixelsPix::kUnreliableRun);
|
---|
1152 |
|
---|
1153 | if (bad.IsUncalibrated(MBadPixelsPix::kLoGainSaturation))
|
---|
1154 | bad.SetUnsuitable(MBadPixelsPix::kUnsuitableRun);
|
---|
1155 |
|
---|
1156 | if (IsOscillations())
|
---|
1157 | {
|
---|
1158 | if (bad.IsUncalibrated(MBadPixelsPix::kHiGainOscillating))
|
---|
1159 | if (!pix.IsHiGainSaturation())
|
---|
1160 | bad.SetUnsuitable(MBadPixelsPix::kUnreliableRun);
|
---|
1161 |
|
---|
1162 | if (bad.IsUncalibrated(MBadPixelsPix::kLoGainOscillating))
|
---|
1163 | if (pix.IsHiGainSaturation())
|
---|
1164 | bad.SetUnsuitable(MBadPixelsPix::kUnreliableRun);
|
---|
1165 | }
|
---|
1166 | }
|
---|
1167 | }
|
---|
1168 |
|
---|
1169 | // --------------------------------------------------------------------------
|
---|
1170 | //
|
---|
1171 | // Calls MHCalibrationPix::DrawClone() for pixel idx
|
---|
1172 | //
|
---|
1173 | void MHCalibrationChargeCam::DrawPixelContent(Int_t idx) const
|
---|
1174 | {
|
---|
1175 | (*this)[idx].DrawClone();
|
---|
1176 | }
|
---|
1177 |
|
---|
1178 |
|
---|
1179 | // -----------------------------------------------------------------------------
|
---|
1180 | //
|
---|
1181 | // Default draw:
|
---|
1182 | //
|
---|
1183 | // Displays the averaged areas, both High Gain and Low Gain
|
---|
1184 | //
|
---|
1185 | // Calls the Draw of the fAverageHiGainAreas and fAverageLoGainAreas objects with options
|
---|
1186 | //
|
---|
1187 | void MHCalibrationChargeCam::Draw(const Option_t *opt)
|
---|
1188 | {
|
---|
1189 |
|
---|
1190 | const Int_t nareas = fAverageHiGainAreas->GetSize();
|
---|
1191 | if (nareas == 0)
|
---|
1192 | return;
|
---|
1193 |
|
---|
1194 | TString option(opt);
|
---|
1195 | option.ToLower();
|
---|
1196 |
|
---|
1197 | if (!option.Contains("datacheck"))
|
---|
1198 | {
|
---|
1199 | MHCalibrationCam::Draw(opt);
|
---|
1200 | return;
|
---|
1201 | }
|
---|
1202 |
|
---|
1203 | //
|
---|
1204 | // From here on , the datacheck - Draw
|
---|
1205 | //
|
---|
1206 | TVirtualPad *pad = gPad ? gPad : MH::MakeDefCanvas(this);
|
---|
1207 | pad->SetBorderMode(0);
|
---|
1208 | pad->Divide(1,nareas);
|
---|
1209 |
|
---|
1210 | //
|
---|
1211 | // Loop over inner and outer pixels
|
---|
1212 | //
|
---|
1213 | for (Int_t i=0; i<nareas;i++)
|
---|
1214 | {
|
---|
1215 |
|
---|
1216 | pad->cd(i+1);
|
---|
1217 |
|
---|
1218 | MHCalibrationChargePix &hipix = (MHCalibrationChargePix&)GetAverageHiGainArea(i);
|
---|
1219 | //
|
---|
1220 | // Ask for Hi-Gain saturation
|
---|
1221 | //
|
---|
1222 | if (hipix.GetSaturated() > fNumHiGainSaturationLimit*hipix.GetHGausHist()->GetEntries() && IsLoGain())
|
---|
1223 | {
|
---|
1224 | MHCalibrationChargePix &lopix = (MHCalibrationChargePix&)GetAverageLoGainArea(i);
|
---|
1225 | DrawDataCheckPixel(lopix,i ? fOuterRefCharge : fInnerRefCharge);
|
---|
1226 | }
|
---|
1227 | else
|
---|
1228 | DrawDataCheckPixel(hipix,i ? fOuterRefCharge : fInnerRefCharge);
|
---|
1229 |
|
---|
1230 | }
|
---|
1231 | }
|
---|
1232 |
|
---|
1233 | // -----------------------------------------------------------------------------
|
---|
1234 | //
|
---|
1235 | // Draw the average pixel for the datacheck:
|
---|
1236 | //
|
---|
1237 | // Displays the averaged areas, both High Gain and Low Gain
|
---|
1238 | //
|
---|
1239 | // Calls the Draw of the fAverageHiGainAreas and fAverageLoGainAreas objects with options
|
---|
1240 | //
|
---|
1241 | void MHCalibrationChargeCam::DrawDataCheckPixel(MHCalibrationChargePix &pix, const Float_t refline)
|
---|
1242 | {
|
---|
1243 | if (pix.IsEmpty())
|
---|
1244 | return;
|
---|
1245 |
|
---|
1246 | TVirtualPad *pad = gPad;
|
---|
1247 | pad->Divide(1,2, 1e-10, 1e-10);
|
---|
1248 | pad->cd(1);
|
---|
1249 |
|
---|
1250 | gPad->SetBorderMode(0);
|
---|
1251 | gPad->SetTicks();
|
---|
1252 | if (!pix.IsEmpty() && !pix.IsOnlyOverflow() && !pix.IsOnlyUnderflow())
|
---|
1253 | gPad->SetLogy();
|
---|
1254 |
|
---|
1255 | TH1F *hist = pix.GetHGausHist();
|
---|
1256 | TAxis *xaxe = hist->GetXaxis();
|
---|
1257 | TAxis *yaxe = hist->GetYaxis();
|
---|
1258 | xaxe->CenterTitle();
|
---|
1259 | yaxe->CenterTitle();
|
---|
1260 | xaxe->SetTitleSize(0.07);
|
---|
1261 | yaxe->SetTitleSize(0.07);
|
---|
1262 | xaxe->SetTitleOffset(0.7);
|
---|
1263 | yaxe->SetTitleOffset(0.55);
|
---|
1264 | xaxe->SetLabelSize(0.06);
|
---|
1265 | yaxe->SetLabelSize(0.06);
|
---|
1266 | xaxe->SetTitle(hist->GetXaxis()->GetTitle());
|
---|
1267 | yaxe->SetTitle(hist->GetYaxis()->GetTitle());
|
---|
1268 | xaxe->SetRange(hist->GetMaximumBin()-50, hist->GetMaximumBin()+50);
|
---|
1269 |
|
---|
1270 | gStyle->SetOptFit();
|
---|
1271 |
|
---|
1272 | hist->Draw();
|
---|
1273 |
|
---|
1274 | TF1 *fit = pix.GetFGausFit();
|
---|
1275 | if (fit)
|
---|
1276 | {
|
---|
1277 | switch (fColor)
|
---|
1278 | {
|
---|
1279 | case MCalibrationCam::kGREEN:
|
---|
1280 | fit->SetLineColor(kGreen);
|
---|
1281 | break;
|
---|
1282 | case MCalibrationCam::kBLUE:
|
---|
1283 | fit->SetLineColor(kBlue);
|
---|
1284 | break;
|
---|
1285 | case MCalibrationCam::kUV:
|
---|
1286 | fit->SetLineColor(106);
|
---|
1287 | break;
|
---|
1288 | case MCalibrationCam::kCT1:
|
---|
1289 | fit->SetLineColor(006);
|
---|
1290 | break;
|
---|
1291 | default:
|
---|
1292 | fit->SetLineColor(kRed);
|
---|
1293 | }
|
---|
1294 | fit->Draw("same");
|
---|
1295 | }
|
---|
1296 |
|
---|
1297 | DisplayRefLines(hist,refline);
|
---|
1298 |
|
---|
1299 | pad->cd(2);
|
---|
1300 | gPad->SetBorderMode(0);
|
---|
1301 | gPad->SetTicks();
|
---|
1302 |
|
---|
1303 | pix.CreateGraphEvents();
|
---|
1304 | TGraph *gr = pix.GetGraphEvents();
|
---|
1305 | if (gr)
|
---|
1306 | {
|
---|
1307 | TH1F *null2 = gr->GetHistogram();
|
---|
1308 |
|
---|
1309 | null2->SetMinimum(pix.GetMean()-10.*pix.GetSigma());
|
---|
1310 | null2->SetMaximum(pix.GetMean()+10.*pix.GetSigma());
|
---|
1311 | null2->SetStats(kFALSE);
|
---|
1312 |
|
---|
1313 | //
|
---|
1314 | // set the labels bigger
|
---|
1315 | //
|
---|
1316 | TAxis *xaxe2 = null2->GetXaxis();
|
---|
1317 | TAxis *yaxe2 = null2->GetYaxis();
|
---|
1318 | xaxe2->CenterTitle();
|
---|
1319 | yaxe2->CenterTitle();
|
---|
1320 | xaxe2->SetTitleSize(0.07);
|
---|
1321 | yaxe2->SetTitleSize(0.07);
|
---|
1322 | xaxe2->SetTitleOffset(0.7);
|
---|
1323 | yaxe2->SetTitleOffset(0.55);
|
---|
1324 | xaxe2->SetLabelSize(0.06);
|
---|
1325 | yaxe2->SetLabelSize(0.06);
|
---|
1326 | xaxe2->SetRangeUser(0, pix.GetEvents()->GetSize()/pix.GetEventFrequency());
|
---|
1327 | }
|
---|
1328 |
|
---|
1329 | pix.DrawEvents();
|
---|
1330 |
|
---|
1331 | // newpad->cd(3);
|
---|
1332 | // pix.DrawPowerSpectrum(*newpad,4);
|
---|
1333 | }
|
---|
1334 |
|
---|
1335 | void MHCalibrationChargeCam::DisplayRefLines(const TH1F *hist, const Float_t refline) const
|
---|
1336 | {
|
---|
1337 | TLine *line = new TLine(refline, 0, refline, hist->GetMaximum());
|
---|
1338 | line->SetLineColor(106);
|
---|
1339 | line->SetLineStyle(2);
|
---|
1340 | line->SetLineWidth(3);
|
---|
1341 | line->SetBit(kCanDelete);
|
---|
1342 | line->Draw();
|
---|
1343 |
|
---|
1344 | TLegend *leg = new TLegend(0.8,0.01,0.99,0.45);
|
---|
1345 | leg->AddEntry(line, "10 Leds UV", "l");
|
---|
1346 | leg->SetBit(kCanDelete);
|
---|
1347 | leg->Draw();
|
---|
1348 | }
|
---|
1349 |
|
---|
1350 | Int_t MHCalibrationChargeCam::ReadEnv(const TEnv &env, TString prefix, Bool_t print)
|
---|
1351 | {
|
---|
1352 |
|
---|
1353 | Int_t rc = MHCalibrationCam::ReadEnv(env,prefix,print);
|
---|
1354 | if (rc==kERROR)
|
---|
1355 | return kERROR;
|
---|
1356 |
|
---|
1357 | if (IsEnvDefined(env, prefix, "HiGainNbins", print))
|
---|
1358 | {
|
---|
1359 | fNbins = GetEnvValue(env, prefix, "HiGainNbins", fNbins);
|
---|
1360 | rc = kTRUE;
|
---|
1361 | }
|
---|
1362 |
|
---|
1363 | if (IsEnvDefined(env, prefix, "HiGainFirst", print))
|
---|
1364 | {
|
---|
1365 | fFirst = GetEnvValue(env, prefix, "HiGainFirst", fFirst);
|
---|
1366 | rc = kTRUE;
|
---|
1367 | }
|
---|
1368 |
|
---|
1369 | if (IsEnvDefined(env, prefix, "HiGainLast", print))
|
---|
1370 | {
|
---|
1371 | fLast = GetEnvValue(env, prefix, "HiGainLast", fLast);
|
---|
1372 | rc = kTRUE;
|
---|
1373 | }
|
---|
1374 |
|
---|
1375 | if (IsEnvDefined(env, prefix, "LoGainNbins", print))
|
---|
1376 | {
|
---|
1377 | fLoGainNbins = GetEnvValue(env, prefix, "LoGainNbins", fLoGainNbins);
|
---|
1378 | rc = kTRUE;
|
---|
1379 | }
|
---|
1380 |
|
---|
1381 | if (IsEnvDefined(env, prefix, "LoGainFirst", print))
|
---|
1382 | {
|
---|
1383 | fLoGainFirst = GetEnvValue(env, prefix, "LoGainFirst", fLoGainFirst);
|
---|
1384 | rc = kTRUE;
|
---|
1385 | }
|
---|
1386 |
|
---|
1387 | if (IsEnvDefined(env, prefix, "LoGainLast", print))
|
---|
1388 | {
|
---|
1389 | fLoGainLast = GetEnvValue(env, prefix, "LoGainLast", fLoGainLast);
|
---|
1390 | rc = kTRUE;
|
---|
1391 | }
|
---|
1392 |
|
---|
1393 | if (IsEnvDefined(env, prefix, "TimeLowerLimit", print))
|
---|
1394 | {
|
---|
1395 | SetTimeLowerLimit(GetEnvValue(env, prefix, "TimeLowerLimit", fTimeLowerLimit));
|
---|
1396 | rc = kTRUE;
|
---|
1397 | }
|
---|
1398 |
|
---|
1399 | if (IsEnvDefined(env, prefix, "TimeUpperLimit", print))
|
---|
1400 | {
|
---|
1401 | SetTimeUpperLimit(GetEnvValue(env, prefix, "TimeUpperLimit", fTimeUpperLimit));
|
---|
1402 | rc = kTRUE;
|
---|
1403 | }
|
---|
1404 |
|
---|
1405 | if (IsEnvDefined(env, prefix, "ReferenceFile", print))
|
---|
1406 | {
|
---|
1407 | SetReferenceFile(GetEnvValue(env,prefix,"ReferenceFile",fReferenceFile.Data()));
|
---|
1408 | rc = kTRUE;
|
---|
1409 | }
|
---|
1410 |
|
---|
1411 | if (IsEnvDefined(env, prefix, "NumHiGainSaturationLimit", print))
|
---|
1412 | {
|
---|
1413 | SetNumHiGainSaturationLimit(GetEnvValue(env, prefix, "NumHiGainSaturationLimit", fNumHiGainSaturationLimit));
|
---|
1414 | rc = kTRUE;
|
---|
1415 | }
|
---|
1416 |
|
---|
1417 | if (IsEnvDefined(env, prefix, "NumLoGainSaturationLimit", print))
|
---|
1418 | {
|
---|
1419 | SetNumLoGainSaturationLimit(GetEnvValue(env, prefix, "NumLoGainSaturationLimit", fNumLoGainSaturationLimit));
|
---|
1420 | rc = kTRUE;
|
---|
1421 | }
|
---|
1422 |
|
---|
1423 | if (IsEnvDefined(env, prefix, "NumLoGainBlackoutLimit", print))
|
---|
1424 | {
|
---|
1425 | SetNumLoGainBlackoutLimit(GetEnvValue(env, prefix, "NumLoGainBlackoutLimit", fNumLoGainBlackoutLimit));
|
---|
1426 | rc = kTRUE;
|
---|
1427 | }
|
---|
1428 |
|
---|
1429 | TEnv refenv(fReferenceFile);
|
---|
1430 |
|
---|
1431 | fInnerRefCharge = refenv.GetValue("InnerRefCharge",fInnerRefCharge);
|
---|
1432 | fOuterRefCharge = refenv.GetValue("OuterRefCharge",fOuterRefCharge);
|
---|
1433 |
|
---|
1434 | return rc;
|
---|
1435 | }
|
---|