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++)
91 //---------------------------------------------------------------
92 AliT0DataDCS::AliT0DataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime, UInt_t startTimeDCSQuery, UInt_t endTimeDCSQuery):
95 fStartTime(startTime),
97 fStartTimeDCSQuery(startTimeDCSQuery),
98 fEndTimeDCSQuery(endTimeDCSQuery),
111 for(Int_t i=0;i<kScalers;i++)
116 for(Int_t i=0;i<kHV;i++)
123 for(Int_t i=0;i<kLV;i++)
130 for(Int_t i=0;i<kTRM;i++)
134 for(Int_t i=0;i<kDRM;i++)
139 AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s \n\tStartTime DCS Query %s \n\tEndTime DCS Query %s", nRun,
140 TTimeStamp(startTime).AsString(),
141 TTimeStamp(endTime).AsString(),
142 TTimeStamp(startTimeDCSQuery).AsString(),
143 TTimeStamp(endTimeDCSQuery).AsString()));
148 //---------------------------------------------------------------
150 AliT0DataDCS::AliT0DataDCS(const AliT0DataDCS & data):
155 fStartTimeDCSQuery(0),
171 fStartTime=data.fStartTime;
172 fEndTime=data.fEndTime;
173 fStartTimeDCSQuery=data.fStartTimeDCSQuery;
174 fEndTimeDCSQuery=data.fEndTimeDCSQuery;
175 fIsProcessed=data.fIsProcessed;
177 fMPDcentA=data.fMPDcentA;
178 fMPDcentC=data.fMPDcentC;
179 fMPDsemiCentA=data.fMPDsemiCentA;
180 fMPDsemiCentC=data.fMPDsemiCentC;
181 fTVDCtop=data.fTVDCtop;
182 fTVDCbottom=data.fTVDCbottom;
183 fMPDmode=data.fMPDmode;
184 for(int i=0;i<kNAliases;i++)
186 fAliasNames[i]=data.fAliasNames[i];
189 for(Int_t i=0;i<kScalers;i++)
191 fScalerMean[i]=data.fScalerMean[i];
192 fScalerSecMean[i]=data.fScalerSecMean[i];
194 for(Int_t i=0;i<kHV;i++)
196 fHViA[i]=data.fHViA[i];
197 fHVvA[i]=data.fHVvA[i];
198 fHViC[i]=data.fHViC[i];
199 fHVvC[i]=data.fHVvC[i];
201 for(Int_t i=0;i<kLV;i++)
203 fLViA[i]=data.fLViA[i];
204 fLVvA[i]=data.fLVvA[i];
205 fLViC[i]=data.fLViC[i];
206 fLVvC[i]=data.fLVvC[i];
208 for(Int_t i=0;i<kTRM;i++)
210 fTRM[i]=data.fTRM[i];
212 for(Int_t i=0;i<kDRM;i++)
214 fDRM[i]=data.fDRM[i];
217 //---------------------------------------------------------------
219 AliT0DataDCS& AliT0DataDCS:: operator=(const AliT0DataDCS & data) {
221 // assignment operator
223 this->fRun=data.fRun;
224 this->fStartTime=data.fStartTime;
225 this->fEndTime=data.fEndTime;
226 this->fStartTimeDCSQuery=data.fStartTimeDCSQuery;
227 this->fEndTimeDCSQuery=data.fEndTimeDCSQuery;
229 for(int i=0;i<kNAliases;i++)
231 this->fAliasNames[i]=data.fAliasNames[i];
237 //---------------------------------------------------------------
238 AliT0DataDCS::~AliT0DataDCS()
242 //---------------------------------------------------------------
243 Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
247 UInt_t t0Scaler[kScalers];
248 UInt_t t0ScalerSec[kScalers];
249 Int_t aliasEntr[kNAliases];
250 Float_t t0AhvImon[kHV];
251 Float_t t0AHVvmon[kHV];
252 Float_t t0AlvImon[kLV];
253 Float_t t0AlvVmon[kLV];
254 Float_t t0ChvImon[kHV];
255 Float_t t0ChvVmon[kHV];
256 Float_t t0ClvImon[kLV];
257 Float_t t0ClvVmon[kLV];
258 Float_t t0AcfdThre[kCFD];
259 Float_t t0AcfdWalk[kCFD];
260 Float_t t0CcfdThre[kCFD];
261 Float_t t0CcfdWalk[kCFD];
262 Float_t t0ACtrm[kTRM];
263 Float_t t0ACdrm[kDRM];
267 Int_t t0MPDsemiCentA=0;
268 Int_t t0MPDsemiCentC=0;
270 Int_t t0TVDCbottom=0;
274 for(Int_t k=0; k<kScalers; k++)
280 for(Int_t k=0; k<kHV; k++)
287 for(Int_t k=0; k<kLV; k++)
294 for(Int_t k=0; k<kCFD; k++)
301 for(Int_t k=0; k<kTRM; k++)
305 for(Int_t k=0; k<kDRM; k++)
310 // here starts the main loop
311 for(Int_t j=0; j<kNAliases; j++)
314 for (Int_t k=0;k<32;k++)
320 aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
324 AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
327 Introduce(j, aliasArr);
328 if(aliasArr->GetEntries()<2)
330 AliError(Form("Alias %s has just %d entries!",
331 fAliasNames[j].Data(),aliasArr->GetEntries()));
336 aliasEntr[j] = aliasArr->GetEntries();
337 for(Int_t l=0; l<aliasEntr[j]; l++)
339 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
340 t0Scaler[j]+= (UInt_t) aValue->GetFloat();
342 fScalerMean[j] = ((UInt_t) t0Scaler[j])/((UInt_t) aliasEntr[j]);
344 else if (j < 2*kScalers)
346 aliasEntr[j] = aliasArr->GetEntries();
347 for(Int_t l=0; l<aliasEntr[j]; l++)
349 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
350 t0ScalerSec[j-kScalers]+= (UInt_t) aValue->GetFloat();
352 fScalerSecMean[j-kScalers] = ((UInt_t) t0ScalerSec[j-kScalers])/((UInt_t) aliasEntr[j]);
354 else if (j < 2*kScalers+kHV)
356 aliasEntr[j] = aliasArr->GetEntries();
357 for(Int_t l=0; l<aliasEntr[j]; l++)
359 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
360 t0AhvImon[j-2*kScalers]+= aValue->GetFloat();
362 fHViA[j-2*kScalers] = t0AhvImon[j-2*kScalers] / aliasEntr[j];
364 else if (j < 2*kScalers+2*kHV)
366 aliasEntr[j] = aliasArr->GetEntries();
367 for(Int_t l=0; l<aliasEntr[j]; l++)
369 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
370 t0AHVvmon[j-(2*kScalers+kHV)]+= aValue->GetFloat();
372 fHVvA[j-(2*kScalers+kHV)] = t0AHVvmon[j-(2*kScalers+kHV)] / aliasEntr[j];
374 else if (j < 2*kScalers+2*kHV+kLV)
376 aliasEntr[j] = aliasArr->GetEntries();
377 for(Int_t l=0; l<aliasEntr[j]; l++)
379 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
380 t0AlvImon[j-(2*kScalers+2*kHV)]+= aValue->GetFloat();
382 fLViA[j-(2*kScalers+2*kHV)] = t0AlvImon[j-(2*kScalers+2*kHV)] / aliasEntr[j];
384 else if (j < 2*kScalers+2*kHV+2*kLV)
386 aliasEntr[j] = aliasArr->GetEntries();
387 for(Int_t l=0; l<aliasEntr[j]; l++)
389 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
390 t0AlvVmon[j-(2*kScalers+2*kHV+kLV)]+= aValue->GetFloat();
392 fLVvA[j-(2*kScalers+2*kHV+kLV)] = t0AlvVmon[j-(2*kScalers+2*kHV+kLV)] / aliasEntr[j];
394 else if (j < 2*kScalers+3*kHV+2*kLV)
396 aliasEntr[j] = aliasArr->GetEntries();
397 for(Int_t l=0; l<aliasEntr[j]; l++)
399 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
400 t0ChvImon[j-(2*kScalers+2*kHV+2*kLV)]+= aValue->GetFloat();
402 fHViC[j-(2*kScalers+2*kHV+2*kLV)] = t0ChvImon[j-(2*kScalers+2*kHV+2*kLV)] / aliasEntr[j];
404 else if (j < 2*kScalers+4*kHV+2*kLV)
406 aliasEntr[j] = aliasArr->GetEntries();
407 for(Int_t l=0; l<aliasEntr[j]; l++)
409 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
410 t0ChvVmon[j-(2*kScalers+3*kHV+2*kLV)]+= aValue->GetFloat();
412 fHVvC[j-(2*kScalers+3*kHV+2*kLV)] = t0ChvVmon[j-(2*kScalers+3*kHV+2*kLV)] / aliasEntr[j];
414 else if (j < 2*kScalers+4*kHV+3*kLV)
416 aliasEntr[j] = aliasArr->GetEntries();
417 for(Int_t l=0; l<aliasEntr[j]; l++)
419 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
420 t0ClvImon[j-(2*kScalers+4*kHV+2*kLV)]+= aValue->GetFloat();
422 fLViC[j-(2*kScalers+4*kHV+2*kLV)] = t0ClvImon[j-(2*kScalers+4*kHV+2*kLV)] / aliasEntr[j];
424 else if (j < 2*kScalers+4*kHV+4*kLV)
426 aliasEntr[j] = aliasArr->GetEntries();
427 for(Int_t l=0; l<aliasEntr[j]; l++)
429 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
430 t0ClvVmon[j-(2*kScalers+4*kHV+3*kLV)]+= aValue->GetFloat();
432 fLVvC[j-(2*kScalers+4*kHV+3*kLV)] = t0ClvVmon[j-(2*kScalers+4*kHV+3*kLV)] / aliasEntr[j];
434 else if (j < 2*kScalers+4*kHV+4*kLV+kCFD)
436 aliasEntr[j] = aliasArr->GetEntries();
437 for(Int_t l=0; l<aliasEntr[j]; l++)
439 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
440 t0AcfdThre[j-(2*kScalers+4*kHV+4*kLV)]+= aValue->GetFloat();
442 fCFDtA[j-(2*kScalers+4*kHV+4*kLV)] = t0AcfdThre[j-(2*kScalers+4*kHV+4*kLV)] / aliasEntr[j];
444 else if (j < 2*kScalers+4*kHV+4*kLV+2*kCFD)
446 aliasEntr[j] = aliasArr->GetEntries();
447 for(Int_t l=0; l<aliasEntr[j]; l++)
449 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
450 t0AcfdWalk[j-(2*kScalers+4*kHV+4*kLV+kCFD)]+= aValue->GetFloat();
452 fCFDwA[j-(2*kScalers+4*kHV+4*kLV+kCFD)] = t0AcfdWalk[j-(2*kScalers+4*kHV+4*kLV+kCFD)] / aliasEntr[j];
454 else if (j < 2*kScalers+4*kHV+4*kLV+3*kCFD)
456 aliasEntr[j] = aliasArr->GetEntries();
457 for(Int_t l=0; l<aliasEntr[j]; l++)
459 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
460 t0CcfdThre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)]+= aValue->GetFloat();
462 fCFDtC[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] = t0CcfdThre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] / aliasEntr[j];
464 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD)
466 aliasEntr[j] = aliasArr->GetEntries();
467 for(Int_t l=0; l<aliasEntr[j]; l++)
469 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
470 t0CcfdWalk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)]+= aValue->GetFloat();
472 fCFDwC[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] = t0CcfdWalk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] / aliasEntr[j];
474 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
476 aliasEntr[j] = aliasArr->GetEntries();
477 for(Int_t l=0; l<aliasEntr[j]; l++)
479 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
480 t0ACtrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)]+= aValue->GetFloat();
482 fTRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] = t0ACtrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] / aliasEntr[j];
484 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
486 aliasEntr[j] = aliasArr->GetEntries();
487 for(Int_t l=0; l<aliasEntr[j]; l++)
489 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
490 t0ACdrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)]+= aValue->GetFloat();
492 fDRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)] = t0ACdrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)] / aliasEntr[j];
494 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+kAtten)
496 aliasEntr[j] = aliasArr->GetEntries();
497 for(Int_t l=0; l<aliasEntr[j]; l++)
499 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
500 t0atten += aValue->GetFloat();
502 fAtten = t0atten /((Float_t) aliasEntr[j]);
504 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+2*kAtten)
506 aliasEntr[j] = aliasArr->GetEntries();
507 for(Int_t l=0; l<aliasEntr[j]; l++)
509 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
510 t0MPDcentA += Int_t(aValue->GetFloat());
512 fMPDcentA =Int_t( t0MPDcentA /((Float_t) aliasEntr[j]) );
514 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+3*kAtten)
516 aliasEntr[j] = aliasArr->GetEntries();
517 for(Int_t l=0; l<aliasEntr[j]; l++)
519 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
520 t0MPDcentC += (Int_t) aValue->GetFloat();
522 fMPDcentC = ((Int_t) t0MPDcentC) /((Int_t) aliasEntr[j]);
524 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+4*kAtten)
526 aliasEntr[j] = aliasArr->GetEntries();
527 for(Int_t l=0; l<aliasEntr[j]; l++)
529 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
530 t0MPDsemiCentA += (Int_t) aValue->GetFloat();
532 fMPDsemiCentA = ((Int_t) t0MPDsemiCentA) /((Int_t) aliasEntr[j]);
534 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+5*kAtten)
536 aliasEntr[j] = aliasArr->GetEntries();
537 for(Int_t l=0; l<aliasEntr[j]; l++)
539 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
540 t0MPDsemiCentC += (Int_t) aValue->GetFloat();
542 fMPDsemiCentC = ((Int_t) t0MPDsemiCentC)/ ((Int_t) aliasEntr[j]);
544 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+6*kAtten)
546 aliasEntr[j] = aliasArr->GetEntries();
547 for(Int_t l=0; l<aliasEntr[j]; l++)
549 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
550 t0TVDCtop += (Int_t) aValue->GetFloat();
552 fTVDCtop = ((Int_t) t0TVDCtop)/((Int_t) aliasEntr[j]);
554 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+7*kAtten)
556 aliasEntr[j] = aliasArr->GetEntries();
557 for(Int_t l=0; l<aliasEntr[j]; l++)
559 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
560 t0TVDCbottom += (Int_t) aValue->GetFloat();
562 fTVDCbottom = ((Int_t) t0TVDCbottom) /((Int_t) aliasEntr[j]);
566 aliasEntr[j] = aliasArr->GetEntries();
567 for(Int_t l=0; l<aliasEntr[j]; l++)
569 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
570 t0MPDmode += (Int_t) aValue->GetFloat();
572 fMPDmode = ((Int_t) t0MPDmode)/((Int_t) aliasEntr[j]);
579 //---------------------------------------------------------------
580 void AliT0DataDCS::Init()
582 // initialize all DP aliases
585 for(int i=0;i<kNAliases;i++)
589 fAliasNames[i] = "t00_ac_scaler_";
590 sindex.Form("%02d",i);
591 fAliasNames[i] += sindex;
593 else if (i < 2*kScalers)
595 fAliasNames[i] = "t00_ac_scaler_sec_";
596 sindex.Form("%02d",i-kScalers);
597 fAliasNames[i] += sindex;
599 else if (i < 2*kScalers+kHV)
601 fAliasNames[i] = "t00_a_hv_imon_";
602 sindex.Form("%02d",i-2*kScalers);
603 fAliasNames[i] += sindex;
605 else if (i < 2*kScalers+2*kHV)
607 fAliasNames[i] = "t00_a_hv_vmon_";
608 sindex.Form("%02d",i-(2*kScalers+kHV));
609 fAliasNames[i] += sindex;
611 else if (i < 2*kScalers+2*kHV+kLV)
613 fAliasNames[i] = "t00_a_lv_imon_";
614 sindex.Form("%01d",i-(2*kScalers+2*kHV));
615 fAliasNames[i] += sindex;
617 else if (i < 2*kScalers+2*kHV+2*kLV)
619 fAliasNames[i] = "t00_a_lv_vmon_";
620 sindex.Form("%01d",i-(2*kScalers+2*kHV+kLV));
621 fAliasNames[i] += sindex;
623 else if (i < 2*kScalers+3*kHV+2*kLV)
625 fAliasNames[i] = "t00_c_hv_imon_";
626 sindex.Form("%02d",i-(2*kScalers+2*kHV+2*kLV));
627 fAliasNames[i] += sindex;
629 else if (i < 2*kScalers+4*kHV+2*kLV)
631 fAliasNames[i] = "t00_c_hv_vmon_";
632 sindex.Form("%02d",i-(2*kScalers+3*kHV+2*kLV));
633 fAliasNames[i] += sindex;
635 else if (i < 2*kScalers+4*kHV+3*kLV)
637 fAliasNames[i] = "t00_c_lv_imon_";
638 sindex.Form("%01d",i-(2*kScalers+4*kHV+2*kLV));
639 fAliasNames[i] += sindex;
641 else if (i < 2*kScalers+4*kHV+4*kLV)
643 fAliasNames[i] = "t00_c_lv_vmon_";
644 sindex.Form("%01d",i-(2*kScalers+4*kHV+3*kLV));
645 fAliasNames[i] += sindex;
647 else if (i < 2*kScalers+4*kHV+4*kLV+kCFD)
649 fAliasNames[i] = "t00_a_cfd_thre_";
650 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV));
651 fAliasNames[i] += sindex;
653 else if (i < 2*kScalers+4*kHV+4*kLV+2*kCFD)
655 fAliasNames[i] = "t00_a_cfd_walk_";
656 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+kCFD));
657 fAliasNames[i] += sindex;
659 else if (i < 2*kScalers+4*kHV+4*kLV+3*kCFD)
661 fAliasNames[i] = "t00_c_cfd_thre_";
662 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+2*kCFD));
663 fAliasNames[i] += sindex;
665 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD)
667 fAliasNames[i] = "t00_c_cfd_walk_";
668 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+3*kCFD));
669 fAliasNames[i] += sindex;
671 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
673 fAliasNames[i] = "t00_ac_trm_";
674 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD));
675 fAliasNames[i] += sindex;
677 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
679 fAliasNames[i] = "t00_ac_drm_";
680 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM));
681 fAliasNames[i] += sindex;
683 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+kAtten)
685 fAliasNames[i] = "t00_ac_atten";
687 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+2*kAtten)
689 fAliasNames[i] = "t00_a_mpd_cent";
691 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+3*kAtten)
693 fAliasNames[i] = "t00_c_mpd_cent";
695 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+4*kAtten)
697 fAliasNames[i] = "t00_a_mpd_scent";
699 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+5*kAtten)
701 fAliasNames[i] = "t00_c_mpd_scent";
703 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+6*kAtten)
705 fAliasNames[i] = "t00_ac_tvdc_top";
707 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+7*kAtten)
709 fAliasNames[i] = "t00_ac_tvdc_bottom";
713 fAliasNames[i] = "t00_ac_mpd_mode";
719 //---------------------------------------------------------------
720 void AliT0DataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
723 int entries=aliasArr->GetEntries();
724 AliInfo(Form("************ Alias: %s **********",fAliasNames[numAlias].Data()));
725 AliInfo(Form(" %d DP values collected",entries));
730 //---------------------------------------------------------------
731 void AliT0DataDCS::PrintfArray(const char *label, const Float_t *array, Int_t numElements) const
733 //print all elements of array
734 printf("%s: \n",label);
735 for(Int_t i=0;i<numElements;i++){
736 printf(" %.2f", array[i]);
740 //---------------------------------------------------------------
742 void AliT0DataDCS::PrintT0Data() const
746 printf("AliT0DataDCS::Print()\n");
747 printf("RUN: %d\n", fRun);
748 printf("START TIME: %d\n", fStartTime);
749 printf("END TIME: %d\n", fEndTime);
750 printf("StartTimeDCSQuery: %d\n", fStartTimeDCSQuery);
751 printf("EndTimeDCSQuery: %d\n", fEndTimeDCSQuery);
753 PrintfArray("HV A side current", fHViA, kHV);
754 PrintfArray("HV A side voltage", fHVvA, kHV);
755 PrintfArray("LV A side current", fLViA, kLV);
756 PrintfArray("LV A side voltage", fLVvA, kLV);
757 PrintfArray("HV C side current", fHViC, kHV);
758 PrintfArray("HV C side voltage", fHVvC, kHV);
759 PrintfArray("LV C side current", fLViC, kLV);
760 PrintfArray("LV C side voltage", fLVvC, kLV);
762 PrintfArray("CFD threshold A side", fCFDtA, kCFD);
763 PrintfArray("CFD walk A side", fCFDwA, kCFD);
764 PrintfArray("CFD threshold C side", fCFDtC, kCFD);
765 PrintfArray("CFD walk C side", fCFDwC, kCFD);
767 //PrintfArray("SCALERS", (Float_t*) fScalerMean, kScalers);
768 printf("SCALERS: \n");
769 for(Int_t i=0;i<kScalers;i++){
770 printf(" %d", fScalerMean[i]);
775 // PrintfArray("SCALERS per second",(Float_t*) fScalerSecMean, kScalers);
776 printf("SCALERS per second: \n");
777 for(Int_t i=0;i<kScalers;i++){
778 printf(" %d", fScalerSecMean[i]);
785 PrintfArray("TRM", fTRM, kTRM);
786 PrintfArray("DRM", fDRM, kDRM);
788 printf("Laser Amplitude: %f\n", fAtten);
789 printf("mult. discrim. central A side: %d\n", fMPDcentA);
790 printf("mult. discrim. central C side: %d\n", fMPDcentC);
791 printf("mult. discrim. semi-central A side: %d\n", fMPDsemiCentA);
792 printf("mult. discrim. semi-central C side: %d\n", fMPDsemiCentC);
794 printf("TVDC top: %d\n", fTVDCtop);
795 printf("TVDC bottom: %d\n", fTVDCbottom);
796 printf("MPDmode: %d\n", fMPDmode);