TOF/AliTOFDataDCS.cxx

   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   *
  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  **************************************************************************/
  15
  16 /*
  17 $Log: AliTOFDataDCS.cxx,v $
  18 Revision 1.9  2007/05/04 14:02:45  decaro
  19 AliTOFDataDCS::Draw(Option_t *) method declared const: compiling warning suppression
  20
  21 Revision 1.8  2007/05/03 09:45:09  decaro
  22 Coding convention: RN11 violation -> suppression
  23
  24 Revision 1.7  2007/05/02 14:09:39  arcelli
  25 Retrieval of Env. Temperature removed (will get it from the GRP)
  26
  27 Revision 1.6  2007/04/04 17:19:19  arcelli
  28 Moved some printout to debug level
  29
  30 Revision 1.5  2007/02/20 15:57:00  decaro
  31 Raw data update: to read the TOF raw data defined in UNPACKED mode
  32
  33 Revision 1.4  2007/02/19 15:41:55  decaro
  34 Coding convention: few corrections
  35
  36 Revision 1.3  2007/01/24 11:19:58  arcelli
  37 Modify ProcessData to return a logical (CZ)
  38
  39 Revision 1.2  2006/12/18 18:17:38  arcelli
  40 Updated Aliases for DCS TOF datapoints (C.Zampolli)
  41
  42 Revision 1.1  2006/10/26 09:10:52  arcelli
  43 Class for handling the TOF DCS data in the Shuttle (C.Zampolli)
  44
  45 */
  46
  47 #include "TString.h"
  48 //#include "TF1.h"
  49 //#include "TH1F.h"
  50 #include "TTimeStamp.h"
  51 #include "TMap.h"
  52 #include "TCanvas.h"
  53
  54 #include "AliDCSValue.h"
  55 #include "AliLog.h"
  56
  57 #include "AliTOFDataDCS.h"
  58 #include "AliTOFFormatDCS.h"
  59
  60 class TH2;
  61 class AliCDBMetaData;
  62 class TDatime;
  63
  64 // AliTOFDataDCS class
  65 // main aim to introduce the aliases for the TOF DCS
  66 // data points to be then
  67 // stored in the OCDB, and to process them.
  68 // Process() method called by TOFPrepr
  69
  70 ClassImp(AliTOFDataDCS)
  71
  72 //---------------------------------------------------------------
  73 AliTOFDataDCS::AliTOFDataDCS():
  74         TObject(),
  75         fRun(0),
  76         fStartTime(0),
  77         fEndTime(0),
  78         fStartTimeDCSQuery(0),
  79         fEndTimeDCSQuery(0),
  80         fIsProcessed(kFALSE),
  81         fFDR(kFALSE)
  82 {
  83
  84   // main constructor
  85
  86   for(int i=0;i<kNHV;i++) {
  87     fHVvp[i]=0x0;
  88     fHVvn[i]=0x0;
  89     fHVip[i]=0x0;
  90     fHVin[i]=0x0;
  91   }
  92
  93
  94 }
  95
  96 //---------------------------------------------------------------
  97 AliTOFDataDCS::AliTOFDataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime, UInt_t startTimeDCSQuery, UInt_t endTimeDCSQuery):
  98         TObject(),
  99         fRun(nRun),
 100         fStartTime(startTime),
 101         fEndTime(endTime),
 102         fStartTimeDCSQuery(startTimeDCSQuery),
 103         fEndTimeDCSQuery(endTimeDCSQuery),
 104         fIsProcessed(kFALSE),
 105         fFDR(kFALSE)
 106 {
 107
 108   // constructor with arguments
 109
 110         AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s \n\tStartTime DCS Query %s \n\tEndTime DCS Query %s", nRun,
 111         TTimeStamp(startTime).AsString(),
 112         TTimeStamp(endTime).AsString(),
 113         TTimeStamp(startTimeDCSQuery).AsString(),
 114         TTimeStamp(endTimeDCSQuery).AsString()));
 115
 116         Init();
 117
 118 }
 119
 120 //---------------------------------------------------------------
 121
 122 AliTOFDataDCS::AliTOFDataDCS(const AliTOFDataDCS & data):
 123   TObject(data),
 124   fRun(data.fRun),
 125   fStartTime(data.fStartTime),
 126   fEndTime(data.fEndTime),
 127   fStartTimeDCSQuery(data.fStartTimeDCSQuery),
 128   fEndTimeDCSQuery(data.fEndTimeDCSQuery),
 129   fIsProcessed(data.fIsProcessed),
 130   fFDR(data.fFDR)
 131
 132 {
 133
 134 // copy constructor
 135
 136   for(int i=0;i<kNAliases;i++) {
 137     fAliasNames[i]=data.fAliasNames[i];
 138   }
 139
 140   for(int i=0;i<kNHV;i++) {
 141     fHVvp[i]=data.fHVvp[i];
 142     fHVvn[i]=data.fHVvn[i];
 143     fHVip[i]=data.fHVip[i];
 144     fHVin[i]=data.fHVin[i];
 145   }
 146
 147
 148 }
 149 //---------------------------------------------------------------
 150
 151 AliTOFDataDCS& AliTOFDataDCS:: operator=(const AliTOFDataDCS & data) {
 152
 153 // assignment operator
 154
 155   if (this == &data)
 156     return *this;
 157
 158   TObject::operator=(data);
 159   fRun=data.GetRun();
 160   fStartTime=data.GetStartTime();
 161   fEndTime=data.GetEndTime();
 162   fStartTimeDCSQuery=data.GetStartTimeDCSQuery();
 163   fEndTimeDCSQuery=data.GetEndTimeDCSQuery();
 164
 165   for(int i=0;i<kNAliases;i++) {
 166     fAliasNames[i]=data.GetAliasName(i);
 167   }
 168
 169   for(int i=0;i<kNHV;i++) {
 170     fHVvp[i]=data.GetHVvp(i);
 171     fHVvn[i]=data.GetHVvn(i);
 172     fHVip[i]=data.GetHVip(i);
 173     fHVin[i]=data.GetHVin(i);
 174   }
 175
 176
 177   return *this;
 178 }
 179 //---------------------------------------------------------------
 180 AliTOFDataDCS::~AliTOFDataDCS() {
 181
 182   // destructor
 183
 184   for(int i=0;i<kNHV;i++) {
 185     delete fHVvp[i];
 186     fHVvp[i]=0;
 187     delete fHVvn[i];
 188     fHVvn[i]=0;
 189     delete fHVip[i];
 190     fHVip[i]=0;
 191     delete fHVin[i];
 192     fHVin[i]=0;
 193   }
 194
 195 }
 196
 197 //---------------------------------------------------------------
 198 Bool_t AliTOFDataDCS::ProcessData(TMap& aliasMap){
 199
 200   // method to process the data
 201
 202   if(!(fAliasNames[0])) Init();
 203
 204   Float_t val=0;
 205   Float_t val0=0;
 206   Float_t val1=0;
 207   Float_t time=0;
 208   Float_t time0=0;
 209   Float_t time1=0;
 210   Float_t delta[2];
 211   Float_t timedelta[2];
 212
 213   AliInfo(Form(" Start Time = %i",fStartTime));
 214   AliInfo(Form(" End Time = %i",fEndTime));
 215   AliInfo(Form(" Start Time DCS Query= %i",fStartTimeDCSQuery));
 216   AliInfo(Form(" End Time DCS Query= %i",fEndTimeDCSQuery));
 217
 218   if (fEndTime==fStartTime){
 219     AliError(Form(" Run with null time length: start time = %i = end time = %i",fStartTime,fEndTime));
 220     return kFALSE;
 221   }
 222
 223   TObjArray *aliasArr;
 224   AliDCSValue* aValue;
 225   AliDCSValue* aValue0;
 226   AliDCSValue* aValue1;
 227
 228   // starting loop on aliases
 229   for(int j=0; j<kNAliases; j++){
 230     for (Int_t k=0;k<2;k++) {
 231       delta[k]=0;
 232       timedelta[k]=0;
 233     }
 234     //AliInfo(Form("j = %i, with alias = %s",j,fAliasNames[j].Data()));
 235     aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
 236     if(!aliasArr){
 237       AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
 238       if (!fFDR){
 239         return kFALSE;    // returning only in case we are not in a FDR run
 240       }
 241       else {
 242         continue;
 243       }
 244     }
 245
 246     Introduce(j, aliasArr);
 247
 248     if(aliasArr->GetEntries()==0){
 249       AliError(Form("Alias %s has no entries! Nothing will be stored",
 250                     fAliasNames[j].Data()));
 251       continue;
 252     }
 253     if(aliasArr->GetEntries() == 1){
 254       AliWarning(Form("Alias %s has just %d entries! Only first value will be stored",
 255                     fAliasNames[j].Data(),aliasArr->GetEntries()));
 256       aValue0 = (AliDCSValue*) aliasArr->At(0);
 257       val0 = aValue0->GetFloat();
 258       time0 = (Float_t) (aValue0->GetTimeStamp());
 259       if (j<kNHV){
 260         fHVvp[j]->SetFloat(0,val0);
 261         fHVvp[j]->SetTimeStampFloat(0,time0);
 262       }
 263       else if (j<kNHV*2){
 264         fHVvn[j-kNHV]->SetFloat(0,val0);
 265         fHVvn[j-kNHV]->SetTimeStampFloat(0,time0);
 266       }
 267       else if (j<kNHV*3){
 268         fHVip[j-2*kNHV]->SetFloat(0,val0);
 269         fHVip[j-2*kNHV]->SetTimeStampFloat(0,time0);
 270       }
 271       else if (j<kNHV*4){
 272         fHVin[j-3*kNHV]->SetFloat(0,val0);
 273         fHVin[j-3*kNHV]->SetTimeStampFloat(0,time0);
 274       }
 275       continue;
 276     }
 277     if(aliasArr->GetEntries()==2){
 278       AliWarning(Form("Alias %s has just %d entries! Storing first and second entry only and the delta between these two",
 279                     fAliasNames[j].Data(),aliasArr->GetEntries()));
 280       aValue0 = (AliDCSValue*) aliasArr->At(0);
 281       val0 = aValue0->GetFloat();
 282       time0 = (Float_t) (aValue0->GetTimeStamp());
 283       aValue1 = (AliDCSValue*) aliasArr->At(1);
 284       val1 = aValue1->GetFloat();
 285       time1 = (Float_t) (aValue1->GetTimeStamp());
 286       if (j<kNHV){
 287         fHVvp[j]->SetFloat(0,val0);
 288         fHVvp[j]->SetTimeStampFloat(0,time0);
 289         fHVvp[j]->SetFloat(1,val1);
 290         fHVvp[j]->SetTimeStampFloat(1,time1);
 291         fHVvp[j]->SetDelta(0,TMath::Abs(val1-val0));
 292         fHVvp[j]->SetTimeStampDelta(0,time1-time0);
 293       }
 294       else if (j<kNHV*2){
 295         fHVvn[j-kNHV]->SetFloat(0,val0);
 296         fHVvn[j-kNHV]->SetTimeStampFloat(0,time0);
 297         fHVvn[j-kNHV]->SetFloat(1,val1);
 298         fHVvn[j-kNHV]->SetTimeStampFloat(1,time1);
 299         fHVvn[j-kNHV]->SetDelta(0,TMath::Abs(val1-val0));
 300         fHVvn[j-kNHV]->SetTimeStampDelta(0,time1-time0);
 301       }
 302       else if (j<kNHV*3){
 303         fHVip[j-2*kNHV]->SetFloat(0,val0);
 304         fHVip[j-2*kNHV]->SetTimeStampFloat(0,time0);
 305         fHVip[j-2*kNHV]->SetFloat(1,val1);
 306         fHVip[j-2*kNHV]->SetTimeStampFloat(1,time1);
 307         fHVip[j-2*kNHV]->SetDelta(0,TMath::Abs(val1-val0));
 308         fHVip[j-2*kNHV]->SetTimeStampDelta(0,time1-time0);
 309       }
 310       else if (j<kNHV*4){
 311         fHVin[j-3*kNHV]->SetFloat(0,val0);
 312         fHVin[j-3*kNHV]->SetTimeStampFloat(0,time0);
 313         fHVin[j-3*kNHV]->SetFloat(1,val1);
 314         fHVin[j-3*kNHV]->SetTimeStampFloat(1,time1);
 315         fHVin[j-3*kNHV]->SetDelta(0,TMath::Abs(val1-val0));
 316         fHVin[j-3*kNHV]->SetTimeStampDelta(0,time1-time0);
 317       }
 318       continue;
 319     }
 320
 321     TIter iterarray(aliasArr);
 322
 323     Int_t nentries = aliasArr->GetEntries();
 324     Int_t deltaTimeStamp = (Int_t) nentries/3;
 325     Int_t deltaTimeStamp1 = (Int_t) nentries/2;
 326
 327     // filling aliases with 10 floats+1 Usign
 328     Int_t index = 0;
 329     for (Int_t k=0;k<3;k++){
 330       index = deltaTimeStamp*k;
 331       if (k==0) {
 332         index=0;
 333       }
 334       else if (k==1) {
 335         index=deltaTimeStamp1;
 336       }
 337       else if (k==2) {
 338         index=nentries-1;
 339       }
 340       aValue = (AliDCSValue*) aliasArr->At(index);
 341       val = aValue->GetFloat();
 342       time = (Float_t) (aValue->GetTimeStamp());
 343       if (j<kNHV){
 344         fHVvp[j]->SetFloat(k,val);
 345         fHVvp[j]->SetTimeStampFloat(k,time);
 346       }
 347       else if (j<kNHV*2){
 348         fHVvn[j-kNHV]->SetFloat(k,val);
 349         fHVvn[j-kNHV]->SetTimeStampFloat(k,time);
 350       }
 351       else if (j<kNHV*3){
 352         fHVip[j-2*kNHV]->SetFloat(k,val);
 353         fHVip[j-2*kNHV]->SetTimeStampFloat(k,time);
 354       }
 355       else if (j<kNHV*4){
 356         fHVin[j-3*kNHV]->SetFloat(k,val);
 357         fHVin[j-3*kNHV]->SetTimeStampFloat(k,time);
 358       }
 359     }
 360
 361     //computing the most significant variations
 362
 363     //Float_t timeDiff = (Float_t)(fEndTime-fStartTime);
 364     Float_t timeDiff = (Float_t)(fEndTimeDCSQuery-fStartTimeDCSQuery);
 365     Int_t deltamin = (Int_t)(60/timeDiff*nentries); //sampling every minute
 366     Int_t klast = nentries-deltamin;
 367
 368     for (Int_t k=0;k<klast;k++){
 369       aValue = (AliDCSValue*) aliasArr->At(k);
 370       aValue1 = (AliDCSValue*) aliasArr->At(k+deltamin);
 371       val = aValue->GetFloat();
 372       val1 = aValue1->GetFloat();
 373       if (delta[0]<=TMath::Abs(val1-val)) {
 374         delta[0]=TMath::Abs(val1-val);
 375         timedelta[0] = (Float_t)k;
 376       }
 377       if (delta[1]<=delta[0]) {
 378         Float_t temp = delta[1];
 379         Float_t timetemp = timedelta[1];
 380         delta[1]=delta[0];
 381         delta[0]=temp;
 382         timedelta[1]=timedelta[0];
 383         timedelta[0]=timetemp;
 384       }
 385     }
 386
 387     for (Int_t kk=0;kk<2;kk++){
 388       if (j<kNHV){
 389         fHVvp[j]->SetDelta(kk,delta[kk]);
 390         fHVvp[j]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
 391       }
 392       else if (j<kNHV*2){
 393         fHVvn[j-kNHV]->SetDelta(kk,delta[kk]);
 394         fHVvn[j-kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
 395       }
 396       else if (j<kNHV*3){
 397         fHVip[j-2*kNHV]->SetDelta(kk,delta[kk]);
 398         fHVip[j-2*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
 399       }
 400       else if (j<kNHV*4){
 401         fHVin[j-3*kNHV]->SetDelta(kk,delta[kk]);
 402         fHVin[j-3*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
 403       }
 404     }
 405   }
 406
 407   fIsProcessed=kTRUE;
 408
 409   return kTRUE;
 410 }
 411
 412 //---------------------------------------------------------------
 413 void AliTOFDataDCS::Init(){
 414
 415   // initialization of aliases and DCS data
 416
 417   TString sindex;
 418   for(int i=0;i<kNAliases;i++){
 419     //HV, v
 420     if (i<kNHV){
 421         fAliasNames[i] = "tof_hv_vp_";
 422         sindex.Form("%02i",i);
 423         fAliasNames[i] += sindex;
 424         fHVvp[i] = new AliTOFFormatDCS();
 425     }
 426     else if (i<kNHV*2){
 427         fAliasNames[i] = "tof_hv_vn_";
 428         sindex.Form("%02i",i-kNHV);
 429         fAliasNames[i] += sindex;
 430         fHVvn[i-kNHV] = new AliTOFFormatDCS();
 431     }
 432     //HV, i
 433     else if (i<kNHV*3){
 434         fAliasNames[i] = "tof_hv_ip_";
 435         sindex.Form("%02i",i-2*kNHV);
 436         fAliasNames[i] += sindex;
 437         fHVip[i-2*kNHV] = new AliTOFFormatDCS();
 438     }
 439     else if (i<kNHV*4){
 440         fAliasNames[i] = "tof_hv_in_";
 441         sindex.Form("%02i",i-3*kNHV);
 442         fAliasNames[i] += sindex;
 443         fHVin[i-3*kNHV] = new AliTOFFormatDCS();
 444     }
 445   }
 446 }
 447
 448
 449 //---------------------------------------------------------------
 450 void AliTOFDataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
 451 {
 452
 453   // method to introduce new aliases
 454
 455   int entries=0;
 456   entries = aliasArr->GetEntries();
 457   int nal=0;
 458   nal=numAlias;
 459   AliDebug(2,Form("************ Alias: %s **********",fAliasNames[numAlias].Data()));
 460   AliDebug(2,Form("     %d DP values collected",entries));
 461
 462 }
 463
 464 //---------------------------------------------------------------
 465 void AliTOFDataDCS::Draw(const Option_t* /*option*/)
 466 {
 467 // Draw all histos and graphs
 468
 469   if(!fIsProcessed) return;
 470
 471   TCanvas *ch;
 472   TString canvasHistoName="Histos";
 473   ch=new TCanvas(canvasHistoName,canvasHistoName,20,20,600,600);
 474   ch->cd();
 475
 476   // to be implemented
 477
 478 }
 479