Line data Source code
1 : #ifndef ALITRDCALIBRAFILLHISTO_H
2 : #define ALITRDCALIBRAFILLHISTO_H
3 : /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 : * See cxx source for full Copyright notice */
5 :
6 : /* $Id$ */
7 :
8 : ///////////////////////////////////////////////////////////////////////////////
9 : // //
10 : // TRD calibration class for the HLT parameters //
11 : // //
12 : ///////////////////////////////////////////////////////////////////////////////
13 :
14 : #ifndef ROOT_TObject
15 : # include <TObject.h>
16 : #endif
17 : #ifndef ROOT_TProfile2D
18 : # include <TProfile2D.h>
19 : #endif
20 :
21 : #include "TObjArray.h"
22 :
23 : class TProfile2D;
24 : class TObjArray;
25 : class TH1F;
26 : class TH2I;
27 : class TH2F;
28 : class TH2;
29 : class TLinearFitter;
30 : class TTreeSRedirector;
31 :
32 : class AliLog;
33 : class AliRawReader;
34 :
35 : class AliESDtrack;
36 :
37 : class AliTRDCalibraMode;
38 : class AliTRDCalibraVector;
39 : class AliTRDCalibraVdriftLinearFit;
40 : class AliTRDCalibraExbAltFit;
41 : class AliTRDcluster;
42 : class AliTRDtrackV1;
43 : class AliTRDseedV1;
44 : class AliTRDgeometry;
45 : class AliTRDCalDet;
46 : class AliTRDCalROC;
47 : class AliTRDcalibDB;
48 :
49 : class AliTRDdigitsManager;
50 : class AliTRDSignalIndex;
51 :
52 : struct eventHeaderStruct;
53 :
54 : class AliTRDCalibraFillHisto : public TObject {
55 :
56 : public:
57 :
58 : // Instance
59 : static AliTRDCalibraFillHisto *Instance();
60 : static void Terminate();
61 : static void Destroy();
62 : void DestroyDebugStreamer();
63 :
64 :
65 : AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c);
66 0 : AliTRDCalibraFillHisto &operator=(const AliTRDCalibraFillHisto &) { return *this; }
67 :
68 : // Functions for initialising and filling with AliTRDtrackV1
69 : Bool_t Init2Dhistos(Int_t nboftimebin = -1);
70 : Bool_t InitCalDet();
71 : Bool_t UpdateHistogramsV1(const AliTRDtrackV1 *t,const AliESDtrack *esdtrack = NULL);
72 :
73 : // Process events DAQ
74 : Int_t ProcessEventDAQ(AliRawReader *rawReader);
75 :
76 : // Is Pad on
77 : Bool_t IsPadOn(Int_t detector, Int_t row, Int_t col) const;
78 :
79 : // Functions for write
80 : void Write2d(const Char_t *filename = "TRD.calibration.root", Bool_t append = kFALSE);
81 :
82 : //For the statistics
83 : Double_t *StatH(TH2 *ch, Int_t i);
84 : Double_t *GetMeanMedianRMSNumberCH();
85 : Double_t *GetMeanMedianRMSNumberLinearFitter() const;
86 : // LinearFitter
87 : void AnalyseLinearFitter();
88 :
89 :
90 : //
91 : // Set of Get the variables
92 : //
93 :
94 0 : void SetIsHLT(Bool_t isHLT = kTRUE) { fIsHLT = isHLT; }
95 0 : Bool_t IsHLT() const { return fIsHLT; }
96 :
97 : // Choice to fill or not the 2D
98 0 : void SetPH2dOn(Bool_t ph2don = kTRUE) { fPH2dOn = ph2don; }
99 0 : void SetCH2dOn(Bool_t ch2don = kTRUE) { fCH2dOn = ch2don; }
100 0 : void SetPRF2dOn(Bool_t prf2don = kTRUE) { fPRF2dOn = prf2don; }
101 0 : void SetHisto2d(Bool_t histo2d = kTRUE) { fHisto2d = histo2d; }
102 0 : void SetVector2d(Bool_t vector2d = kTRUE) { fVector2d = vector2d; }
103 0 : void SetLinearFitterOn(Bool_t linearfitteron = kTRUE) { fLinearFitterOn = linearfitteron;}
104 0 : void SetLinearFitterDebugOn(Bool_t debug = kTRUE) { fLinearFitterDebugOn = debug; }
105 0 : void SetExbAltFitOn(Bool_t fiton = kTRUE) { fExbAltFitOn = fiton;}
106 0 : void SetScaleWithTPCSignal(Bool_t scaleWithTPCSignal = kTRUE) { fScaleWithTPCSignal = scaleWithTPCSignal;}
107 0 : void SetTakeSnapshot(Bool_t takesnapshot) { fTakeSnapshot = takesnapshot; }
108 0 : void SetFirstRunGain(Int_t firstRunGain) { fFirstRunGain = firstRunGain; }
109 0 : void SetVersionGainUsed(Int_t versionGainUsed) { fVersionGainUsed = versionGainUsed; }
110 0 : void SetSubVersionGainUsed(Int_t subVersionGainUsed) { fSubVersionGainUsed = subVersionGainUsed; }
111 0 : void SetFirstRunGainLocal(Int_t firstRunGainLocal) { fFirstRunGainLocal = firstRunGainLocal; }
112 0 : void SetVersionGainLocalUsed(Int_t versionGainLocalUsed) { fVersionGainLocalUsed = versionGainLocalUsed; }
113 0 : void SetSubVersionGainLocalUsed(Int_t subVersionGainLocalUsed) { fSubVersionGainLocalUsed = subVersionGainLocalUsed; }
114 0 : void SetFirstRunVdrift(Int_t firstRunVdrift) { fFirstRunVdrift = firstRunVdrift; }
115 0 : void SetVersionVdriftUsed(Int_t versionVdriftUsed) { fVersionVdriftUsed = versionVdriftUsed; }
116 0 : void SetSubVersionVdriftUsed(Int_t subVersionVdriftUsed) { fSubVersionVdriftUsed = subVersionVdriftUsed; }
117 0 : void SetFirstRunExB(Int_t firstRunExB) { fFirstRunExB = firstRunExB; }
118 0 : void SetVersionExBUsed(Int_t versionExBUsed) { fVersionExBUsed = versionExBUsed; }
119 0 : void SetSubVersionExBUsed(Int_t subVersionExBUsed) { fSubVersionExBUsed = subVersionExBUsed; }
120 :
121 :
122 0 : Bool_t GetPH2dOn() const { return fPH2dOn; }
123 0 : Bool_t GetCH2dOn() const { return fCH2dOn; }
124 0 : Bool_t GetPRF2dOn() const { return fPRF2dOn; }
125 208 : Bool_t GetHisto2d() const { return fHisto2d; }
126 0 : Bool_t GetVector2d() const { return fVector2d; }
127 0 : Bool_t GetLinearFitterOn() const { return fLinearFitterOn; }
128 0 : Bool_t GetLinearFitterDebugOn() const { return fLinearFitterDebugOn; }
129 0 : Int_t GetVersionGainUsed() const { return fVersionGainUsed; }
130 0 : Int_t GetSubVersionGainUsed() const { return fSubVersionGainUsed; }
131 0 : Int_t GetVersionVdriftUsed() const { return fVersionVdriftUsed; }
132 0 : Int_t GetSubVersionVdriftUsed() const { return fSubVersionVdriftUsed; }
133 :
134 :
135 : // Get stuff that are filled
136 : TH2I *GetCH2d();
137 : TProfile2D *GetPH2d(Int_t nbtimebin=24, Float_t samplefrequency= 10.0);
138 0 : TProfile2D *GetPRF2d() const { return fPRF2d; }
139 0 : TObjArray GetLinearFitterArray() const { return fLinearFitterArray; }
140 : TLinearFitter *GetLinearFitter(Int_t detector, Bool_t force=kFALSE);
141 0 : AliTRDCalibraVdriftLinearFit *GetVdriftLinearFit() const { return fLinearVdriftFit; }
142 0 : AliTRDCalibraExbAltFit *GetExbAltFit() const { return fExbAltFit; }
143 :
144 :
145 : // How to fill the 2D
146 : void SetRelativeScale(Float_t relativeScale);
147 0 : void SetThresholdClusterPRF2(Float_t thresholdClusterPRF2) { fThresholdClusterPRF2 = thresholdClusterPRF2; }
148 0 : void SetLimitChargeIntegration(Bool_t limitChargeIntegration) { fLimitChargeIntegration = limitChargeIntegration; }
149 0 : void SetFillWithZero(Bool_t fillWithZero) { fFillWithZero = fillWithZero; }
150 0 : void SetNormalizeNbOfCluster(Bool_t normalizeNbOfCluster) { fNormalizeNbOfCluster = normalizeNbOfCluster; }
151 0 : void SetMaxCluster(Float_t maxCluster) { fMaxCluster = maxCluster; }
152 0 : void SetNbMaxCluster(Short_t nbMaxCluster) { fNbMaxCluster = nbMaxCluster; }
153 0 : void SetCutWithVdriftCalib(Bool_t cutWithVdriftCalib) { fCutWithVdriftCalib = cutWithVdriftCalib; }
154 0 : void SetMinNbTRDtracklets(Int_t minNbTRDtracklets) { fMinNbTRDtracklets = minNbTRDtracklets; }
155 0 : void SetMinTRDMomentum(Float_t minTRDMomentum) { fMinTRDMomentum = minTRDMomentum; }
156 : void SetNz(Int_t i, Short_t nz);
157 : void SetNrphi(Int_t i, Short_t nrphi);
158 : void SetAllTogether(Int_t i);
159 : void SetPerSuperModule(Int_t i);
160 0 : void SetProcent(Float_t procent) { fProcent = procent; }
161 0 : void SetDifference(Short_t difference) { fDifference = difference; }
162 0 : void SetNumberClusters(Short_t numberClusters) { if(numberClusters >= 0) fNumberClusters = numberClusters; }
163 0 : void SetNumberClustersf(Short_t numberClustersf) { fNumberClustersf = numberClustersf; }
164 0 : void SetNumberClustersProcent(Float_t numberClustersProcent) { fNumberClustersProcent = numberClustersProcent; }
165 0 : void SetThresholdClustersDAQ(Float_t thresholdClustersDAQ) { fThresholdClustersDAQ = thresholdClustersDAQ; }
166 0 : void SetNumberRowDAQ(Short_t numberRowDAQ) { fNumberRowDAQ = numberRowDAQ; }
167 0 : void SetNumberColDAQ(Short_t numberColDAQ) { fNumberColDAQ = numberColDAQ; }
168 0 : void SetRangeHistoCharge(Float_t rangeHistoCharge) { fRangeHistoCharge = rangeHistoCharge; }
169 0 : void SetNumberBinCharge(Short_t numberBinCharge) { fNumberBinCharge = numberBinCharge; }
170 0 : void SetNumberBinPRF(Short_t numberBinPRF) { fNumberBinPRF = numberBinPRF; }
171 : void SetNumberGroupsPRF(Short_t numberGroupsPRF);
172 :
173 0 : Float_t GetRelativeScale() const { return fRelativeScale; }
174 0 : Float_t GetThresholdClusterPRF2() const { return fThresholdClusterPRF2; }
175 0 : Bool_t GetLimitChargeIntegration() const { return fLimitChargeIntegration; }
176 0 : Bool_t GetFillWithZero() const { return fFillWithZero; }
177 0 : Bool_t GetNormalizeNbOfCluster() const { return fNormalizeNbOfCluster; }
178 0 : Float_t GetMaxCluster() const { return fMaxCluster; }
179 0 : Short_t GetNbMaxCluster() const { return fNbMaxCluster; }
180 0 : Bool_t GetCutWithVdriftCalib() const { return fCutWithVdriftCalib; }
181 0 : Float_t GetProcent() const { return fProcent; }
182 0 : Short_t GetDifference() const { return fDifference; }
183 0 : Short_t GetNumberClusters() const { return fNumberClusters; }
184 0 : Short_t GetNumberClustersf() const { return fNumberClustersf; }
185 0 : Short_t GetNumberBinCharge() const { return fNumberBinCharge; }
186 0 : Short_t GetNumberBinPRF() const { return fNumberBinPRF; }
187 0 : Short_t GetNumberGroupsPRF() const { return fNgroupprf; }
188 0 : Int_t *GetEntriesLinearFitter() const { return fEntriesLinearFitter; }
189 :
190 : // Debug
191 0 : void SetDebugLevel(Short_t level) { fDebugLevel = level; }
192 :
193 : // Vector method
194 0 : AliTRDCalibraVector *GetCalibraVector() const { return fCalibraVector; }
195 :
196 : protected:
197 :
198 : // Geometry
199 : AliTRDgeometry *fGeo; //! The TRD geometry
200 : // calibration DB
201 : AliTRDcalibDB *fCalibDB; //! The pointer to the TRDcalibDB instance
202 :
203 : // Is HLT
204 : Bool_t fIsHLT; // Now if HLT, the per detector
205 :
206 : // Choice to fill or not the 2D
207 : Bool_t fCH2dOn; // Chose to fill the 2D histos or vectors for the relative gain calibration
208 : Bool_t fPH2dOn; // Chose to fill the 2D histos or vectors for the drift velocity and T0
209 : Bool_t fPRF2dOn; // Chose to fill the 2D histos or vectors for the pad response function calibration
210 : Bool_t fHisto2d; // Chose to fill the 2D histos
211 : Bool_t fVector2d; // Chose to fill vectors
212 : Bool_t fLinearFitterOn; // Method with linear fit for drift velocity
213 : Bool_t fLinearFitterDebugOn; // Method with linear fit for drift velocity
214 : Bool_t fExbAltFitOn; // Enable parabolic fit for exb
215 : Bool_t fScaleWithTPCSignal; // Scale the gain with TPC signal (If use then ask at least 70 TPC clusters)
216 :
217 : // How to fill the 2D
218 : Float_t fRelativeScale; // Scale of the deposited charge
219 : Float_t fThresholdClusterPRF2; // Threshold on cluster pad signals
220 : Bool_t fLimitChargeIntegration; // Integration range for the gain calibration
221 : Bool_t fFillWithZero; // Fill with zero or not the average pulse height
222 : Bool_t fNormalizeNbOfCluster; // Normalize with the number of cluster for the gain
223 : Float_t fMaxCluster; // Max amplitude of one cluster
224 : Short_t fNbMaxCluster; // Number of tb at the end
225 : Bool_t fCutWithVdriftCalib; // CutWithVdriftCalib for the gain and PH
226 : Int_t fMinNbTRDtracklets; // Min number of TRD tracklets
227 : Float_t fMinTRDMomentum; // Min TRD momentum
228 : // Back correction
229 : Bool_t fTakeSnapshot; // Take from snapshot
230 : Int_t fFirstRunGain; // FirstRunGain
231 : Int_t fVersionGainUsed; // VersionGainUsed
232 : Int_t fSubVersionGainUsed; // SubVersionGainUsed
233 : Int_t fFirstRunGainLocal; // FirstRunGainLocal
234 : Int_t fVersionGainLocalUsed; // VersionGainUsed
235 : Int_t fSubVersionGainLocalUsed;// SubVersionGainUsed
236 : Int_t fFirstRunVdrift; // FirstRunVdrift
237 : Int_t fVersionVdriftUsed; // VersionVdriftUsed
238 : Int_t fSubVersionVdriftUsed; // SubVersionVdriftUsed
239 : Int_t fFirstRunExB; // FirstRunExB
240 : Int_t fVersionExBUsed; // VersionExBUsed
241 : Int_t fSubVersionExBUsed; // SubVersionExBUsed
242 : // Calibration mode
243 : AliTRDCalibraMode *fCalibraMode; // Calibration mode
244 :
245 : //For debugging
246 : TTreeSRedirector *fDebugStreamer; //!Debug streamer
247 : Short_t fDebugLevel; // Flag for debugging
248 : //
249 : // Internal variables
250 : //
251 :
252 : // Fill the 2D histos in the offline tracking
253 : Int_t fDetectorPreviousTrack; // Change of detector
254 : Int_t fMCMPrevious; // Change of MCM
255 : Int_t fROBPrevious; // Change of ROB
256 : Short_t fNumberClusters; // Minimum number of clusters in the tracklets
257 : Short_t fNumberClustersf; // Maximum number of clusters in the tracklets
258 : Float_t fNumberClustersProcent; // Procent of number of time bins for fNumberClusters
259 : Float_t fThresholdClustersDAQ; // Threshold clusters for DAQ algorithm
260 : Short_t fNumberRowDAQ; // Size of the spot for DAQ algorithm
261 : Short_t fNumberColDAQ; // Size of the spot for DAQ algorithm
262 : Float_t fProcent; // Limit to take the info of the most important calibration group if the track goes through 2 groups (CH)
263 : Short_t fDifference; // Limit to take the info of the most important calibration group if the track goes through 2 groups (CH)
264 : Int_t fNumberTrack; // How many tracks could be used (Debug for the moment)
265 : Int_t fNumberUsedCh[2]; // How many tracks have been really used for the gain (0, strict; 1 with fProcent)
266 : Int_t fNumberUsedPh[2]; // How many tracks have been really used for the drift velocity (0, strict; 1 with fDifference)
267 : Int_t fTimeMax; // Number of time bins
268 : Float_t fSf; // Sampling frequence
269 : Float_t fRangeHistoCharge; // Range of the histo for the charge
270 : Short_t fNumberBinCharge; // Number of bins for the gain factor
271 : Short_t fNumberBinPRF; // Number of bin for the PRF
272 : Short_t fNgroupprf; // Number of groups in tnp bins for PRF /2.0
273 :
274 : // Variables per tracklet
275 : Float_t *fAmpTotal; // Energy deposited in the calibration group by the track
276 : Short_t *fPHPlace; // Calibration group of PH
277 : Float_t *fPHValue; // PH
278 : Bool_t fGoodTracklet; // Good tracklet
279 : TLinearFitter *fLinearFitterTracklet; // linear fitter tracklet
280 : //Statistics
281 : Int_t *fEntriesCH; // Number of entries CH
282 : Int_t *fEntriesLinearFitter; // Number of entries LinearFitter
283 :
284 :
285 : //
286 : // Vector method
287 : //
288 :
289 : AliTRDCalibraVector *fCalibraVector; // The vector object
290 :
291 :
292 : // Histograms to store the info from the digits, from the tracklets or from the tracks
293 : TProfile2D *fPH2d; // 2D average pulse height
294 : TProfile2D *fPRF2d; // 2D PRF
295 : TH2I *fCH2d; // 2D deposited charge
296 : TObjArray fLinearFitterArray; // TObjArray of Linear Fitters for the detectors
297 : AliTRDCalibraVdriftLinearFit *fLinearVdriftFit; // Info Linear Fit
298 : AliTRDCalibraExbAltFit *fExbAltFit; // ExB parabolic fit (alternative to vdrift linear fit)
299 :
300 : // Current calib object: to correct for the database used
301 : AliTRDCalDet *fCalDetGain; // Current calib object gain
302 : AliTRDCalROC *fCalROCGain; // Current calib object gain
303 :
304 : //
305 : // A lot of internal functions......
306 : // Init
307 : Bool_t InitCalPad(Int_t detector);
308 : //
309 : // Create the 2D histo to be filled Online
310 : void CreateCH2d(Int_t nn);
311 : void CreatePH2d(Int_t nn);
312 : void CreatePRF2d(Int_t nn);
313 :
314 : // Calibration with AliTRDtrackV1
315 : void FillTheInfoOfTheTrackPH();
316 : void FillTheInfoOfTheTrackCH(Int_t nbclusters);
317 : Bool_t FindP1TrackPHtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters);
318 : Bool_t HandlePRFtrackletV1(const AliTRDseedV1 *tracklet, Int_t nbclusters);
319 : void ResetfVariablestracklet();
320 : Float_t StoreInfoCHPHtrack(const AliTRDcluster *cl,const Double_t dqdl,const Int_t *group,const Int_t row,const Int_t col,const AliTRDcluster *cls=0x0);
321 : void FillCH2d(Int_t x, Float_t y);
322 :
323 : // Calibration on DAQ
324 :
325 : Int_t FillDAQ(Double_t phvalue[16][144][36]);
326 : Bool_t UpdateDAQ(Int_t det, Int_t /*row*/, Int_t /*col*/, Int_t timebin, Float_t signal, Int_t nbtimebins);
327 :
328 : // row col calibration groups stuff
329 : Bool_t LocalisationDetectorXbins(Int_t detector);
330 : Int_t CalculateTotalNumberOfBins(Int_t i);
331 : void CheckGoodTrackletV0(const Int_t detector,const Int_t row,const Int_t col);
332 : void CheckGoodTrackletV1(const AliTRDcluster *cl);
333 : Int_t CalculateCalibrationGroup(Int_t i, Int_t row, Int_t col) const;
334 :
335 : // Clear
336 : void ClearHistos();
337 :
338 : // Some basic geometry function
339 : virtual Int_t GetLayer(Int_t d) const;
340 : virtual Int_t GetStack(Int_t d) const;
341 : virtual Int_t GetSector(Int_t d) const;
342 :
343 :
344 : // Instance of this class and so on
345 : static AliTRDCalibraFillHisto *fgInstance; // Instance
346 : static Bool_t fgTerminated; // If terminated
347 :
348 : private:
349 :
350 : // This is a singleton, contructor is private!
351 : AliTRDCalibraFillHisto();
352 : virtual ~AliTRDCalibraFillHisto();
353 :
354 48 : ClassDef(AliTRDCalibraFillHisto,8) // TRD Calibration class
355 :
356 : };
357 :
358 : #endif
359 :
360 :
|
