]>
Commit | Line | Data |
---|---|---|
b9bbd271 | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | /* $Id: AliRsnTOFT0maker.cxx,v 1.8 2010/01/19 16:32:20 noferini Exp $ */ | |
16 | ||
17 | ///////////////////////////////////////////////////////////////////////////// | |
18 | // // | |
19 | // This class contains the basic functions for the time zero // | |
20 | // evaluation with TOF detector informations. // | |
21 | // Use case in an analysis task: // | |
22 | // // | |
23 | // Create the object in the task constructor (fTOFmakerANA is a private var) // | |
24 | // fTOFmakerANA = new AliRsnTOFT0maker(); // | |
25 | // fTOFmakerANA->SetTimeResolution(115.0e-12); // if you want set the TOF res // | |
26 | // 115 ps is the TOF default resolution value // | |
27 | // // | |
28 | // Use the RemakePID method in the task::Exec // | |
29 | // Double_t* calcolot0; // | |
30 | // calcolot0=fTOFmakerANA->RemakePID(fESD); // | |
31 | // //calcolot0[0] = calculated event time // | |
32 | // //calcolot0[1] = event time time resolution // | |
33 | // //calcolot0[2] = average event time for the current fill // | |
34 | // // | |
35 | // Let consider that: // | |
36 | // - the PIF is automatically recalculated with the event time subtrction // | |
37 | // // | |
38 | ///////////////////////////////////////////////////////////////////////////// | |
39 | ||
40 | #include <Riostream.h> | |
41 | #include <stdlib.h> | |
42 | ||
43 | #include "AliTOFT0v1.h" | |
44 | #include "AliTOFcalibHisto.h" | |
45 | #include "AliPID.h" | |
46 | #include "AliESDpid.h" | |
47 | #include "TFile.h" | |
48 | #include "AliRsnTOFT0maker.h" | |
49 | ||
50 | ClassImp(AliRsnTOFT0maker) | |
51 | ||
52 | //____________________________________________________________________________ | |
53 | AliRsnTOFT0maker::AliRsnTOFT0maker(): | |
54 | fSettings(kNone), | |
55 | fCalib(new AliTOFcalibHisto()), | |
56 | fESDswitch(0), | |
57 | fTimeResolution(115), | |
58 | fT0sigma(1000), | |
59 | fHmapChannel(0), | |
60 | fKmask(0), | |
61 | fNoTOFT0(0) | |
62 | { | |
63 | fCalculated[0] = 0; | |
64 | fCalculated[1] = 0; | |
65 | fCalculated[2] = 0; | |
66 | fCalculated[3] = 0; | |
67 | ||
68 | fCalib->LoadCalibPar(); | |
69 | ||
70 | if(AliPID::ParticleMass(0) == 0) new AliPID(); | |
71 | } | |
72 | //____________________________________________________________________________ | |
73 | AliRsnTOFT0maker::AliRsnTOFT0maker(const AliRsnTOFT0maker & t) : | |
74 | TObject(), | |
75 | fSettings(t.fSettings), | |
76 | fCalib(t.fCalib), | |
77 | fESDswitch(t.fESDswitch), | |
78 | fTimeResolution(t.fTimeResolution), | |
79 | fT0sigma(t.fT0sigma), | |
80 | fHmapChannel(t.fHmapChannel), | |
81 | fKmask(t.fKmask), | |
82 | fNoTOFT0(t.fNoTOFT0) | |
83 | { | |
84 | } | |
85 | ||
86 | //____________________________________________________________________________ | |
87 | AliRsnTOFT0maker& AliRsnTOFT0maker::operator=(const AliRsnTOFT0maker &t) | |
88 | { | |
89 | // | |
90 | // assign. operator | |
91 | // | |
92 | ||
93 | fSettings = t.fSettings; | |
94 | if (this == &t) | |
95 | return *this; | |
96 | fCalib = t.fCalib; | |
97 | fESDswitch = t.fESDswitch; | |
98 | fTimeResolution = t.fTimeResolution; | |
99 | fT0sigma = t.fT0sigma; | |
100 | ||
101 | return *this; | |
102 | } | |
103 | //____________________________________________________________________________ | |
104 | AliRsnTOFT0maker::~AliRsnTOFT0maker() | |
105 | { | |
106 | // dtor | |
107 | if(fCalib) delete fCalib; | |
108 | } | |
109 | //____________________________________________________________________________ | |
110 | Double_t* AliRsnTOFT0maker::RemakePID(AliESDEvent *esd,Double_t t0time,Double_t t0sigma){ | |
111 | // | |
112 | // Remake TOF PID probabilities | |
113 | // | |
114 | ||
115 | Double_t *t0tof; | |
116 | ||
117 | if(fKmask) ApplyMask(esd); | |
118 | ||
119 | AliTOFT0v1* t0makerANA=new AliTOFT0v1(esd); | |
120 | // t0makerANA->SetCalib(fCalib); | |
121 | t0makerANA->SetTimeResolution(fTimeResolution*1e-12); | |
122 | ||
123 | if(! fESDswitch){ | |
124 | TakeTimeRawCorrection(esd); | |
125 | } | |
126 | ||
127 | t0tof=t0makerANA->DefineT0("all"); | |
128 | ||
129 | Float_t lT0Current=0.; | |
130 | fT0sigma=1000; | |
131 | ||
132 | Int_t nrun = 0;//esd->GetRunNumber(); | |
133 | Double_t t0fill = 175;//GetT0Fill(nrun); | |
134 | if (fSettings == kPass2 || fSettings == kPass4) // cambiato!!!!!!!! | |
135 | { | |
136 | nrun = esd->GetRunNumber(); | |
137 | t0fill = GetT0Fill(nrun); | |
138 | } | |
139 | else if (fSettings == kLHC09d10) // e' il MC del pass2? | |
140 | { | |
141 | t0fill = GetT0Fill(nrun); | |
142 | } | |
143 | ||
144 | fCalculated[0]=-1000*t0tof[0]; | |
145 | fCalculated[1]=1000*t0tof[1]; | |
146 | fCalculated[2] = t0fill; | |
147 | fCalculated[3] = t0tof[2]; | |
148 | ||
149 | if(fCalculated[1] < 150 && TMath::Abs(fCalculated[0] - t0fill) < 500){ | |
150 | fT0sigma=fCalculated[1]; | |
151 | lT0Current=fCalculated[0]; | |
152 | } | |
153 | ||
154 | if(t0sigma < 1000){ | |
155 | if(fT0sigma < 1000){ | |
156 | Double_t w1 = 1./t0sigma/t0sigma; | |
157 | Double_t w2 = 1./fCalculated[1]/fCalculated[1]; | |
158 | ||
159 | Double_t wtot = w1+w2; | |
160 | ||
161 | lT0Current = (w1*t0time + w2*fCalculated[0]) / wtot; | |
162 | fT0sigma = TMath::Sqrt(1./wtot); | |
163 | } | |
164 | else{ | |
165 | lT0Current=t0time; | |
166 | fT0sigma=t0sigma; | |
167 | } | |
168 | } | |
169 | ||
170 | if(fT0sigma >= 1000 || fNoTOFT0){ | |
171 | lT0Current = t0fill; | |
172 | fT0sigma = 135; | |
173 | ||
174 | fCalculated[0] = t0fill; | |
175 | fCalculated[1] = 150; | |
176 | } | |
177 | ||
178 | RemakeTOFpid(esd,lT0Current); | |
179 | ||
180 | return fCalculated; | |
181 | } | |
182 | //____________________________________________________________________________ | |
183 | void AliRsnTOFT0maker::TakeTimeRawCorrection(AliESDEvent * const esd){ | |
184 | // | |
185 | // Take raw corrections for time measurements | |
186 | // | |
187 | ||
188 | Int_t ntracks = esd->GetNumberOfTracks(); | |
189 | ||
190 | while (ntracks--) { | |
191 | AliESDtrack *t=esd->GetTrack(ntracks); | |
192 | ||
193 | if ((t->GetStatus()&AliESDtrack::kTOFout)==0) continue; | |
194 | ||
195 | Double_t time=t->GetTOFsignalRaw(); | |
196 | Double_t tot = t->GetTOFsignalToT(); | |
197 | Int_t chan = t->GetTOFCalChannel(); | |
198 | Double_t corr = fCalib->GetFullCorrection(chan,tot) - fCalib->GetCorrection(AliTOFcalibHisto::kTimeSlewingCorr,chan,0); | |
199 | time -= corr*1000; | |
200 | ||
201 | //Int_t crate = Int_t(fCalib->GetCalibMap(AliTOFcalibHisto::kDDL,chan)); | |
202 | ||
203 | // if(crate == 63 || crate == 62){ | |
204 | // time += 9200; | |
205 | ||
206 | // } | |
207 | ||
208 | // if(crate == 63 || crate == 62|| crate == 61){ | |
209 | // printf("%i) %f\n",crate,time); | |
210 | // getchar(); | |
211 | // } | |
212 | t->SetTOFsignal(time); | |
213 | } | |
214 | } | |
215 | //____________________________________________________________________________ | |
216 | void AliRsnTOFT0maker::RemakeTOFpid(AliESDEvent *esd,Float_t timezero){ | |
217 | // | |
218 | // Recalculate TOF PID probabilities | |
219 | // | |
220 | AliESDpid pidESD; | |
221 | pidESD.GetTOFResponse().SetTimeResolution(TMath::Sqrt(fT0sigma*fT0sigma + fTimeResolution*fTimeResolution)); | |
222 | pidESD.MakePID(esd,kFALSE,timezero); | |
223 | ||
224 | } | |
225 | //____________________________________________________________________________ | |
226 | Double_t AliRsnTOFT0maker::GetT0Fill(Int_t nrun) const { | |
227 | // | |
228 | // Return T0 of filling | |
229 | // | |
230 | ||
231 | Double_t t0; | |
232 | if(nrun==104065) t0= 1771614; | |
233 | else if(nrun==104068) t0= 1771603; | |
234 | else if(nrun==104070) t0= 1771594; | |
235 | else if(nrun==104073) t0= 1771610; | |
236 | else if(nrun==104080) t0= 1771305; | |
237 | else if(nrun==104083) t0= 1771613; | |
238 | else if(nrun==104157) t0= 1771665; | |
239 | else if(nrun==104159) t0= 1771679; | |
240 | else if(nrun==104160) t0= 1771633; | |
241 | else if(nrun==104316) t0= 1764344; | |
242 | else if(nrun==104320) t0= 1764342; | |
243 | else if(nrun==104321) t0= 1764371; | |
244 | else if(nrun==104439) t0= 1771750; | |
245 | else if(nrun==104792) t0= 1771755; | |
246 | else if(nrun==104793) t0= 1771762; | |
247 | else if(nrun==104799) t0= 1771828; | |
248 | else if(nrun==104800) t0= 1771788; | |
249 | else if(nrun==104801) t0= 1771796; | |
250 | else if(nrun==104802) t0= 1771775; | |
251 | else if(nrun==104803) t0= 1771795; | |
252 | else if(nrun==104824) t0= 1771751; | |
253 | else if(nrun==104825) t0= 1771763; | |
254 | else if(nrun==104845) t0= 1771792; | |
255 | else if(nrun==104852) t0= 1771817; | |
256 | else if(nrun==104864) t0= 1771825; | |
257 | else if(nrun==104865) t0= 1771827; | |
258 | else if(nrun==104867) t0= 1771841; | |
259 | else if(nrun==104876) t0= 1771856; | |
260 | else if(nrun==104878) t0= 1771847; | |
261 | else if(nrun==104879) t0= 1771830; | |
262 | else if(nrun==104892) t0= 1771837; | |
263 | else t0= 487; | |
264 | ||
265 | if(fESDswitch) t0 -= 487; | |
266 | else { if (fSettings == kPass4) t0 -=37*1024*24.4; } | |
267 | ||
268 | return t0; | |
269 | } | |
270 | ||
271 | //____________________________________________________________________________ | |
272 | void AliRsnTOFT0maker::LoadChannelMap(char *filename){ | |
273 | // Load the histo with the channel off map | |
274 | TFile *f= new TFile(filename); | |
275 | if(!f){ | |
276 | printf("Cannot open the channel map file (%s)\n",filename); | |
277 | return; | |
278 | } | |
279 | ||
280 | fHmapChannel = (TH1F *) f->Get("hChEnabled"); | |
281 | ||
282 | if(!fHmapChannel){ | |
283 | printf("Cannot laod the channel map histo (from %s)\n",filename); | |
284 | return; | |
285 | } | |
286 | ||
287 | } | |
288 | //____________________________________________________________________________ | |
289 | void AliRsnTOFT0maker::ApplyMask(AliESDEvent *esd){ | |
290 | // Switch off the disable channel | |
291 | if(!fHmapChannel){ | |
292 | printf("Channel Map is not available\n"); | |
293 | return; | |
294 | } | |
295 | ||
296 | Int_t ntracks = esd->GetNumberOfTracks(); | |
297 | ||
298 | while (ntracks--) { | |
299 | AliESDtrack *t=esd->GetTrack(ntracks); | |
300 | ||
301 | if ((t->GetStatus()&AliESDtrack::kTOFout)==0) continue; | |
302 | ||
303 | Int_t chan = t->GetTOFCalChannel(); | |
304 | ||
305 | if(fHmapChannel->GetBinContent(chan) < 0.01){ | |
306 | t->ResetStatus(AliESDtrack::kTOFout); | |
307 | } | |
308 | } | |
309 | } |