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
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;
244 for(int i=0;i<kNAliases;i++)
246 this->fAliasNames[i]=data.fAliasNames[i];
252 //---------------------------------------------------------------
253 AliT0DataDCS::~AliT0DataDCS()
257 //---------------------------------------------------------------
258 Bool_t AliT0DataDCS::ProcessData(TMap& aliasMap)
262 UInt_t t0Scaler[kScalers];
263 UInt_t t0ScalerSec[kScalers];
264 Int_t aliasEntr[kNAliases];
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];
282 Int_t t0MPDsemiCentA=0;
283 Int_t t0MPDsemiCentC=0;
285 Int_t t0TVDCbottom=0;
289 for(Int_t k=0; k<kScalers; k++)
295 for(Int_t k=0; k<kHV; k++)
302 for(Int_t k=0; k<kLV; k++)
309 for(Int_t k=0; k<kCFD; k++)
316 for(Int_t k=0; k<kTRM; k++)
320 for(Int_t k=0; k<kDRM; k++)
325 // here starts the main loop
326 for(Int_t j=0; j<kNAliases; j++)
329 for (Int_t k=0;k<32;k++)
335 aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
339 AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
342 Introduce(j, aliasArr);
343 if(aliasArr->GetEntries()<2)
345 AliError(Form("Alias %s has just %d entries!",
346 fAliasNames[j].Data(),aliasArr->GetEntries()));
351 aliasEntr[j] = aliasArr->GetEntries();
352 for(Int_t l=0; l<aliasEntr[j]; l++)
354 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
355 t0Scaler[j]+= (UInt_t) aValue->GetFloat();
357 fScalerMean[j] = ((UInt_t) t0Scaler[j])/((UInt_t) aliasEntr[j]);
359 else if (j < 2*kScalers)
361 aliasEntr[j] = aliasArr->GetEntries();
362 for(Int_t l=0; l<aliasEntr[j]; l++)
364 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
365 t0ScalerSec[j-kScalers]+= (UInt_t) aValue->GetFloat();
367 fScalerSecMean[j-kScalers] = ((UInt_t) t0ScalerSec[j-kScalers])/((UInt_t) aliasEntr[j]);
369 else if (j < 2*kScalers+kHV)
371 aliasEntr[j] = aliasArr->GetEntries();
372 for(Int_t l=0; l<aliasEntr[j]; l++)
374 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
375 t0AhvImon[j-2*kScalers]+= aValue->GetFloat();
377 fHViA[j-2*kScalers] = t0AhvImon[j-2*kScalers] / aliasEntr[j];
379 else if (j < 2*kScalers+2*kHV)
381 aliasEntr[j] = aliasArr->GetEntries();
382 for(Int_t l=0; l<aliasEntr[j]; l++)
384 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
385 t0AHVvmon[j-(2*kScalers+kHV)]+= aValue->GetFloat();
387 fHVvA[j-(2*kScalers+kHV)] = t0AHVvmon[j-(2*kScalers+kHV)] / aliasEntr[j];
389 else if (j < 2*kScalers+2*kHV+kLV)
391 aliasEntr[j] = aliasArr->GetEntries();
392 for(Int_t l=0; l<aliasEntr[j]; l++)
394 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
395 t0AlvImon[j-(2*kScalers+2*kHV)]+= aValue->GetFloat();
397 fLViA[j-(2*kScalers+2*kHV)] = t0AlvImon[j-(2*kScalers+2*kHV)] / aliasEntr[j];
399 else if (j < 2*kScalers+2*kHV+2*kLV)
401 aliasEntr[j] = aliasArr->GetEntries();
402 for(Int_t l=0; l<aliasEntr[j]; l++)
404 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
405 t0AlvVmon[j-(2*kScalers+2*kHV+kLV)]+= aValue->GetFloat();
407 fLVvA[j-(2*kScalers+2*kHV+kLV)] = t0AlvVmon[j-(2*kScalers+2*kHV+kLV)] / aliasEntr[j];
409 else if (j < 2*kScalers+3*kHV+2*kLV)
411 aliasEntr[j] = aliasArr->GetEntries();
412 for(Int_t l=0; l<aliasEntr[j]; l++)
414 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
415 t0ChvImon[j-(2*kScalers+2*kHV+2*kLV)]+= aValue->GetFloat();
417 fHViC[j-(2*kScalers+2*kHV+2*kLV)] = t0ChvImon[j-(2*kScalers+2*kHV+2*kLV)] / aliasEntr[j];
419 else if (j < 2*kScalers+4*kHV+2*kLV)
421 aliasEntr[j] = aliasArr->GetEntries();
422 for(Int_t l=0; l<aliasEntr[j]; l++)
424 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
425 t0ChvVmon[j-(2*kScalers+3*kHV+2*kLV)]+= aValue->GetFloat();
427 fHVvC[j-(2*kScalers+3*kHV+2*kLV)] = t0ChvVmon[j-(2*kScalers+3*kHV+2*kLV)] / aliasEntr[j];
429 else if (j < 2*kScalers+4*kHV+3*kLV)
431 aliasEntr[j] = aliasArr->GetEntries();
432 for(Int_t l=0; l<aliasEntr[j]; l++)
434 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
435 t0ClvImon[j-(2*kScalers+4*kHV+2*kLV)]+= aValue->GetFloat();
437 fLViC[j-(2*kScalers+4*kHV+2*kLV)] = t0ClvImon[j-(2*kScalers+4*kHV+2*kLV)] / aliasEntr[j];
439 else if (j < 2*kScalers+4*kHV+4*kLV)
441 aliasEntr[j] = aliasArr->GetEntries();
442 for(Int_t l=0; l<aliasEntr[j]; l++)
444 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
445 t0ClvVmon[j-(2*kScalers+4*kHV+3*kLV)]+= aValue->GetFloat();
447 fLVvC[j-(2*kScalers+4*kHV+3*kLV)] = t0ClvVmon[j-(2*kScalers+4*kHV+3*kLV)] / aliasEntr[j];
449 else if (j < 2*kScalers+4*kHV+4*kLV+kCFD)
451 aliasEntr[j] = aliasArr->GetEntries();
452 for(Int_t l=0; l<aliasEntr[j]; l++)
454 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
455 t0AcfdThre[j-(2*kScalers+4*kHV+4*kLV)]+= aValue->GetFloat();
457 fCFDtA[j-(2*kScalers+4*kHV+4*kLV)] = t0AcfdThre[j-(2*kScalers+4*kHV+4*kLV)] / aliasEntr[j];
459 else if (j < 2*kScalers+4*kHV+4*kLV+2*kCFD)
461 aliasEntr[j] = aliasArr->GetEntries();
462 for(Int_t l=0; l<aliasEntr[j]; l++)
464 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
465 t0AcfdWalk[j-(2*kScalers+4*kHV+4*kLV+kCFD)]+= aValue->GetFloat();
467 fCFDwA[j-(2*kScalers+4*kHV+4*kLV+kCFD)] = t0AcfdWalk[j-(2*kScalers+4*kHV+4*kLV+kCFD)] / aliasEntr[j];
469 else if (j < 2*kScalers+4*kHV+4*kLV+3*kCFD)
471 aliasEntr[j] = aliasArr->GetEntries();
472 for(Int_t l=0; l<aliasEntr[j]; l++)
474 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
475 t0CcfdThre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)]+= aValue->GetFloat();
477 fCFDtC[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] = t0CcfdThre[j-(2*kScalers+4*kHV+4*kLV+2*kCFD)] / aliasEntr[j];
479 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD)
481 aliasEntr[j] = aliasArr->GetEntries();
482 for(Int_t l=0; l<aliasEntr[j]; l++)
484 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
485 t0CcfdWalk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)]+= aValue->GetFloat();
487 fCFDwC[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] = t0CcfdWalk[j-(2*kScalers+4*kHV+4*kLV+3*kCFD)] / aliasEntr[j];
489 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
491 aliasEntr[j] = aliasArr->GetEntries();
492 for(Int_t l=0; l<aliasEntr[j]; l++)
494 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
495 t0ACtrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)]+= aValue->GetFloat();
497 fTRM[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] = t0ACtrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD)] / aliasEntr[j];
499 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
501 aliasEntr[j] = aliasArr->GetEntries();
502 for(Int_t l=0; l<aliasEntr[j]; l++)
504 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
505 t0ACdrm[j-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)]+= aValue->GetFloat();
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];
509 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+kAtten)
511 aliasEntr[j] = aliasArr->GetEntries();
512 for(Int_t l=0; l<aliasEntr[j]; l++)
514 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
515 t0atten += aValue->GetFloat();
517 fAtten = t0atten /((Float_t) aliasEntr[j]);
519 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+2*kAtten)
521 aliasEntr[j] = aliasArr->GetEntries();
522 for(Int_t l=0; l<aliasEntr[j]; l++)
524 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
525 t0MPDcentA += Int_t(aValue->GetFloat());
528 fMPDcentA = t0MPDcentA / aliasEntr[j];
530 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+3*kAtten)
532 aliasEntr[j] = aliasArr->GetEntries();
533 for(Int_t l=0; l<aliasEntr[j]; l++)
535 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
536 t0MPDcentC += (Int_t) aValue->GetFloat();
538 fMPDcentC = ((Int_t) t0MPDcentC) /((Int_t) aliasEntr[j]);
540 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+4*kAtten)
542 aliasEntr[j] = aliasArr->GetEntries();
543 for(Int_t l=0; l<aliasEntr[j]; l++)
545 AliDCSValue *aValue=dynamic_cast<AliDCSValue*> (aliasArr->At(l));
546 t0MPDsemiCentA += (Int_t) aValue->GetFloat();
548 fMPDsemiCentA = ((Int_t) t0MPDsemiCentA) /((Int_t) aliasEntr[j]);
550 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+5*kAtten)
552 aliasEntr[j] = aliasArr->GetEntries();
553 for(Int_t l=0; l<aliasEntr[j]; l++)
555 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
556 t0MPDsemiCentC += (Int_t) aValue->GetFloat();
558 fMPDsemiCentC = ((Int_t) t0MPDsemiCentC)/ ((Int_t) aliasEntr[j]);
560 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+6*kAtten)
562 aliasEntr[j] = aliasArr->GetEntries();
563 for(Int_t l=0; l<aliasEntr[j]; l++)
565 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
566 t0TVDCtop += (Int_t) aValue->GetFloat();
568 fTVDCtop = ((Int_t) t0TVDCtop)/((Int_t) aliasEntr[j]);
570 else if (j < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+7*kAtten)
572 aliasEntr[j] = aliasArr->GetEntries();
573 for(Int_t l=0; l<aliasEntr[j]; l++)
575 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
576 t0TVDCbottom += (Int_t) aValue->GetFloat();
578 fTVDCbottom = ((Int_t) t0TVDCbottom) /((Int_t) aliasEntr[j]);
582 aliasEntr[j] = aliasArr->GetEntries();
583 for(Int_t l=0; l<aliasEntr[j]; l++)
585 AliDCSValue *aValue=static_cast<AliDCSValue*> (aliasArr->At(l));
586 t0MPDmode += (Int_t) aValue->GetFloat();
588 fMPDmode = ((Int_t) t0MPDmode)/((Int_t) aliasEntr[j]);
595 //---------------------------------------------------------------
596 void AliT0DataDCS::Init()
598 // initialize all DP aliases
601 for(int i=0;i<kNAliases;i++)
605 fAliasNames[i] = "t00_ac_scaler_";
606 sindex.Form("%02d",i);
607 fAliasNames[i] += sindex;
609 else if (i < 2*kScalers)
611 fAliasNames[i] = "t00_ac_scaler_sec_";
612 sindex.Form("%02d",i-kScalers);
613 fAliasNames[i] += sindex;
615 else if (i < 2*kScalers+kHV)
617 fAliasNames[i] = "t00_a_hv_imon_";
618 sindex.Form("%02d",i-2*kScalers);
619 fAliasNames[i] += sindex;
621 else if (i < 2*kScalers+2*kHV)
623 fAliasNames[i] = "t00_a_hv_vmon_";
624 sindex.Form("%02d",i-(2*kScalers+kHV));
625 fAliasNames[i] += sindex;
627 else if (i < 2*kScalers+2*kHV+kLV)
629 fAliasNames[i] = "t00_a_lv_imon_";
630 sindex.Form("%01d",i-(2*kScalers+2*kHV));
631 fAliasNames[i] += sindex;
633 else if (i < 2*kScalers+2*kHV+2*kLV)
635 fAliasNames[i] = "t00_a_lv_vmon_";
636 sindex.Form("%01d",i-(2*kScalers+2*kHV+kLV));
637 fAliasNames[i] += sindex;
639 else if (i < 2*kScalers+3*kHV+2*kLV)
641 fAliasNames[i] = "t00_c_hv_imon_";
642 sindex.Form("%02d",i-(2*kScalers+2*kHV+2*kLV));
643 fAliasNames[i] += sindex;
645 else if (i < 2*kScalers+4*kHV+2*kLV)
647 fAliasNames[i] = "t00_c_hv_vmon_";
648 sindex.Form("%02d",i-(2*kScalers+3*kHV+2*kLV));
649 fAliasNames[i] += sindex;
651 else if (i < 2*kScalers+4*kHV+3*kLV)
653 fAliasNames[i] = "t00_c_lv_imon_";
654 sindex.Form("%01d",i-(2*kScalers+4*kHV+2*kLV));
655 fAliasNames[i] += sindex;
657 else if (i < 2*kScalers+4*kHV+4*kLV)
659 fAliasNames[i] = "t00_c_lv_vmon_";
660 sindex.Form("%01d",i-(2*kScalers+4*kHV+3*kLV));
661 fAliasNames[i] += sindex;
663 else if (i < 2*kScalers+4*kHV+4*kLV+kCFD)
665 fAliasNames[i] = "t00_a_cfd_thre_";
666 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV));
667 fAliasNames[i] += sindex;
669 else if (i < 2*kScalers+4*kHV+4*kLV+2*kCFD)
671 fAliasNames[i] = "t00_a_cfd_walk_";
672 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+kCFD));
673 fAliasNames[i] += sindex;
675 else if (i < 2*kScalers+4*kHV+4*kLV+3*kCFD)
677 fAliasNames[i] = "t00_c_cfd_thre_";
678 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+2*kCFD));
679 fAliasNames[i] += sindex;
681 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD)
683 fAliasNames[i] = "t00_c_cfd_walk_";
684 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+3*kCFD));
685 fAliasNames[i] += sindex;
687 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM)
689 fAliasNames[i] = "t00_ac_trm_";
690 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD));
691 fAliasNames[i] += sindex;
693 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM)
695 fAliasNames[i] = "t00_ac_drm_";
696 sindex.Form("%02d",i-(2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM));
697 fAliasNames[i] += sindex;
699 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+kAtten)
701 fAliasNames[i] = "t00_ac_atten";
703 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+2*kAtten)
705 fAliasNames[i] = "t00_a_mpd_cent";
707 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+3*kAtten)
709 fAliasNames[i] = "t00_c_mpd_cent";
711 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+4*kAtten)
713 fAliasNames[i] = "t00_a_mpd_scent";
715 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+5*kAtten)
717 fAliasNames[i] = "t00_c_mpd_scent";
719 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+6*kAtten)
721 fAliasNames[i] = "t00_ac_tvdc_top";
723 else if (i < 2*kScalers+4*kHV+4*kLV+4*kCFD+kTRM+kDRM+7*kAtten)
725 fAliasNames[i] = "t00_ac_tvdc_bottom";
729 fAliasNames[i] = "t00_ac_mpd_mode";
735 //---------------------------------------------------------------
736 void AliT0DataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
739 int entries=aliasArr->GetEntries();
740 AliInfo(Form("************ Alias: %s **********",fAliasNames[numAlias].Data()));
741 AliInfo(Form(" %d DP values collected",entries));
746 //---------------------------------------------------------------
747 void AliT0DataDCS::PrintfArray(const char *label, const Float_t *array, Int_t numElements) const
749 //print all elements of array
750 printf("%s: \n",label);
751 for(Int_t i=0;i<numElements;i++){
752 printf(" %.2f", array[i]);
756 //---------------------------------------------------------------
758 void AliT0DataDCS::PrintT0Data() const
762 printf("AliT0DataDCS::Print()\n");
763 printf("RUN: %d\n", fRun);
764 printf("START TIME: %d\n", fStartTime);
765 printf("END TIME: %d\n", fEndTime);
766 printf("StartTimeDCSQuery: %d\n", fStartTimeDCSQuery);
767 printf("EndTimeDCSQuery: %d\n", fEndTimeDCSQuery);
769 PrintfArray("HV A side current", fHViA, kHV);
770 PrintfArray("HV A side voltage", fHVvA, kHV);
771 PrintfArray("LV A side current", fLViA, kLV);
772 PrintfArray("LV A side voltage", fLVvA, kLV);
773 PrintfArray("HV C side current", fHViC, kHV);
774 PrintfArray("HV C side voltage", fHVvC, kHV);
775 PrintfArray("LV C side current", fLViC, kLV);
776 PrintfArray("LV C side voltage", fLVvC, kLV);
778 PrintfArray("CFD threshold A side", fCFDtA, kCFD);
779 PrintfArray("CFD walk A side", fCFDwA, kCFD);
780 PrintfArray("CFD threshold C side", fCFDtC, kCFD);
781 PrintfArray("CFD walk C side", fCFDwC, kCFD);
783 //PrintfArray("SCALERS", (Float_t*) fScalerMean, kScalers);
784 printf("SCALERS: \n");
785 for(Int_t i=0;i<kScalers;i++){
786 printf(" %d", fScalerMean[i]);
791 // PrintfArray("SCALERS per second",(Float_t*) fScalerSecMean, kScalers);
792 printf("SCALERS per second: \n");
793 for(Int_t i=0;i<kScalers;i++){
794 printf(" %d", fScalerSecMean[i]);
801 PrintfArray("TRM", fTRM, kTRM);
802 PrintfArray("DRM", fDRM, kDRM);
804 printf("Laser Amplitude: %f\n", fAtten);
805 printf("mult. discrim. central A side: %d\n", fMPDcentA);
806 printf("mult. discrim. central C side: %d\n", fMPDcentC);
807 printf("mult. discrim. semi-central A side: %d\n", fMPDsemiCentA);
808 printf("mult. discrim. semi-central C side: %d\n", fMPDsemiCentC);
810 printf("TVDC top: %d\n", fTVDCtop);
811 printf("TVDC bottom: %d\n", fTVDCbottom);
812 printf("MPDmode: %d\n", fMPDmode);