]> git.uio.no Git - u/mrichter/AliRoot.git/blame - T0/AliT0DataDCS.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
warnings fixed
[u/mrichter/AliRoot.git] / T0 / AliT0DataDCS.cxx
CommitLineData
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
19Fetching data points from DCS, calculating mean and storing data to Reference DB
20
21 Version 1.1 2006/10
22Preliminary 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>
dc7ca31d 33
9dcc11e4 34// AliT0DataDCS class
35// declaring DCS aliases for T0
36// fetching T0 data points from DCS,
37// calculating mean values for the entire run
38// and storing the result to Reference DB
39
dc7ca31d 40ClassImp(AliT0DataDCS)
41
42//---------------------------------------------------------------
43AliT0DataDCS::AliT0DataDCS():
44 TObject(),
9dcc11e4 45 fRun(0),
dc7ca31d 46 fStartTime(0),
47 fEndTime(0),
8eb4ac75 48 fStartTimeDCSQuery(0),
49 fEndTimeDCSQuery(0),
50 fAtten(0.),
955ef7d2 51 fMPDcentA(0),
52 fMPDcentC(0),
53 fMPDsemiCentA(0),
54 fMPDsemiCentC(0),
55 fTVDCtop(0),
56 fTVDCbottom(0),
57 fMPDmode(0),
dc7ca31d 58 fIsProcessed(kFALSE)
59{
d99eeddf 60 // default constructor
61 //
8eb4ac75 62 for(Int_t i=0;i<kScalers;i++)
63 {
5bdebf6a 64 fScalerMean[i]=0;
65 fScalerSecMean[i]=0;
8eb4ac75 66 }
67 for(Int_t i=0;i<kHV;i++)
68 {
69 fHViA[i]=0.;
70 fHVvA[i]=0.;
71 fHViC[i]=0.;
72 fHVvC[i]=0.;
73 }
74 for(Int_t i=0;i<kLV;i++)
75 {
76 fLViA[i]=0.;
77 fLVvA[i]=0.;
78 fLViC[i]=0.;
79 fLVvC[i]=0.;
80 }
81 for(Int_t i=0;i<kTRM;i++)
82 {
83 fTRM[i]=0.;
84 }
85 for(Int_t i=0;i<kDRM;i++)
86 {
87 fDRM[i]=0.;
88 }
36cde487 89 for ( Int_t i=0; i<kCFD; i++ )
90 {
91 fCFDtA[i] = 0;
92 fCFDtC[i] = 0;
93 fCFDwA[i] = 0;
94 fCFDwC[i] = 0;
95 }
96
dc7ca31d 97
8eb4ac75 98}
dc7ca31d 99//---------------------------------------------------------------
8eb4ac75 100AliT0DataDCS::AliT0DataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime, UInt_t startTimeDCSQuery, UInt_t endTimeDCSQuery):
dc7ca31d 101 TObject(),
102 fRun(nRun),
103 fStartTime(startTime),
104 fEndTime(endTime),
8eb4ac75 105 fStartTimeDCSQuery(startTimeDCSQuery),
106 fEndTimeDCSQuery(endTimeDCSQuery),
107 fAtten(0.),
955ef7d2 108 fMPDcentA(0),
109 fMPDcentC(0),
110 fMPDsemiCentA(0),
111 fMPDsemiCentC(0),
112 fTVDCtop(0),
113 fTVDCbottom(0),
114 fMPDmode(0),
dc7ca31d 115 fIsProcessed(kFALSE)
116{
d99eeddf 117 // constructor
118
8eb4ac75 119 for(Int_t i=0;i<kScalers;i++)
120 {
5bdebf6a 121 fScalerMean[i]=0;
122 fScalerSecMean[i]=0;
8eb4ac75 123 }
124 for(Int_t i=0;i<kHV;i++)
125 {
126 fHViA[i]=0.;
127 fHVvA[i]=0.;
128 fHViC[i]=0.;
129 fHVvC[i]=0.;
130 }
131 for(Int_t i=0;i<kLV;i++)
132 {
133 fLViA[i]=0.;
134 fLVvA[i]=0.;
135 fLViC[i]=0.;
136 fLVvC[i]=0.;
137 }
138 for(Int_t i=0;i<kTRM;i++)
139 {
140 fTRM[i]=0.;
141 }
142 for(Int_t i=0;i<kDRM;i++)
143 {
144 fDRM[i]=0.;
145 }
146
147 AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s \n\tStartTime DCS Query %s \n\tEndTime DCS Query %s", nRun,
dc7ca31d 148 TTimeStamp(startTime).AsString(),
8eb4ac75 149 TTimeStamp(endTime).AsString(),
150 TTimeStamp(startTimeDCSQuery).AsString(),
151 TTimeStamp(endTimeDCSQuery).AsString()));
dc7ca31d 152
dc7ca31d 153 Init();
154
155}
8eb4ac75 156//---------------------------------------------------------------
157
158AliT0DataDCS::AliT0DataDCS(const AliT0DataDCS & data):
159 TObject(),
160 fRun(0),
161 fStartTime(0),
162 fEndTime(0),
163 fStartTimeDCSQuery(0),
164 fEndTimeDCSQuery(0),
165 fAtten(0.),
955ef7d2 166 fMPDcentA(0),
167 fMPDcentC(0),
168 fMPDsemiCentA(0),
169 fMPDsemiCentC(0),
170 fTVDCtop(0),
171 fTVDCbottom(0),
172 fMPDmode(0),
8eb4ac75 173 fIsProcessed(kFALSE)
174{
175
176// copy constructor
dc7ca31d 177
8eb4ac75 178 fRun=data.fRun;
179 fStartTime=data.fStartTime;
180 fEndTime=data.fEndTime;
181 fStartTimeDCSQuery=data.fStartTimeDCSQuery;
182 fEndTimeDCSQuery=data.fEndTimeDCSQuery;
183 fIsProcessed=data.fIsProcessed;
184 fAtten=data.fAtten;
955ef7d2 185 fMPDcentA=data.fMPDcentA;
186 fMPDcentC=data.fMPDcentC;
187 fMPDsemiCentA=data.fMPDsemiCentA;
188 fMPDsemiCentC=data.fMPDsemiCentC;
189 fTVDCtop=data.fTVDCtop;
190 fTVDCbottom=data.fTVDCbottom;
191 fMPDmode=data.fMPDmode;
8eb4ac75 192 for(int i=0;i<kNAliases;i++)
193 {
194 fAliasNames[i]=data.fAliasNames[i];
195 }
196
197 for(Int_t i=0;i<kScalers;i++)
198 {
199 fScalerMean[i]=data.fScalerMean[i];
200 fScalerSecMean[i]=data.fScalerSecMean[i];
201 }
202 for(Int_t i=0;i<kHV;i++)
203 {
204 fHViA[i]=data.fHViA[i];
205 fHVvA[i]=data.fHVvA[i];
206 fHViC[i]=data.fHViC[i];
207 fHVvC[i]=data.fHVvC[i];
208 }
209 for(Int_t i=0;i<kLV;i++)
210 {
211 fLViA[i]=data.fLViA[i];
212 fLVvA[i]=data.fLVvA[i];
213 fLViC[i]=data.fLViC[i];
214 fLVvC[i]=data.fLVvC[i];
215 }
216 for(Int_t i=0;i<kTRM;i++)
217 {
218 fTRM[i]=data.fTRM[i];
219 }
220 for(Int_t i=0;i<kDRM;i++)
221 {
222 fDRM[i]=data.fDRM[i];
223 }
36cde487 224 for ( Int_t i=0; i<kCFD; i++ )
225 {
226 fCFDtA[i] = data.fCFDtA[i];
227 fCFDtC[i] = data.fCFDtC[i];
228 fCFDwA[i] = data.fCFDwA[i];
229 fCFDwC[i] = data.fCFDwC[i];
230 }
8eb4ac75 231}
dc7ca31d 232//---------------------------------------------------------------
dc7ca31d 233
8eb4ac75 234AliT0DataDCS& AliT0DataDCS:: operator=(const AliT0DataDCS & data) {
235
236// assignment operator
237
238 this->fRun=data.fRun;
239 this->fStartTime=data.fStartTime;
240 this->fEndTime=data.fEndTime;
241 this->fStartTimeDCSQuery=data.fStartTimeDCSQuery;
242 this->fEndTimeDCSQuery=data.fEndTimeDCSQuery;
243
244 for(int i=0;i<kNAliases;i++)
245 {
246 this->fAliasNames[i]=data.fAliasNames[i];
247 }
248
249 return *this;
250}
251
252//---------------------------------------------------------------
253AliT0DataDCS::~AliT0DataDCS()
254{
dc7ca31d 255}
256
257//---------------------------------------------------------------
91366e58 258Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
259{
d99eeddf 260 //process DCS data
261
262 UInt_t t0Scaler[kScalers];
263 UInt_t t0ScalerSec[kScalers];
8eb4ac75 264 Int_t aliasEntr[kNAliases];
d99eeddf 265 Float_t t0AhvImon[kHV];
266 Float_t t0AHVvmon[kHV];
267 Float_t t0AlvImon[kLV];
268 Float_t t0AlvVmon[kLV];
269 Float_t t0ChvImon[kHV];
270 Float_t t0ChvVmon[kHV];
271 Float_t t0ClvImon[kLV];
272 Float_t t0ClvVmon[kLV];
273 Float_t t0AcfdThre[kCFD];
274 Float_t t0AcfdWalk[kCFD];
275 Float_t t0CcfdThre[kCFD];
276 Float_t t0CcfdWalk[kCFD];
277 Float_t t0ACtrm[kTRM];
278 Float_t t0ACdrm[kDRM];
279 Float_t t0atten=0.;
280 Int_t t0MPDcentA=0;
281 Int_t t0MPDcentC=0;
282 Int_t t0MPDsemiCentA=0;
283 Int_t t0MPDsemiCentC=0;
284 Int_t t0TVDCtop=0;
285 Int_t t0TVDCbottom=0;
286 Int_t t0MPDmode=0;
955ef7d2 287
970bb0d0 288 TObjArray *aliasArr;
8eb4ac75 289 for(Int_t k=0; k<kScalers; k++)
290 {
d99eeddf 291 t0Scaler[k]=0;
292 t0ScalerSec[k]=0;
8eb4ac75 293 }
294
295 for(Int_t k=0; k<kHV; k++)
296 {
d99eeddf 297 t0AhvImon[k]=0.;
298 t0AHVvmon[k]=0.;
299 t0ChvImon[k]=0.;
300 t0ChvVmon[k]=0.;
8eb4ac75 301 }
882ad8b4 302 for(Int_t k=0; k<kLV; k++)
8eb4ac75 303 {
d99eeddf 304 t0AlvImon[k]=0.;
305 t0AlvVmon[k]=0.;
306 t0ClvImon[k]=0.;
307 t0ClvVmon[k]=0.;
8eb4ac75 308 }
309 for(Int_t k=0; k<kCFD; k++)
310 {
d99eeddf 311 t0AcfdThre[k]=0.;
312 t0AcfdWalk[k]=0.;
313 t0CcfdThre[k]=0.;
314 t0CcfdWalk[k]=0.;
8eb4ac75 315 }
316 for(Int_t k=0; k<kTRM; k++)
317 {
d99eeddf 318 t0ACtrm[k]=0.;
8eb4ac75 319 }
320 for(Int_t k=0; k<kDRM; k++)
321 {
d99eeddf 322 t0ACdrm[k]=0.;
8eb4ac75 323 }
324
5bdebf6a 325 // here starts the main loop
8eb4ac75 326 for(Int_t j=0; j<kNAliases; j++)
970bb0d0 327 {
8eb4ac75 328 aliasEntr[j]=0;
9dcc11e4 329 for (Int_t k=0;k<32;k++)
330 {
d99eeddf 331 t0Scaler[k]=0;
332 t0ScalerSec[k]=0;
8eb4ac75 333
9dcc11e4 334 }
335 aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
5bdebf6a 336
970bb0d0 337 if(!aliasArr)
338 {
339 AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
91366e58 340 continue;
970bb0d0 341 }
8eb4ac75 342 Introduce(j, aliasArr);
970bb0d0 343 if(aliasArr->GetEntries()<2)
344 {
345 AliError(Form("Alias %s has just %d entries!",
346 fAliasNames[j].Data(),aliasArr->GetEntries()));
347 continue;
348 }
8eb4ac75 349 if (j < kScalers)
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));
d99eeddf 355 t0Scaler[j]+= (UInt_t) aValue->GetFloat();
8eb4ac75 356 }
d99eeddf 357 fScalerMean[j] = ((UInt_t) t0Scaler[j])/((UInt_t) aliasEntr[j]);
8eb4ac75 358 }
359 else if (j < 2*kScalers)
970bb0d0 360 {
8eb4ac75 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));
d99eeddf 365 t0ScalerSec[j-kScalers]+= (UInt_t) aValue->GetFloat();
8eb4ac75 366 }
d99eeddf 367 fScalerSecMean[j-kScalers] = ((UInt_t) t0ScalerSec[j-kScalers])/((UInt_t) aliasEntr[j]);
8eb4ac75 368 }
369 else if (j < 2*kScalers+kHV)
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));
d99eeddf 375 t0AhvImon[j-2*kScalers]+= aValue->GetFloat();
8eb4ac75 376 }
d99eeddf 377 fHViA[j-2*kScalers] = t0AhvImon[j-2*kScalers] / aliasEntr[j];
8eb4ac75 378 }
379 else if (j < 2*kScalers+2*kHV)
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));
d99eeddf 385 t0AHVvmon[j-(2*kScalers+kHV)]+= aValue->GetFloat();
8eb4ac75 386 }
d99eeddf 387 fHVvA[j-(2*kScalers+kHV)] = t0AHVvmon[j-(2*kScalers+kHV)] / aliasEntr[j];
8eb4ac75 388 }
389 else if (j < 2*kScalers+2*kHV+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));
d99eeddf 395 t0AlvImon[j-(2*kScalers+2*kHV)]+= aValue->GetFloat();
8eb4ac75 396 }
d99eeddf 397 fLViA[j-(2*kScalers+2*kHV)] = t0AlvImon[j-(2*kScalers+2*kHV)] / aliasEntr[j];
8eb4ac75 398 }
399 else if (j < 2*kScalers+2*kHV+2*kLV)
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));
d99eeddf 405 t0AlvVmon[j-(2*kScalers+2*kHV+kLV)]+= aValue->GetFloat();
8eb4ac75 406 }
d99eeddf 407 fLVvA[j-(2*kScalers+2*kHV+kLV)] = t0AlvVmon[j-(2*kScalers+2*kHV+kLV)] / aliasEntr[j];
8eb4ac75 408 }
409 else if (j < 2*kScalers+3*kHV+2*kLV)
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));
d99eeddf 415 t0ChvImon[j-(2*kScalers+2*kHV+2*kLV)]+= aValue->GetFloat();
8eb4ac75 416 }
d99eeddf 417 fHViC[j-(2*kScalers+2*kHV+2*kLV)] = t0ChvImon[j-(2*kScalers+2*kHV+2*kLV)] / aliasEntr[j];
8eb4ac75 418 }
419 else if (j < 2*kScalers+4*kHV+2*kLV)
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));
d99eeddf 425 t0ChvVmon[j-(2*kScalers+3*kHV+2*kLV)]+= aValue->GetFloat();
8eb4ac75 426 }
d99eeddf 427 fHVvC[j-(2*kScalers+3*kHV+2*kLV)] = t0ChvVmon[j-(2*kScalers+3*kHV+2*kLV)] / aliasEntr[j];
8eb4ac75 428 }
429 else if (j < 2*kScalers+4*kHV+3*kLV)
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));
d99eeddf 435 t0ClvImon[j-(2*kScalers+4*kHV+2*kLV)]+= aValue->GetFloat();
8eb4ac75 436 }
d99eeddf 437 fLViC[j-(2*kScalers+4*kHV+2*kLV)] = t0ClvImon[j-(2*kScalers+4*kHV+2*kLV)] / aliasEntr[j];
8eb4ac75 438 }
439 else if (j < 2*kScalers+4*kHV+4*kLV)
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));
d99eeddf 445 t0ClvVmon[j-(2*kScalers+4*kHV+3*kLV)]+= aValue->GetFloat();
8eb4ac75 446 }
d99eeddf 447 fLVvC[j-(2*kScalers+4*kHV+3*kLV)] = t0ClvVmon[j-(2*kScalers+4*kHV+3*kLV)] / aliasEntr[j];
8eb4ac75 448 }
449 else if (j < 2*kScalers+4*kHV+4*kLV+kCFD)
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));
d99eeddf 455 t0AcfdThre[j-(2*kScalers+4*kHV+4*kLV)]+= aValue->GetFloat();
8eb4ac75 456 }
d99eeddf 457 fCFDtA[j-(2*kScalers+4*kHV+4*kLV)] = t0AcfdThre[j-(2*kScalers+4*kHV+4*kLV)] / aliasEntr[j];
8eb4ac75 458 }
459 else if (j < 2*kScalers+4*kHV+4*kLV+2*kCFD)
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));
d99eeddf 465 t0AcfdWalk[j-(2*kScalers+4*kHV+4*kLV+kCFD)]+= aValue->GetFloat();
8eb4ac75 466 }
d99eeddf 467 fCFDwA[j-(2*kScalers+4*kHV+4*kLV+kCFD)] = t0AcfdWalk[j-(2*kScalers+4*kHV+4*kLV+kCFD)] / aliasEntr[j];
8eb4ac75 468 }
469 else if (j < 2*kScalers+4*kHV+4*kLV+3*kCFD)
470 {
471 aliasEntr[j] = aliasArr->GetEntries();
472 for(Int_t l=0; l<aliasEntr[j]; l++)
473 {
474 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
d99eeddf 475 t0CcfdThre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)]+= aValue->GetFloat();
8eb4ac75 476 }
d99eeddf 477 fCFDtC[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] = t0CcfdThre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] / aliasEntr[j];
8eb4ac75 478 }
479 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD)
480 {
481 aliasEntr[j] = aliasArr->GetEntries();
482 for(Int_t l=0; l<aliasEntr[j]; l++)
483 {
484 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
d99eeddf 485 t0CcfdWalk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)]+= aValue->GetFloat();
8eb4ac75 486 }
d99eeddf 487 fCFDwC[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] = t0CcfdWalk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] / aliasEntr[j];
8eb4ac75 488 }
489 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
490 {
491 aliasEntr[j] = aliasArr->GetEntries();
492 for(Int_t l=0; l<aliasEntr[j]; l++)
493 {
494 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
d99eeddf 495 t0ACtrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)]+= aValue->GetFloat();
8eb4ac75 496 }
d99eeddf 497 fTRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] = t0ACtrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] / aliasEntr[j];
8eb4ac75 498 }
499 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
500 {
501 aliasEntr[j] = aliasArr->GetEntries();
502 for(Int_t l=0; l<aliasEntr[j]; l++)
503 {
504 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
d99eeddf 505 t0ACdrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)]+= aValue->GetFloat();
8eb4ac75 506 }
d99eeddf 507 fDRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)] = t0ACdrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)] / aliasEntr[j];
8eb4ac75 508 }
955ef7d2 509 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+kAtten)
8eb4ac75 510 {
511 aliasEntr[j] = aliasArr->GetEntries();
512 for(Int_t l=0; l<aliasEntr[j]; l++)
513 {
514 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
d99eeddf 515 t0atten += aValue->GetFloat();
8eb4ac75 516 }
d99eeddf 517 fAtten = t0atten /((Float_t) aliasEntr[j]);
8eb4ac75 518 }
955ef7d2 519 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+2*kAtten)
520 {
521 aliasEntr[j] = aliasArr->GetEntries();
522 for(Int_t l=0; l<aliasEntr[j]; l++)
523 {
524 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
36cde487 525 t0MPDcentA += aValue->GetFloat();
955ef7d2 526 }
36cde487 527 fMPDcentA = t0MPDcentA /((Float_t) aliasEntr[j]);
955ef7d2 528 }
529 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+3*kAtten)
530 {
531 aliasEntr[j] = aliasArr->GetEntries();
532 for(Int_t l=0; l<aliasEntr[j]; l++)
533 {
534 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
d99eeddf 535 t0MPDcentC += (Int_t) aValue->GetFloat();
955ef7d2 536 }
d99eeddf 537 fMPDcentC = ((Int_t) t0MPDcentC) /((Int_t) aliasEntr[j]);
955ef7d2 538 }
539 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+4*kAtten)
540 {
541 aliasEntr[j] = aliasArr->GetEntries();
542 for(Int_t l=0; l<aliasEntr[j]; l++)
543 {
544 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
d99eeddf 545 t0MPDsemiCentA += (Int_t) aValue->GetFloat();
955ef7d2 546 }
d99eeddf 547 fMPDsemiCentA = ((Int_t) t0MPDsemiCentA) /((Int_t) aliasEntr[j]);
955ef7d2 548 }
549 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+5*kAtten)
550 {
551 aliasEntr[j] = aliasArr->GetEntries();
552 for(Int_t l=0; l<aliasEntr[j]; l++)
553 {
554 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
d99eeddf 555 t0MPDsemiCentC += (Int_t) aValue->GetFloat();
955ef7d2 556 }
d99eeddf 557 fMPDsemiCentC = ((Int_t) t0MPDsemiCentC)/ ((Int_t) aliasEntr[j]);
955ef7d2 558 }
559 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+6*kAtten)
560 {
561 aliasEntr[j] = aliasArr->GetEntries();
562 for(Int_t l=0; l<aliasEntr[j]; l++)
563 {
564 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
d99eeddf 565 t0TVDCtop += (Int_t) aValue->GetFloat();
955ef7d2 566 }
d99eeddf 567 fTVDCtop = ((Int_t) t0TVDCtop)/((Int_t) aliasEntr[j]);
955ef7d2 568 }
569 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+7*kAtten)
570 {
571 aliasEntr[j] = aliasArr->GetEntries();
572 for(Int_t l=0; l<aliasEntr[j]; l++)
573 {
574 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
d99eeddf 575 t0TVDCbottom += (Int_t) aValue->GetFloat();
955ef7d2 576 }
d99eeddf 577 fTVDCbottom = ((Int_t) t0TVDCbottom) /((Int_t) aliasEntr[j]);
955ef7d2 578 }
579 else
580 {
581 aliasEntr[j] = aliasArr->GetEntries();
582 for(Int_t l=0; l<aliasEntr[j]; l++)
583 {
584 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
d99eeddf 585 t0MPDmode += (Int_t) aValue->GetFloat();
955ef7d2 586 }
d99eeddf 587 fMPDmode = ((Int_t) t0MPDmode)/((Int_t) aliasEntr[j]);
955ef7d2 588 }
19fb06bd 589 }
dc7ca31d 590 fIsProcessed=kTRUE;
9dcc11e4 591 return kTRUE;
dc7ca31d 592}
593
594//---------------------------------------------------------------
d99eeddf 595void AliT0DataDCS::Init()
596{
597 // initialize all DP aliases
598
599 TString sindex;
600 for(int i=0;i<kNAliases;i++)
601 {
602 if (i<kScalers)
603 {
604 fAliasNames[i] = "t00_ac_scaler_";
605 sindex.Form("%02d",i);
606 fAliasNames[i] += sindex;
607 }
608 else if (i < 2*kScalers)
609 {
610 fAliasNames[i] = "t00_ac_scaler_sec_";
611 sindex.Form("%02d",i-kScalers);
612 fAliasNames[i] += sindex;
613 }
614 else if (i < 2*kScalers+kHV)
615 {
616 fAliasNames[i] = "t00_a_hv_imon_";
617 sindex.Form("%02d",i-2*kScalers);
618 fAliasNames[i] += sindex;
619 }
620 else if (i < 2*kScalers+2*kHV)
621 {
622 fAliasNames[i] = "t00_a_hv_vmon_";
623 sindex.Form("%02d",i-(2*kScalers+kHV));
624 fAliasNames[i] += sindex;
625 }
626 else if (i < 2*kScalers+2*kHV+kLV)
627 {
628 fAliasNames[i] = "t00_a_lv_imon_";
629 sindex.Form("%01d",i-(2*kScalers+2*kHV));
630 fAliasNames[i] += sindex;
631 }
632 else if (i < 2*kScalers+2*kHV+2*kLV)
633 {
634 fAliasNames[i] = "t00_a_lv_vmon_";
635 sindex.Form("%01d",i-(2*kScalers+2*kHV+kLV));
636 fAliasNames[i] += sindex;
637 }
638 else if (i < 2*kScalers+3*kHV+2*kLV)
639 {
640 fAliasNames[i] = "t00_c_hv_imon_";
641 sindex.Form("%02d",i-(2*kScalers+2*kHV+2*kLV));
642 fAliasNames[i] += sindex;
643 }
644 else if (i < 2*kScalers+4*kHV+2*kLV)
645 {
646 fAliasNames[i] = "t00_c_hv_vmon_";
647 sindex.Form("%02d",i-(2*kScalers+3*kHV+2*kLV));
648 fAliasNames[i] += sindex;
649 }
650 else if (i < 2*kScalers+4*kHV+3*kLV)
651 {
652 fAliasNames[i] = "t00_c_lv_imon_";
653 sindex.Form("%01d",i-(2*kScalers+4*kHV+2*kLV));
654 fAliasNames[i] += sindex;
655 }
656 else if (i < 2*kScalers+4*kHV+4*kLV)
657 {
658 fAliasNames[i] = "t00_c_lv_vmon_";
659 sindex.Form("%01d",i-(2*kScalers+4*kHV+3*kLV));
660 fAliasNames[i] += sindex;
661 }
662 else if (i < 2*kScalers+4*kHV+4*kLV+kCFD)
663 {
664 fAliasNames[i] = "t00_a_cfd_thre_";
665 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV));
666 fAliasNames[i] += sindex;
667 }
668 else if (i < 2*kScalers+4*kHV+4*kLV+2*kCFD)
669 {
670 fAliasNames[i] = "t00_a_cfd_walk_";
671 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+kCFD));
672 fAliasNames[i] += sindex;
673 }
674 else if (i < 2*kScalers+4*kHV+4*kLV+3*kCFD)
675 {
676 fAliasNames[i] = "t00_c_cfd_thre_";
19fb06bd 677 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+2*kCFD));
8eb4ac75 678 fAliasNames[i] += sindex;
d99eeddf 679 }
680 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD)
8eb4ac75 681 {
682 fAliasNames[i] = "t00_c_cfd_walk_";
19fb06bd 683 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+3*kCFD));
8eb4ac75 684 fAliasNames[i] += sindex;
685 }
d99eeddf 686 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
687 {
688 fAliasNames[i] = "t00_ac_trm_";
689 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD));
690 fAliasNames[i] += sindex;
691 }
692 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
693 {
694 fAliasNames[i] = "t00_ac_drm_";
695 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM));
696 fAliasNames[i] += sindex;
697 }
698 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+kAtten)
699 {
700 fAliasNames[i] = "t00_ac_atten";
701 }
702 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+2*kAtten)
703 {
704 fAliasNames[i] = "t00_a_mpd_cent";
705 }
706 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+3*kAtten)
707 {
708 fAliasNames[i] = "t00_c_mpd_cent";
709 }
710 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+4*kAtten)
711 {
712 fAliasNames[i] = "t00_a_mpd_scent";
955ef7d2 713 }
d99eeddf 714 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+5*kAtten)
715 {
716 fAliasNames[i] = "t00_c_mpd_scent";
717 }
718 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+6*kAtten)
719 {
720 fAliasNames[i] = "t00_ac_tvdc_top";
721 }
722 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+7*kAtten)
723 {
724 fAliasNames[i] = "t00_ac_tvdc_bottom";
dc7ca31d 725 }
d99eeddf 726 else
727 {
728 fAliasNames[i] = "t00_ac_mpd_mode";
729 }
730 }
dc7ca31d 731
dc7ca31d 732}
733
734//---------------------------------------------------------------
8eb4ac75 735void AliT0DataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
736{
dc7ca31d 737
738 int entries=aliasArr->GetEntries();
739 AliInfo(Form("************ Alias: %s **********",fAliasNames[numAlias].Data()));
740 AliInfo(Form(" %d DP values collected",entries));
741
742}
743
dc7ca31d 744
5bdebf6a 745//---------------------------------------------------------------
746void AliT0DataDCS::PrintfArray(const char *label, const Float_t *array, Int_t numElements) const
747{
d99eeddf 748 //print all elements of array
5bdebf6a 749 printf("%s: \n",label);
750 for(Int_t i=0;i<numElements;i++){
751 printf(" %.2f", array[i]);
752 }
753 printf("\n");
754}
755//---------------------------------------------------------------
756
757void AliT0DataDCS::PrintT0Data() const
758{
d99eeddf 759 //print DP values
760
5bdebf6a 761 printf("AliT0DataDCS::Print()\n");
762 printf("RUN: %d\n", fRun);
763 printf("START TIME: %d\n", fStartTime);
764 printf("END TIME: %d\n", fEndTime);
765 printf("StartTimeDCSQuery: %d\n", fStartTimeDCSQuery);
766 printf("EndTimeDCSQuery: %d\n", fEndTimeDCSQuery);
767
768 PrintfArray("HV A side current", fHViA, kHV);
769 PrintfArray("HV A side voltage", fHVvA, kHV);
770 PrintfArray("LV A side current", fLViA, kLV);
771 PrintfArray("LV A side voltage", fLVvA, kLV);
772 PrintfArray("HV C side current", fHViC, kHV);
773 PrintfArray("HV C side voltage", fHVvC, kHV);
774 PrintfArray("LV C side current", fLViC, kLV);
775 PrintfArray("LV C side voltage", fLVvC, kLV);
776
777 PrintfArray("CFD threshold A side", fCFDtA, kCFD);
778 PrintfArray("CFD walk A side", fCFDwA, kCFD);
779 PrintfArray("CFD threshold C side", fCFDtC, kCFD);
780 PrintfArray("CFD walk C side", fCFDwC, kCFD);
781
782 //PrintfArray("SCALERS", (Float_t*) fScalerMean, kScalers);
783 printf("SCALERS: \n");
784 for(Int_t i=0;i<kScalers;i++){
785 printf(" %d", fScalerMean[i]);
786 }
787 printf("\n");
788
789
790 // PrintfArray("SCALERS per second",(Float_t*) fScalerSecMean, kScalers);
791 printf("SCALERS per second: \n");
792 for(Int_t i=0;i<kScalers;i++){
793 printf(" %d", fScalerSecMean[i]);
794 }
795 printf("\n");
796
797
798
799
800 PrintfArray("TRM", fTRM, kTRM);
801 PrintfArray("DRM", fDRM, kDRM);
802
803 printf("Laser Amplitude: %f\n", fAtten);
804 printf("mult. discrim. central A side: %d\n", fMPDcentA);
805 printf("mult. discrim. central C side: %d\n", fMPDcentC);
806 printf("mult. discrim. semi-central A side: %d\n", fMPDsemiCentA);
807 printf("mult. discrim. semi-central C side: %d\n", fMPDsemiCentC);
808
809 printf("TVDC top: %d\n", fTVDCtop);
810 printf("TVDC bottom: %d\n", fTVDCbottom);
811 printf("MPDmode: %d\n", fMPDmode);
812}
813
91366e58 814