1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
17 $Log: AliT0DataDCS.cxx,v $
19 Fetching data points from DCS, calculating mean and storing data to Reference DB
22 Preliminary test version (T.Malkiewicz)
25 #include "AliT0DataDCS.h"
27 #include "AliCDBMetaData.h"
28 #include "AliDCSValue.h"
31 #include <TTimeStamp.h>
32 #include <TObjString.h>
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
40 ClassImp(AliT0DataDCS)
42 //---------------------------------------------------------------
43 AliT0DataDCS::AliT0DataDCS():
48 fStartTimeDCSQuery(0),
60 // default constructor
62 for(Int_t i=0;i<kScalers;i++)
67 for(Int_t i=0;i<kHV;i++)
74 for(Int_t i=0;i<kLV;i++)
81 for(Int_t i=0;i<kTRM;i++)
85 for(Int_t i=0;i<kDRM;i++)
89 for ( Int_t i=0; i<kCFD; i++ )
99 //---------------------------------------------------------------
100 AliT0DataDCS::AliT0DataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime, UInt_t startTimeDCSQuery, UInt_t endTimeDCSQuery):
103 fStartTime(startTime),
105 fStartTimeDCSQuery(startTimeDCSQuery),
106 fEndTimeDCSQuery(endTimeDCSQuery),
119 for(Int_t i=0;i<kScalers;i++)
124 for(Int_t i=0;i<kHV;i++)
131 for(Int_t i=0;i<kLV;i++)
138 for(Int_t i=0;i<kTRM;i++)
142 for(Int_t i=0;i<kDRM;i++)
147 AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s \n\tStartTime DCS Query %s \n\tEndTime DCS Query %s", nRun,
148 TTimeStamp(startTime).AsString(),
149 TTimeStamp(endTime).AsString(),
150 TTimeStamp(startTimeDCSQuery).AsString(),
151 TTimeStamp(endTimeDCSQuery).AsString()));
156 //---------------------------------------------------------------
158 AliT0DataDCS::AliT0DataDCS(const AliT0DataDCS & data):
163 fStartTimeDCSQuery(0),
179 fStartTime=data.fStartTime;
180 fEndTime=data.fEndTime;
181 fStartTimeDCSQuery=data.fStartTimeDCSQuery;
182 fEndTimeDCSQuery=data.fEndTimeDCSQuery;
183 fIsProcessed=data.fIsProcessed;
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;
192 for(int i=0;i<kNAliases;i++)
194 fAliasNames[i]=data.fAliasNames[i];
197 for(Int_t i=0;i<kScalers;i++)
199 fScalerMean[i]=data.fScalerMean[i];
200 fScalerSecMean[i]=data.fScalerSecMean[i];
202 for(Int_t i=0;i<kHV;i++)
204 fHViA[i]=data.fHViA[i];
205 fHVvA[i]=data.fHVvA[i];
206 fHViC[i]=data.fHViC[i];
207 fHVvC[i]=data.fHVvC[i];
209 for(Int_t i=0;i<kLV;i++)
211 fLViA[i]=data.fLViA[i];
212 fLVvA[i]=data.fLVvA[i];
213 fLViC[i]=data.fLViC[i];
214 fLVvC[i]=data.fLVvC[i];
216 for(Int_t i=0;i<kTRM;i++)
218 fTRM[i]=data.fTRM[i];
220 for(Int_t i=0;i<kDRM;i++)
222 fDRM[i]=data.fDRM[i];
224 for ( Int_t i=0; i<kCFD; i++ )
226 fCFDtA[i] = data.fCFDtA[i];
227 fCFDtC[i] = data.fCFDtC[i];
228 fCFDwA[i] = data.fCFDwA[i];
229 fCFDwC[i] = data.fCFDwC[i];
232 //---------------------------------------------------------------
234 AliT0DataDCS& AliT0DataDCS:: operator=(const AliT0DataDCS & data) {
236 // assignment operator
239 AliT0DataDCS::operator=(data);
241 this->fRun=data.fRun;
242 this->fStartTime=data.fStartTime;
243 this->fEndTime=data.fEndTime;
244 this->fStartTimeDCSQuery=data.fStartTimeDCSQuery;
245 this->fEndTimeDCSQuery=data.fEndTimeDCSQuery;
247 for(int i=0;i<kNAliases;i++)
249 this->fAliasNames[i]=data.fAliasNames[i];
255 //---------------------------------------------------------------
256 AliT0DataDCS::~AliT0DataDCS()
260 //---------------------------------------------------------------
261 Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
265 UInt_t t0Scaler[kScalers];
266 UInt_t t0ScalerSec[kScalers];
267 Int_t aliasEntr[kNAliases];
268 Float_t t0AhvImon[kHV];
269 Float_t t0AHVvmon[kHV];
270 Float_t t0AlvImon[kLV];
271 Float_t t0AlvVmon[kLV];
272 Float_t t0ChvImon[kHV];
273 Float_t t0ChvVmon[kHV];
274 Float_t t0ClvImon[kLV];
275 Float_t t0ClvVmon[kLV];
276 Float_t t0AcfdThre[kCFD];
277 Float_t t0AcfdWalk[kCFD];
278 Float_t t0CcfdThre[kCFD];
279 Float_t t0CcfdWalk[kCFD];
280 Float_t t0ACtrm[kTRM];
281 Float_t t0ACdrm[kDRM];
285 Int_t t0MPDsemiCentA=0;
286 Int_t t0MPDsemiCentC=0;
288 Int_t t0TVDCbottom=0;
292 for(Int_t k=0; k<kScalers; k++)
298 for(Int_t k=0; k<kHV; k++)
305 for(Int_t k=0; k<kLV; k++)
312 for(Int_t k=0; k<kCFD; k++)
319 for(Int_t k=0; k<kTRM; k++)
323 for(Int_t k=0; k<kDRM; k++)
328 // here starts the main loop
329 for(Int_t j=0; j<kNAliases; j++)
332 for (Int_t k=0;k<32;k++)
338 aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
342 AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
345 Introduce(j, aliasArr);
346 if(aliasArr->GetEntries()<2)
348 AliError(Form("Alias %s has just %d entries!",
349 fAliasNames[j].Data(),aliasArr->GetEntries()));
354 aliasEntr[j] = aliasArr->GetEntries();
355 for(Int_t l=0; l<aliasEntr[j]; l++)
357 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
358 t0Scaler[j]+= (UInt_t) aValue->GetFloat();
360 fScalerMean[j] = ((UInt_t) t0Scaler[j])/((UInt_t) aliasEntr[j]);
362 else if (j < 2*kScalers)
364 aliasEntr[j] = aliasArr->GetEntries();
365 for(Int_t l=0; l<aliasEntr[j]; l++)
367 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
368 t0ScalerSec[j-kScalers]+= (UInt_t) aValue->GetFloat();
370 fScalerSecMean[j-kScalers] = ((UInt_t) t0ScalerSec[j-kScalers])/((UInt_t) aliasEntr[j]);
372 else if (j < 2*kScalers+kHV)
374 aliasEntr[j] = aliasArr->GetEntries();
375 for(Int_t l=0; l<aliasEntr[j]; l++)
377 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
378 t0AhvImon[j-2*kScalers]+= aValue->GetFloat();
380 fHViA[j-2*kScalers] = t0AhvImon[j-2*kScalers] / aliasEntr[j];
382 else if (j < 2*kScalers+2*kHV)
384 aliasEntr[j] = aliasArr->GetEntries();
385 for(Int_t l=0; l<aliasEntr[j]; l++)
387 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
388 t0AHVvmon[j-(2*kScalers+kHV)]+= aValue->GetFloat();
390 fHVvA[j-(2*kScalers+kHV)] = t0AHVvmon[j-(2*kScalers+kHV)] / aliasEntr[j];
392 else if (j < 2*kScalers+2*kHV+kLV)
394 aliasEntr[j] = aliasArr->GetEntries();
395 for(Int_t l=0; l<aliasEntr[j]; l++)
397 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
398 t0AlvImon[j-(2*kScalers+2*kHV)]+= aValue->GetFloat();
400 fLViA[j-(2*kScalers+2*kHV)] = t0AlvImon[j-(2*kScalers+2*kHV)] / aliasEntr[j];
402 else if (j < 2*kScalers+2*kHV+2*kLV)
404 aliasEntr[j] = aliasArr->GetEntries();
405 for(Int_t l=0; l<aliasEntr[j]; l++)
407 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
408 t0AlvVmon[j-(2*kScalers+2*kHV+kLV)]+= aValue->GetFloat();
410 fLVvA[j-(2*kScalers+2*kHV+kLV)] = t0AlvVmon[j-(2*kScalers+2*kHV+kLV)] / aliasEntr[j];
412 else if (j < 2*kScalers+3*kHV+2*kLV)
414 aliasEntr[j] = aliasArr->GetEntries();
415 for(Int_t l=0; l<aliasEntr[j]; l++)
417 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
418 t0ChvImon[j-(2*kScalers+2*kHV+2*kLV)]+= aValue->GetFloat();
420 fHViC[j-(2*kScalers+2*kHV+2*kLV)] = t0ChvImon[j-(2*kScalers+2*kHV+2*kLV)] / aliasEntr[j];
422 else if (j < 2*kScalers+4*kHV+2*kLV)
424 aliasEntr[j] = aliasArr->GetEntries();
425 for(Int_t l=0; l<aliasEntr[j]; l++)
427 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
428 t0ChvVmon[j-(2*kScalers+3*kHV+2*kLV)]+= aValue->GetFloat();
430 fHVvC[j-(2*kScalers+3*kHV+2*kLV)] = t0ChvVmon[j-(2*kScalers+3*kHV+2*kLV)] / aliasEntr[j];
432 else if (j < 2*kScalers+4*kHV+3*kLV)
434 aliasEntr[j] = aliasArr->GetEntries();
435 for(Int_t l=0; l<aliasEntr[j]; l++)
437 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
438 t0ClvImon[j-(2*kScalers+4*kHV+2*kLV)]+= aValue->GetFloat();
440 fLViC[j-(2*kScalers+4*kHV+2*kLV)] = t0ClvImon[j-(2*kScalers+4*kHV+2*kLV)] / aliasEntr[j];
442 else if (j < 2*kScalers+4*kHV+4*kLV)
444 aliasEntr[j] = aliasArr->GetEntries();
445 for(Int_t l=0; l<aliasEntr[j]; l++)
447 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
448 t0ClvVmon[j-(2*kScalers+4*kHV+3*kLV)]+= aValue->GetFloat();
450 fLVvC[j-(2*kScalers+4*kHV+3*kLV)] = t0ClvVmon[j-(2*kScalers+4*kHV+3*kLV)] / aliasEntr[j];
452 else if (j < 2*kScalers+4*kHV+4*kLV+kCFD)
454 aliasEntr[j] = aliasArr->GetEntries();
455 for(Int_t l=0; l<aliasEntr[j]; l++)
457 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
458 t0AcfdThre[j-(2*kScalers+4*kHV+4*kLV)]+= aValue->GetFloat();
460 fCFDtA[j-(2*kScalers+4*kHV+4*kLV)] = t0AcfdThre[j-(2*kScalers+4*kHV+4*kLV)] / aliasEntr[j];
462 else if (j < 2*kScalers+4*kHV+4*kLV+2*kCFD)
464 aliasEntr[j] = aliasArr->GetEntries();
465 for(Int_t l=0; l<aliasEntr[j]; l++)
467 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
468 t0AcfdWalk[j-(2*kScalers+4*kHV+4*kLV+kCFD)]+= aValue->GetFloat();
470 fCFDwA[j-(2*kScalers+4*kHV+4*kLV+kCFD)] = t0AcfdWalk[j-(2*kScalers+4*kHV+4*kLV+kCFD)] / aliasEntr[j];
472 else if (j < 2*kScalers+4*kHV+4*kLV+3*kCFD)
474 aliasEntr[j] = aliasArr->GetEntries();
475 for(Int_t l=0; l<aliasEntr[j]; l++)
477 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
478 t0CcfdThre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)]+= aValue->GetFloat();
480 fCFDtC[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] = t0CcfdThre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] / aliasEntr[j];
482 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD)
484 aliasEntr[j] = aliasArr->GetEntries();
485 for(Int_t l=0; l<aliasEntr[j]; l++)
487 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
488 t0CcfdWalk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)]+= aValue->GetFloat();
490 fCFDwC[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] = t0CcfdWalk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] / aliasEntr[j];
492 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
494 aliasEntr[j] = aliasArr->GetEntries();
495 for(Int_t l=0; l<aliasEntr[j]; l++)
497 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
498 t0ACtrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)]+= aValue->GetFloat();
500 fTRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] = t0ACtrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] / aliasEntr[j];
502 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
504 aliasEntr[j] = aliasArr->GetEntries();
505 for(Int_t l=0; l<aliasEntr[j]; l++)
507 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
508 t0ACdrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)]+= aValue->GetFloat();
510 fDRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)] = t0ACdrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)] / aliasEntr[j];
512 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+kAtten)
514 aliasEntr[j] = aliasArr->GetEntries();
515 for(Int_t l=0; l<aliasEntr[j]; l++)
517 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
518 t0atten += aValue->GetFloat();
520 fAtten = t0atten /((Float_t) aliasEntr[j]);
522 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+2*kAtten)
524 aliasEntr[j] = aliasArr->GetEntries();
525 for(Int_t l=0; l<aliasEntr[j]; l++)
527 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
528 t0MPDcentA += Int_t(aValue->GetFloat());
531 fMPDcentA = t0MPDcentA / aliasEntr[j];
533 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+3*kAtten)
535 aliasEntr[j] = aliasArr->GetEntries();
536 for(Int_t l=0; l<aliasEntr[j]; l++)
538 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
539 t0MPDcentC += (Int_t) aValue->GetFloat();
541 fMPDcentC = ((Int_t) t0MPDcentC) /((Int_t) aliasEntr[j]);
543 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+4*kAtten)
545 aliasEntr[j] = aliasArr->GetEntries();
546 for(Int_t l=0; l<aliasEntr[j]; l++)
548 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
549 t0MPDsemiCentA += (Int_t) aValue->GetFloat();
551 fMPDsemiCentA = ((Int_t) t0MPDsemiCentA) /((Int_t) aliasEntr[j]);
553 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+5*kAtten)
555 aliasEntr[j] = aliasArr->GetEntries();
556 for(Int_t l=0; l<aliasEntr[j]; l++)
558 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
559 t0MPDsemiCentC += (Int_t) aValue->GetFloat();
561 fMPDsemiCentC = ((Int_t) t0MPDsemiCentC)/ ((Int_t) aliasEntr[j]);
563 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+6*kAtten)
565 aliasEntr[j] = aliasArr->GetEntries();
566 for(Int_t l=0; l<aliasEntr[j]; l++)
568 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
569 t0TVDCtop += (Int_t) aValue->GetFloat();
571 fTVDCtop = ((Int_t) t0TVDCtop)/((Int_t) aliasEntr[j]);
573 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+7*kAtten)
575 aliasEntr[j] = aliasArr->GetEntries();
576 for(Int_t l=0; l<aliasEntr[j]; l++)
578 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
579 t0TVDCbottom += (Int_t) aValue->GetFloat();
581 fTVDCbottom = ((Int_t) t0TVDCbottom) /((Int_t) aliasEntr[j]);
585 aliasEntr[j] = aliasArr->GetEntries();
586 for(Int_t l=0; l<aliasEntr[j]; l++)
588 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
589 t0MPDmode += (Int_t) aValue->GetFloat();
591 fMPDmode = ((Int_t) t0MPDmode)/((Int_t) aliasEntr[j]);
598 //---------------------------------------------------------------
599 void AliT0DataDCS::Init()
601 // initialize all DP aliases
604 for(int i=0;i<kNAliases;i++)
608 fAliasNames[i] = "t00_ac_scaler_";
609 sindex.Form("%02d",i);
610 fAliasNames[i] += sindex;
612 else if (i < 2*kScalers)
614 fAliasNames[i] = "t00_ac_scaler_sec_";
615 sindex.Form("%02d",i-kScalers);
616 fAliasNames[i] += sindex;
618 else if (i < 2*kScalers+kHV)
620 fAliasNames[i] = "t00_a_hv_imon_";
621 sindex.Form("%02d",i-2*kScalers);
622 fAliasNames[i] += sindex;
624 else if (i < 2*kScalers+2*kHV)
626 fAliasNames[i] = "t00_a_hv_vmon_";
627 sindex.Form("%02d",i-(2*kScalers+kHV));
628 fAliasNames[i] += sindex;
630 else if (i < 2*kScalers+2*kHV+kLV)
632 fAliasNames[i] = "t00_a_lv_imon_";
633 sindex.Form("%01d",i-(2*kScalers+2*kHV));
634 fAliasNames[i] += sindex;
636 else if (i < 2*kScalers+2*kHV+2*kLV)
638 fAliasNames[i] = "t00_a_lv_vmon_";
639 sindex.Form("%01d",i-(2*kScalers+2*kHV+kLV));
640 fAliasNames[i] += sindex;
642 else if (i < 2*kScalers+3*kHV+2*kLV)
644 fAliasNames[i] = "t00_c_hv_imon_";
645 sindex.Form("%02d",i-(2*kScalers+2*kHV+2*kLV));
646 fAliasNames[i] += sindex;
648 else if (i < 2*kScalers+4*kHV+2*kLV)
650 fAliasNames[i] = "t00_c_hv_vmon_";
651 sindex.Form("%02d",i-(2*kScalers+3*kHV+2*kLV));
652 fAliasNames[i] += sindex;
654 else if (i < 2*kScalers+4*kHV+3*kLV)
656 fAliasNames[i] = "t00_c_lv_imon_";
657 sindex.Form("%01d",i-(2*kScalers+4*kHV+2*kLV));
658 fAliasNames[i] += sindex;
660 else if (i < 2*kScalers+4*kHV+4*kLV)
662 fAliasNames[i] = "t00_c_lv_vmon_";
663 sindex.Form("%01d",i-(2*kScalers+4*kHV+3*kLV));
664 fAliasNames[i] += sindex;
666 else if (i < 2*kScalers+4*kHV+4*kLV+kCFD)
668 fAliasNames[i] = "t00_a_cfd_thre_";
669 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV));
670 fAliasNames[i] += sindex;
672 else if (i < 2*kScalers+4*kHV+4*kLV+2*kCFD)
674 fAliasNames[i] = "t00_a_cfd_walk_";
675 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+kCFD));
676 fAliasNames[i] += sindex;
678 else if (i < 2*kScalers+4*kHV+4*kLV+3*kCFD)
680 fAliasNames[i] = "t00_c_cfd_thre_";
681 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+2*kCFD));
682 fAliasNames[i] += sindex;
684 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD)
686 fAliasNames[i] = "t00_c_cfd_walk_";
687 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+3*kCFD));
688 fAliasNames[i] += sindex;
690 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
692 fAliasNames[i] = "t00_ac_trm_";
693 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD));
694 fAliasNames[i] += sindex;
696 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
698 fAliasNames[i] = "t00_ac_drm_";
699 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM));
700 fAliasNames[i] += sindex;
702 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+kAtten)
704 fAliasNames[i] = "t00_ac_atten";
706 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+2*kAtten)
708 fAliasNames[i] = "t00_a_mpd_cent";
710 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+3*kAtten)
712 fAliasNames[i] = "t00_c_mpd_cent";
714 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+4*kAtten)
716 fAliasNames[i] = "t00_a_mpd_scent";
718 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+5*kAtten)
720 fAliasNames[i] = "t00_c_mpd_scent";
722 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+6*kAtten)
724 fAliasNames[i] = "t00_ac_tvdc_top";
726 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+7*kAtten)
728 fAliasNames[i] = "t00_ac_tvdc_bottom";
732 fAliasNames[i] = "t00_ac_mpd_mode";
738 //---------------------------------------------------------------
739 void AliT0DataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
742 int entries=aliasArr->GetEntries();
743 AliInfo(Form("************ Alias: %s **********",fAliasNames[numAlias].Data()));
744 AliInfo(Form(" %d DP values collected",entries));
749 //---------------------------------------------------------------
750 void AliT0DataDCS::PrintfArray(const char *label, const Float_t *array, Int_t numElements) const
752 //print all elements of array
753 printf("%s: \n",label);
754 for(Int_t i=0;i<numElements;i++){
755 printf(" %.2f", array[i]);
759 //---------------------------------------------------------------
761 void AliT0DataDCS::PrintT0Data() const
765 printf("AliT0DataDCS::Print()\n");
766 printf("RUN: %d\n", fRun);
767 printf("START TIME: %d\n", fStartTime);
768 printf("END TIME: %d\n", fEndTime);
769 printf("StartTimeDCSQuery: %d\n", fStartTimeDCSQuery);
770 printf("EndTimeDCSQuery: %d\n", fEndTimeDCSQuery);
772 PrintfArray("HV A side current", fHViA, kHV);
773 PrintfArray("HV A side voltage", fHVvA, kHV);
774 PrintfArray("LV A side current", fLViA, kLV);
775 PrintfArray("LV A side voltage", fLVvA, kLV);
776 PrintfArray("HV C side current", fHViC, kHV);
777 PrintfArray("HV C side voltage", fHVvC, kHV);
778 PrintfArray("LV C side current", fLViC, kLV);
779 PrintfArray("LV C side voltage", fLVvC, kLV);
781 PrintfArray("CFD threshold A side", fCFDtA, kCFD);
782 PrintfArray("CFD walk A side", fCFDwA, kCFD);
783 PrintfArray("CFD threshold C side", fCFDtC, kCFD);
784 PrintfArray("CFD walk C side", fCFDwC, kCFD);
786 //PrintfArray("SCALERS", (Float_t*) fScalerMean, kScalers);
787 printf("SCALERS: \n");
788 for(Int_t i=0;i<kScalers;i++){
789 printf(" %d", fScalerMean[i]);
794 // PrintfArray("SCALERS per second",(Float_t*) fScalerSecMean, kScalers);
795 printf("SCALERS per second: \n");
796 for(Int_t i=0;i<kScalers;i++){
797 printf(" %d", fScalerSecMean[i]);
804 PrintfArray("TRM", fTRM, kTRM);
805 PrintfArray("DRM", fDRM, kDRM);
807 printf("Laser Amplitude: %f\n", fAtten);
808 printf("mult. discrim. central A side: %d\n", fMPDcentA);
809 printf("mult. discrim. central C side: %d\n", fMPDcentC);
810 printf("mult. discrim. semi-central A side: %d\n", fMPDsemiCentA);
811 printf("mult. discrim. semi-central C side: %d\n", fMPDsemiCentC);
813 printf("TVDC top: %d\n", fTVDCtop);
814 printf("TVDC bottom: %d\n", fTVDCbottom);
815 printf("MPDmode: %d\n", fMPDmode);