[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$
*/  

#include "AliTOFDataDCS.h"

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

#include "TString.h"
#include "AliTOFFormatDCS.h"
#include "TF1.h"
#include "TCanvas.h"
#include "TH1F.h"
#include "TTimeStamp.h"
#include "TMap.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)
{

  // main constructor 

	for(int i=0;i<kNHV;i++) {
	  fHVvpos[i]=0x0;
	  fHVvneg[i]=0x0;
	  fHVcpos[i]=0x0;
	  fHVcneg[i]=0x0;
	}

	for(int i=0;i<kNLV;i++) {
	  fLVv[i]=0x0;
	  fLVc[i]=0x0;
	}

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

	for(int i=0;i<kNFEEt;i++) {
	  fFEEt[i]=0x0;
	}

	for(int i=0;i<3;i++) {
	  fT[i]=0;
	  fP[i]=0;
	}

}

//---------------------------------------------------------------
AliTOFDataDCS::AliTOFDataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime):
	TObject(),
	fRun(nRun),
	fStartTime(startTime),
	fEndTime(endTime),
	fIsProcessed(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)

{

// copy constructor

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

  for(int i=0;i<kNAliases;i++) {
    fAliasNames[i]=data.fAliasNames[i];
  }
 
  for(int i=0;i<kNHV;i++) {
    fHVvpos[i]=data.fHVvpos[i];
    fHVvneg[i]=data.fHVvneg[i];
    fHVcpos[i]=data.fHVcpos[i];
    fHVcneg[i]=data.fHVcneg[i];
  }
  
  for(int i=0;i<kNLV;i++) {
    fLVv[i]=data.fLVv[i];
    fLVc[i]=data.fLVc[i];
  }

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

  for(int i=0;i<kNFEEt;i++) {
    fFEEt[i]=data.fFEEt[i];
  }
  
  for(int i=0;i<3;i++) {
    fT[i]=data.fT[i];
    fP[i]=data.fP[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<3;i++) {
    this->fT[i]=data.GetT(i);
    this->fP[i]=data.GetP(i);
  }

  //this->fCal=data.GetCal();

  for(int i=0;i<kNHV;i++) {
    this->fHVvpos[i]=data.GetHVvpos(i);
    this->fHVvneg[i]=data.GetHVvneg(i);
    this->fHVcpos[i]=data.GetHVcpos(i);
    this->fHVcneg[i]=data.GetHVcneg(i);
  }

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

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

  for(int i=0;i<kNFEEt;i++) {
    this->fFEEt[i]=data.GetFEEt(i);
  }

  this->fIsProcessed=data.fIsProcessed;

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

  // destructor

	for(int i=0;i<kNHV;i++) {
	  delete fHVvpos[i];
	  fHVvpos[i]=0;
	  delete fHVvneg[i];
	  fHVvneg[i]=0;
	  delete fHVcpos[i];
	  fHVcpos[i]=0;
	  delete fHVcneg[i];
	  fHVcneg[i]=0;
	}

	for(int i=0;i<kNLV;i++) {
	  delete fLVv[i];
	  fLVv[i]=0;
	  delete fLVc[i];
	  fLVc[i]=0;
	}

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

	for(int i=0;i<kNFEEt;i++) {
	  delete fFEEt[i];
	  fFEEt[i]=0;
	}
}

//-----------------------------------------------------------------------------
Float_t* AliTOFDataDCS::GetT()const {

  // method to retrieve environment temperature info

  Float_t* t=0;
  for (Int_t i=0;i<3;i++){
    t[i]=this->fT[i];
  }
  return t;
}
//-----------------------------------------------------------------------------
Float_t* AliTOFDataDCS::GetP() const{

  // method to retrieve environment pressure info

  Float_t* p=0;
  for (Int_t i=0;i<3;i++){
    p[i]=this->fP[i];
  }
  return p;
}

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

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

  Float_t timeMin = (Float_t)fStartTime;
  Float_t timeMax = (Float_t)fEndTime;
  Int_t nminutes = (Int_t)((timeMax-timeMin)/60);
  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;
  TH1F * histoT=0x0;
  TH1F * histoP=0x0;

  // 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()));
      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();
    //AliInfo(Form("entries = %i",nentries));
    Int_t deltaTimeStamp = (Int_t) nentries/3;
    Int_t deltaTimeStamp1 = (Int_t) nentries/2;
    AliDCSValue *lastDCSvalue = (AliDCSValue*) aliasArr->At(nentries-1);
    Float_t maxTimeStamp = (Float_t) (lastDCSvalue->GetTimeStamp());
    Float_t minTimeStamp = 0;

    // filling aliases with 10 floats+1 Usign
    if (j < kNHV*4+kNLV*2+kNFEEthr+kNFEEt){
      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){
	  fHVvpos[j]->SetFloat(k,val);
	  fHVvpos[j]->SetTimeStampFloat(k,time);
	}
	else if (j<kNHV*2){
	  fHVvneg[j-kNHV]->SetFloat(k,val);
	  fHVvneg[j-kNHV]->SetTimeStampFloat(k,time);
	}
	else if (j<kNHV*3){
	  fHVcpos[j-2*kNHV]->SetFloat(k,val);
	  fHVcpos[j-2*kNHV]->SetTimeStampFloat(k,time);
	}
	else if (j<kNHV*4){
	  fHVcneg[j-3*kNHV]->SetFloat(k,val);
	  fHVcneg[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){
	  fLVc[j-4*kNHV-kNLV]->SetFloat(k,val);
	  fLVc[j-4*kNHV-kNLV]->SetTimeStampFloat(k,time);
	}
	else if (j<kNHV*4+kNLV*2+kNFEEthr){
	  fFEEthr[j-4*kNHV-2*kNLV]->SetFloat(k,val);
	  fFEEthr[j-4*kNHV-2*kNLV]->SetTimeStampFloat(k,time);
	}
	else {
	  fFEEt[j-4*kNHV-2*kNLV-kNFEEthr]->SetFloat(k,val);
	  fFEEt[j-4*kNHV-2*kNLV-kNFEEthr]->SetTimeStampFloat(k,time);
	}
      }
    }
  
    //filling Temperature and Pressure aliases
    
    else {
      Int_t entriesT=0;
      Int_t entriesP=0;
      if (j<kNHV*4+kNLV*2+kNFEEthr+kNFEEt+1){
	histoT=new TH1F("histoT","histoT",nentries,minTimeStamp,maxTimeStamp);
      }
      else if (j<kNHV*4+kNLV*2+kNFEEthr+kNFEEt+2) {
	histoP=new TH1F("histoP","histoP",nentries,minTimeStamp,maxTimeStamp);
      }
      while ((aValue = (AliDCSValue*) iterarray.Next())) {
	val = aValue->GetFloat();
	time = (Float_t) (aValue->GetTimeStamp());
	if (j<kNHV*4+kNLV*2+kNFEEthr+kNFEEt+1){
	  histoT->Fill(time,val);
	  entriesT = (Int_t)(histoT->GetEntries());
	}
	else if (j<kNHV*4+kNLV*2+kNFEEthr+kNFEEt+2){
	  histoP->Fill(time,val);
	  entriesP = (Int_t)(histoP->GetEntries());
	}
      }
    
      if (j==kNHV*4+kNLV*2+kNFEEthr+kNFEEt+1){
	entriesT = (Int_t)(histoT->GetEntries());
	histoT->Fit("pol1","Q","");
	histoP->Fit("pol1","Q","");
      
	TF1 *tempFunc = histoT->GetFunction("pol1");
	TF1 *pressFunc = histoP->GetFunction("pol1");
      
	SetInterceptT((Float_t)tempFunc->GetParameter(0));
	SetSlopeT((Float_t)tempFunc->GetParameter(1));
	SetMaxT((Float_t)histoT->GetMaximum());
	SetInterceptP((Float_t)pressFunc->GetParameter(0));
	SetSlopeP((Float_t)pressFunc->GetParameter(1));
	SetMaxP((Float_t)histoP->GetMaximum());
      
	TCanvas *chT;
	TString canvasHistoNameT="HistosT";
	chT=new TCanvas(canvasHistoNameT,canvasHistoNameT,20,20,600,600);
	chT->cd();
	histoT->Draw();
	TCanvas *chP;
	TString canvasHistoNameP="HistosP";
	chP=new TCanvas(canvasHistoNameP,canvasHistoNameP,20,20,600,600);
	chP->cd();
	histoP->Draw();
      }
    }
 
    //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*4+kNLV*2+kNFEEthr){
	if (j<kNHV){
	  fHVvpos[j]->SetDelta(kk,delta[kk]);
	  fHVvpos[j]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	}
	else if (j<kNHV*2){
	  fHVvneg[j-kNHV]->SetDelta(kk,delta[kk]);
	  fHVvneg[j-kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	}
	else if (j<kNHV*3){
	  fHVcpos[j-2*kNHV]->SetDelta(kk,delta[kk]);
	  fHVcpos[j-2*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	}
	else if (j<kNHV*4){
	  fHVcneg[j-3*kNHV]->SetDelta(kk,delta[kk]);
	  fHVcneg[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){
	  fLVc[j-4*kNHV-kNLV]->SetDelta(kk,delta[kk]);
	  fLVc[j-4*kNHV-kNLV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	}
	else if (j<kNHV*4+kNLV*2+kNFEEthr){
	  fFEEthr[j-4*kNHV-2*kNLV]->SetDelta(kk,delta[kk]);
	  fFEEthr[j-4*kNHV-2*kNLV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	}
	else if (j<kNHV*4+kNLV*2+kNFEEthr+kNFEEt){
	  fFEEt[j-4*kNHV-2*kNLV+kNFEEthr]->SetDelta(kk,delta[kk]);
	  fFEEt[j-4*kNHV-2*kNLV+kNFEEthr]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
	}
      }
       
      
    //filling for temperature and pressure
    
      else if (j==kNHV*4+kNLV*2+kNFEEthr+kNFEEt){
	fT[2]=delta[1];
      }
      else if (j==kNHV*4+kNLV*2+kNFEEthr+kNFEEt+1){
	fP[2]=delta[1];
      }
      
        }
  }
    
  fIsProcessed=kTRUE;

}

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

  // initialization of aliases and DCS data

  for(int i=0;i<kNAliases;i++){
    if (i<kNHV){
	fAliasNames[i] = "HVvpos";
	fAliasNames[i] += i;
	//AliInfo(Form("i = %i, alias name = %s ", i, fAliasNames[i].Data())); 
	fHVvpos[i] = new AliTOFFormatDCS();
    }
    else if (i<kNHV*2){
	fAliasNames[i] = "HVvneg";
	fAliasNames[i] += i-kNHV;
	fHVvneg[i-kNHV] = new AliTOFFormatDCS();
    }
    else if (i<kNHV*3){
	fAliasNames[i] = "HVcpos";
	fAliasNames[i] += i-2*kNHV;
	fHVcpos[i-2*kNHV] = new AliTOFFormatDCS();
    }
    else if (i<kNHV*4){
	fAliasNames[i] = "HVcneg";
	fAliasNames[i] += i-3*kNHV;
	fHVcneg[i-3*kNHV] = new AliTOFFormatDCS();
    }
    else if (i<(kNHV*4+kNLV)){
	fAliasNames[i] = "LVv";
	fAliasNames[i] += i-4*kNHV;
	fLVv[i-4*kNHV] = new AliTOFFormatDCS();
    }
    else if (i<(kNHV*4+kNLV*2)){
	fAliasNames[i] = "LVc";
	fAliasNames[i] += i-4*kNHV-kNLV;
	fLVc[i-4*kNHV-kNLV] = new AliTOFFormatDCS();
    }
    else if (i<(kNHV*4+kNLV*2+kNFEEthr)){
	fAliasNames[i] = "FEEthr";
	fAliasNames[i] += i-4*kNHV-2*kNLV;
 	fFEEthr[i-4*kNHV-2*kNLV] = new AliTOFFormatDCS();
    }
    else if (i<(kNHV*4+kNLV*2+kNFEEthr+kNFEEt)){
	fAliasNames[i] = "FEEt";
	fAliasNames[i] += i-4*kNHV-2*kNLV-kNFEEthr;
 	fFEEt[i-4*kNHV-2*kNLV-kNFEEthr] = new AliTOFFormatDCS();
    }
    else if (i<(kNHV*4+kNLV*2+kNFEEthr+kNFEEt+1)){
	fAliasNames[i] = "Temperature";
    }
    else if (i<(kNHV*4+kNLV*2+kNFEEthr+kNFEEt+2)){
	fAliasNames[i] = "Pressure";
    }
  }
}


//---------------------------------------------------------------
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;
  //AliInfo(Form("************ Alias: %s **********",fAliasNames[numAlias].Data()));
  //AliInfo(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	/*
	17	$Log$
	18	*/
	19
	20	#include "AliTOFDataDCS.h"
	21
	22	#include "AliDCSValue.h"
	23	#include "AliLog.h"
	24
	25	#include "TString.h"
	26	#include "AliTOFFormatDCS.h"
	27	#include "TF1.h"
	28	#include "TCanvas.h"
	29	#include "TH1F.h"
	30	#include "TTimeStamp.h"
	31	#include "TMap.h"
	32
	33	class TH2;
	34	class AliCDBMetaData;
	35	class TDatime;
	36
	37	// AliTOFDataDCS class
	38	// main aim to introduce the aliases for the TOF DCS
	39	// data points to be then
	40	// stored in the OCDB, and to process them.
	41	// Process() method called by TOFPrepr
	42
	43	ClassImp(AliTOFDataDCS)
	44
	45	//---------------------------------------------------------------
	46	AliTOFDataDCS::AliTOFDataDCS():
	47	TObject(),
	48	fRun(0),
	49	fStartTime(0),
	50	fEndTime(0),
	51	fIsProcessed(kFALSE)
	52	{
	53
	54	// main constructor
	55
	56	for(int i=0;i<kNHV;i++) {
	57	fHVvpos[i]=0x0;
	58	fHVvneg[i]=0x0;
	59	fHVcpos[i]=0x0;
	60	fHVcneg[i]=0x0;
	61	}
	62
	63	for(int i=0;i<kNLV;i++) {
	64	fLVv[i]=0x0;
65	fLVc[i]=0x0;
66	}
67
68	for(int i=0;i<kNFEEthr;i++) {
69	fFEEthr[i]=0x0;
70	}
71
72	for(int i=0;i<kNFEEt;i++) {
73	fFEEt[i]=0x0;
74	}
75
76	for(int i=0;i<3;i++) {
77	fT[i]=0;
78	fP[i]=0;
79	}
80
81	}
82
83	//---------------------------------------------------------------
84	AliTOFDataDCS::AliTOFDataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime):
85	TObject(),
86	fRun(nRun),
87	fStartTime(startTime),
88	fEndTime(endTime),
89	fIsProcessed(kFALSE)
90	{
91
92	// constructor with arguments
93
94	AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", nRun,
95	TTimeStamp(startTime).AsString(),
96	TTimeStamp(endTime).AsString()));
97
98	Init();
99
100	}
101
102	//---------------------------------------------------------------
103
104	AliTOFDataDCS::AliTOFDataDCS(const AliTOFDataDCS & data):
105	TObject(),
106	fRun(0),
107	fStartTime(0),
108	fEndTime(0),
109	fIsProcessed(kFALSE)
110
111	{
112
113	// copy constructor
114
115	fRun=data.fRun;
116	fStartTime=data.fStartTime;
117	fEndTime=data.fEndTime;
118	fIsProcessed=data.fIsProcessed;
119
120	for(int i=0;i<kNAliases;i++) {
121	fAliasNames[i]=data.fAliasNames[i];
122	}
123
124	for(int i=0;i<kNHV;i++) {
125	fHVvpos[i]=data.fHVvpos[i];
126	fHVvneg[i]=data.fHVvneg[i];
127	fHVcpos[i]=data.fHVcpos[i];
128	fHVcneg[i]=data.fHVcneg[i];
129	}
130
131	for(int i=0;i<kNLV;i++) {
132	fLVv[i]=data.fLVv[i];
133	fLVc[i]=data.fLVc[i];
134	}
135
136	for(int i=0;i<kNFEEthr;i++) {
137	fFEEthr[i]=data.fFEEthr[i];
138	}
139
140	for(int i=0;i<kNFEEt;i++) {
141	fFEEt[i]=data.fFEEt[i];
142	}
143
144	for(int i=0;i<3;i++) {
145	fT[i]=data.fT[i];
146	fP[i]=data.fP[i];
147	}
148
149	}
150	//---------------------------------------------------------------
151
152	AliTOFDataDCS& AliTOFDataDCS:: operator=(const AliTOFDataDCS & data) {
153
154	// assignment operator
155
156	this->fRun=data.GetRun();
157	this->fStartTime=data.GetStartTime();
158	this->fEndTime=data.GetEndTime();
159
160	for(int i=0;i<kNAliases;i++) {
161	this->fAliasNames[i]=data.GetAliasName(i);
162	}
163
164	for(int i=0;i<3;i++) {
165	this->fT[i]=data.GetT(i);
166	this->fP[i]=data.GetP(i);
167	}
168
169	//this->fCal=data.GetCal();
170
171	for(int i=0;i<kNHV;i++) {
172	this->fHVvpos[i]=data.GetHVvpos(i);
173	this->fHVvneg[i]=data.GetHVvneg(i);
174	this->fHVcpos[i]=data.GetHVcpos(i);
175	this->fHVcneg[i]=data.GetHVcneg(i);
176	}
177
178	for(int i=0;i<kNLV;i++) {
179	this->fLVv[i]=data.GetLVv(i);
180	this->fLVc[i]=data.GetLVc(i);
181	}
182
183	for(int i=0;i<kNFEEthr;i++) {
184	this->fFEEthr[i]=data.GetFEEthr(i);
185	}
186
187	for(int i=0;i<kNFEEt;i++) {
188	this->fFEEt[i]=data.GetFEEt(i);
189	}
190
191	this->fIsProcessed=data.fIsProcessed;
192
193	return *this;
194	}
195	//---------------------------------------------------------------
196	AliTOFDataDCS::~AliTOFDataDCS() {
197
198	// destructor
199
200	for(int i=0;i<kNHV;i++) {
201	delete fHVvpos[i];
202	fHVvpos[i]=0;
203	delete fHVvneg[i];
204	fHVvneg[i]=0;
205	delete fHVcpos[i];
206	fHVcpos[i]=0;
207	delete fHVcneg[i];
208	fHVcneg[i]=0;
209	}
210
211	for(int i=0;i<kNLV;i++) {
212	delete fLVv[i];
213	fLVv[i]=0;
214	delete fLVc[i];
215	fLVc[i]=0;
216	}
217
218	for(int i=0;i<kNFEEthr;i++) {
219	delete fFEEthr[i];
220	fFEEthr[i]=0;
221	}
222
223	for(int i=0;i<kNFEEt;i++) {
224	delete fFEEt[i];
225	fFEEt[i]=0;
226	}
227	}
228
229	//-----------------------------------------------------------------------------
230	Float_t* AliTOFDataDCS::GetT()const {
231
232	// method to retrieve environment temperature info
233
234	Float_t* t=0;
235	for (Int_t i=0;i<3;i++){
236	t[i]=this->fT[i];
237	}
238	return t;
239	}
240	//-----------------------------------------------------------------------------
241	Float_t* AliTOFDataDCS::GetP() const{
242
243	// method to retrieve environment pressure info
244
245	Float_t* p=0;
246	for (Int_t i=0;i<3;i++){
247	p[i]=this->fP[i];
248	}
249	return p;
250	}
251
252	//---------------------------------------------------------------
253	void AliTOFDataDCS::ProcessData(TMap& aliasMap){
254
255	if(!(fAliasNames[0])) Init();
256
257	Float_t timeMin = (Float_t)fStartTime;
258	Float_t timeMax = (Float_t)fEndTime;
259	Int_t nminutes = (Int_t)((timeMax-timeMin)/60);
260	Float_t val=0;
261	Float_t val1=0;
262	Float_t time=0;
263	Float_t delta[2];
264	Float_t timedelta[2];
265
266	TObjArray *aliasArr;
267	AliDCSValue* aValue;
268	AliDCSValue* aValue1;
269	TH1F * histoT=0x0;
270	TH1F * histoP=0x0;
271
272	// starting loop on aliases
273	for(int j=0; j<kNAliases; j++){
274	for (Int_t k=0;k<2;k++) {
275	delta[k]=0;
276	timedelta[k]=0;
277	}
278	//AliInfo(Form("j = %i, with alias = %s",j,fAliasNames[j].Data()));
279	aliasArr = (TObjArray*) aliasMap.GetValue(fAliasNames[j].Data());
280	if(!aliasArr){
281	AliError(Form("Alias %s not found!", fAliasNames[j].Data()));
282	continue;
283	}
284
285	Introduce(j, aliasArr);
286
287	if(aliasArr->GetEntries()<3){
288	AliError(Form("Alias %s has just %d entries!",
289	fAliasNames[j].Data(),aliasArr->GetEntries()));
290	continue;
291	}
292
293	TIter iterarray(aliasArr);
294
295	Int_t nentries = aliasArr->GetEntries();
296	//AliInfo(Form("entries = %i",nentries));
297	Int_t deltaTimeStamp = (Int_t) nentries/3;
298	Int_t deltaTimeStamp1 = (Int_t) nentries/2;
299	AliDCSValue lastDCSvalue = (AliDCSValue) aliasArr->At(nentries-1);
300	Float_t maxTimeStamp = (Float_t) (lastDCSvalue->GetTimeStamp());
301	Float_t minTimeStamp = 0;
302
303	// filling aliases with 10 floats+1 Usign
304	if (j < kNHV4+kNLV2+kNFEEthr+kNFEEt){
305	Int_t index = 0;
306	for (Int_t k=0;k<3;k++){
307	index = deltaTimeStamp*k;
308	if (k==0) {
309	index=0;
310	}
311	else if (k==1) {
312	index=deltaTimeStamp1;
313	}
314	else if (k==2) {
315	index=nentries-1;
316	}
317	aValue = (AliDCSValue*) aliasArr->At(index);
318	val = aValue->GetFloat();
319	time = (Float_t) (aValue->GetTimeStamp());
320	if (j<kNHV){
321	fHVvpos[j]->SetFloat(k,val);
322	fHVvpos[j]->SetTimeStampFloat(k,time);
323	}
324	else if (j<kNHV*2){
325	fHVvneg[j-kNHV]->SetFloat(k,val);
326	fHVvneg[j-kNHV]->SetTimeStampFloat(k,time);
327	}
328	else if (j<kNHV*3){
329	fHVcpos[j-2*kNHV]->SetFloat(k,val);
330	fHVcpos[j-2*kNHV]->SetTimeStampFloat(k,time);
331	}
332	else if (j<kNHV*4){
333	fHVcneg[j-3*kNHV]->SetFloat(k,val);
334	fHVcneg[j-3*kNHV]->SetTimeStampFloat(k,time);
335	}
336	else if (j<kNHV*4+kNLV){
337	fLVv[j-4*kNHV]->SetFloat(k,val);
338	fLVv[j-4*kNHV]->SetTimeStampFloat(k,time);
339	}
340	else if (j<kNHV4+kNLV2){
341	fLVc[j-4*kNHV-kNLV]->SetFloat(k,val);
342	fLVc[j-4*kNHV-kNLV]->SetTimeStampFloat(k,time);
343	}
344	else if (j<kNHV4+kNLV2+kNFEEthr){
345	fFEEthr[j-4kNHV-2kNLV]->SetFloat(k,val);
346	fFEEthr[j-4kNHV-2kNLV]->SetTimeStampFloat(k,time);
347	}
348	else {
349	fFEEt[j-4kNHV-2kNLV-kNFEEthr]->SetFloat(k,val);
350	fFEEt[j-4kNHV-2kNLV-kNFEEthr]->SetTimeStampFloat(k,time);
351	}
352	}
353	}
354
355	//filling Temperature and Pressure aliases
356
357	else {
358	Int_t entriesT=0;
359	Int_t entriesP=0;
360	if (j<kNHV4+kNLV2+kNFEEthr+kNFEEt+1){
361	histoT=new TH1F("histoT","histoT",nentries,minTimeStamp,maxTimeStamp);
362	}
363	else if (j<kNHV4+kNLV2+kNFEEthr+kNFEEt+2) {
364	histoP=new TH1F("histoP","histoP",nentries,minTimeStamp,maxTimeStamp);
365	}
366	while ((aValue = (AliDCSValue*) iterarray.Next())) {
367	val = aValue->GetFloat();
368	time = (Float_t) (aValue->GetTimeStamp());
369	if (j<kNHV4+kNLV2+kNFEEthr+kNFEEt+1){
370	histoT->Fill(time,val);
371	entriesT = (Int_t)(histoT->GetEntries());
372	}
373	else if (j<kNHV4+kNLV2+kNFEEthr+kNFEEt+2){
374	histoP->Fill(time,val);
375	entriesP = (Int_t)(histoP->GetEntries());
376	}
377	}
378
379	if (j==kNHV4+kNLV2+kNFEEthr+kNFEEt+1){
380	entriesT = (Int_t)(histoT->GetEntries());
381	histoT->Fit("pol1","Q","");
382	histoP->Fit("pol1","Q","");
383
384	TF1 *tempFunc = histoT->GetFunction("pol1");
385	TF1 *pressFunc = histoP->GetFunction("pol1");
386
387	SetInterceptT((Float_t)tempFunc->GetParameter(0));
388	SetSlopeT((Float_t)tempFunc->GetParameter(1));
389	SetMaxT((Float_t)histoT->GetMaximum());
390	SetInterceptP((Float_t)pressFunc->GetParameter(0));
391	SetSlopeP((Float_t)pressFunc->GetParameter(1));
392	SetMaxP((Float_t)histoP->GetMaximum());
393
394	TCanvas *chT;
395	TString canvasHistoNameT="HistosT";
396	chT=new TCanvas(canvasHistoNameT,canvasHistoNameT,20,20,600,600);
397	chT->cd();
398	histoT->Draw();
399	TCanvas *chP;
400	TString canvasHistoNameP="HistosP";
401	chP=new TCanvas(canvasHistoNameP,canvasHistoNameP,20,20,600,600);
402	chP->cd();
403	histoP->Draw();
404	}
405	}
406
407	//computing the most significant variations
408
409	Int_t deltamin = (Int_t)(60/(timeMax-timeMin)*nentries);
410	Int_t klast = nentries-deltamin;
411
412	for (Int_t k=0;k<klast;k++){
413	aValue = (AliDCSValue*) aliasArr->At(k);
414	aValue1 = (AliDCSValue*) aliasArr->At(k+deltamin);
415	val = aValue->GetFloat();
416	val1 = aValue1->GetFloat();
417	if (delta[0]<=TMath::Abs(val1-val)) {
418	delta[0]=TMath::Abs(val1-val);
419	timedelta[0] = (Float_t)k;
420	}
421	if (delta[1]<=delta[0]) {
422	Float_t temp = delta[1];
423	Float_t timetemp = timedelta[1];
424	delta[1]=delta[0];
425	delta[0]=temp;
426	timedelta[1]=timedelta[0];
427	timedelta[0]=timetemp;
428	}
429	}
430
431	for (Int_t kk=0;kk<2;kk++){
432	if (j < kNHV4+kNLV2+kNFEEthr){
433	if (j<kNHV){
434	fHVvpos[j]->SetDelta(kk,delta[kk]);
435	fHVvpos[j]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
436	}
437	else if (j<kNHV*2){
438	fHVvneg[j-kNHV]->SetDelta(kk,delta[kk]);
439	fHVvneg[j-kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
440	}
441	else if (j<kNHV*3){
442	fHVcpos[j-2*kNHV]->SetDelta(kk,delta[kk]);
443	fHVcpos[j-2*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
444	}
445	else if (j<kNHV*4){
446	fHVcneg[j-3*kNHV]->SetDelta(kk,delta[kk]);
447	fHVcneg[j-3*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
448	}
449	else if (j<kNHV*4+kNLV){
450	fLVv[j-4*kNHV]->SetDelta(kk,delta[kk]);
451	fLVv[j-4*kNHV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
452	}
453	else if (j<kNHV4+kNLV2){
454	fLVc[j-4*kNHV-kNLV]->SetDelta(kk,delta[kk]);
455	fLVc[j-4*kNHV-kNLV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
456	}
457	else if (j<kNHV4+kNLV2+kNFEEthr){
458	fFEEthr[j-4kNHV-2kNLV]->SetDelta(kk,delta[kk]);
459	fFEEthr[j-4kNHV-2kNLV]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
460	}
461	else if (j<kNHV4+kNLV2+kNFEEthr+kNFEEt){
462	fFEEt[j-4kNHV-2kNLV+kNFEEthr]->SetDelta(kk,delta[kk]);
463	fFEEt[j-4kNHV-2kNLV+kNFEEthr]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
464	}
465	}
466
467
468	//filling for temperature and pressure
469
470	else if (j==kNHV4+kNLV2+kNFEEthr+kNFEEt){
471	fT[2]=delta[1];
472	}
473	else if (j==kNHV4+kNLV2+kNFEEthr+kNFEEt+1){
474	fP[2]=delta[1];
475	}
476
477	}
478	}
479
480	fIsProcessed=kTRUE;
481
482	}
483
484	//---------------------------------------------------------------
485	void AliTOFDataDCS::Init(){
486
487	// initialization of aliases and DCS data
488
489	for(int i=0;i<kNAliases;i++){
490	if (i<kNHV){
491	fAliasNames[i] = "HVvpos";
492	fAliasNames[i] += i;
493	//AliInfo(Form("i = %i, alias name = %s ", i, fAliasNames[i].Data()));
494	fHVvpos[i] = new AliTOFFormatDCS();
495	}
496	else if (i<kNHV*2){
497	fAliasNames[i] = "HVvneg";
498	fAliasNames[i] += i-kNHV;
499	fHVvneg[i-kNHV] = new AliTOFFormatDCS();
500	}
501	else if (i<kNHV*3){
502	fAliasNames[i] = "HVcpos";
503	fAliasNames[i] += i-2*kNHV;
504	fHVcpos[i-2*kNHV] = new AliTOFFormatDCS();
505	}
506	else if (i<kNHV*4){
507	fAliasNames[i] = "HVcneg";
508	fAliasNames[i] += i-3*kNHV;
509	fHVcneg[i-3*kNHV] = new AliTOFFormatDCS();
510	}
511	else if (i<(kNHV*4+kNLV)){
512	fAliasNames[i] = "LVv";
513	fAliasNames[i] += i-4*kNHV;
514	fLVv[i-4*kNHV] = new AliTOFFormatDCS();
515	}
516	else if (i<(kNHV4+kNLV2)){
517	fAliasNames[i] = "LVc";
518	fAliasNames[i] += i-4*kNHV-kNLV;
519	fLVc[i-4*kNHV-kNLV] = new AliTOFFormatDCS();
520	}
521	else if (i<(kNHV4+kNLV2+kNFEEthr)){
522	fAliasNames[i] = "FEEthr";
523	fAliasNames[i] += i-4kNHV-2kNLV;
524	fFEEthr[i-4kNHV-2kNLV] = new AliTOFFormatDCS();
525	}
526	else if (i<(kNHV4+kNLV2+kNFEEthr+kNFEEt)){
527	fAliasNames[i] = "FEEt";
528	fAliasNames[i] += i-4kNHV-2kNLV-kNFEEthr;
529	fFEEt[i-4kNHV-2kNLV-kNFEEthr] = new AliTOFFormatDCS();
530	}
531	else if (i<(kNHV4+kNLV2+kNFEEthr+kNFEEt+1)){
532	fAliasNames[i] = "Temperature";
533	}
534	else if (i<(kNHV4+kNLV2+kNFEEthr+kNFEEt+2)){
535	fAliasNames[i] = "Pressure";
536	}
537	}
538	}
539
540
541	//---------------------------------------------------------------
542	void AliTOFDataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
543	{
544
545	// method to introduce new aliases
546
547	int entries=0;
548	entries = aliasArr->GetEntries();
549	int nal=0;
550	nal=numAlias;
551	//AliInfo(Form("********** Alias: %s ********",fAliasNames[numAlias].Data()));
552	//AliInfo(Form(" %d DP values collected",entries));
553
554	}
555
556	//---------------------------------------------------------------
557	void AliTOFDataDCS::Draw(const Option_t* /option/)
558	{
559	// Draw all histos and graphs
560
561	if(!fIsProcessed) return;
562
563	TCanvas *ch;
564	TString canvasHistoName="Histos";
565	ch=new TCanvas(canvasHistoName,canvasHistoName,20,20,600,600);
566	ch->cd();
567
568	// to be implemented
569
570	}
571