[u/mrichter/AliRoot.git] / EMCAL / AliEMCALCalibTimeDep.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.                  *
 **************************************************************************/

/* $Id: AliEMCALCalibTimeDep.cxx $ */

//_________________________________________________________________________
///*-- Author: 
///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// class for EMCAL time-dep calibration                                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <TGraphSmooth.h>
#include "AliLog.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliEMCALSensorTempArray.h"
#include "AliEMCALCalibTimeDep.h"

/* first a bunch of constants.. */
const double fkSecToHour = 1.0/3600.0; // conversion factor from seconds to hours

// some global variables for APD handling; assume the same for all, at least to start with
const double fkTempSlope = 0.017; // 1.7% per deg. C, seems about right for all APDs, from studies at Catania, and by Rachid. 
// Note that this is only valid at gain M~30; i.e. voltages at V30. 
// At V50, it's more like 2.25%/C, and at V20 about 1.35%/C (also info from Catania)
const double fkNormTemp = 20; // let's say that 20 degrees C is normal as default

const double fkErrorCode = -999; // to indicate that something went wrong

using namespace std;

ClassImp(AliEMCALCalibTimeDep)

//________________________________________________________________
AliEMCALCalibTimeDep::AliEMCALCalibTimeDep() :
  fRun(0),
  fStartTime(0),
  fEndTime(0),
  fMinTemp(0),
  fMaxTemp(0),
  fMinTime(0),
  fMaxTime(0),
  fRefTemp(fkNormTemp), 
  fTempArray(NULL)
{
  // Constructor
}

//________________________________________________________________
AliEMCALCalibTimeDep::AliEMCALCalibTimeDep(const AliEMCALCalibTimeDep& calibt) :
  TObject(calibt),
  fRun(calibt.GetRunNumber()),
  fStartTime(calibt.GetStartTime()),
  fEndTime(calibt.GetEndTime()),
  fMinTemp(calibt.GetMinTemp()),
  fMaxTemp(calibt.GetMaxTemp()),
  fMinTime(calibt.GetMinTime()),
  fMaxTime(calibt.GetMaxTime()),
  fRefTemp(calibt.GetRefTemp()),
  fTempArray(calibt.GetTempArray())
{
  // copy constructor
}


//________________________________________________________________
AliEMCALCalibTimeDep &AliEMCALCalibTimeDep::operator =(const AliEMCALCalibTimeDep& calibt)
{
  // assignment operator; use copy ctor
  if (&calibt == this) return *this;

  new (this) AliEMCALCalibTimeDep(calibt);
  return *this;
}

//________________________________________________________________
AliEMCALCalibTimeDep::~AliEMCALCalibTimeDep()
{
  // Destructor
}

//________________________________________________________________
void  AliEMCALCalibTimeDep::Reset() 
{
  // clear variables to default
  fRun = 0;
  fStartTime = 0;
  fEndTime = 0;
  fMinTemp = 0;
  fMaxTemp = 0;
  fMinTime = 0;
  fMaxTime = 0;
  fRefTemp = fkNormTemp;
  fTempArray = NULL;
  return;
}

//________________________________________________________________
void  AliEMCALCalibTimeDep::PrintInfo() const
{
  // print some info
  cout << endl << " AliEMCALCalibTimeDep::Print() " << endl;
  // basic variables, all 'publicly available' also
  cout << " VARIABLE DUMP: " << endl
       << " GetStartTime() " << GetStartTime() << endl
       << " GetEndTime() " << GetEndTime() << endl
       << " GetMinTemp() " << GetMinTemp() << endl
       << " GetMaxTemp() " << GetMaxTemp() << endl
       << " GetRefTemp() " << GetRefTemp() << endl;
  // run ranges
  cout << " RUN INFO: " << endl
       << " length (in hours) " << GetLengthOfRunInHours() << endl
       << " range of temperature measurements (in hours) " << GetRangeOfTempMeasureInHours()
       << " (in deg. C) " << GetRangeOfTempMeasureInDegrees()
       << endl;
  // range in correction values
  double corrAtMinTemp = GetCorrection( fMinTemp );
  double corrAtMaxTemp = GetCorrection( fMaxTemp );
  double corrMaxMinDiff = 100*(corrAtMinTemp - corrAtMaxTemp);
  cout << " CORRECTION INFO : " << endl
       << " corrAtMinTemp " << corrAtMinTemp << endl
       << " corrAtMaxTemp " << corrAtMaxTemp << endl
       << " corrMaxMinDiff (~%) [=(corrAtMin - corrAtMax)*100] " 
       << corrMaxMinDiff << endl;

  return;
}
//________________________________________________________________ 
double AliEMCALCalibTimeDep::GetLengthOfRunInHours() const
{
  return (fEndTime - fStartTime)*fkSecToHour;
}
//________________________________________________________________ 
double AliEMCALCalibTimeDep::GetRangeOfTempMeasureInHours() const
{
  return (fMaxTime - fMinTime)*fkSecToHour;
}
//________________________________________________________________ 
double AliEMCALCalibTimeDep::GetRangeOfTempMeasureInDegrees() const
{
  return (fMaxTemp - fMinTemp);
}

//________________________________________________________________
void AliEMCALCalibTimeDep::Initialize(Int_t run, 
				      UInt_t startTime, UInt_t endTime)
{
  Reset(); // start fresh

  fRun = run;
  fStartTime = startTime;
  fEndTime = endTime;
  
  // collect the needed information
  GetTemperatureInfo(); // temperature readings during the run

  return;
}

//________________________________________________________________
double AliEMCALCalibTimeDep::GetTemperature(UInt_t timeStamp) const
{// return estimate for all SuperModules and sensors, that had data 

  // first convert from seconds to hours..
  double timeHour = (timeStamp - fStartTime) * fkSecToHour;

  double average = 0;
  int n = 0;

  for (int i=0; i<fTempArray->NumSensors(); i++) {
    
    AliEMCALSensorTemp *st = fTempArray->GetSensor(i);

    // check if we had valid data for the time that is being asked for
    if ( timeStamp>=st->GetStartTime() && timeStamp<=st->GetEndTime() ) {
      AliSplineFit *f = st->GetFit();
      if (f) { // ok, looks like we have valid data/info
	// let's check what the expected value at the time appears to be
	double val = f->Eval(timeHour);
	average += val;
	n++;
      }
    } // time
  } // loop over fTempArray
  
  if (n>0) { // some valid data was found
    average /= n;
    return average;
  }
  else { // no good data
    return fkErrorCode;
  }

}

//________________________________________________________________
double AliEMCALCalibTimeDep::GetTemperatureSM(int imod, UInt_t timeStamp) const
{// return estimate for this one SuperModule, if it had data 

  // first convert from seconds to hours..
  double timeHour = (timeStamp - fStartTime) * fkSecToHour;

  double average = 0;
  int n = 0;

  for (int i=0; i<fTempArray->NumSensors(); i++) {
    
    AliEMCALSensorTemp *st = fTempArray->GetSensor(i);
    int module = st->GetSector()*2 + st->GetSide();
    if ( module == imod ) { // right module
      // check if we had valid data for the time that is being asked for
      if ( timeStamp>=st->GetStartTime() && timeStamp<=st->GetEndTime() ) {
	AliSplineFit *f = st->GetFit();
	if (f) { // ok, looks like we have valid data/info
	  // let's check what the expected value at the time appears to be
	  double val = f->Eval(timeHour);
	  cout << " i " << i << " val " << val << endl;
	  average += val;
	  n++;
	}
      } // time
    }
    
  } // loop over fTempArray
  
  if (n>0) { // some valid data was found
    average /= n;
    return average;
  }
  else { // no good data
    return fkErrorCode;
  }

}

//________________________________________________________________
double AliEMCALCalibTimeDep::GetTemperatureSMSensor(int imod, int isens, UInt_t timeStamp) const
{// return estimate for this one SuperModule and sensor, if it had data 

  // first convert from seconds to hours..
  double timeHour = (timeStamp - fStartTime) * fkSecToHour;

  for (int i=0; i<fTempArray->NumSensors(); i++) {
    
    AliEMCALSensorTemp *st = fTempArray->GetSensor(i);
    int module = st->GetSector()*2 + st->GetSide();
    if ( module == imod && st->GetNum()==isens ) { // right module, and sensor
      // check if we had valid data for the time that is being asked for
      if ( timeStamp>=st->GetStartTime() && timeStamp<=st->GetEndTime() ) {
	AliSplineFit *f = st->GetFit();
	if (f) { // ok, looks like we have valid data/info
	  // let's check what the expected value at the time appears to be
	  double val = f->Eval(timeHour);

	  return val; // no point to move further in for loop, we have found the sensor we were looking for
	}
      } // time
    }
    
  } // loop over fTempArray
  
  // if we made it all here, it means that we didn't find the sensor we were looking for
  // i.e. no good data
  return fkErrorCode;

}

//________________________________________________________________
double AliEMCALCalibTimeDep::GetCorrection(double temperature) const
{ // gain decreases with increasing temperature
  double gain = (1.0 - (temperature-fRefTemp)*fkTempSlope);  
  // i.e. multiplicative correction to ADC increases with increasing temperature
  return 1.0/gain;
}

/* Next comes the method that does the work in picking up all the needed info..*/
//________________________________________________________________
void AliEMCALCalibTimeDep::GetTemperatureInfo() 
{
  // pick up Preprocessor output, based on fRun (most recent version)
  AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/Temperature", fRun);
  if (entry) {
    fTempArray = (AliEMCALSensorTempArray *) entry->GetObject();
  }

  if (fTempArray) { 
    AliInfo( Form("NumSensors %d - IdDCS: first %d last %d",
		  fTempArray->NumSensors(),
		  fTempArray->GetFirstIdDCS(), fTempArray->GetLastIdDCS() ) );
  }
  else {
    AliWarning( Form("AliEMCALSensorTempArray not found!") );
  }
  
  return;
}
Commit	Line	Data
a42992b7	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	/* $Id: AliEMCALCalibTimeDep.cxx $ */
	17
	18	//_________________________________________________________________________
	19	///*-- Author:
	20	///////////////////////////////////////////////////////////////////////////////
	21	// //
	22	// class for EMCAL time-dep calibration //
	23	// //
	24	///////////////////////////////////////////////////////////////////////////////
	25
	26	#include <iostream>
	27	#include <TGraphSmooth.h>
	28	#include "AliLog.h"
	29	#include "AliCDBEntry.h"
	30	#include "AliCDBManager.h"
	31	#include "AliEMCALSensorTempArray.h"
	32	#include "AliEMCALCalibTimeDep.h"
	33
	34	/* first a bunch of constants.. */
	35	const double fkSecToHour = 1.0/3600.0; // conversion factor from seconds to hours
	36
	37	// some global variables for APD handling; assume the same for all, at least to start with
bee992bc	38	const double fkTempSlope = 0.017; // 1.7% per deg. C, seems about right for all APDs, from studies at Catania, and by Rachid.
	39	// Note that this is only valid at gain M~30; i.e. voltages at V30.
	40	// At V50, it's more like 2.25%/C, and at V20 about 1.35%/C (also info from Catania)
a42992b7	41	const double fkNormTemp = 20; // let's say that 20 degrees C is normal as default
a42992b7	42
621ff010	43	const double fkErrorCode = -999; // to indicate that something went wrong
621ff010	44
a42992b7	45	using namespace std;
	46
	47	ClassImp(AliEMCALCalibTimeDep)
	48
	49	//________________________________________________________________
	50	AliEMCALCalibTimeDep::AliEMCALCalibTimeDep() :
	51	fRun(0),
	52	fStartTime(0),
	53	fEndTime(0),
	54	fMinTemp(0),
	55	fMaxTemp(0),
	56	fMinTime(0),
	57	fMaxTime(0),
	58	fRefTemp(fkNormTemp),
	59	fTempArray(NULL)
	60	{
	61	// Constructor
	62	}
	63
	64	//________________________________________________________________
	65	AliEMCALCalibTimeDep::AliEMCALCalibTimeDep(const AliEMCALCalibTimeDep& calibt) :
621ff010	66	TObject(calibt),
a42992b7	67	fRun(calibt.GetRunNumber()),
	68	fStartTime(calibt.GetStartTime()),
	69	fEndTime(calibt.GetEndTime()),
	70	fMinTemp(calibt.GetMinTemp()),
	71	fMaxTemp(calibt.GetMaxTemp()),
	72	fMinTime(calibt.GetMinTime()),
	73	fMaxTime(calibt.GetMaxTime()),
	74	fRefTemp(calibt.GetRefTemp()),
	75	fTempArray(calibt.GetTempArray())
	76	{
	77	// copy constructor
	78	}
	79
	80
	81	//________________________________________________________________
	82	AliEMCALCalibTimeDep &AliEMCALCalibTimeDep::operator =(const AliEMCALCalibTimeDep& calibt)
	83	{
	84	// assignment operator; use copy ctor
	85	if (&calibt == this) return *this;
	86
	87	new (this) AliEMCALCalibTimeDep(calibt);
	88	return *this;
	89	}
	90
	91	//________________________________________________________________
	92	AliEMCALCalibTimeDep::~AliEMCALCalibTimeDep()
	93	{
	94	// Destructor
	95	}
	96
	97	//________________________________________________________________
	98	void AliEMCALCalibTimeDep::Reset()
	99	{
	100	// clear variables to default
	101	fRun = 0;
	102	fStartTime = 0;
	103	fEndTime = 0;
	104	fMinTemp = 0;
	105	fMaxTemp = 0;
	106	fMinTime = 0;
	107	fMaxTime = 0;
	108	fRefTemp = fkNormTemp;
	109	fTempArray = NULL;
	110	return;
	111	}
	112
	113	//________________________________________________________________
621ff010	114	void AliEMCALCalibTimeDep::PrintInfo() const
a42992b7	115	{
	116	// print some info
	117	cout << endl << " AliEMCALCalibTimeDep::Print() " << endl;
	118	// basic variables, all 'publicly available' also
	119	cout << " VARIABLE DUMP: " << endl
	120	<< " GetStartTime() " << GetStartTime() << endl
	121	<< " GetEndTime() " << GetEndTime() << endl
	122	<< " GetMinTemp() " << GetMinTemp() << endl
	123	<< " GetMaxTemp() " << GetMaxTemp() << endl
	124	<< " GetRefTemp() " << GetRefTemp() << endl;
	125	// run ranges
	126	cout << " RUN INFO: " << endl
	127	<< " length (in hours) " << GetLengthOfRunInHours() << endl
	128	<< " range of temperature measurements (in hours) " << GetRangeOfTempMeasureInHours()
	129	<< " (in deg. C) " << GetRangeOfTempMeasureInDegrees()
	130	<< endl;
	131	// range in correction values
	132	double corrAtMinTemp = GetCorrection( fMinTemp );
	133	double corrAtMaxTemp = GetCorrection( fMaxTemp );
	134	double corrMaxMinDiff = 100*(corrAtMinTemp - corrAtMaxTemp);
	135	cout << " CORRECTION INFO : " << endl
	136	<< " corrAtMinTemp " << corrAtMinTemp << endl
	137	<< " corrAtMaxTemp " << corrAtMaxTemp << endl
	138	<< " corrMaxMinDiff (~%) [=(corrAtMin - corrAtMax)*100] "
	139	<< corrMaxMinDiff << endl;
	140
	141	return;
	142	}
	143	//________________________________________________________________
	144	double AliEMCALCalibTimeDep::GetLengthOfRunInHours() const
	145	{
	146	return (fEndTime - fStartTime)*fkSecToHour;
	147	}
	148	//________________________________________________________________
	149	double AliEMCALCalibTimeDep::GetRangeOfTempMeasureInHours() const
	150	{
	151	return (fMaxTime - fMinTime)*fkSecToHour;
	152	}
	153	//________________________________________________________________
	154	double AliEMCALCalibTimeDep::GetRangeOfTempMeasureInDegrees() const
	155	{
	156	return (fMaxTemp - fMinTemp);
	157	}
	158
	159	//________________________________________________________________
	160	void AliEMCALCalibTimeDep::Initialize(Int_t run,
	161	UInt_t startTime, UInt_t endTime)
	162	{
	163	Reset(); // start fresh
	164
	165	fRun = run;
	166	fStartTime = startTime;
	167	fEndTime = endTime;
	168
	169	// collect the needed information
	170	GetTemperatureInfo(); // temperature readings during the run
	171
	172	return;
	173	}
	174
	175	//________________________________________________________________
621ff010	176	double AliEMCALCalibTimeDep::GetTemperature(UInt_t timeStamp) const
a42992b7	177	{// return estimate for all SuperModules and sensors, that had data
	178
	179	// first convert from seconds to hours..
621ff010	180	double timeHour = (timeStamp - fStartTime) * fkSecToHour;
	181
	182	double average = 0;
	183	int n = 0;
	184
	185	for (int i=0; i<fTempArray->NumSensors(); i++) {
	186
	187	AliEMCALSensorTemp *st = fTempArray->GetSensor(i);
	188
	189	// check if we had valid data for the time that is being asked for
	190	if ( timeStamp>=st->GetStartTime() && timeStamp<=st->GetEndTime() ) {
	191	AliSplineFit *f = st->GetFit();
	192	if (f) { // ok, looks like we have valid data/info
	193	// let's check what the expected value at the time appears to be
	194	double val = f->Eval(timeHour);
	195	average += val;
	196	n++;
	197	}
	198	} // time
	199	} // loop over fTempArray
	200
	201	if (n>0) { // some valid data was found
	202	average /= n;
	203	return average;
	204	}
	205	else { // no good data
	206	return fkErrorCode;
	207	}
a42992b7	208
a42992b7	209	}
	210
	211	//________________________________________________________________
621ff010	212	double AliEMCALCalibTimeDep::GetTemperatureSM(int imod, UInt_t timeStamp) const
a42992b7	213	{// return estimate for this one SuperModule, if it had data
	214
	215	// first convert from seconds to hours..
621ff010	216	double timeHour = (timeStamp - fStartTime) * fkSecToHour;
	217
	218	double average = 0;
	219	int n = 0;
	220
	221	for (int i=0; i<fTempArray->NumSensors(); i++) {
	222
	223	AliEMCALSensorTemp *st = fTempArray->GetSensor(i);
	224	int module = st->GetSector()*2 + st->GetSide();
	225	if ( module == imod ) { // right module
	226	// check if we had valid data for the time that is being asked for
	227	if ( timeStamp>=st->GetStartTime() && timeStamp<=st->GetEndTime() ) {
	228	AliSplineFit *f = st->GetFit();
	229	if (f) { // ok, looks like we have valid data/info
	230	// let's check what the expected value at the time appears to be
	231	double val = f->Eval(timeHour);
	232	cout << " i " << i << " val " << val << endl;
	233	average += val;
	234	n++;
	235	}
	236	} // time
	237	}
	238
	239	} // loop over fTempArray
	240
	241	if (n>0) { // some valid data was found
	242	average /= n;
	243	return average;
	244	}
	245	else { // no good data
	246	return fkErrorCode;
	247	}
a42992b7	248
a42992b7	249	}
	250
	251	//________________________________________________________________
621ff010	252	double AliEMCALCalibTimeDep::GetTemperatureSMSensor(int imod, int isens, UInt_t timeStamp) const
a42992b7	253	{// return estimate for this one SuperModule and sensor, if it had data
621ff010	254
a42992b7	255	// first convert from seconds to hours..
621ff010	256	double timeHour = (timeStamp - fStartTime) * fkSecToHour;
	257
	258	for (int i=0; i<fTempArray->NumSensors(); i++) {
	259
	260	AliEMCALSensorTemp *st = fTempArray->GetSensor(i);
	261	int module = st->GetSector()*2 + st->GetSide();
	262	if ( module == imod && st->GetNum()==isens ) { // right module, and sensor
	263	// check if we had valid data for the time that is being asked for
	264	if ( timeStamp>=st->GetStartTime() && timeStamp<=st->GetEndTime() ) {
	265	AliSplineFit *f = st->GetFit();
	266	if (f) { // ok, looks like we have valid data/info
	267	// let's check what the expected value at the time appears to be
	268	double val = f->Eval(timeHour);
	269
	270	return val; // no point to move further in for loop, we have found the sensor we were looking for
	271	}
	272	} // time
	273	}
	274
	275	} // loop over fTempArray
a42992b7	276
621ff010	277	// if we made it all here, it means that we didn't find the sensor we were looking for
	278	// i.e. no good data
	279	return fkErrorCode;
	280
a42992b7	281	}
	282
	283	//________________________________________________________________
	284	double AliEMCALCalibTimeDep::GetCorrection(double temperature) const
	285	{ // gain decreases with increasing temperature
	286	double gain = (1.0 - (temperature-fRefTemp)*fkTempSlope);
	287	// i.e. multiplicative correction to ADC increases with increasing temperature
	288	return 1.0/gain;
	289	}
	290
	291	/* Next comes the method that does the work in picking up all the needed info..*/
	292	//________________________________________________________________
	293	void AliEMCALCalibTimeDep::GetTemperatureInfo()
	294	{
	295	// pick up Preprocessor output, based on fRun (most recent version)
	296	AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/Temperature", fRun);
	297	if (entry) {
	298	fTempArray = (AliEMCALSensorTempArray *) entry->GetObject();
	299	}
	300
621ff010	301	if (fTempArray) {
a42992b7	302	AliInfo( Form("NumSensors %d - IdDCS: first %d last %d",
	303	fTempArray->NumSensors(),
	304	fTempArray->GetFirstIdDCS(), fTempArray->GetLastIdDCS() ) );
621ff010	305	}
	306	else {
	307	AliWarning( Form("AliEMCALSensorTempArray not found!") );
a42992b7	308	}
	309
	310	return;
	311	}