[u/mrichter/AliRoot.git] / TOF / AliTOFDataDCS.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/*
$Log: AliTOFDataDCS.cxx,v $
Revision 1.9  2007/05/04 14:02:45  decaro
AliTOFDataDCS::Draw(Option_t *) method declared const: compiling warning suppression

Revision 1.8  2007/05/03 09:45:09  decaro
Coding convention: RN11 violation -> suppression

Revision 1.7  2007/05/02 14:09:39  arcelli
Retrieval of Env. Temperature removed (will get it from the GRP)

Revision 1.6  2007/04/04 17:19:19  arcelli
Moved some printout to debug level

Revision 1.5  2007/02/20 15:57:00  decaro
Raw data update: to read the TOF raw data defined in UNPACKED mode

Revision 1.4  2007/02/19 15:41:55  decaro
Coding convention: few corrections

Revision 1.3  2007/01/24 11:19:58  arcelli
Modify ProcessData to return a logical (CZ)

Revision 1.2  2006/12/18 18:17:38  arcelli
Updated Aliases for DCS TOF datapoints (C.Zampolli)

Revision 1.1  2006/10/26 09:10:52  arcelli
Class for handling the TOF DCS data in the Shuttle (C.Zampolli)

*/  

#include "TString.h"
//#include "TF1.h"
//#include "TH1F.h"
#include "TTimeStamp.h"
#include "TMap.h"
#include "TCanvas.h"

#include "AliDCSValue.h"
#include "AliLog.h"

#include "AliTOFDataDCS.h"
#include "AliTOFFormatDCS.h"

class TH2;
class AliCDBMetaData;
class TDatime;

// AliTOFDataDCS class
// main aim to introduce the aliases for the TOF DCS
// data points to be then
// stored in the OCDB, and to process them. 
// Process() method called by TOFPrepr

ClassImp(AliTOFDataDCS)

//---------------------------------------------------------------
AliTOFDataDCS::AliTOFDataDCS():
	TObject(),
	fRun(0),
	fStartTime(0),
	fEndTime(0),
	fIsProcessed(kFALSE),
	fFDR(kFALSE)
{

  // main constructor 

  for(int i=0;i<kNHV;i++) {
    fHVvp[i]=0x0;
    fHVvn[i]=0x0;
    fHVip[i]=0x0;
    fHVin[i]=0x0;
  }
  
  for(int i=0;i<kNLV;i++) {
    fLVv[i]=0x0;
    fLVi[i]=0x0;
  }
  
  for(int i=0;i<kNLV33;i++) {
    fLVv33[i]=0x0;
    fLVi33[i]=0x0;
  }
  
  for(int i=0;i<kNLV50;i++) {
    fLVv50[i]=0x0;
    fLVi50[i]=0x0;
  }
  
  for(int i=0;i<kNLV48;i++) {
    fLVv48[i]=0x0;
    fLVi48[i]=0x0;
  }
  
  for(int i=0;i<kNFEEthr;i++) {
    fFEEthr[i]=0x0;
  }
  
  for(int i=0;i<kNFEEtfeac;i++) {
    fFEEtfeac[i]=0x0;
  }
  
  for(int i=0;i<kNFEEttrm;i++) {
    fFEEttrm[i]=0x0;
  }
  
  
}

//---------------------------------------------------------------
AliTOFDataDCS::AliTOFDataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime):
	TObject(),
	fRun(nRun),
	fStartTime(startTime),
	fEndTime(endTime),
	fIsProcessed(kFALSE),
	fFDR(kFALSE)
{

  // constructor with arguments

	AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", nRun,
	TTimeStamp(startTime).AsString(),
	TTimeStamp(endTime).AsString()));

	Init();

}

//---------------------------------------------------------------

AliTOFDataDCS::AliTOFDataDCS(const AliTOFDataDCS & data):
  TObject(), 
  fRun(0),
  fStartTime(0),
  fEndTime(0),
  fIsProcessed(kFALSE),
  fFDR(kFALSE)

{

// copy constructor

  fRun=data.fRun;
  fStartTime=data.fStartTime;
  fEndTime=data.fEndTime;
  fIsProcessed=data.fIsProcessed;
  fFDR=data.fFDR;

  for(int i=0;i<kNAliases;i++) {
    fAliasNames[i]=data.fAliasNames[i];
  }
 
  for(int i=0;i<kNHV;i++) {
    fHVvp[i]=data.fHVvp[i];
    fHVvn[i]=data.fHVvn[i];
    fHVip[i]=data.fHVip[i];
    fHVin[i]=data.fHVin[i];
  }
  
  for(int i=0;i<kNLV;i++) {
    fLVv[i]=data.fLVv[i];
    fLVi[i]=data.fLVi[i];
  }

  for(int i=0;i<kNLV33;i++) {
    fLVv33[i]=data.fLVv33[i];
    fLVi33[i]=data.fLVi33[i];
  }

  for(int i=0;i<kNLV50;i++) {
    fLVv50[i]=data.fLVv50[i];
    fLVi50[i]=data.fLVi50[i];
  }

  for(int i=0;i<kNLV48;i++) {
    fLVv48[i]=data.fLVv48[i];
    fLVi48[i]=data.fLVi48[i];
  }

  for(int i=0;i<kNFEEthr;i++) {
    fFEEthr[i]=data.fFEEthr[i];
  }

  for(int i=0;i<kNFEEtfeac;i++) {
    fFEEtfeac[i]=data.fFEEtfeac[i];
  }

  for(int i=0;i<kNFEEttrm;i++) {
    fFEEttrm[i]=data.fFEEttrm[i];
  }
    
}
//---------------------------------------------------------------

AliTOFDataDCS& AliTOFDataDCS:: operator=(const AliTOFDataDCS & data) { 

// assignment operator

  this->fRun=data.GetRun();
  this->fStartTime=data.GetStartTime();
  this->fEndTime=data.GetEndTime();

  for(int i=0;i<kNAliases;i++) {
    this->fAliasNames[i]=data.GetAliasName(i);
  }

  for(int i=0;i<kNHV;i++) {
    this->fHVvp[i]=data.GetHVvp(i);
    this->fHVvn[i]=data.GetHVvn(i);
    this->fHVip[i]=data.GetHVip(i);
    this->fHVin[i]=data.GetHVin(i);
  }

  for(int i=0;i<kNLV;i++) {
    this->fLVv[i]=data.GetLVv(i);
    this->fLVi[i]=data.GetLVi(i);
  }

  for(int i=0;i<kNLV33;i++) {
    this->fLVv33[i]=data.GetLVv33(i);
    this->fLVi33[i]=data.GetLVi33(i);
  }

  for(int i=0;i<kNLV50;i++) {
    this->fLVv50[i]=data.GetLVv50(i);
    this->fLVi50[i]=data.GetLVi50(i);
  }

  for(int i=0;i<kNLV48;i++) {
    this->fLVv48[i]=data.GetLVv48(i);
    this->fLVi48[i]=data.GetLVi48(i);
  }

  for(int i=0;i<kNFEEthr;i++) {
    this->fFEEthr[i]=data.GetFEEthr(i);
  }

  for(int i=0;i<kNFEEtfeac;i++) {
    this->fFEEtfeac[i]=data.GetFEEtfeac(i);
  }

  for(int i=0;i<kNFEEttrm;i++) {
    this->fFEEttrm[i]=data.GetFEEttrm(i);
  }

  this->fIsProcessed=data.fIsProcessed;
  this->fFDR=data.fFDR;

  return *this;
}
//---------------------------------------------------------------
AliTOFDataDCS::~AliTOFDataDCS() {

  // destructor

  for(int i=0;i<kNHV;i++) {
    delete fHVvp[i];
    fHVvp[i]=0;
    delete fHVvn[i];
    fHVvn[i]=0;
    delete fHVip[i];
    fHVip[i]=0;
    delete fHVin[i];
    fHVin[i]=0;
  }
  
  for(int i=0;i<kNLV;i++) {
    delete fLVv[i];
    fLVv[i]=0;
    delete fLVi[i];
    fLVi[i]=0;
  }
  
  for(int i=0;i<kNLV33;i++) {
    delete fLVv33[i];
    fLVv33[i]=0;
    delete fLVi33[i];
    fLVi33[i]=0;
  }
  
  for(int i=0;i<kNLV50;i++) {
    delete fLVv50[i];
    fLVv50[i]=0;
    delete fLVi50[i];
    fLVi50[i]=0;
  }
  
  for(int i=0;i<kNLV48;i++) {
    delete fLVv48[i];
    fLVv48[i]=0;
    delete fLVi48[i];
    fLVi48[i]=0;
  }
  
  for(int i=0;i<kNFEEthr;i++) {
    delete fFEEthr[i];
    fFEEthr[i]=0;
  }
  
  for(int i=0;i<kNFEEtfeac;i++) {
    delete fFEEtfeac[i];
    fFEEtfeac[i]=0;
  }
  
  for(int i=0;i<kNFEEttrm;i++) {
    delete fFEEttrm[i];
    fFEEttrm[i]=0;
  }
}

//---------------------------------------------------------------
Bool_t AliTOFDataDCS::ProcessData(TMap& aliasMap){

  // method to process the data

  if(!(fAliasNames[0])) Init();

  Float_t timeMin = (Float_t)fStartTime;
  Float_t timeMax = (Float_t)fEndTime;
  Float_t val=0;
  Float_t val1=0;
  Float_t time=0; 
  Float_t delta[2];
  Float_t timedelta[2];

  TObjArray *aliasArr;
  AliDCSValue* aValue;
  AliDCSValue* aValue1;

  // starting loop on aliases
  for(int j=0; j<kNAliases; j++){
    for (Int_t k=0;k<2;k++) {
      delta[k]=0;
      timedelta[k]=0;
    }
    //AliInfo(Form("j = %i, with alias = %s",j,fAliasNames[j].Data()));
    aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
    if(!aliasArr){
      AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
      if (!fFDR){
	return kFALSE;    // returning only in case we are not in a FDR run
      }
      else {
	continue;
      }
    }

    Introduce(j, aliasArr);
    
    if(aliasArr->GetEntries()<3){
      AliError(Form("Alias %s has just %d entries!",
		    fAliasNames[j].Data(),aliasArr->GetEntries()));
      continue;
    }
    
    TIter iterarray(aliasArr);
    
    Int_t nentries = aliasArr->GetEntries();
    Int_t deltaTimeStamp = (Int_t) nentries/3;
    Int_t deltaTimeStamp1 = (Int_t) nentries/2;

    // filling aliases with 10 floats+1 Usign
    Int_t index = 0;
    for (Int_t k=0;k<3;k++){
      index = deltaTimeStamp*k;
      if (k==0) {
	index=0;
      }
      else if (k==1) {
	index=deltaTimeStamp1;
      } 
      else if (k==2) {
	index=nentries-1; 
      }
      aValue = (AliDCSValue*) aliasArr->At(index);
      val = aValue->GetFloat();
      time = (Float_t) (aValue->GetTimeStamp());
      if (j<kNHV){
	fHVvp[j]->SetFloat(k,val);
	fHVvp[j]->SetTimeStampFloat(k,time);
      }
      else if (j<kNHV*2){
	fHVvn[j-kNHV]->SetFloat(k,val);
	fHVvn[j-kNHV]->SetTimeStampFloat(k,time);
      }
      else if (j<kNHV*3){
	fHVip[j-2*kNHV]->SetFloat(k,val);
	fHVip[j-2*kNHV]->SetTimeStampFloat(k,time);
      }
      else if (j<kNHV*4){
	fHVin[j-3*kNHV]->SetFloat(k,val);
	fHVin[j-3*kNHV]->SetTimeStampFloat(k,time);
      }
      else if (j<kNHV*4+kNLV){
	fLVv[j-4*kNHV]->SetFloat(k,val);
	fLVv[j-4*kNHV]->SetTimeStampFloat(k,time);
      }
      else if (j<kNHV*4+kNLV*2){
	fLVi[j-4*kNHV-kNLV]->SetFloat(k,val);
	fLVi[j-4*kNHV-kNLV]->SetTimeStampFloat(k,time);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33){
	fLVv33[j-4*kNHV-2*kNLV]->SetFloat(k,val);
	fLVv33[j-4*kNHV-2*kNLV]->SetTimeStampFloat(k,time);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2){
	fLVi33[j-4*kNHV-2*kNLV-kNLV33]->SetFloat(k,val);
	fLVi33[j-4*kNHV-2*kNLV-kNLV33]->SetTimeStampFloat(k,time);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50){
	fLVv50[j-4*kNHV-2*kNLV-2*kNLV33]->SetFloat(k,val);
	fLVv50[j-4*kNHV-2*kNLV-2*kNLV33]->SetTimeStampFloat(k,time);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2){
	fLVi50[j-4*kNHV-2*kNLV-2*kNLV33-kNLV50]->SetFloat(k,val);
	fLVi50[j-4*kNHV-2*kNLV-2*kNLV33-kNLV50]->SetTimeStampFloat(k,time);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48){
	fLVv48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50]->SetFloat(k,val);
	fLVv48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50]->SetTimeStampFloat(k,time);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2){
	fLVi48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-kNLV48]->SetFloat(k,val);
	fLVi48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-kNLV48]->SetTimeStampFloat(k,time);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr){
	fFEEthr[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48]->SetFloat(k,val);
	fFEEthr[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48]->SetTimeStampFloat(k,time);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac){
	fFEEtfeac[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr]->SetFloat(k,val);
	fFEEtfeac[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr]->SetTimeStampFloat(k,time);
      }
      else {
	fFEEttrm[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac]->SetFloat(k,val);
	fFEEttrm[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac]->SetTimeStampFloat(k,time);
      }
    }
  
    //computing the most significant variations

    Int_t deltamin = (Int_t)(60/(timeMax-timeMin)*nentries);
    Int_t klast = nentries-deltamin;
      
    for (Int_t k=0;k<klast;k++){
      aValue = (AliDCSValue*) aliasArr->At(k);
      aValue1 = (AliDCSValue*) aliasArr->At(k+deltamin);
      val = aValue->GetFloat();
      val1 = aValue1->GetFloat();
      if (delta[0]<=TMath::Abs(val1-val)) {
	delta[0]=TMath::Abs(val1-val);
	timedelta[0] = (Float_t)k;
      }
      if (delta[1]<=delta[0]) {
	Float_t temp = delta[1];
	Float_t timetemp = timedelta[1];
	delta[1]=delta[0];
	delta[0]=temp;
	timedelta[1]=timedelta[0];
	timedelta[0]=timetemp;
      }
    }
    
    for (Int_t kk=0;kk<2;kk++){
      if (j<kNHV){
	fHVvp[j]->SetDelta(kk,delta[kk]);
	fHVvp[j]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*2){
	fHVvn[j-kNHV]->SetDelta(kk,delta[kk]);
	fHVvn[j-kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*3){
	fHVip[j-2*kNHV]->SetDelta(kk,delta[kk]);
	fHVip[j-2*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*4){
	fHVin[j-3*kNHV]->SetDelta(kk,delta[kk]);
	fHVin[j-3*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*4+kNLV){
	fLVv[j-4*kNHV]->SetDelta(kk,delta[kk]);
	fLVv[j-4*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*4+kNLV*2){
	fLVi[j-4*kNHV-kNLV]->SetDelta(kk,delta[kk]);
	fLVi[j-4*kNHV-kNLV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33){
	fLVv33[j-4*kNHV-2*kNLV]->SetDelta(kk,delta[kk]);
	fLVv33[j-4*kNHV-2*kNLV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2){
	fLVi33[j-4*kNHV-2*kNLV-kNLV33]->SetDelta(kk,delta[kk]);
	fLVi33[j-4*kNHV-2*kNLV-kNLV33]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50){
	fLVv50[j-4*kNHV-2*kNLV-2*kNLV33]->SetDelta(kk,delta[kk]);
	fLVv50[j-4*kNHV-2*kNLV-2*kNLV33]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2){
	fLVi50[j-4*kNHV-2*kNLV-2*kNLV33-kNLV50]->SetDelta(kk,delta[kk]);
	fLVi50[j-4*kNHV-2*kNLV-2*kNLV33-kNLV50]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48){
	fLVv48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50]->SetDelta(kk,delta[kk]);
	fLVv48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2){
	fLVi48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-kNLV48]->SetDelta(kk,delta[kk]);
	fLVi48[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-kNLV48]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr){
	fFEEthr[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48]->SetDelta(kk,delta[kk]);
	fFEEthr[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac){
	fFEEtfeac[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr]->SetDelta(kk,delta[kk]);
	fFEEtfeac[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
      else if (j<kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm){
	fFEEttrm[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac]->SetDelta(kk,delta[kk]);
	fFEEttrm[j-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
      }
    }
  }
  
  fIsProcessed=kTRUE;

  return kTRUE;
}

//---------------------------------------------------------------
void AliTOFDataDCS::Init(){

  // initialization of aliases and DCS data

  TString sindex;
  for(int i=0;i<kNAliases;i++){
    //HV, v
    if (i<kNHV){
	fAliasNames[i] = "tof_hv_vp_";
	sindex.Form("%02i",i);
	fAliasNames[i] += sindex;
	fHVvp[i] = new AliTOFFormatDCS();
    }
    else if (i<kNHV*2){
	fAliasNames[i] = "tof_hv_vn_";
	sindex.Form("%02i",i-kNHV);
	fAliasNames[i] += sindex;
	fHVvn[i-kNHV] = new AliTOFFormatDCS();
    }
    //HV, i
    else if (i<kNHV*3){
	fAliasNames[i] = "tof_hv_ip_";
	sindex.Form("%02i",i-2*kNHV);
	fAliasNames[i] += sindex;
	fHVip[i-2*kNHV] = new AliTOFFormatDCS();
    }
    else if (i<kNHV*4){
	fAliasNames[i] = "tof_hv_in_";
	sindex.Form("%02i",i-3*kNHV);
	fAliasNames[i] += sindex;
	fHVin[i-3*kNHV] = new AliTOFFormatDCS();
    }
    //LV, v
    else if (i<(kNHV*4+kNLV)){
	fAliasNames[i] = "tof_lv_vfea_";
	sindex.Form("%03i",i-4*kNHV);
	fAliasNames[i] += sindex;
	fLVv[i-4*kNHV] = new AliTOFFormatDCS();
    }
    //LV, i
    else if (i<(kNHV*4+kNLV*2)){
	fAliasNames[i] = "tof_lv_ifea_";
	sindex.Form("%03i",i-4*kNHV-kNLV);
	fAliasNames[i] += sindex;
	fLVi[i-4*kNHV-kNLV] = new AliTOFFormatDCS();
    }
    //LV 3.3, v
    else if (i<(kNHV*4+kNLV*2+kNLV33)){
	fAliasNames[i] = "tof_lv_v33_";
	sindex.Form("%02i",i-4*kNHV-2*kNLV);
	fAliasNames[i] += sindex;
	fLVv33[i-4*kNHV-2*kNLV] = new AliTOFFormatDCS();
    }
    //LV 3.3, i
    else if (i<(kNHV*4+kNLV*2+kNLV33*2)){
	fAliasNames[i] = "tof_lv_i33_";
	sindex.Form("%02i",i-4*kNHV-2*kNLV-kNLV33);
	fAliasNames[i] += sindex;
	fLVi33[i-4*kNHV-2*kNLV-kNLV33] = new AliTOFFormatDCS();
    }
    //LV 5.0, v
    else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50)){
	fAliasNames[i] = "tof_lv_v50_";
	sindex.Form("%02i",i-4*kNHV-2*kNLV-2*kNLV33);
	fAliasNames[i] += sindex;
	fLVv50[i-4*kNHV-2*kNLV-2*kNLV33] = new AliTOFFormatDCS();
    }
    //LV 5.0, i
    else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2)){
	fAliasNames[i] = "tof_lv_i50_";
	sindex.Form("%02i",i-4*kNHV-2*kNLV-2*kNLV33-kNLV50);
	fAliasNames[i] += sindex;
	fLVi50[i-4*kNHV-2*kNLV-2*kNLV33-kNLV50] = new AliTOFFormatDCS();
    }
    //LV 48, v
    else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48)){
	fAliasNames[i] = "tof_lv_v48_";
	sindex.Form("%02i",i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50);
	fAliasNames[i] += sindex;
	fLVv48[i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50] = new AliTOFFormatDCS();
    }
    //LV 48, i
    else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2)){
	fAliasNames[i] = "tof_lv_i48_";
	sindex.Form("%02i",i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-kNLV48);
	fAliasNames[i] += sindex;
	fLVi48[i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-kNLV48] = new AliTOFFormatDCS();
    }
    //FEE thresholds
    else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr)){
	fAliasNames[i] = "tof_fee_th_";
	sindex.Form("%04i",i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48);
	fAliasNames[i] += sindex;
 	fFEEthr[i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48] = new AliTOFFormatDCS();
    }
    //FEE FEAC temperatures
    else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac)){
	fAliasNames[i] = "tof_fee_tfeac_";
	sindex.Form("%03i",i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr);
	fAliasNames[i] += sindex;
 	fFEEtfeac[i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr] = new AliTOFFormatDCS();
    }
    //FEE trms temperatures
    else if (i<(kNHV*4+kNLV*2+kNLV33*2+kNLV50*2+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm)){
	fAliasNames[i] = "tof_fee_ttrm_";
	sindex.Form("%04i",i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac);
	fAliasNames[i] += sindex;
 	fFEEttrm[i-4*kNHV-2*kNLV-2*kNLV33-2*kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac] = new AliTOFFormatDCS();
    }
  }
}


//---------------------------------------------------------------
void AliTOFDataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
{

  // method to introduce new aliases

  int entries=0;
  entries = aliasArr->GetEntries();
  int nal=0;
  nal=numAlias;
  AliDebug(2,Form("************ Alias: %s **********",fAliasNames[numAlias].Data()));
  AliDebug(2,Form("    	%d DP values collected",entries));

}

//---------------------------------------------------------------
void AliTOFDataDCS::Draw(const Option_t* /*option*/)
{
// Draw all histos and graphs

  if(!fIsProcessed) return;

  TCanvas *ch;
  TString canvasHistoName="Histos";
  ch=new TCanvas(canvasHistoName,canvasHistoName,20,20,600,600);
  ch->cd();

  // to be implemented

}
Commit	Line	Data
345932e4	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	/*
7fffa85b	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
b52b97c2	21	Revision 1.8 2007/05/03 09:45:09 decaro
	22	Coding convention: RN11 violation -> suppression
	23
9d5fd6fe	24	Revision 1.7 2007/05/02 14:09:39 arcelli
	25	Retrieval of Env. Temperature removed (will get it from the GRP)
	26
38e3bbf1	27	Revision 1.6 2007/04/04 17:19:19 arcelli
	28	Moved some printout to debug level
	29
72bf252d	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
15ec34b9	33	Revision 1.4 2007/02/19 15:41:55 decaro
	34	Coding convention: few corrections
	35
3a3ece53	36	Revision 1.3 2007/01/24 11:19:58 arcelli
	37	Modify ProcessData to return a logical (CZ)
	38
ebab534a	39	Revision 1.2 2006/12/18 18:17:38 arcelli
	40	Updated Aliases for DCS TOF datapoints (C.Zampolli)
	41
8259e6f8	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
345932e4	45	*/
345932e4	46
5c7c93fa	47	#include "TString.h"
	48	//#include "TF1.h"
	49	//#include "TH1F.h"
	50	#include "TTimeStamp.h"
	51	#include "TMap.h"
	52	#include "TCanvas.h"
345932e4	53
	54	#include "AliDCSValue.h"
	55	#include "AliLog.h"
	56
5c7c93fa	57	#include "AliTOFDataDCS.h"
345932e4	58	#include "AliTOFFormatDCS.h"
345932e4	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),
7fffa85b	78	fIsProcessed(kFALSE),
7fffa85b	79	fFDR(kFALSE)
345932e4	80	{
	81
	82	// main constructor
	83
8259e6f8	84	for(int i=0;i<kNHV;i++) {
	85	fHVvp[i]=0x0;
	86	fHVvn[i]=0x0;
	87	fHVip[i]=0x0;
	88	fHVin[i]=0x0;
	89	}
	90
	91	for(int i=0;i<kNLV;i++) {
	92	fLVv[i]=0x0;
	93	fLVi[i]=0x0;
	94	}
	95
	96	for(int i=0;i<kNLV33;i++) {
	97	fLVv33[i]=0x0;
	98	fLVi33[i]=0x0;
	99	}
	100
	101	for(int i=0;i<kNLV50;i++) {
	102	fLVv50[i]=0x0;
	103	fLVi50[i]=0x0;
	104	}
	105
	106	for(int i=0;i<kNLV48;i++) {
	107	fLVv48[i]=0x0;
	108	fLVi48[i]=0x0;
	109	}
	110
	111	for(int i=0;i<kNFEEthr;i++) {
	112	fFEEthr[i]=0x0;
	113	}
	114
	115	for(int i=0;i<kNFEEtfeac;i++) {
	116	fFEEtfeac[i]=0x0;
	117	}
	118
	119	for(int i=0;i<kNFEEttrm;i++) {
	120	fFEEttrm[i]=0x0;
	121	}
	122
8259e6f8	123
345932e4	124	}
	125
	126	//---------------------------------------------------------------
	127	AliTOFDataDCS::AliTOFDataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime):
	128	TObject(),
	129	fRun(nRun),
	130	fStartTime(startTime),
	131	fEndTime(endTime),
7fffa85b	132	fIsProcessed(kFALSE),
7fffa85b	133	fFDR(kFALSE)
345932e4	134	{
	135
	136	// constructor with arguments
	137
	138	AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", nRun,
	139	TTimeStamp(startTime).AsString(),
	140	TTimeStamp(endTime).AsString()));
	141
	142	Init();
	143
	144	}
	145
	146	//---------------------------------------------------------------
	147
	148	AliTOFDataDCS::AliTOFDataDCS(const AliTOFDataDCS & data):
	149	TObject(),
	150	fRun(0),
	151	fStartTime(0),
	152	fEndTime(0),
7fffa85b	153	fIsProcessed(kFALSE),
7fffa85b	154	fFDR(kFALSE)
345932e4	155
	156	{
	157
	158	// copy constructor
	159
	160	fRun=data.fRun;
	161	fStartTime=data.fStartTime;
	162	fEndTime=data.fEndTime;
	163	fIsProcessed=data.fIsProcessed;
7fffa85b	164	fFDR=data.fFDR;
345932e4	165
	166	for(int i=0;i<kNAliases;i++) {
	167	fAliasNames[i]=data.fAliasNames[i];
	168	}
	169
	170	for(int i=0;i<kNHV;i++) {
8259e6f8	171	fHVvp[i]=data.fHVvp[i];
	172	fHVvn[i]=data.fHVvn[i];
	173	fHVip[i]=data.fHVip[i];
	174	fHVin[i]=data.fHVin[i];
345932e4	175	}
	176
	177	for(int i=0;i<kNLV;i++) {
	178	fLVv[i]=data.fLVv[i];
8259e6f8	179	fLVi[i]=data.fLVi[i];
	180	}
	181
	182	for(int i=0;i<kNLV33;i++) {
	183	fLVv33[i]=data.fLVv33[i];
	184	fLVi33[i]=data.fLVi33[i];
	185	}
	186
	187	for(int i=0;i<kNLV50;i++) {
	188	fLVv50[i]=data.fLVv50[i];
	189	fLVi50[i]=data.fLVi50[i];
	190	}
	191
	192	for(int i=0;i<kNLV48;i++) {
	193	fLVv48[i]=data.fLVv48[i];
	194	fLVi48[i]=data.fLVi48[i];
345932e4	195	}
	196
	197	for(int i=0;i<kNFEEthr;i++) {
	198	fFEEthr[i]=data.fFEEthr[i];
	199	}
	200
8259e6f8	201	for(int i=0;i<kNFEEtfeac;i++) {
	202	fFEEtfeac[i]=data.fFEEtfeac[i];
	203	}
	204
	205	for(int i=0;i<kNFEEttrm;i++) {
	206	fFEEttrm[i]=data.fFEEttrm[i];
345932e4	207	}
38e3bbf1	208
345932e4	209	}
	210	//---------------------------------------------------------------
	211
	212	AliTOFDataDCS& AliTOFDataDCS:: operator=(const AliTOFDataDCS & data) {
	213
	214	// assignment operator
	215
	216	this->fRun=data.GetRun();
	217	this->fStartTime=data.GetStartTime();
	218	this->fEndTime=data.GetEndTime();
	219
	220	for(int i=0;i<kNAliases;i++) {
	221	this->fAliasNames[i]=data.GetAliasName(i);
	222	}
	223
345932e4	224	for(int i=0;i<kNHV;i++) {
8259e6f8	225	this->fHVvp[i]=data.GetHVvp(i);
	226	this->fHVvn[i]=data.GetHVvn(i);
	227	this->fHVip[i]=data.GetHVip(i);
	228	this->fHVin[i]=data.GetHVin(i);
345932e4	229	}
	230
	231	for(int i=0;i<kNLV;i++) {
	232	this->fLVv[i]=data.GetLVv(i);
8259e6f8	233	this->fLVi[i]=data.GetLVi(i);
	234	}
	235
	236	for(int i=0;i<kNLV33;i++) {
	237	this->fLVv33[i]=data.GetLVv33(i);
	238	this->fLVi33[i]=data.GetLVi33(i);
	239	}
	240
	241	for(int i=0;i<kNLV50;i++) {
	242	this->fLVv50[i]=data.GetLVv50(i);
	243	this->fLVi50[i]=data.GetLVi50(i);
	244	}
	245
	246	for(int i=0;i<kNLV48;i++) {
	247	this->fLVv48[i]=data.GetLVv48(i);
	248	this->fLVi48[i]=data.GetLVi48(i);
345932e4	249	}
	250
	251	for(int i=0;i<kNFEEthr;i++) {
	252	this->fFEEthr[i]=data.GetFEEthr(i);
	253	}
	254
8259e6f8	255	for(int i=0;i<kNFEEtfeac;i++) {
	256	this->fFEEtfeac[i]=data.GetFEEtfeac(i);
	257	}
	258
	259	for(int i=0;i<kNFEEttrm;i++) {
	260	this->fFEEttrm[i]=data.GetFEEttrm(i);
345932e4	261	}
	262
	263	this->fIsProcessed=data.fIsProcessed;
7fffa85b	264	this->fFDR=data.fFDR;
345932e4	265
	266	return *this;
	267	}
	268	//---------------------------------------------------------------
	269	AliTOFDataDCS::~AliTOFDataDCS() {
	270
	271	// destructor
	272
8259e6f8	273	for(int i=0;i<kNHV;i++) {
	274	delete fHVvp[i];
	275	fHVvp[i]=0;
	276	delete fHVvn[i];
	277	fHVvn[i]=0;
	278	delete fHVip[i];
	279	fHVip[i]=0;
	280	delete fHVin[i];
	281	fHVin[i]=0;
	282	}
	283
	284	for(int i=0;i<kNLV;i++) {
	285	delete fLVv[i];
	286	fLVv[i]=0;
	287	delete fLVi[i];
	288	fLVi[i]=0;
	289	}
	290
	291	for(int i=0;i<kNLV33;i++) {
	292	delete fLVv33[i];
	293	fLVv33[i]=0;
	294	delete fLVi33[i];
	295	fLVi33[i]=0;
	296	}
	297
	298	for(int i=0;i<kNLV50;i++) {
	299	delete fLVv50[i];
	300	fLVv50[i]=0;
	301	delete fLVi50[i];
	302	fLVi50[i]=0;
	303	}
	304
	305	for(int i=0;i<kNLV48;i++) {
	306	delete fLVv48[i];
	307	fLVv48[i]=0;
	308	delete fLVi48[i];
	309	fLVi48[i]=0;
	310	}
	311
	312	for(int i=0;i<kNFEEthr;i++) {
	313	delete fFEEthr[i];
	314	fFEEthr[i]=0;
	315	}
	316
	317	for(int i=0;i<kNFEEtfeac;i++) {
	318	delete fFEEtfeac[i];
	319	fFEEtfeac[i]=0;
	320	}
	321
	322	for(int i=0;i<kNFEEttrm;i++) {
	323	delete fFEEttrm[i];
	324	fFEEttrm[i]=0;
	325	}
345932e4	326	}
345932e4	327
345932e4	328	//---------------------------------------------------------------
ebab534a	329	Bool_t AliTOFDataDCS::ProcessData(TMap& aliasMap){
345932e4	330
3a3ece53	331	// method to process the data
3a3ece53	332
345932e4	333	if(!(fAliasNames[0])) Init();
	334
	335	Float_t timeMin = (Float_t)fStartTime;
	336	Float_t timeMax = (Float_t)fEndTime;
345932e4	337	Float_t val=0;
	338	Float_t val1=0;
	339	Float_t time=0;
	340	Float_t delta[2];
	341	Float_t timedelta[2];
	342
	343	TObjArray *aliasArr;
	344	AliDCSValue* aValue;
	345	AliDCSValue* aValue1;
345932e4	346
	347	// starting loop on aliases
	348	for(int j=0; j<kNAliases; j++){
	349	for (Int_t k=0;k<2;k++) {
	350	delta[k]=0;
	351	timedelta[k]=0;
	352	}
	353	//AliInfo(Form("j = %i, with alias = %s",j,fAliasNames[j].Data()));
	354	aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
	355	if(!aliasArr){
	356	AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
7fffa85b	357	if (!fFDR){
	358	return kFALSE; // returning only in case we are not in a FDR run
	359	}
	360	else {
	361	continue;
	362	}
345932e4	363	}
	364
	365	Introduce(j, aliasArr);
	366
	367	if(aliasArr->GetEntries()<3){
	368	AliError(Form("Alias %s has just %d entries!",
	369	fAliasNames[j].Data(),aliasArr->GetEntries()));
	370	continue;
	371	}
	372
	373	TIter iterarray(aliasArr);
	374
	375	Int_t nentries = aliasArr->GetEntries();
345932e4	376	Int_t deltaTimeStamp = (Int_t) nentries/3;
345932e4	377	Int_t deltaTimeStamp1 = (Int_t) nentries/2;
345932e4	378
345932e4	379	// filling aliases with 10 floats+1 Usign
38e3bbf1	380	Int_t index = 0;
	381	for (Int_t k=0;k<3;k++){
	382	index = deltaTimeStamp*k;
	383	if (k==0) {
	384	index=0;
345932e4	385	}
38e3bbf1	386	else if (k==1) {
	387	index=deltaTimeStamp1;
	388	}
	389	else if (k==2) {
	390	index=nentries-1;
345932e4	391	}
38e3bbf1	392	aValue = (AliDCSValue*) aliasArr->At(index);
	393	val = aValue->GetFloat();
	394	time = (Float_t) (aValue->GetTimeStamp());
	395	if (j<kNHV){
	396	fHVvp[j]->SetFloat(k,val);
	397	fHVvp[j]->SetTimeStampFloat(k,time);
	398	}
	399	else if (j<kNHV*2){
	400	fHVvn[j-kNHV]->SetFloat(k,val);
	401	fHVvn[j-kNHV]->SetTimeStampFloat(k,time);
	402	}
	403	else if (j<kNHV*3){
	404	fHVip[j-2*kNHV]->SetFloat(k,val);
	405	fHVip[j-2*kNHV]->SetTimeStampFloat(k,time);
	406	}
	407	else if (j<kNHV*4){
	408	fHVin[j-3*kNHV]->SetFloat(k,val);
	409	fHVin[j-3*kNHV]->SetTimeStampFloat(k,time);
	410	}
	411	else if (j<kNHV*4+kNLV){
	412	fLVv[j-4*kNHV]->SetFloat(k,val);
	413	fLVv[j-4*kNHV]->SetTimeStampFloat(k,time);
	414	}
	415	else if (j<kNHV4+kNLV2){
	416	fLVi[j-4*kNHV-kNLV]->SetFloat(k,val);
	417	fLVi[j-4*kNHV-kNLV]->SetTimeStampFloat(k,time);
	418	}
	419	else if (j<kNHV4+kNLV2+kNLV33){
	420	fLVv33[j-4kNHV-2kNLV]->SetFloat(k,val);
	421	fLVv33[j-4kNHV-2kNLV]->SetTimeStampFloat(k,time);
	422	}
	423	else if (j<kNHV4+kNLV2+kNLV33*2){
	424	fLVi33[j-4kNHV-2kNLV-kNLV33]->SetFloat(k,val);
	425	fLVi33[j-4kNHV-2kNLV-kNLV33]->SetTimeStampFloat(k,time);
	426	}
	427	else if (j<kNHV4+kNLV2+kNLV33*2+kNLV50){
	428	fLVv50[j-4kNHV-2kNLV-2*kNLV33]->SetFloat(k,val);
	429	fLVv50[j-4kNHV-2kNLV-2*kNLV33]->SetTimeStampFloat(k,time);
	430	}
	431	else if (j<kNHV4+kNLV2+kNLV332+kNLV502){
	432	fLVi50[j-4kNHV-2kNLV-2*kNLV33-kNLV50]->SetFloat(k,val);
	433	fLVi50[j-4kNHV-2kNLV-2*kNLV33-kNLV50]->SetTimeStampFloat(k,time);
	434	}
	435	else if (j<kNHV4+kNLV2+kNLV332+kNLV502+kNLV48){
	436	fLVv48[j-4kNHV-2kNLV-2kNLV33-2kNLV50]->SetFloat(k,val);
	437	fLVv48[j-4kNHV-2kNLV-2kNLV33-2kNLV50]->SetTimeStampFloat(k,time);
	438	}
	439	else if (j<kNHV4+kNLV2+kNLV332+kNLV502+kNLV48*2){
	440	fLVi48[j-4kNHV-2kNLV-2kNLV33-2kNLV50-kNLV48]->SetFloat(k,val);
	441	fLVi48[j-4kNHV-2kNLV-2kNLV33-2kNLV50-kNLV48]->SetTimeStampFloat(k,time);
	442	}
	443	else if (j<kNHV4+kNLV2+kNLV332+kNLV502+kNLV48*2+kNFEEthr){
	444	fFEEthr[j-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48]->SetFloat(k,val);
	445	fFEEthr[j-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48]->SetTimeStampFloat(k,time);
	446	}
	447	else if (j<kNHV4+kNLV2+kNLV332+kNLV502+kNLV48*2+kNFEEthr+kNFEEtfeac){
	448	fFEEtfeac[j-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48-kNFEEthr]->SetFloat(k,val);
	449	fFEEtfeac[j-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48-kNFEEthr]->SetTimeStampFloat(k,time);
	450	}
	451	else {
	452	fFEEttrm[j-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac]->SetFloat(k,val);
	453	fFEEttrm[j-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac]->SetTimeStampFloat(k,time);
345932e4	454	}
345932e4	455	}
38e3bbf1	456
345932e4	457	//computing the most significant variations
	458
	459	Int_t deltamin = (Int_t)(60/(timeMax-timeMin)*nentries);
	460	Int_t klast = nentries-deltamin;
38e3bbf1	461
345932e4	462	for (Int_t k=0;k<klast;k++){
	463	aValue = (AliDCSValue*) aliasArr->At(k);
	464	aValue1 = (AliDCSValue*) aliasArr->At(k+deltamin);
	465	val = aValue->GetFloat();
	466	val1 = aValue1->GetFloat();
	467	if (delta[0]<=TMath::Abs(val1-val)) {
	468	delta[0]=TMath::Abs(val1-val);
	469	timedelta[0] = (Float_t)k;
	470	}
	471	if (delta[1]<=delta[0]) {
	472	Float_t temp = delta[1];
	473	Float_t timetemp = timedelta[1];
	474	delta[1]=delta[0];
	475	delta[0]=temp;
	476	timedelta[1]=timedelta[0];
	477	timedelta[0]=timetemp;
	478	}
	479	}
	480
	481	for (Int_t kk=0;kk<2;kk++){
38e3bbf1	482	if (j<kNHV){
	483	fHVvp[j]->SetDelta(kk,delta[kk]);
	484	fHVvp[j]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
345932e4	485	}
38e3bbf1	486	else if (j<kNHV*2){
	487	fHVvn[j-kNHV]->SetDelta(kk,delta[kk]);
	488	fHVvn[j-kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	489	}
	490	else if (j<kNHV*3){
	491	fHVip[j-2*kNHV]->SetDelta(kk,delta[kk]);
	492	fHVip[j-2*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	493	}
	494	else if (j<kNHV*4){
	495	fHVin[j-3*kNHV]->SetDelta(kk,delta[kk]);
	496	fHVin[j-3*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	497	}
	498	else if (j<kNHV*4+kNLV){
	499	fLVv[j-4*kNHV]->SetDelta(kk,delta[kk]);
	500	fLVv[j-4*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	501	}
	502	else if (j<kNHV4+kNLV2){
	503	fLVi[j-4*kNHV-kNLV]->SetDelta(kk,delta[kk]);
	504	fLVi[j-4*kNHV-kNLV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	505	}
	506	else if (j<kNHV4+kNLV2+kNLV33){
	507	fLVv33[j-4kNHV-2kNLV]->SetDelta(kk,delta[kk]);
	508	fLVv33[j-4kNHV-2kNLV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	509	}
	510	else if (j<kNHV4+kNLV2+kNLV33*2){
	511	fLVi33[j-4kNHV-2kNLV-kNLV33]->SetDelta(kk,delta[kk]);
	512	fLVi33[j-4kNHV-2kNLV-kNLV33]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	513	}
	514	else if (j<kNHV4+kNLV2+kNLV33*2+kNLV50){
	515	fLVv50[j-4kNHV-2kNLV-2*kNLV33]->SetDelta(kk,delta[kk]);
	516	fLVv50[j-4kNHV-2kNLV-2*kNLV33]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	517	}
	518	else if (j<kNHV4+kNLV2+kNLV332+kNLV502){
	519	fLVi50[j-4kNHV-2kNLV-2*kNLV33-kNLV50]->SetDelta(kk,delta[kk]);
	520	fLVi50[j-4kNHV-2kNLV-2*kNLV33-kNLV50]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	521	}
	522	else if (j<kNHV4+kNLV2+kNLV332+kNLV502+kNLV48){
	523	fLVv48[j-4kNHV-2kNLV-2kNLV33-2kNLV50]->SetDelta(kk,delta[kk]);
	524	fLVv48[j-4kNHV-2kNLV-2kNLV33-2kNLV50]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	525	}
	526	else if (j<kNHV4+kNLV2+kNLV332+kNLV502+kNLV48*2){
	527	fLVi48[j-4kNHV-2kNLV-2kNLV33-2kNLV50-kNLV48]->SetDelta(kk,delta[kk]);
	528	fLVi48[j-4kNHV-2kNLV-2kNLV33-2kNLV50-kNLV48]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	529	}
	530	else if (j<kNHV4+kNLV2+kNLV332+kNLV502+kNLV48*2+kNFEEthr){
	531	fFEEthr[j-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48]->SetDelta(kk,delta[kk]);
	532	fFEEthr[j-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	533	}
	534	else if (j<kNHV4+kNLV2+kNLV332+kNLV502+kNLV48*2+kNFEEthr+kNFEEtfeac){
	535	fFEEtfeac[j-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48-kNFEEthr]->SetDelta(kk,delta[kk]);
	536	fFEEtfeac[j-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48-kNFEEthr]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	537	}
	538	else if (j<kNHV4+kNLV2+kNLV332+kNLV502+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm){
	539	fFEEttrm[j-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac]->SetDelta(kk,delta[kk]);
	540	fFEEttrm[j-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
345932e4	541	}
8259e6f8	542	}
345932e4	543	}
38e3bbf1	544
345932e4	545	fIsProcessed=kTRUE;
345932e4	546
ebab534a	547	return kTRUE;
345932e4	548	}
	549
	550	//---------------------------------------------------------------
	551	void AliTOFDataDCS::Init(){
	552
	553	// initialization of aliases and DCS data
	554
8259e6f8	555	TString sindex;
345932e4	556	for(int i=0;i<kNAliases;i++){
8259e6f8	557	//HV, v
345932e4	558	if (i<kNHV){
8259e6f8	559	fAliasNames[i] = "tof_hv_vp_";
	560	sindex.Form("%02i",i);
	561	fAliasNames[i] += sindex;
	562	fHVvp[i] = new AliTOFFormatDCS();
345932e4	563	}
345932e4	564	else if (i<kNHV*2){
8259e6f8	565	fAliasNames[i] = "tof_hv_vn_";
	566	sindex.Form("%02i",i-kNHV);
	567	fAliasNames[i] += sindex;
	568	fHVvn[i-kNHV] = new AliTOFFormatDCS();
345932e4	569	}
8259e6f8	570	//HV, i
345932e4	571	else if (i<kNHV*3){
8259e6f8	572	fAliasNames[i] = "tof_hv_ip_";
	573	sindex.Form("%02i",i-2*kNHV);
	574	fAliasNames[i] += sindex;
	575	fHVip[i-2*kNHV] = new AliTOFFormatDCS();
345932e4	576	}
345932e4	577	else if (i<kNHV*4){
8259e6f8	578	fAliasNames[i] = "tof_hv_in_";
	579	sindex.Form("%02i",i-3*kNHV);
	580	fAliasNames[i] += sindex;
	581	fHVin[i-3*kNHV] = new AliTOFFormatDCS();
345932e4	582	}
8259e6f8	583	//LV, v
345932e4	584	else if (i<(kNHV*4+kNLV)){
8259e6f8	585	fAliasNames[i] = "tof_lv_vfea_";
	586	sindex.Form("%03i",i-4*kNHV);
	587	fAliasNames[i] += sindex;
345932e4	588	fLVv[i-4*kNHV] = new AliTOFFormatDCS();
345932e4	589	}
8259e6f8	590	//LV, i
345932e4	591	else if (i<(kNHV4+kNLV2)){
8259e6f8	592	fAliasNames[i] = "tof_lv_ifea_";
	593	sindex.Form("%03i",i-4*kNHV-kNLV);
	594	fAliasNames[i] += sindex;
	595	fLVi[i-4*kNHV-kNLV] = new AliTOFFormatDCS();
	596	}
	597	//LV 3.3, v
	598	else if (i<(kNHV4+kNLV2+kNLV33)){
	599	fAliasNames[i] = "tof_lv_v33_";
	600	sindex.Form("%02i",i-4kNHV-2kNLV);
	601	fAliasNames[i] += sindex;
	602	fLVv33[i-4kNHV-2kNLV] = new AliTOFFormatDCS();
	603	}
	604	//LV 3.3, i
	605	else if (i<(kNHV4+kNLV2+kNLV33*2)){
	606	fAliasNames[i] = "tof_lv_i33_";
	607	sindex.Form("%02i",i-4kNHV-2kNLV-kNLV33);
	608	fAliasNames[i] += sindex;
	609	fLVi33[i-4kNHV-2kNLV-kNLV33] = new AliTOFFormatDCS();
345932e4	610	}
8259e6f8	611	//LV 5.0, v
	612	else if (i<(kNHV4+kNLV2+kNLV33*2+kNLV50)){
	613	fAliasNames[i] = "tof_lv_v50_";
	614	sindex.Form("%02i",i-4kNHV-2kNLV-2*kNLV33);
	615	fAliasNames[i] += sindex;
	616	fLVv50[i-4kNHV-2kNLV-2*kNLV33] = new AliTOFFormatDCS();
345932e4	617	}
8259e6f8	618	//LV 5.0, i
	619	else if (i<(kNHV4+kNLV2+kNLV332+kNLV502)){
	620	fAliasNames[i] = "tof_lv_i50_";
	621	sindex.Form("%02i",i-4kNHV-2kNLV-2*kNLV33-kNLV50);
	622	fAliasNames[i] += sindex;
	623	fLVi50[i-4kNHV-2kNLV-2*kNLV33-kNLV50] = new AliTOFFormatDCS();
345932e4	624	}
8259e6f8	625	//LV 48, v
	626	else if (i<(kNHV4+kNLV2+kNLV332+kNLV502+kNLV48)){
	627	fAliasNames[i] = "tof_lv_v48_";
	628	sindex.Form("%02i",i-4kNHV-2kNLV-2kNLV33-2kNLV50);
	629	fAliasNames[i] += sindex;
	630	fLVv48[i-4kNHV-2kNLV-2kNLV33-2kNLV50] = new AliTOFFormatDCS();
	631	}
	632	//LV 48, i
	633	else if (i<(kNHV4+kNLV2+kNLV332+kNLV502+kNLV48*2)){
	634	fAliasNames[i] = "tof_lv_i48_";
	635	sindex.Form("%02i",i-4kNHV-2kNLV-2kNLV33-2kNLV50-kNLV48);
	636	fAliasNames[i] += sindex;
	637	fLVi48[i-4kNHV-2kNLV-2kNLV33-2kNLV50-kNLV48] = new AliTOFFormatDCS();
	638	}
	639	//FEE thresholds
	640	else if (i<(kNHV4+kNLV2+kNLV332+kNLV502+kNLV48*2+kNFEEthr)){
	641	fAliasNames[i] = "tof_fee_th_";
	642	sindex.Form("%04i",i-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48);
	643	fAliasNames[i] += sindex;
	644	fFEEthr[i-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48] = new AliTOFFormatDCS();
	645	}
	646	//FEE FEAC temperatures
	647	else if (i<(kNHV4+kNLV2+kNLV332+kNLV502+kNLV48*2+kNFEEthr+kNFEEtfeac)){
	648	fAliasNames[i] = "tof_fee_tfeac_";
	649	sindex.Form("%03i",i-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48-kNFEEthr);
	650	fAliasNames[i] += sindex;
	651	fFEEtfeac[i-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48-kNFEEthr] = new AliTOFFormatDCS();
	652	}
	653	//FEE trms temperatures
	654	else if (i<(kNHV4+kNLV2+kNLV332+kNLV502+kNLV48*2+kNFEEthr+kNFEEtfeac+kNFEEttrm)){
8259e6f8	655	fAliasNames[i] = "tof_fee_ttrm_";
	656	sindex.Form("%04i",i-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac);
	657	fAliasNames[i] += sindex;
	658	fFEEttrm[i-4kNHV-2kNLV-2kNLV33-2kNLV50-2*kNLV48-kNFEEthr-kNFEEtfeac] = new AliTOFFormatDCS();
	659	}
345932e4	660	}
	661	}
	662
	663
	664	//---------------------------------------------------------------
	665	void AliTOFDataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
	666	{
	667
	668	// method to introduce new aliases
	669
	670	int entries=0;
	671	entries = aliasArr->GetEntries();
	672	int nal=0;
	673	nal=numAlias;
72bf252d	674	AliDebug(2,Form("********** Alias: %s ********",fAliasNames[numAlias].Data()));
72bf252d	675	AliDebug(2,Form(" %d DP values collected",entries));
345932e4	676
	677	}
	678
	679	//---------------------------------------------------------------
b52b97c2	680	void AliTOFDataDCS::Draw(const Option_t* /option/)
345932e4	681	{
	682	// Draw all histos and graphs
	683
	684	if(!fIsProcessed) return;
	685
	686	TCanvas *ch;
	687	TString canvasHistoName="Histos";
	688	ch=new TCanvas(canvasHistoName,canvasHistoName,20,20,600,600);
	689	ch->cd();
	690
	691	// to be implemented
	692
	693	}
	694