]>
Commit | Line | Data |
---|---|---|
9dcc11e4 | 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 * | |
8eb4ac75 | 10 | * copies and that both the copyright notice and this permission notice * |
11 | * appear in the supporting documentation. The authors make no claims * | |
9dcc11e4 | 12 | * about the suitability of this software for any purpose. It is * |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | /* | |
17 | $Log: AliT0DataDCS.cxx,v $ | |
18 | Revision 2008/01/30 | |
19 | Fetching data points from DCS, calculating mean and storing data to Reference DB | |
20 | ||
21 | Version 1.1 2006/10 | |
22 | Preliminary test version (T.Malkiewicz) | |
23 | */ | |
24 | ||
dc7ca31d | 25 | #include "AliT0DataDCS.h" |
26 | ||
27 | #include "AliCDBMetaData.h" | |
28 | #include "AliDCSValue.h" | |
29 | #include "AliLog.h" | |
30 | ||
31 | #include <TTimeStamp.h> | |
32 | #include <TObjString.h> | |
33 | #include <TH2F.h> | |
34 | #include <TProfile.h> | |
35 | #include <TGraph.h> | |
36 | #include <TDatime.h> | |
37 | #include <TStyle.h> | |
38 | #include <TCanvas.h> | |
39 | ||
9dcc11e4 | 40 | // AliT0DataDCS class |
41 | // declaring DCS aliases for T0 | |
42 | // fetching T0 data points from DCS, | |
43 | // calculating mean values for the entire run | |
44 | // and storing the result to Reference DB | |
45 | ||
dc7ca31d | 46 | ClassImp(AliT0DataDCS) |
47 | ||
48 | //--------------------------------------------------------------- | |
49 | AliT0DataDCS::AliT0DataDCS(): | |
50 | TObject(), | |
9dcc11e4 | 51 | fRun(0), |
dc7ca31d | 52 | fStartTime(0), |
53 | fEndTime(0), | |
8eb4ac75 | 54 | fStartTimeDCSQuery(0), |
55 | fEndTimeDCSQuery(0), | |
56 | fAtten(0.), | |
dc7ca31d | 57 | fIsProcessed(kFALSE) |
58 | { | |
8eb4ac75 | 59 | for(Int_t i=0;i<kScalers;i++) |
60 | { | |
61 | fScalerMean[i]=0.; | |
62 | fScalerSecMean[i]=0.; | |
63 | } | |
64 | for(Int_t i=0;i<kHV;i++) | |
65 | { | |
66 | fHViA[i]=0.; | |
67 | fHVvA[i]=0.; | |
68 | fHViC[i]=0.; | |
69 | fHVvC[i]=0.; | |
70 | } | |
71 | for(Int_t i=0;i<kLV;i++) | |
72 | { | |
73 | fLViA[i]=0.; | |
74 | fLVvA[i]=0.; | |
75 | fLViC[i]=0.; | |
76 | fLVvC[i]=0.; | |
77 | } | |
78 | for(Int_t i=0;i<kTRM;i++) | |
79 | { | |
80 | fTRM[i]=0.; | |
81 | } | |
82 | for(Int_t i=0;i<kDRM;i++) | |
83 | { | |
84 | fDRM[i]=0.; | |
85 | } | |
dc7ca31d | 86 | |
8eb4ac75 | 87 | } |
dc7ca31d | 88 | //--------------------------------------------------------------- |
8eb4ac75 | 89 | AliT0DataDCS::AliT0DataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime, UInt_t startTimeDCSQuery, UInt_t endTimeDCSQuery): |
dc7ca31d | 90 | TObject(), |
91 | fRun(nRun), | |
92 | fStartTime(startTime), | |
93 | fEndTime(endTime), | |
8eb4ac75 | 94 | fStartTimeDCSQuery(startTimeDCSQuery), |
95 | fEndTimeDCSQuery(endTimeDCSQuery), | |
96 | fAtten(0.), | |
dc7ca31d | 97 | fIsProcessed(kFALSE) |
98 | { | |
8eb4ac75 | 99 | for(Int_t i=0;i<kScalers;i++) |
100 | { | |
101 | fScalerMean[i]=0.; | |
102 | fScalerSecMean[i]=0.; | |
103 | } | |
104 | for(Int_t i=0;i<kHV;i++) | |
105 | { | |
106 | fHViA[i]=0.; | |
107 | fHVvA[i]=0.; | |
108 | fHViC[i]=0.; | |
109 | fHVvC[i]=0.; | |
110 | } | |
111 | for(Int_t i=0;i<kLV;i++) | |
112 | { | |
113 | fLViA[i]=0.; | |
114 | fLVvA[i]=0.; | |
115 | fLViC[i]=0.; | |
116 | fLVvC[i]=0.; | |
117 | } | |
118 | for(Int_t i=0;i<kTRM;i++) | |
119 | { | |
120 | fTRM[i]=0.; | |
121 | } | |
122 | for(Int_t i=0;i<kDRM;i++) | |
123 | { | |
124 | fDRM[i]=0.; | |
125 | } | |
126 | ||
127 | AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s \n\tStartTime DCS Query %s \n\tEndTime DCS Query %s", nRun, | |
dc7ca31d | 128 | TTimeStamp(startTime).AsString(), |
8eb4ac75 | 129 | TTimeStamp(endTime).AsString(), |
130 | TTimeStamp(startTimeDCSQuery).AsString(), | |
131 | TTimeStamp(endTimeDCSQuery).AsString())); | |
dc7ca31d | 132 | |
dc7ca31d | 133 | Init(); |
134 | ||
135 | } | |
8eb4ac75 | 136 | //--------------------------------------------------------------- |
137 | ||
138 | AliT0DataDCS::AliT0DataDCS(const AliT0DataDCS & data): | |
139 | TObject(), | |
140 | fRun(0), | |
141 | fStartTime(0), | |
142 | fEndTime(0), | |
143 | fStartTimeDCSQuery(0), | |
144 | fEndTimeDCSQuery(0), | |
145 | fAtten(0.), | |
146 | fIsProcessed(kFALSE) | |
147 | { | |
148 | ||
149 | // copy constructor | |
dc7ca31d | 150 | |
8eb4ac75 | 151 | fRun=data.fRun; |
152 | fStartTime=data.fStartTime; | |
153 | fEndTime=data.fEndTime; | |
154 | fStartTimeDCSQuery=data.fStartTimeDCSQuery; | |
155 | fEndTimeDCSQuery=data.fEndTimeDCSQuery; | |
156 | fIsProcessed=data.fIsProcessed; | |
157 | fAtten=data.fAtten; | |
158 | ||
159 | for(int i=0;i<kNAliases;i++) | |
160 | { | |
161 | fAliasNames[i]=data.fAliasNames[i]; | |
162 | } | |
163 | ||
164 | for(Int_t i=0;i<kScalers;i++) | |
165 | { | |
166 | fScalerMean[i]=data.fScalerMean[i]; | |
167 | fScalerSecMean[i]=data.fScalerSecMean[i]; | |
168 | } | |
169 | for(Int_t i=0;i<kHV;i++) | |
170 | { | |
171 | fHViA[i]=data.fHViA[i]; | |
172 | fHVvA[i]=data.fHVvA[i]; | |
173 | fHViC[i]=data.fHViC[i]; | |
174 | fHVvC[i]=data.fHVvC[i]; | |
175 | } | |
176 | for(Int_t i=0;i<kLV;i++) | |
177 | { | |
178 | fLViA[i]=data.fLViA[i]; | |
179 | fLVvA[i]=data.fLVvA[i]; | |
180 | fLViC[i]=data.fLViC[i]; | |
181 | fLVvC[i]=data.fLVvC[i]; | |
182 | } | |
183 | for(Int_t i=0;i<kTRM;i++) | |
184 | { | |
185 | fTRM[i]=data.fTRM[i]; | |
186 | } | |
187 | for(Int_t i=0;i<kDRM;i++) | |
188 | { | |
189 | fDRM[i]=data.fDRM[i]; | |
190 | } | |
191 | } | |
dc7ca31d | 192 | //--------------------------------------------------------------- |
dc7ca31d | 193 | |
8eb4ac75 | 194 | AliT0DataDCS& AliT0DataDCS:: operator=(const AliT0DataDCS & data) { |
195 | ||
196 | // assignment operator | |
197 | ||
198 | this->fRun=data.fRun; | |
199 | this->fStartTime=data.fStartTime; | |
200 | this->fEndTime=data.fEndTime; | |
201 | this->fStartTimeDCSQuery=data.fStartTimeDCSQuery; | |
202 | this->fEndTimeDCSQuery=data.fEndTimeDCSQuery; | |
203 | ||
204 | for(int i=0;i<kNAliases;i++) | |
205 | { | |
206 | this->fAliasNames[i]=data.fAliasNames[i]; | |
207 | } | |
208 | ||
209 | return *this; | |
210 | } | |
211 | ||
212 | //--------------------------------------------------------------- | |
213 | AliT0DataDCS::~AliT0DataDCS() | |
214 | { | |
dc7ca31d | 215 | } |
216 | ||
217 | //--------------------------------------------------------------- | |
91366e58 | 218 | Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap) |
219 | { | |
8eb4ac75 | 220 | Int_t t0_scaler[kScalers]; |
221 | Int_t t0_scaler_sec[kScalers]; | |
222 | Int_t aliasEntr[kNAliases]; | |
223 | Float_t t0_a_hv_imon[kHV]; | |
224 | Float_t t0_a_hv_vmon[kHV]; | |
225 | Float_t t0_a_lv_imon[kLV]; | |
226 | Float_t t0_a_lv_vmon[kLV]; | |
227 | Float_t t0_c_hv_imon[kHV]; | |
228 | Float_t t0_c_hv_vmon[kHV]; | |
229 | Float_t t0_c_lv_imon[kLV]; | |
230 | Float_t t0_c_lv_vmon[kLV]; | |
231 | Float_t t0_a_cfd_thre[kCFD]; | |
232 | Float_t t0_a_cfd_walk[kCFD]; | |
233 | Float_t t0_c_cfd_thre[kCFD]; | |
234 | Float_t t0_c_cfd_walk[kCFD]; | |
235 | Float_t t0_ac_trm[kTRM]; | |
236 | Float_t t0_ac_drm[kDRM]; | |
237 | Float_t t0_atten=0.; | |
238 | ||
970bb0d0 | 239 | TObjArray *aliasArr; |
8eb4ac75 | 240 | for(Int_t k=0; k<kScalers; k++) |
241 | { | |
242 | t0_scaler[k]=0; | |
243 | t0_scaler_sec[k]=0; | |
244 | } | |
245 | ||
246 | for(Int_t k=0; k<kHV; k++) | |
247 | { | |
248 | t0_a_hv_imon[k]=0.; | |
249 | t0_a_hv_vmon[k]=0.; | |
250 | t0_c_hv_imon[k]=0.; | |
251 | t0_c_hv_vmon[k]=0.; | |
252 | } | |
253 | for(Int_t k=0; k<kHV; k++) | |
254 | { | |
255 | t0_a_lv_imon[k]=0.; | |
256 | t0_a_lv_vmon[k]=0.; | |
257 | t0_c_lv_imon[k]=0.; | |
258 | t0_c_lv_vmon[k]=0.; | |
259 | } | |
260 | for(Int_t k=0; k<kCFD; k++) | |
261 | { | |
262 | t0_a_cfd_thre[k]=0.; | |
263 | t0_a_cfd_walk[k]=0.; | |
264 | t0_c_cfd_thre[k]=0.; | |
265 | t0_c_cfd_walk[k]=0.; | |
266 | } | |
267 | for(Int_t k=0; k<kTRM; k++) | |
268 | { | |
269 | t0_ac_trm[k]=0.; | |
270 | } | |
271 | for(Int_t k=0; k<kDRM; k++) | |
272 | { | |
273 | t0_ac_drm[k]=0.; | |
274 | } | |
275 | ||
276 | // here starts the main loop | |
277 | for(Int_t j=0; j<kNAliases; j++) | |
970bb0d0 | 278 | { |
8eb4ac75 | 279 | aliasEntr[j]=0; |
9dcc11e4 | 280 | for (Int_t k=0;k<32;k++) |
281 | { | |
282 | t0_scaler[k]=0; | |
8eb4ac75 | 283 | t0_scaler_sec[k]=0; |
284 | ||
9dcc11e4 | 285 | } |
286 | aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data()); | |
970bb0d0 | 287 | if(!aliasArr) |
288 | { | |
289 | AliError(Form("Alias %s not found!", fAliasNames[j].Data())); | |
91366e58 | 290 | continue; |
970bb0d0 | 291 | } |
8eb4ac75 | 292 | Introduce(j, aliasArr); |
970bb0d0 | 293 | if(aliasArr->GetEntries()<2) |
294 | { | |
295 | AliError(Form("Alias %s has just %d entries!", | |
296 | fAliasNames[j].Data(),aliasArr->GetEntries())); | |
297 | continue; | |
298 | } | |
8eb4ac75 | 299 | if (j < kScalers) |
300 | { | |
301 | aliasEntr[j] = aliasArr->GetEntries(); | |
302 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
303 | { | |
304 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
305 | t0_scaler[j]+= aValue->GetUInt(); | |
306 | } | |
307 | fScalerMean[j] = t0_scaler[j] / aliasEntr[j]; | |
308 | } | |
309 | else if (j < 2*kScalers) | |
970bb0d0 | 310 | { |
8eb4ac75 | 311 | aliasEntr[j] = aliasArr->GetEntries(); |
312 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
313 | { | |
314 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 315 | t0_scaler_sec[j-kScalers]+= aValue->GetUInt(); |
8eb4ac75 | 316 | } |
19fb06bd | 317 | fScalerSecMean[j-kScalers] = t0_scaler_sec[j-kScalers] / aliasEntr[j]; |
8eb4ac75 | 318 | } |
319 | else if (j < 2*kScalers+kHV) | |
320 | { | |
321 | aliasEntr[j] = aliasArr->GetEntries(); | |
322 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
323 | { | |
324 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 325 | t0_a_hv_imon[j-2*kScalers]+= aValue->GetFloat(); |
8eb4ac75 | 326 | } |
19fb06bd | 327 | fHViA[j-2*kScalers] = t0_a_hv_imon[j-2*kScalers] / aliasEntr[j]; |
8eb4ac75 | 328 | } |
329 | else if (j < 2*kScalers+2*kHV) | |
330 | { | |
331 | aliasEntr[j] = aliasArr->GetEntries(); | |
332 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
333 | { | |
334 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 335 | t0_a_hv_vmon[j-(2*kScalers+kHV)]+= aValue->GetFloat(); |
8eb4ac75 | 336 | } |
19fb06bd | 337 | fHVvA[j-(2*kScalers+kHV)] = t0_a_hv_vmon[j-(2*kScalers+kHV)] / aliasEntr[j]; |
8eb4ac75 | 338 | } |
339 | else if (j < 2*kScalers+2*kHV+kLV) | |
340 | { | |
341 | aliasEntr[j] = aliasArr->GetEntries(); | |
342 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
343 | { | |
344 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 345 | t0_a_lv_imon[j-(2*kScalers+2*kHV)]+= aValue->GetFloat(); |
8eb4ac75 | 346 | } |
19fb06bd | 347 | fLViA[j-(2*kScalers+2*kHV)] = t0_a_lv_imon[j-(2*kScalers+2*kHV)] / aliasEntr[j]; |
8eb4ac75 | 348 | } |
349 | else if (j < 2*kScalers+2*kHV+2*kLV) | |
350 | { | |
351 | aliasEntr[j] = aliasArr->GetEntries(); | |
352 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
353 | { | |
354 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 355 | t0_a_lv_vmon[j-(2*kScalers+2*kHV+kLV)]+= aValue->GetFloat(); |
8eb4ac75 | 356 | } |
19fb06bd | 357 | fLVvA[j-(2*kScalers+2*kHV+kLV)] = t0_a_lv_vmon[j-(2*kScalers+2*kHV+kLV)] / aliasEntr[j]; |
8eb4ac75 | 358 | } |
359 | else if (j < 2*kScalers+3*kHV+2*kLV) | |
360 | { | |
361 | aliasEntr[j] = aliasArr->GetEntries(); | |
362 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
363 | { | |
364 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 365 | t0_c_hv_imon[j-(2*kScalers+2*kHV+2*kLV)]+= aValue->GetFloat(); |
8eb4ac75 | 366 | } |
19fb06bd | 367 | fHViC[j-(2*kScalers+2*kHV+2*kLV)] = t0_c_hv_imon[j-(2*kScalers+2*kHV+2*kLV)] / aliasEntr[j]; |
8eb4ac75 | 368 | } |
369 | else if (j < 2*kScalers+4*kHV+2*kLV) | |
370 | { | |
371 | aliasEntr[j] = aliasArr->GetEntries(); | |
372 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
373 | { | |
374 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 375 | t0_c_hv_vmon[j-(2*kScalers+3*kHV+2*kLV)]+= aValue->GetFloat(); |
8eb4ac75 | 376 | } |
19fb06bd | 377 | fHVvC[j-(2*kScalers+3*kHV+2*kLV)] = t0_c_hv_vmon[j-(2*kScalers+3*kHV+2*kLV)] / aliasEntr[j]; |
8eb4ac75 | 378 | } |
379 | else if (j < 2*kScalers+4*kHV+3*kLV) | |
380 | { | |
381 | aliasEntr[j] = aliasArr->GetEntries(); | |
382 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
383 | { | |
384 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 385 | t0_c_lv_imon[j-(2*kScalers+4*kHV+2*kLV)]+= aValue->GetFloat(); |
8eb4ac75 | 386 | } |
19fb06bd | 387 | fLViC[j-(2*kScalers+4*kHV+2*kLV)] = t0_c_lv_imon[j-(2*kScalers+4*kHV+2*kLV)] / aliasEntr[j]; |
8eb4ac75 | 388 | } |
389 | else if (j < 2*kScalers+4*kHV+4*kLV) | |
390 | { | |
391 | aliasEntr[j] = aliasArr->GetEntries(); | |
392 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
393 | { | |
394 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 395 | t0_c_lv_vmon[j-(2*kScalers+4*kHV+3*kLV)]+= aValue->GetFloat(); |
8eb4ac75 | 396 | } |
19fb06bd | 397 | fLVvC[j-(2*kScalers+4*kHV+3*kLV)] = t0_c_lv_vmon[j-(2*kScalers+4*kHV+3*kLV)] / aliasEntr[j]; |
8eb4ac75 | 398 | } |
399 | else if (j < 2*kScalers+4*kHV+4*kLV+kCFD) | |
400 | { | |
401 | aliasEntr[j] = aliasArr->GetEntries(); | |
402 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
403 | { | |
404 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 405 | t0_a_cfd_thre[j-(2*kScalers+4*kHV+4*kLV)]+= aValue->GetFloat(); |
8eb4ac75 | 406 | } |
19fb06bd | 407 | fCFDtA[j-(2*kScalers+4*kHV+4*kLV)] = t0_a_cfd_thre[j-(2*kScalers+4*kHV+4*kLV)] / aliasEntr[j]; |
8eb4ac75 | 408 | } |
409 | else if (j < 2*kScalers+4*kHV+4*kLV+2*kCFD) | |
410 | { | |
411 | aliasEntr[j] = aliasArr->GetEntries(); | |
412 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
413 | { | |
414 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 415 | t0_a_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+kCFD)]+= aValue->GetFloat(); |
8eb4ac75 | 416 | } |
19fb06bd | 417 | fCFDwA[j-(2*kScalers+4*kHV+4*kLV+kCFD)] = t0_a_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+kCFD)] / aliasEntr[j]; |
8eb4ac75 | 418 | } |
419 | else if (j < 2*kScalers+4*kHV+4*kLV+3*kCFD) | |
420 | { | |
421 | aliasEntr[j] = aliasArr->GetEntries(); | |
422 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
423 | { | |
424 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 425 | t0_c_cfd_thre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)]+= aValue->GetFloat(); |
8eb4ac75 | 426 | } |
19fb06bd | 427 | fCFDtC[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] = t0_c_cfd_thre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] / aliasEntr[j]; |
8eb4ac75 | 428 | } |
429 | else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD) | |
430 | { | |
431 | aliasEntr[j] = aliasArr->GetEntries(); | |
432 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
433 | { | |
434 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 435 | t0_c_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)]+= aValue->GetFloat(); |
8eb4ac75 | 436 | } |
19fb06bd | 437 | fCFDwC[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] = t0_c_cfd_walk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] / aliasEntr[j]; |
8eb4ac75 | 438 | } |
439 | else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM) | |
440 | { | |
441 | aliasEntr[j] = aliasArr->GetEntries(); | |
442 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
443 | { | |
444 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 445 | t0_ac_trm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)]+= aValue->GetFloat(); |
8eb4ac75 | 446 | } |
19fb06bd | 447 | fTRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] = t0_ac_trm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] / aliasEntr[j]; |
8eb4ac75 | 448 | } |
449 | else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM) | |
450 | { | |
451 | aliasEntr[j] = aliasArr->GetEntries(); | |
452 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
453 | { | |
454 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
19fb06bd | 455 | t0_ac_drm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)]+= aValue->GetFloat(); |
8eb4ac75 | 456 | } |
19fb06bd | 457 | fDRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)] = t0_ac_drm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)] / aliasEntr[j]; |
8eb4ac75 | 458 | } |
459 | else | |
460 | { | |
461 | aliasEntr[j] = aliasArr->GetEntries(); | |
462 | for(Int_t l=0; l<aliasEntr[j]; l++) | |
463 | { | |
464 | AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l)); | |
465 | t0_atten += aValue->GetInt(); | |
466 | } | |
19fb06bd | 467 | fAtten = t0_atten / aliasEntr[j]; |
8eb4ac75 | 468 | } |
19fb06bd | 469 | } |
dc7ca31d | 470 | fIsProcessed=kTRUE; |
9dcc11e4 | 471 | return kTRUE; |
dc7ca31d | 472 | } |
473 | ||
474 | //--------------------------------------------------------------- | |
91366e58 | 475 | void AliT0DataDCS::Init() |
476 | { | |
9dcc11e4 | 477 | TString sindex; |
91366e58 | 478 | for(int i=0;i<kNAliases;i++) |
8eb4ac75 | 479 | { |
480 | if (i<kScalers) | |
481 | { | |
482 | fAliasNames[i] = "t00_ac_scaler_"; | |
483 | sindex.Form("%02d",i); | |
484 | fAliasNames[i] += sindex; | |
485 | } | |
486 | else if (i < 2*kScalers) | |
487 | { | |
488 | fAliasNames[i] = "t00_ac_scaler_sec_"; | |
19fb06bd | 489 | sindex.Form("%02d",i-kScalers); |
8eb4ac75 | 490 | fAliasNames[i] += sindex; |
491 | } | |
492 | else if (i < 2*kScalers+kHV) | |
493 | { | |
494 | fAliasNames[i] = "t00_a_hv_imon_"; | |
19fb06bd | 495 | sindex.Form("%02d",i-2*kScalers); |
8eb4ac75 | 496 | fAliasNames[i] += sindex; |
497 | } | |
498 | else if (i < 2*kScalers+2*kHV) | |
499 | { | |
500 | fAliasNames[i] = "t00_a_hv_vmon_"; | |
19fb06bd | 501 | sindex.Form("%02d",i-(2*kScalers+kHV)); |
8eb4ac75 | 502 | fAliasNames[i] += sindex; |
503 | } | |
504 | else if (i < 2*kScalers+2*kHV+kLV) | |
505 | { | |
506 | fAliasNames[i] = "t00_a_lv_imon_"; | |
19fb06bd | 507 | sindex.Form("%02d",i-(2*kScalers+2*kHV)); |
8eb4ac75 | 508 | fAliasNames[i] += sindex; |
509 | } | |
510 | else if (i < 2*kScalers+2*kHV+2*kLV) | |
511 | { | |
512 | fAliasNames[i] = "t00_a_lv_vmon_"; | |
19fb06bd | 513 | sindex.Form("%02d",i-(2*kScalers+2*kHV+kLV)); |
8eb4ac75 | 514 | fAliasNames[i] += sindex; |
515 | } | |
516 | else if (i < 2*kScalers+3*kHV+2*kLV) | |
517 | { | |
518 | fAliasNames[i] = "t00_c_hv_imon_"; | |
19fb06bd | 519 | sindex.Form("%02d",i-(2*kScalers+2*kHV+2*kLV)); |
8eb4ac75 | 520 | fAliasNames[i] += sindex; |
521 | } | |
522 | else if (i < 2*kScalers+4*kHV+2*kLV) | |
523 | { | |
524 | fAliasNames[i] = "t00_c_hv_vmon_"; | |
19fb06bd | 525 | sindex.Form("%02d",i-(2*kScalers+3*kHV+2*kLV)); |
8eb4ac75 | 526 | fAliasNames[i] += sindex; |
527 | } | |
528 | else if (i < 2*kScalers+4*kHV+3*kLV) | |
529 | { | |
530 | fAliasNames[i] = "t00_c_lv_imon_"; | |
19fb06bd | 531 | sindex.Form("%02d",i-(2*kScalers+4*kHV+2*kLV)); |
8eb4ac75 | 532 | fAliasNames[i] += sindex; |
533 | } | |
534 | else if (i < 2*kScalers+4*kHV+4*kLV) | |
535 | { | |
536 | fAliasNames[i] = "t00_c_lv_vmon_"; | |
19fb06bd | 537 | sindex.Form("%02d",i-(2*kScalers+4*kHV+3*kLV)); |
8eb4ac75 | 538 | fAliasNames[i] += sindex; |
539 | } | |
540 | else if (i < 2*kScalers+4*kHV+4*kLV+kCFD) | |
541 | { | |
542 | fAliasNames[i] = "t00_a_cfd_thre_"; | |
19fb06bd | 543 | sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV)); |
8eb4ac75 | 544 | fAliasNames[i] += sindex; |
545 | } | |
546 | else if (i < 2*kScalers+4*kHV+4*kLV+2*kCFD) | |
547 | { | |
548 | fAliasNames[i] = "t00_a_cfd_walk_"; | |
19fb06bd | 549 | sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+kCFD)); |
8eb4ac75 | 550 | fAliasNames[i] += sindex; |
551 | } | |
552 | else if (i < 2*kScalers+4*kHV+4*kLV+3*kCFD) | |
553 | { | |
554 | fAliasNames[i] = "t00_c_cfd_thre_"; | |
19fb06bd | 555 | sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+2*kCFD)); |
8eb4ac75 | 556 | fAliasNames[i] += sindex; |
557 | } | |
558 | else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD) | |
559 | { | |
560 | fAliasNames[i] = "t00_c_cfd_walk_"; | |
19fb06bd | 561 | sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+3*kCFD)); |
8eb4ac75 | 562 | fAliasNames[i] += sindex; |
563 | } | |
564 | else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM) | |
565 | { | |
566 | fAliasNames[i] = "t00_ac_trm_"; | |
19fb06bd | 567 | sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD)); |
8eb4ac75 | 568 | fAliasNames[i] += sindex; |
569 | } | |
570 | else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM) | |
571 | { | |
572 | fAliasNames[i] = "t00_ac_drm_"; | |
19fb06bd | 573 | sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)); |
8eb4ac75 | 574 | fAliasNames[i] += sindex; |
575 | } | |
576 | else | |
577 | { | |
19fb06bd | 578 | fAliasNames[i] = "t00_ac_atten"; |
8eb4ac75 | 579 | } |
580 | ||
dc7ca31d | 581 | } |
582 | ||
dc7ca31d | 583 | } |
584 | ||
585 | //--------------------------------------------------------------- | |
8eb4ac75 | 586 | void AliT0DataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const |
587 | { | |
dc7ca31d | 588 | |
589 | int entries=aliasArr->GetEntries(); | |
590 | AliInfo(Form("************ Alias: %s **********",fAliasNames[numAlias].Data())); | |
591 | AliInfo(Form(" %d DP values collected",entries)); | |
592 | ||
593 | } | |
594 | ||
dc7ca31d | 595 | |
91366e58 | 596 |