[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),
	fStartTimeDCSQuery(0),
	fEndTimeDCSQuery(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;
  }
    
  
}

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

  // constructor with arguments

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

	Init();

}

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

AliTOFDataDCS::AliTOFDataDCS(const AliTOFDataDCS & data):
  TObject(data), 
  fRun(data.fRun),
  fStartTime(data.fStartTime),
  fEndTime(data.fEndTime),
  fStartTimeDCSQuery(data.fStartTimeDCSQuery),
  fEndTimeDCSQuery(data.fEndTimeDCSQuery),
  fIsProcessed(data.fIsProcessed),
  fFDR(data.fFDR)

{

// copy constructor

  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];
  }
  
    
}
//---------------------------------------------------------------

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

// assignment operator

  if (this == &data)
    return *this;

  TObject::operator=(data);
  fRun=data.GetRun();
  fStartTime=data.GetStartTime();
  fEndTime=data.GetEndTime();
  fStartTimeDCSQuery=data.GetStartTimeDCSQuery();
  fEndTimeDCSQuery=data.GetEndTimeDCSQuery();

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

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


  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;
  }
  
}

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

  // method to process the data

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

  Float_t val=0;
  Float_t val0=0;
  Float_t val1=0;
  Float_t time=0; 
  Float_t time0=0; 
  Float_t time1=0; 
  Float_t delta[2];
  Float_t timedelta[2];

  AliInfo(Form(" Start Time = %i",fStartTime));
  AliInfo(Form(" End Time = %i",fEndTime));
  AliInfo(Form(" Start Time DCS Query= %i",fStartTimeDCSQuery));
  AliInfo(Form(" End Time DCS Query= %i",fEndTimeDCSQuery));

  if (fEndTime==fStartTime){
    AliError(Form(" Run with null time length: start time = %i = end time = %i",fStartTime,fEndTime));
    return kFALSE;
  }

  TObjArray *aliasArr;
  AliDCSValue* aValue;
  AliDCSValue* aValue0;
  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()==0){
      AliError(Form("Alias %s has no entries! Nothing will be stored",
		    fAliasNames[j].Data()));
      continue;
    }
    if(aliasArr->GetEntries() == 1){
      AliWarning(Form("Alias %s has just %d entries! Only first value will be stored",
		    fAliasNames[j].Data(),aliasArr->GetEntries()));
      aValue0 = (AliDCSValue*) aliasArr->At(0);
      val0 = aValue0->GetFloat();
      time0 = (Float_t) (aValue0->GetTimeStamp());
      if (j<kNHV){
	fHVvp[j]->SetFloat(0,val0);
	fHVvp[j]->SetTimeStampFloat(0,time0);
      }
      else if (j<kNHV*2){
	fHVvn[j-kNHV]->SetFloat(0,val0);
	fHVvn[j-kNHV]->SetTimeStampFloat(0,time0);
      }
      else if (j<kNHV*3){
	fHVip[j-2*kNHV]->SetFloat(0,val0);
	fHVip[j-2*kNHV]->SetTimeStampFloat(0,time0);
      }
      else if (j<kNHV*4){
	fHVin[j-3*kNHV]->SetFloat(0,val0);
	fHVin[j-3*kNHV]->SetTimeStampFloat(0,time0);
      }
      continue;
    }
    if(aliasArr->GetEntries()==2){
      AliWarning(Form("Alias %s has just %d entries! Storing first and second entry only and the delta between these two",
		    fAliasNames[j].Data(),aliasArr->GetEntries()));
      aValue0 = (AliDCSValue*) aliasArr->At(0);
      val0 = aValue0->GetFloat();
      time0 = (Float_t) (aValue0->GetTimeStamp());
      aValue1 = (AliDCSValue*) aliasArr->At(1);
      val1 = aValue1->GetFloat();
      time1 = (Float_t) (aValue1->GetTimeStamp());
      if (j<kNHV){
	fHVvp[j]->SetFloat(0,val0);
	fHVvp[j]->SetTimeStampFloat(0,time0);
	fHVvp[j]->SetFloat(1,val1);
	fHVvp[j]->SetTimeStampFloat(1,time1);
	fHVvp[j]->SetDelta(0,TMath::Abs(val1-val0));
	fHVvp[j]->SetTimeStampDelta(0,time1-time0);
      }
      else if (j<kNHV*2){
	fHVvn[j-kNHV]->SetFloat(0,val0);
	fHVvn[j-kNHV]->SetTimeStampFloat(0,time0);
	fHVvn[j-kNHV]->SetFloat(1,val1);
	fHVvn[j-kNHV]->SetTimeStampFloat(1,time1);
	fHVvn[j-kNHV]->SetDelta(0,TMath::Abs(val1-val0));
	fHVvn[j-kNHV]->SetTimeStampDelta(0,time1-time0);
      }
      else if (j<kNHV*3){
	fHVip[j-2*kNHV]->SetFloat(0,val0);
	fHVip[j-2*kNHV]->SetTimeStampFloat(0,time0);
	fHVip[j-2*kNHV]->SetFloat(1,val1);
	fHVip[j-2*kNHV]->SetTimeStampFloat(1,time1);
	fHVip[j-2*kNHV]->SetDelta(0,TMath::Abs(val1-val0));
	fHVip[j-2*kNHV]->SetTimeStampDelta(0,time1-time0);
      }
      else if (j<kNHV*4){
	fHVin[j-3*kNHV]->SetFloat(0,val0);
	fHVin[j-3*kNHV]->SetTimeStampFloat(0,time0);
	fHVin[j-3*kNHV]->SetFloat(1,val1);
	fHVin[j-3*kNHV]->SetTimeStampFloat(1,time1);
	fHVin[j-3*kNHV]->SetDelta(0,TMath::Abs(val1-val0));
	fHVin[j-3*kNHV]->SetTimeStampDelta(0,time1-time0);
      }
      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);
      }
    }
  
    //computing the most significant variations

    //Float_t timeDiff = (Float_t)(fEndTime-fStartTime);
    Float_t timeDiff = (Float_t)(fEndTimeDCSQuery-fStartTimeDCSQuery);
    Int_t deltamin = (Int_t)(60/timeDiff*nentries); //sampling every minute
    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]);
      }
    }
  }
  
  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();
    }
  }
}


//---------------------------------------------------------------
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),
ff326f84	78	fStartTimeDCSQuery(0),
ff326f84	79	fEndTimeDCSQuery(0),
7fffa85b	80	fIsProcessed(kFALSE),
7fffa85b	81	fFDR(kFALSE)
345932e4	82	{
	83
	84	// main constructor
	85
8259e6f8	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	}
d202b31a	92
8259e6f8	93
345932e4	94	}
	95
	96	//---------------------------------------------------------------
ff326f84	97	AliTOFDataDCS::AliTOFDataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime, UInt_t startTimeDCSQuery, UInt_t endTimeDCSQuery):
345932e4	98	TObject(),
	99	fRun(nRun),
	100	fStartTime(startTime),
	101	fEndTime(endTime),
ff326f84	102	fStartTimeDCSQuery(startTimeDCSQuery),
ff326f84	103	fEndTimeDCSQuery(endTimeDCSQuery),
7fffa85b	104	fIsProcessed(kFALSE),
7fffa85b	105	fFDR(kFALSE)
345932e4	106	{
	107
	108	// constructor with arguments
	109
ff326f84	110	AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s \n\tStartTime DCS Query %s \n\tEndTime DCS Query %s", nRun,
345932e4	111	TTimeStamp(startTime).AsString(),
ff326f84	112	TTimeStamp(endTime).AsString(),
	113	TTimeStamp(startTimeDCSQuery).AsString(),
	114	TTimeStamp(endTimeDCSQuery).AsString()));
345932e4	115
	116	Init();
	117
	118	}
	119
	120	//---------------------------------------------------------------
	121
	122	AliTOFDataDCS::AliTOFDataDCS(const AliTOFDataDCS & data):
8a190ba2	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)
345932e4	131
	132	{
	133
	134	// copy constructor
	135
345932e4	136	for(int i=0;i<kNAliases;i++) {
	137	fAliasNames[i]=data.fAliasNames[i];
	138	}
	139
	140	for(int i=0;i<kNHV;i++) {
8259e6f8	141	fHVvp[i]=data.fHVvp[i];
	142	fHVvn[i]=data.fHVvn[i];
	143	fHVip[i]=data.fHVip[i];
	144	fHVin[i]=data.fHVin[i];
345932e4	145	}
345932e4	146
38e3bbf1	147
345932e4	148	}
	149	//---------------------------------------------------------------
	150
	151	AliTOFDataDCS& AliTOFDataDCS:: operator=(const AliTOFDataDCS & data) {
	152
	153	// assignment operator
	154
8a190ba2	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();
345932e4	164
345932e4	165	for(int i=0;i<kNAliases;i++) {
8a190ba2	166	fAliasNames[i]=data.GetAliasName(i);
345932e4	167	}
345932e4	168
345932e4	169	for(int i=0;i<kNHV;i++) {
8a190ba2	170	fHVvp[i]=data.GetHVvp(i);
	171	fHVvn[i]=data.GetHVvn(i);
	172	fHVip[i]=data.GetHVip(i);
	173	fHVin[i]=data.GetHVin(i);
345932e4	174	}
345932e4	175
345932e4	176
	177	return *this;
	178	}
	179	//---------------------------------------------------------------
	180	AliTOFDataDCS::~AliTOFDataDCS() {
	181
	182	// destructor
	183
8259e6f8	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
345932e4	195	}
345932e4	196
345932e4	197	//---------------------------------------------------------------
ebab534a	198	Bool_t AliTOFDataDCS::ProcessData(TMap& aliasMap){
345932e4	199
3a3ece53	200	// method to process the data
3a3ece53	201
345932e4	202	if(!(fAliasNames[0])) Init();
345932e4	203
345932e4	204	Float_t val=0;
5f2d4eea	205	Float_t val0=0;
345932e4	206	Float_t val1=0;
345932e4	207	Float_t time=0;
5f2d4eea	208	Float_t time0=0;
5f2d4eea	209	Float_t time1=0;
345932e4	210	Float_t delta[2];
	211	Float_t timedelta[2];
	212
e83a0dd0	213	AliInfo(Form(" Start Time = %i",fStartTime));
e83a0dd0	214	AliInfo(Form(" End Time = %i",fEndTime));
ff326f84	215	AliInfo(Form(" Start Time DCS Query= %i",fStartTimeDCSQuery));
ff326f84	216	AliInfo(Form(" End Time DCS Query= %i",fEndTimeDCSQuery));
e83a0dd0	217
	218	if (fEndTime==fStartTime){
	219	AliError(Form(" Run with null time length: start time = %i = end time = %i",fStartTime,fEndTime));
	220	return kFALSE;
96fec15b	221	}
96fec15b	222
345932e4	223	TObjArray *aliasArr;
345932e4	224	AliDCSValue* aValue;
5f2d4eea	225	AliDCSValue* aValue0;
345932e4	226	AliDCSValue* aValue1;
345932e4	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()));
7fffa85b	238	if (!fFDR){
	239	return kFALSE; // returning only in case we are not in a FDR run
	240	}
	241	else {
	242	continue;
	243	}
345932e4	244	}
	245
	246	Introduce(j, aliasArr);
	247
5f2d4eea	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",
345932e4	255	fAliasNames[j].Data(),aliasArr->GetEntries()));
5f2d4eea	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	}
345932e4	318	continue;
	319	}
	320
	321	TIter iterarray(aliasArr);
	322
	323	Int_t nentries = aliasArr->GetEntries();
345932e4	324	Int_t deltaTimeStamp = (Int_t) nentries/3;
345932e4	325	Int_t deltaTimeStamp1 = (Int_t) nentries/2;
345932e4	326
345932e4	327	// filling aliases with 10 floats+1 Usign
38e3bbf1	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;
345932e4	333	}
38e3bbf1	334	else if (k==1) {
	335	index=deltaTimeStamp1;
	336	}
	337	else if (k==2) {
	338	index=nentries-1;
345932e4	339	}
38e3bbf1	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	}
345932e4	359	}
38e3bbf1	360
345932e4	361	//computing the most significant variations
345932e4	362
ff326f84	363	//Float_t timeDiff = (Float_t)(fEndTime-fStartTime);
ff326f84	364	Float_t timeDiff = (Float_t)(fEndTimeDCSQuery-fStartTimeDCSQuery);
e83a0dd0	365	Int_t deltamin = (Int_t)(60/timeDiff*nentries); //sampling every minute
345932e4	366	Int_t klast = nentries-deltamin;
38e3bbf1	367
345932e4	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++){
38e3bbf1	388	if (j<kNHV){
	389	fHVvp[j]->SetDelta(kk,delta[kk]);
	390	fHVvp[j]->SetTimeStampDelta(kk,(Float_t)timedelta[kk]);
345932e4	391	}
38e3bbf1	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	}
8259e6f8	404	}
345932e4	405	}
38e3bbf1	406
345932e4	407	fIsProcessed=kTRUE;
345932e4	408
ebab534a	409	return kTRUE;
345932e4	410	}
	411
	412	//---------------------------------------------------------------
	413	void AliTOFDataDCS::Init(){
	414
	415	// initialization of aliases and DCS data
	416
8259e6f8	417	TString sindex;
345932e4	418	for(int i=0;i<kNAliases;i++){
8259e6f8	419	//HV, v
345932e4	420	if (i<kNHV){
8259e6f8	421	fAliasNames[i] = "tof_hv_vp_";
	422	sindex.Form("%02i",i);
	423	fAliasNames[i] += sindex;
	424	fHVvp[i] = new AliTOFFormatDCS();
345932e4	425	}
345932e4	426	else if (i<kNHV*2){
8259e6f8	427	fAliasNames[i] = "tof_hv_vn_";
	428	sindex.Form("%02i",i-kNHV);
	429	fAliasNames[i] += sindex;
	430	fHVvn[i-kNHV] = new AliTOFFormatDCS();
345932e4	431	}
8259e6f8	432	//HV, i
345932e4	433	else if (i<kNHV*3){
8259e6f8	434	fAliasNames[i] = "tof_hv_ip_";
	435	sindex.Form("%02i",i-2*kNHV);
	436	fAliasNames[i] += sindex;
	437	fHVip[i-2*kNHV] = new AliTOFFormatDCS();
345932e4	438	}
345932e4	439	else if (i<kNHV*4){
8259e6f8	440	fAliasNames[i] = "tof_hv_in_";
	441	sindex.Form("%02i",i-3*kNHV);
	442	fAliasNames[i] += sindex;
	443	fHVin[i-3*kNHV] = new AliTOFFormatDCS();
345932e4	444	}
345932e4	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;
72bf252d	459	AliDebug(2,Form("********** Alias: %s ********",fAliasNames[numAlias].Data()));
72bf252d	460	AliDebug(2,Form(" %d DP values collected",entries));
345932e4	461
	462	}
	463
	464	//---------------------------------------------------------------
b52b97c2	465	void AliTOFDataDCS::Draw(const Option_t* /option/)
345932e4	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