[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
const double fkNormTemp = 20; // let's say that 20 degrees C is normal as default

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) :
  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::Print() 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(int secSinceRunStart) const
{// return estimate for all SuperModules and sensors, that had data 

  // first convert from seconds to hours..
  double timeHour = secSinceRunStart * fkSecToHour;

  //  return fTempSpline->Eval(timeHour);
  return timeHour; // DStmp - FIXME - just return time for now
}

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

  // first convert from seconds to hours..
  double timeHour = secSinceRunStart * fkSecToHour;

  //  return fTempSpline->Eval(timeHour);
  return timeHour; // DStmp - FIXME - just return time for now
}

//________________________________________________________________
double AliEMCALCalibTimeDep::GetTemperatureSMSensor(int imod, int isens, int secSinceRunStart) const
{// return estimate for this one SuperModule and sensor, if it had data 
  // first convert from seconds to hours..
  double timeHour = secSinceRunStart * fkSecToHour;
  
  //  return fTempSpline->Eval(timeHour);
  return timeHour; // DStmp - FIXME - just return time for now
}

//________________________________________________________________
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) { // DStmp - FIXME - not implemented what should be done here yet
    AliInfo( Form("NumSensors %d - IdDCS: first %d last %d",
		  fTempArray->NumSensors(),
		  fTempArray->GetFirstIdDCS(), fTempArray->GetLastIdDCS() ) );

    /* // below is just examples on what could be done to access the data..
 
  AliEMCALSensorTemp *o = arr->GetSensor(0);
  o->Print();
  cout << " side " << o->GetSide()
       << " sector " << o->GetSector()
       << " num " << o->GetNum()
       << " startTime " << o->GetStartTime()
       << " endTime " << o->GetEndTime()
       << endl;

  AliSplineFit *f = o->GetFit();
  int np = 0;

  if (f) {
    f->SplineFit(0);

    np = f->GetKnots();
    cout << " np " << np << endl;
    Double_t *x = f->GetX();
    Double_t *y0 = f->GetY0();
    Double_t *y1 = f->GetY1();
    for (int i=0; i<np; i++) {
      cout << " i " << i
           << " x " << x[i]
           << " y0 " << y0[i]
           << " y1 " << y1[i]
           << endl;
      //      g->SetPoint(i, x[i], y0[i]);
    }
    double start = x[0];
    double stop = x[np-1];

    TGraph *g = f->MakeGraph(start, stop, np);
    f->MakeSmooth(g, ratio, "normal");
    np = f->GetKnots();
    cout << " np " << np << endl;
    TGraph *gSmooth = f->MakeGraph(start, stop, np);

  // compare the raw and smoothed versions and select one..
    // plot in 2 canvases/pads - CONTINUE HERE

    g->Draw("ALP");
    gSmooth->Draw("ALP");
    f->Draw();
    }

     */

  }
  
  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
	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	const double fkNormTemp = 20; // let's say that 20 degrees C is normal as default
	40
	41	using namespace std;
	42
	43	ClassImp(AliEMCALCalibTimeDep)
	44
	45	//________________________________________________________________
	46	AliEMCALCalibTimeDep::AliEMCALCalibTimeDep() :
	47	fRun(0),
	48	fStartTime(0),
	49	fEndTime(0),
	50	fMinTemp(0),
	51	fMaxTemp(0),
	52	fMinTime(0),
	53	fMaxTime(0),
	54	fRefTemp(fkNormTemp),
	55	fTempArray(NULL)
	56	{
	57	// Constructor
	58	}
	59
	60	//________________________________________________________________
	61	AliEMCALCalibTimeDep::AliEMCALCalibTimeDep(const AliEMCALCalibTimeDep& calibt) :
	62	fRun(calibt.GetRunNumber()),
	63	fStartTime(calibt.GetStartTime()),
	64	fEndTime(calibt.GetEndTime()),
65	fMinTemp(calibt.GetMinTemp()),
66	fMaxTemp(calibt.GetMaxTemp()),
67	fMinTime(calibt.GetMinTime()),
68	fMaxTime(calibt.GetMaxTime()),
69	fRefTemp(calibt.GetRefTemp()),
70	fTempArray(calibt.GetTempArray())
71	{
72	// copy constructor
73	}
74
75
76	//________________________________________________________________
77	AliEMCALCalibTimeDep &AliEMCALCalibTimeDep::operator =(const AliEMCALCalibTimeDep& calibt)
78	{
79	// assignment operator; use copy ctor
80	if (&calibt == this) return *this;
81
82	new (this) AliEMCALCalibTimeDep(calibt);
83	return *this;
84	}
85
86	//________________________________________________________________
87	AliEMCALCalibTimeDep::~AliEMCALCalibTimeDep()
88	{
89	// Destructor
90	}
91
92	//________________________________________________________________
93	void AliEMCALCalibTimeDep::Reset()
94	{
95	// clear variables to default
96	fRun = 0;
97	fStartTime = 0;
98	fEndTime = 0;
99	fMinTemp = 0;
100	fMaxTemp = 0;
101	fMinTime = 0;
102	fMaxTime = 0;
103	fRefTemp = fkNormTemp;
104	fTempArray = NULL;
105	return;
106	}
107
108	//________________________________________________________________
109	void AliEMCALCalibTimeDep::Print() const
110	{
111	// print some info
112	cout << endl << " AliEMCALCalibTimeDep::Print() " << endl;
113	// basic variables, all 'publicly available' also
114	cout << " VARIABLE DUMP: " << endl
115	<< " GetStartTime() " << GetStartTime() << endl
116	<< " GetEndTime() " << GetEndTime() << endl
117	<< " GetMinTemp() " << GetMinTemp() << endl
118	<< " GetMaxTemp() " << GetMaxTemp() << endl
119	<< " GetRefTemp() " << GetRefTemp() << endl;
120	// run ranges
121	cout << " RUN INFO: " << endl
122	<< " length (in hours) " << GetLengthOfRunInHours() << endl
123	<< " range of temperature measurements (in hours) " << GetRangeOfTempMeasureInHours()
124	<< " (in deg. C) " << GetRangeOfTempMeasureInDegrees()
125	<< endl;
126	// range in correction values
127	double corrAtMinTemp = GetCorrection( fMinTemp );
128	double corrAtMaxTemp = GetCorrection( fMaxTemp );
129	double corrMaxMinDiff = 100*(corrAtMinTemp - corrAtMaxTemp);
130	cout << " CORRECTION INFO : " << endl
131	<< " corrAtMinTemp " << corrAtMinTemp << endl
132	<< " corrAtMaxTemp " << corrAtMaxTemp << endl
133	<< " corrMaxMinDiff (~%) [=(corrAtMin - corrAtMax)*100] "
134	<< corrMaxMinDiff << endl;
135
136	return;
137	}
138	//________________________________________________________________
139	double AliEMCALCalibTimeDep::GetLengthOfRunInHours() const
140	{
141	return (fEndTime - fStartTime)*fkSecToHour;
142	}
143	//________________________________________________________________
144	double AliEMCALCalibTimeDep::GetRangeOfTempMeasureInHours() const
145	{
146	return (fMaxTime - fMinTime)*fkSecToHour;
147	}
148	//________________________________________________________________
149	double AliEMCALCalibTimeDep::GetRangeOfTempMeasureInDegrees() const
150	{
151	return (fMaxTemp - fMinTemp);
152	}
153
154	//________________________________________________________________
155	void AliEMCALCalibTimeDep::Initialize(Int_t run,
156	UInt_t startTime, UInt_t endTime)
157	{
158	Reset(); // start fresh
159
160	fRun = run;
161	fStartTime = startTime;
162	fEndTime = endTime;
163
164	// collect the needed information
165	GetTemperatureInfo(); // temperature readings during the run
166
167	return;
168	}
169
170	//________________________________________________________________
171	double AliEMCALCalibTimeDep::GetTemperature(int secSinceRunStart) const
172	{// return estimate for all SuperModules and sensors, that had data
173
174	// first convert from seconds to hours..
175	double timeHour = secSinceRunStart * fkSecToHour;
176
177	// return fTempSpline->Eval(timeHour);
178	return timeHour; // DStmp - FIXME - just return time for now
179	}
180
181	//________________________________________________________________
182	double AliEMCALCalibTimeDep::GetTemperatureSM(int imod, int secSinceRunStart) const
183	{// return estimate for this one SuperModule, if it had data
184
185	// first convert from seconds to hours..
186	double timeHour = secSinceRunStart * fkSecToHour;
187
188	// return fTempSpline->Eval(timeHour);
189	return timeHour; // DStmp - FIXME - just return time for now
190	}
191
192	//________________________________________________________________
193	double AliEMCALCalibTimeDep::GetTemperatureSMSensor(int imod, int isens, int secSinceRunStart) const
194	{// return estimate for this one SuperModule and sensor, if it had data
195	// first convert from seconds to hours..
196	double timeHour = secSinceRunStart * fkSecToHour;
197
198	// return fTempSpline->Eval(timeHour);
199	return timeHour; // DStmp - FIXME - just return time for now
200	}
201
202	//________________________________________________________________
203	double AliEMCALCalibTimeDep::GetCorrection(double temperature) const
204	{ // gain decreases with increasing temperature
205	double gain = (1.0 - (temperature-fRefTemp)*fkTempSlope);
206	// i.e. multiplicative correction to ADC increases with increasing temperature
207	return 1.0/gain;
208	}
209
210	/* Next comes the method that does the work in picking up all the needed info..*/
211	//________________________________________________________________
212	void AliEMCALCalibTimeDep::GetTemperatureInfo()
213	{
214	// pick up Preprocessor output, based on fRun (most recent version)
215	AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/Temperature", fRun);
216	if (entry) {
217	fTempArray = (AliEMCALSensorTempArray *) entry->GetObject();
218	}
219
220	if (fTempArray) { // DStmp - FIXME - not implemented what should be done here yet
221	AliInfo( Form("NumSensors %d - IdDCS: first %d last %d",
222	fTempArray->NumSensors(),
223	fTempArray->GetFirstIdDCS(), fTempArray->GetLastIdDCS() ) );
224
225	/* // below is just examples on what could be done to access the data..
226
227	AliEMCALSensorTemp *o = arr->GetSensor(0);
228	o->Print();
229	cout << " side " << o->GetSide()
230	<< " sector " << o->GetSector()
231	<< " num " << o->GetNum()
232	<< " startTime " << o->GetStartTime()
233	<< " endTime " << o->GetEndTime()
234	<< endl;
235
236	AliSplineFit *f = o->GetFit();
237	int np = 0;
238
239	if (f) {
240	f->SplineFit(0);
241
242	np = f->GetKnots();
243	cout << " np " << np << endl;
244	Double_t *x = f->GetX();
245	Double_t *y0 = f->GetY0();
246	Double_t *y1 = f->GetY1();
247	for (int i=0; i<np; i++) {
248	cout << " i " << i
249	<< " x " << x[i]
250	<< " y0 " << y0[i]
251	<< " y1 " << y1[i]
252	<< endl;
253	// g->SetPoint(i, x[i], y0[i]);
254	}
255	double start = x[0];
256	double stop = x[np-1];
257
258	TGraph *g = f->MakeGraph(start, stop, np);
259	f->MakeSmooth(g, ratio, "normal");
260	np = f->GetKnots();
261	cout << " np " << np << endl;
262	TGraph *gSmooth = f->MakeGraph(start, stop, np);
263
264	// compare the raw and smoothed versions and select one..
265	// plot in 2 canvases/pads - CONTINUE HERE
266
267	g->Draw("ALP");
268	gSmooth->Draw("ALP");
269	f->Draw();
270	}
271
272	*/
273
274	}
275
276	return;
277	}