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


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  TPC calibration class for temperature maps and tendencies                //
//  (based on TPC Temperature Sensors and FiniteElement Simulation)          //
//                                                                           //
//  Authors: Stefan Rossegger, Haavard Helstrup                              //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "AliTPCSensorTempArray.h"
#include "TLinearFitter.h"
#include "TString.h"
#include "TGraph2D.h"

#include "AliTPCTempMap.h"


ClassImp(AliTPCTempMap)
  
  const char kStringFEsimulation[] = "FEsimulation.txt";

//_____________________________________________________________________________
AliTPCTempMap::AliTPCTempMap(AliTPCSensorTempArray *sensorDCS):
  TNamed(),
  ft(0),
  fStringFEsimulation(kStringFEsimulation)
{
  //
  // AliTPCTempMap default constructor
  //

  ft = sensorDCS;

}

//_____________________________________________________________________________
AliTPCTempMap::AliTPCTempMap(const AliTPCTempMap &c):
  TNamed(c),
  ft(c.ft),
  fStringFEsimulation(c.fStringFEsimulation)
{
  //
  // AliTPCTempMap copy constructor
  //

}

//_____________________________________________________________________________
AliTPCTempMap::~AliTPCTempMap()
{
  //
  // AliTPCTempMap destructor
  //
  
}

//_____________________________________________________________________________
AliTPCTempMap &AliTPCTempMap::operator=(const AliTPCTempMap &c)
{
  //
  // Assignment operator
  //

  if (this != &c) ((AliTPCTempMap &) c).Copy(*this);
  return *this;

}

//_____________________________________________________________________________
void AliTPCTempMap::Copy(TObject &c) const
{
  //
  // Copy function
  //
  
  TObject::Copy(c);
  
}

//_____________________________________________________________________________

Double_t AliTPCTempMap::GetTempGradientY(UInt_t timeSec, Int_t side){
 //
 // Extract Linear Vertical Temperature Gradient [K/cm] within the TPC on 
 // Shaft Side(A): 0
 // Muon  Side(C): 1
 // Values based on TemperatureSensors within the TPC ( type: 3 (TPC) )
 //
 // FIXME: Also return residual-distribution, covariance Matrix
 //        or simply chi2 for validity check? 
 //        -> better use GetLinearFitter - function in this case!
  
 TLinearFitter fitter(3,"x0++x1++x2");
 TVectorD param(3);
 Int_t i = 0;

 Int_t nsensors = ft->NumSensors();
 for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over all sensors
   AliTPCSensorTemp *entry = (AliTPCSensorTemp*)ft->GetSensorNum(isensor);
   
   if (entry->GetType()==3 && entry->GetSide()==side) { // take SensorType:TPC 
     Double_t x[3];
     x[0]=1;
     x[1]=entry->GetX();
     x[2]=entry->GetY();    
     Double_t y = entry->GetValue(timeSec); // get temperature value
     fitter.AddPoint(x,y,1); // add values to LinearFitter
     i++;
   }

 }  
 fitter.Eval();
 fitter.GetParameters(param);
 fitter.~TLinearFitter();

 return param[2]; // return vertical (Y) tempGradient in [K/cm]
  
}

//_____________________________________________________________________________

TLinearFitter *AliTPCTempMap::GetLinearFitter(Int_t type, Int_t side, UInt_t timeSec)
{
  // 
  // Creates a TlinearFitter object for the desired region of the TPC 
  // (via choosen type and side of TPC temperature sensors) at a given 
  // timeSec (in secounds) after start time
  // type: 0 ... ReadOutChambers (ROC)
  //       1 ... OuterContainmentVessel (OFC)
  //       2 ... InnerContainmentVessel (IFC) + ThermalScreener (TS)
  //       3 ... Within the TPC (DriftVolume) (TPC)
  // side: Can be choosen for type 0 and 3 (otherwise it will be ignored in 
  //       in order to get all temperature sensors of interest)
  //       0 ... Shaft Side (A)
  //       1 ... Muon Side (C)
  // 

  TLinearFitter *fitter = new TLinearFitter(3);
  Double_t *x = new Double_t[3];
  Double_t y = 0;

  if (type == 1 || type == 2) {
    fitter->SetFormula("x0++x1++TMath::Sin(x2)"); // returns Z,Y gradient
  } else {
    fitter->SetFormula("x0++x1++x2"); // returns X,Y gradient
  }

  Int_t i = 0;
  Int_t nsensors = ft->NumSensors();
  for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over all sensors
    AliTPCSensorTemp *entry = (AliTPCSensorTemp*)ft->GetSensorNum(isensor);
    
    if (type==0 || type==3) { // 'side' information used
      if (entry->GetType()==type && entry->GetSide()==side) {
	x[0]=1;
	x[1]=entry->GetX();
	x[2]=entry->GetY();    
	y = entry->GetValue(timeSec); // get temperature value
	fitter->AddPoint(x,y,1); // add values to LinearFitter
	i++;
      }
    } else if (type==2) { // in case of IFC also usage of TS values
      if ((entry->GetType()==2) || (entry->GetType()==5)) {
	x[0]=1;
	x[1]=entry->GetZ();
	x[2]=entry->GetPhi();    
	y = entry->GetValue(timeSec);
	fitter->AddPoint(x,y,1); 
	i++;
      }
    } else if (type==1){
      if (entry->GetType()==type) {
	x[0]=1;
	x[1]=entry->GetZ();
	x[2]=entry->GetPhi();    
	y = entry->GetValue(timeSec);
	fitter->AddPoint(x,y,1);
	i++;	
      }
    }
  }  
  fitter->Eval(); // Evaluates fitter
  
  delete [] x;

  return fitter; 

  // returns TLinearFitter object where Chi2, Fitparameters and residuals can 
  // be extracted via usual memberfunctions
  // example: fitter.GetParameters(param)
  // In case of type IFC or OFC, the parameters are the gradients in 
  // Z and Y direction (see fitformula)
  // Caution: Parameters are [K/cm] except Y at IFC,OFC ([K/radius]) 
}

//_____________________________________________________________________________

TGraph2D *AliTPCTempMap::GetTempMapsViaSensors(Int_t type, Int_t side, UInt_t timeSec)
{
  // 
  // Creates a TGraph2D object for the desired region of the TPC 
  // (via choosen type and side of TPC temperature sensors) at a given 
  // timeSec (in secounds) after start time
  // type: 0 ... ReadOutChambers (ROC)
  //       1 ... OuterContainmentVessel (OFC)
  //       2 ... InnerContainmentVessel (IFC) + ThermalScreener (TS)
  //       3 ... Within the TPC (DriftVolume) (TPC)
  // side: Can be choosen for type 0 and 3 (otherwise it will be ignored in 
  //       in order to get all temperature sensors of interest)
  //       0 ... Shaft Side (A)
  //       1 ... Muon Side (C)
  // 

  TGraph2D *graph2D = new TGraph2D();

  Int_t i = 0;
  

  Int_t nsensors = ft->NumSensors();

 
  for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over all sensors
    AliTPCSensorTemp *entry = (AliTPCSensorTemp*)ft->GetSensorNum(isensor);

    Double_t x, y, z, r, phi, tempValue;
    x = entry->GetX();
    y = entry->GetY();
    z = entry->GetZ();
    r = entry->GetR();
    phi = entry->GetPhi();
    tempValue = entry->GetValue(timeSec);

    if (type==0 || type==3) { // 'side' information used
      if (entry->GetType()==type && entry->GetSide()==side) {
	graph2D->SetPoint(i,x,y,tempValue);
	i++;
      }
    } else if (type==2) { // in case of IFC also usage of TS values
      if (entry->GetType()==2 || entry->GetType()==5) {
	graph2D->SetPoint(i,z,phi,tempValue);
	i++;
      }
    } else if (type==1){
      if (entry->GetType()==type) {
	graph2D->SetPoint(i,z,phi,tempValue);
	i++;
      }
    }
  }  
  
  if (type==0 || type==3) {
    graph2D->GetXaxis()->SetTitle("X[cm]");
    graph2D->GetYaxis()->SetTitle("Y[cm]");
    if (type==0 && side==0) {
      graph2D->SetTitle("ROC A - Endplate Shaft Side");
    } else if (type==0 && side==1) {
      graph2D->SetTitle("ROC C - Endplate Muon Side");
    } else if (type==3 && side==0) {
      graph2D->SetTitle("TPC A - Inside the TPC Shaft Side");
    } else if (type==3 && side==1) {
      graph2D->SetTitle("TPC C - Inside the TPC Muon Side");
    }
  } else if (type==1 || type==2) {
    graph2D->GetXaxis()->SetTitle("Z[cm]");
    graph2D->GetYaxis()->SetTitle("Phi[RAD]");
    if (type==1) {
      graph2D->SetTitle("Outer Containment Vessel");
    } else if (type==2) {
      graph2D->SetTitle("InnerContainmentVessel + ThermalScreeners");
    }
  }

  if (!graph2D->GetN()) {
    printf("Returned TGraph2D is empty: check type and side values\n");
  }

  graph2D->GetXaxis()->SetLabelOffset(0.0);
  graph2D->GetYaxis()->SetLabelOffset(0.005);
  graph2D->GetZaxis()->SetLabelOffset(-0.04);
  

  return graph2D; // returns TGgraph2D object
  
}


//_____________________________________________________________________________

TGraph *AliTPCTempMap::MakeGraphGradient(Int_t axis, Int_t side, Int_t nPoints)
{  
  //
  // Make graph from start time to end time of TempGradient in axis direction
  // axis: 0 ... horizontal Temperature Gradient (X)
  //       1 ... vertical Temperature Gradient (Y)
  //       2 ... longitudenal Temperature Gradient (Z) (side is ignored) 
  //             z gradient value based on OFC temperature sensors
  //             Caution!: better z gradient values through difference between 
  //             param[0] A- and param[0] C-side !
  // side for X and Y gradient: 
  //       0 ... Shaft Side (A)
  //       1 ... Muon Side (C)
  //
  
  TVectorD param(3);
  TLinearFitter *fitter = new TLinearFitter(3);

  UInt_t fStartTime = ft->AliTPCSensorTempArray::GetStartTime();
  UInt_t fEndTime = ft->AliTPCSensorTempArray::GetEndTime();
  
  UInt_t stepTime = (fEndTime-fStartTime)/nPoints;

  Double_t *x = new Double_t[nPoints];
  Double_t *y = new Double_t[nPoints];
  for (Int_t ip=0; ip<nPoints; ip++) {
    x[ip] = fStartTime+ip*stepTime;
    if (axis==2) {// Gradient in Z direction (based on OFC tempSensors)
      fitter = GetLinearFitter(1, side, ip*stepTime);
    } else {// Gradient in X or Y direction (based on TPC tempSensors)
      fitter = GetLinearFitter(3, side, ip*stepTime);
    }
    fitter->GetParameters(param);
    // multiplied by 500 since TempGradient is in [K/cm] 
    // (TPC diameter and length ~500cm)
    if (axis==1) { // Y axis
      y[ip] = param[2]*500;
    } else { // X axis
      y[ip] = param[1]*500;
    }
  }

  TGraph *graph = new TGraph(nPoints,x,y);

  fitter->~TLinearFitter(); 
  delete [] x;
  delete [] y;

  graph->GetXaxis()->SetTimeDisplay(1);
  graph->GetXaxis()->SetLabelOffset(0.02);
  graph->GetXaxis()->SetTimeFormat("#splitline{%d/%m}{%H:%M}");

  return graph;
}

//_____________________________________________________________________________

Double_t AliTPCTempMap::GetTemperature(Double_t x, Double_t y, Double_t z, UInt_t timeSec)
{  
  //
  // Returns estimated Temperature at given position (x,y,z) at given time 
  // (timeSec) after starttime
  // Method: so far just a linear interpolation between Linar fits of 
  //         the TPC temperature sensors
  //         FIXME: 'Educated Fit' through FiniteElement Simulation results!
  // FIXXME: Return 0? if x,y,z out of range
  //
  
  TVectorD paramA(3), paramC(3);
  TLinearFitter *fitterA = new TLinearFitter(3);
  TLinearFitter *fitterC = new TLinearFitter(3);

  fitterA = GetLinearFitter(3, 0, timeSec);
  fitterA->GetParameters(paramA);
  fitterC = GetLinearFitter(3, 1, timeSec);
  fitterC->GetParameters(paramC);

  Double_t fvalA = paramA[0]+paramA[1]*x+paramA[2]*y;
  Double_t fvalC = paramC[0]+paramC[1]*x+paramC[2]*y;

  Double_t k = (fvalA-fvalC)/(2*247);
  Double_t tempValue = fvalC+(fvalA-fvalC)/2+k*z;

  fitterA->~TLinearFitter();
  fitterC->~TLinearFitter();

  return tempValue;
}
Commit	Line	Data
1209231c	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	///////////////////////////////////////////////////////////////////////////////
	18	// //
	19	// TPC calibration class for temperature maps and tendencies //
	20	// (based on TPC Temperature Sensors and FiniteElement Simulation) //
	21	// //
	22	// Authors: Stefan Rossegger, Haavard Helstrup //
	23	// //
	24	///////////////////////////////////////////////////////////////////////////////
	25
	26	#include "AliTPCSensorTempArray.h"
	27	#include "TLinearFitter.h"
	28	#include "TString.h"
	29	#include "TGraph2D.h"
	30
	31	#include "AliTPCTempMap.h"
	32
	33
	34	ClassImp(AliTPCTempMap)
	35
	36	const char kStringFEsimulation[] = "FEsimulation.txt";
	37
	38	//_____________________________________________________________________________
	39	AliTPCTempMap::AliTPCTempMap(AliTPCSensorTempArray *sensorDCS):
	40	TNamed(),
	41	ft(0),
	42	fStringFEsimulation(kStringFEsimulation)
	43	{
	44	//
	45	// AliTPCTempMap default constructor
	46	//
	47
	48	ft = sensorDCS;
	49
	50	}
	51
	52	//_____________________________________________________________________________
	53	AliTPCTempMap::AliTPCTempMap(const AliTPCTempMap &c):
	54	TNamed(c),
	55	ft(c.ft),
	56	fStringFEsimulation(c.fStringFEsimulation)
	57	{
	58	//
	59	// AliTPCTempMap copy constructor
	60	//
	61
	62	}
	63
	64	//_____________________________________________________________________________
65	AliTPCTempMap::~AliTPCTempMap()
66	{
67	//
68	// AliTPCTempMap destructor
69	//
70
71	}
72
73	//_____________________________________________________________________________
74	AliTPCTempMap &AliTPCTempMap::operator=(const AliTPCTempMap &c)
75	{
76	//
77	// Assignment operator
78	//
79
80	if (this != &c) ((AliTPCTempMap &) c).Copy(*this);
81	return *this;
82
83	}
84
85	//_____________________________________________________________________________
86	void AliTPCTempMap::Copy(TObject &c) const
87	{
88	//
89	// Copy function
90	//
91
92	TObject::Copy(c);
93
94	}
95
96	//_____________________________________________________________________________
97
98	Double_t AliTPCTempMap::GetTempGradientY(UInt_t timeSec, Int_t side){
99	//
100	// Extract Linear Vertical Temperature Gradient [K/cm] within the TPC on
101	// Shaft Side(A): 0
102	// Muon Side(C): 1
103	// Values based on TemperatureSensors within the TPC ( type: 3 (TPC) )
104	//
105	// FIXME: Also return residual-distribution, covariance Matrix
106	// or simply chi2 for validity check?
107	// -> better use GetLinearFitter - function in this case!
108
109	TLinearFitter fitter(3,"x0++x1++x2");
110	TVectorD param(3);
111	Int_t i = 0;
112
113	Int_t nsensors = ft->NumSensors();
114	for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over all sensors
115	AliTPCSensorTemp entry = (AliTPCSensorTemp)ft->GetSensorNum(isensor);
116
117	if (entry->GetType()==3 && entry->GetSide()==side) { // take SensorType:TPC
118	Double_t x[3];
119	x[0]=1;
120	x[1]=entry->GetX();
121	x[2]=entry->GetY();
122	Double_t y = entry->GetValue(timeSec); // get temperature value
123	fitter.AddPoint(x,y,1); // add values to LinearFitter
124	i++;
125	}
126
127	}
128	fitter.Eval();
129	fitter.GetParameters(param);
130	fitter.~TLinearFitter();
131
132	return param[2]; // return vertical (Y) tempGradient in [K/cm]
133
134	}
135
136	//_____________________________________________________________________________
137
138	TLinearFitter *AliTPCTempMap::GetLinearFitter(Int_t type, Int_t side, UInt_t timeSec)
139	{
140	//
141	// Creates a TlinearFitter object for the desired region of the TPC
142	// (via choosen type and side of TPC temperature sensors) at a given
143	// timeSec (in secounds) after start time
144	// type: 0 ... ReadOutChambers (ROC)
145	// 1 ... OuterContainmentVessel (OFC)
146	// 2 ... InnerContainmentVessel (IFC) + ThermalScreener (TS)
147	// 3 ... Within the TPC (DriftVolume) (TPC)
148	// side: Can be choosen for type 0 and 3 (otherwise it will be ignored in
149	// in order to get all temperature sensors of interest)
150	// 0 ... Shaft Side (A)
151	// 1 ... Muon Side (C)
152	//
153
154	TLinearFitter *fitter = new TLinearFitter(3);
155	Double_t *x = new Double_t[3];
156	Double_t y = 0;
157
158	if (type == 1 \|\| type == 2) {
159	fitter->SetFormula("x0++x1++TMath::Sin(x2)"); // returns Z,Y gradient
160	} else {
161	fitter->SetFormula("x0++x1++x2"); // returns X,Y gradient
162	}
163
164	Int_t i = 0;
165	Int_t nsensors = ft->NumSensors();
166	for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over all sensors
167	AliTPCSensorTemp entry = (AliTPCSensorTemp)ft->GetSensorNum(isensor);
168
169	if (type==0 \|\| type==3) { // 'side' information used
170	if (entry->GetType()==type && entry->GetSide()==side) {
171	x[0]=1;
172	x[1]=entry->GetX();
173	x[2]=entry->GetY();
174	y = entry->GetValue(timeSec); // get temperature value
175	fitter->AddPoint(x,y,1); // add values to LinearFitter
176	i++;
177	}
178	} else if (type==2) { // in case of IFC also usage of TS values
179	if ((entry->GetType()==2) \|\| (entry->GetType()==5)) {
180	x[0]=1;
181	x[1]=entry->GetZ();
182	x[2]=entry->GetPhi();
183	y = entry->GetValue(timeSec);
184	fitter->AddPoint(x,y,1);
185	i++;
186	}
187	} else if (type==1){
188	if (entry->GetType()==type) {
189	x[0]=1;
190	x[1]=entry->GetZ();
191	x[2]=entry->GetPhi();
192	y = entry->GetValue(timeSec);
193	fitter->AddPoint(x,y,1);
194	i++;
195	}
196	}
197	}
198	fitter->Eval(); // Evaluates fitter
199
200	delete [] x;
201
202	return fitter;
203
204	// returns TLinearFitter object where Chi2, Fitparameters and residuals can
205	// be extracted via usual memberfunctions
206	// example: fitter.GetParameters(param)
207	// In case of type IFC or OFC, the parameters are the gradients in
208	// Z and Y direction (see fitformula)
209	// Caution: Parameters are [K/cm] except Y at IFC,OFC ([K/radius])
210	}
211
212	//_____________________________________________________________________________
213
214	TGraph2D *AliTPCTempMap::GetTempMapsViaSensors(Int_t type, Int_t side, UInt_t timeSec)
215	{
216	//
217	// Creates a TGraph2D object for the desired region of the TPC
218	// (via choosen type and side of TPC temperature sensors) at a given
219	// timeSec (in secounds) after start time
220	// type: 0 ... ReadOutChambers (ROC)
221	// 1 ... OuterContainmentVessel (OFC)
222	// 2 ... InnerContainmentVessel (IFC) + ThermalScreener (TS)
223	// 3 ... Within the TPC (DriftVolume) (TPC)
224	// side: Can be choosen for type 0 and 3 (otherwise it will be ignored in
225	// in order to get all temperature sensors of interest)
226	// 0 ... Shaft Side (A)
227	// 1 ... Muon Side (C)
228	//
229
230	TGraph2D *graph2D = new TGraph2D();
231
232	Int_t i = 0;
233
234
235	Int_t nsensors = ft->NumSensors();
236
237
238	for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over all sensors
239	AliTPCSensorTemp entry = (AliTPCSensorTemp)ft->GetSensorNum(isensor);
240
241	Double_t x, y, z, r, phi, tempValue;
242	x = entry->GetX();
243	y = entry->GetY();
244	z = entry->GetZ();
245	r = entry->GetR();
246	phi = entry->GetPhi();
247	tempValue = entry->GetValue(timeSec);
248
249	if (type==0 \|\| type==3) { // 'side' information used
250	if (entry->GetType()==type && entry->GetSide()==side) {
251	graph2D->SetPoint(i,x,y,tempValue);
252	i++;
253	}
254	} else if (type==2) { // in case of IFC also usage of TS values
255	if (entry->GetType()==2 \|\| entry->GetType()==5) {
256	graph2D->SetPoint(i,z,phi,tempValue);
257	i++;
258	}
259	} else if (type==1){
260	if (entry->GetType()==type) {
261	graph2D->SetPoint(i,z,phi,tempValue);
262	i++;
263	}
264	}
265	}
266
267	if (type==0 \|\| type==3) {
268	graph2D->GetXaxis()->SetTitle("X[cm]");
269	graph2D->GetYaxis()->SetTitle("Y[cm]");
270	if (type==0 && side==0) {
271	graph2D->SetTitle("ROC A - Endplate Shaft Side");
272	} else if (type==0 && side==1) {
273	graph2D->SetTitle("ROC C - Endplate Muon Side");
274	} else if (type==3 && side==0) {
275	graph2D->SetTitle("TPC A - Inside the TPC Shaft Side");
276	} else if (type==3 && side==1) {
277	graph2D->SetTitle("TPC C - Inside the TPC Muon Side");
278	}
279	} else if (type==1 \|\| type==2) {
280	graph2D->GetXaxis()->SetTitle("Z[cm]");
281	graph2D->GetYaxis()->SetTitle("Phi[RAD]");
282	if (type==1) {
283	graph2D->SetTitle("Outer Containment Vessel");
284	} else if (type==2) {
285	graph2D->SetTitle("InnerContainmentVessel + ThermalScreeners");
286	}
287	}
288
289	if (!graph2D->GetN()) {
290	printf("Returned TGraph2D is empty: check type and side values\n");
291	}
292
293	graph2D->GetXaxis()->SetLabelOffset(0.0);
294	graph2D->GetYaxis()->SetLabelOffset(0.005);
295	graph2D->GetZaxis()->SetLabelOffset(-0.04);
296
297
298	return graph2D; // returns TGgraph2D object
299
300	}
301
302
303	//_____________________________________________________________________________
304
305	TGraph *AliTPCTempMap::MakeGraphGradient(Int_t axis, Int_t side, Int_t nPoints)
306	{
307	//
308	// Make graph from start time to end time of TempGradient in axis direction
309	// axis: 0 ... horizontal Temperature Gradient (X)
310	// 1 ... vertical Temperature Gradient (Y)
311	// 2 ... longitudenal Temperature Gradient (Z) (side is ignored)
312	// z gradient value based on OFC temperature sensors
313	// Caution!: better z gradient values through difference between
314	// param[0] A- and param[0] C-side !
315	// side for X and Y gradient:
316	// 0 ... Shaft Side (A)
317	// 1 ... Muon Side (C)
318	//
319
320	TVectorD param(3);
321	TLinearFitter *fitter = new TLinearFitter(3);
322
323	UInt_t fStartTime = ft->AliTPCSensorTempArray::GetStartTime();
324	UInt_t fEndTime = ft->AliTPCSensorTempArray::GetEndTime();
325
326	UInt_t stepTime = (fEndTime-fStartTime)/nPoints;
327
328	Double_t *x = new Double_t[nPoints];
329	Double_t *y = new Double_t[nPoints];
330	for (Int_t ip=0; ip<nPoints; ip++) {
331	x[ip] = fStartTime+ip*stepTime;
332	if (axis==2) {// Gradient in Z direction (based on OFC tempSensors)
333	fitter = GetLinearFitter(1, side, ip*stepTime);
334	} else {// Gradient in X or Y direction (based on TPC tempSensors)
335	fitter = GetLinearFitter(3, side, ip*stepTime);
336	}
337	fitter->GetParameters(param);
338	// multiplied by 500 since TempGradient is in [K/cm]
339	// (TPC diameter and length ~500cm)
340	if (axis==1) { // Y axis
341	y[ip] = param[2]*500;
342	} else { // X axis
343	y[ip] = param[1]*500;
344	}
345	}
346
347	TGraph *graph = new TGraph(nPoints,x,y);
348
349	fitter->~TLinearFitter();
350	delete [] x;
351	delete [] y;
352
353	graph->GetXaxis()->SetTimeDisplay(1);
354	graph->GetXaxis()->SetLabelOffset(0.02);
355	graph->GetXaxis()->SetTimeFormat("#splitline{%d/%m}{%H:%M}");
356
357	return graph;
358	}
359
360	//_____________________________________________________________________________
361
362	Double_t AliTPCTempMap::GetTemperature(Double_t x, Double_t y, Double_t z, UInt_t timeSec)
363	{
364	//
365	// Returns estimated Temperature at given position (x,y,z) at given time
366	// (timeSec) after starttime
367	// Method: so far just a linear interpolation between Linar fits of
368	// the TPC temperature sensors
369	// FIXME: 'Educated Fit' through FiniteElement Simulation results!
370	// FIXXME: Return 0? if x,y,z out of range
371	//
372
373	TVectorD paramA(3), paramC(3);
374	TLinearFitter *fitterA = new TLinearFitter(3);
375	TLinearFitter *fitterC = new TLinearFitter(3);
376
377	fitterA = GetLinearFitter(3, 0, timeSec);
378	fitterA->GetParameters(paramA);
379	fitterC = GetLinearFitter(3, 1, timeSec);
380	fitterC->GetParameters(paramC);
381
382	Double_t fvalA = paramA[0]+paramA[1]x+paramA[2]y;
383	Double_t fvalC = paramC[0]+paramC[1]x+paramC[2]y;
384
385	Double_t k = (fvalA-fvalC)/(2*247);
386	Double_t tempValue = fvalC+(fvalA-fvalC)/2+k*z;
387
388	fitterA->~TLinearFitter();
389	fitterC->~TLinearFitter();
390
391	return tempValue;
392	}
393