[u/mrichter/AliRoot.git] / TPC / CalibMacros / CalibEnv.C

/*
gSystem->AddIncludePath("-I$ALICE_ROOT/TPC");

gSystem->Load("libXrdClient.so");
gSystem->Load("libNetx.so");
if (!gGrid) TGrid::Connect("alien://",0,0,"t");


.L CalibEnv.C++
Init();
CalibEnv("listAll.txt");
TFile f("dcsTime.root")


*/

#include <iostream>
#include <fstream>
#include <AliCDBManager.h>
#include <AliCDBEntry.h>
#include <AliLog.h>
#include <AliMagF.h>
#include "AliTPCcalibDB.h"
#include "AliTPCAltroMapping.h"
#include "AliTPCExB.h"
#include "AliTPCCalROC.h"
#include "AliTPCCalPad.h"
#include "AliTPCSensorTempArray.h"
#include "AliGRPObject.h"
#include "AliTPCTransform.h"
#include "TFile.h"
#include "TKey.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TString.h"
#include "AliTPCCalPad.h"
#include "AliTPCCalibPulser.h"
#include "AliTPCCalibPedestal.h"
#include "AliTPCCalibCE.h"
#include "AliTPCExBFirst.h"
#include "TTreeStream.h"
#include "AliTPCTempMap.h"

void ProcessGoofie( AliDCSSensorArray* goofieArray, TVectorD & vecEntries, TVectorD & vecMedian, TVectorD &vecMean, TVectorD &vecRMS);

void Init(){
  //
  //
  //
  AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/Parameters","local://$ALICE_ROOT/OCDB");
  AliCDBManager::Instance()->SetSpecificStorage("GRP/GRP/Data","local:///lustre_alpha/alice/alien/alice/data/2008/LHC08d/OCDB/");
  AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/Temperature","local:///lustre_alpha/alice/alien/alice/data/2008/LHC08d/OCDB/");
  AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/HighVoltage","local:///lustre_alpha/alice/alien/alice/data/2008/LHC08d/OCDB/");
  AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/Goofie","local:///lustre_alpha/alice/alien/alice/data/2008/LHC08d/OCDB/");
  AliCDBManager::Instance()->SetRun(1);
}


void InitAlien(const char *path="LHC08b"){
  //
  //
  //
  TString alpath="alien://folder=/alice/data/2008/";
  alpath+=path;
  alpath+="/OCDB";
    
  AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/Parameters","local://$ALICE_ROOT/OCDB");
  AliCDBManager::Instance()->SetSpecificStorage("GRP/GRP/Data",alpath.Data());
  AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/Temperature",alpath.Data());
  AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/Goofie",alpath.Data());
  AliCDBManager::Instance()->SetRun(1);
}


void CalibEnv(const char * runList){
  //
  //
  //  
  AliTPCcalibDB * calibDB = AliTPCcalibDB::Instance();
  ifstream in;
  in.open(runList);
  Int_t irun=0;
  TTreeSRedirector *pcstream = new TTreeSRedirector("dcsTime.root");
  //  for (Int_t irun=startRun; irun<stopRun; irun++){
  while(in.good()) {
    in >> irun;
    if (irun==0) continue;
    printf("Processing run %d ...\n",irun);
    AliDCSSensor * sensorPressure = AliTPCcalibDB::Instance()->GetPressureSensor(irun);
    if (!sensorPressure) continue;
    AliTPCSensorTempArray * tempArray = AliTPCcalibDB::Instance()->GetTemperatureSensor(irun);
    AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray);
    AliDCSSensorArray* goofieArray = AliTPCcalibDB::Instance()->GetGoofieSensors(irun);
    //
    Int_t startTime = sensorPressure->GetStartTime();
    Int_t endTime = sensorPressure->GetEndTime();
    Int_t dtime = TMath::Max((endTime-startTime)/20,10*60);
    for (Int_t itime=startTime; itime<endTime; itime+=dtime){
      //
      TTimeStamp tstamp(itime); 
      Float_t valuePressure  = calibDB->GetPressure(tstamp,irun,0);
      Float_t valuePressure2 = calibDB->GetPressure(tstamp,irun,1);

      TLinearFitter * fitter = 0;
      TVectorD vecTemp[10];
      for (Int_t itype=0; itype<5; itype++)
	for (Int_t iside=0; iside<2; iside++){	  
	  fitter= tempMap->GetLinearFitter(itype,iside,tstamp);	  
	  if (!fitter) continue;
	  fitter->Eval(); 
	  fitter->GetParameters(vecTemp[itype+iside*5]);
	  delete fitter;
	} 
      
      
      TVectorD vecGoofie, vecEntries, vecMean, vecMedian,vecRMS;
      if (goofieArray){	
	vecGoofie.ResizeTo(goofieArray->NumSensors());
	ProcessGoofie(goofieArray, vecEntries ,vecMedian, vecMean, vecRMS);
	//
	for (Int_t isensor=0; isensor<goofieArray->NumSensors();isensor++){
	  AliDCSSensor *gsensor = goofieArray->GetSensor(isensor);
	  if (gsensor){
	    vecGoofie[isensor] = gsensor->GetValue(tstamp);
	  }
	}
      }
      Double_t ptrelative0 = AliTPCcalibDB::GetPTRelative(tstamp,irun,0);
      Double_t ptrelative1 = AliTPCcalibDB::GetPTRelative(tstamp,irun,1);
      //
      Double_t voltagesIROC[36]; 
      Double_t voltagesOROC[36]; 
      for(Int_t j=1; j<36; j++) voltagesIROC[j-1] = AliTPCcalibDB::Instance()->GetChamberHighVoltage(startTime, irun, j);
      for(Int_t j=36; j<72; j++) voltagesOROC[j-36] = AliTPCcalibDB::Instance()->GetChamberHighVoltage(startTime, irun, j);
      Double_t voltIROC = TMath::Median(36, voltagesIROC);
      Double_t voltOROC = TMath::Median(36, voltagesOROC);

      //tempMap->GetLinearFitter(0,0,itime);
      (*pcstream)<<"dcs"<<
	"run="<<irun<<
	"time="<<itime<<
	"voltageIROC="<<voltIROC<<
	"voltageOROC="<<voltOROC<<
	"ptrel0="<<ptrelative0<<
	"ptrel1="<<ptrelative1<<
	"goofie.="<<&vecGoofie<<
	"goofieE.="<<&vecEntries<<
	"goofieMean.="<<&vecMean<<
	"goofieMedian.="<<&vecMedian<<
	"goofieRMS.="<<&vecRMS<<
	"press="<<valuePressure<<
	"press2="<<valuePressure2<<
	"temp00.="<<&vecTemp[0]<<
	"temp10.="<<&vecTemp[1]<<
	"temp20.="<<&vecTemp[2]<<
	"temp30.="<<&vecTemp[3]<<
	"temp40.="<<&vecTemp[4]<<
	"temp01.="<<&vecTemp[5]<<
	"temp11.="<<&vecTemp[6]<<
	"temp21.="<<&vecTemp[7]<<
	"temp31.="<<&vecTemp[8]<<
	"temp41.="<<&vecTemp[9]<<
	"\n";
    }
  }
  delete pcstream;
}


void ProcessGoofie( AliDCSSensorArray* goofieArray, TVectorD & vecEntries, TVectorD & vecMedian, TVectorD &vecMean, TVectorD &vecRMS){
  /*
    
  1       TPC_ANODE_I_A00_STAT
  2       TPC_DVM_CO2
  3       TPC_DVM_DriftVelocity
  4       TPC_DVM_FCageHV
  5       TPC_DVM_GainFar
  6       TPC_DVM_GainNear
  7       TPC_DVM_N2
  8       TPC_DVM_NumberOfSparks
  9       TPC_DVM_PeakAreaFar
  10      TPC_DVM_PeakAreaNear
  11      TPC_DVM_PeakPosFar
  12      TPC_DVM_PeakPosNear
  13      TPC_DVM_PickupHV
  14      TPC_DVM_Pressure
  15      TPC_DVM_T1_Over_P
  16      TPC_DVM_T2_Over_P
  17      TPC_DVM_T_Over_P
  18      TPC_DVM_TemperatureS1
   */
  //
  //
  //  TVectorD  vecMedian; TVectorD  vecEntries; TVectorD  vecMean; TVectorD  vecRMS;
  Double_t kEpsilon=0.0000000001;
  Double_t kBig=100000000000.;
  Int_t nsensors = goofieArray->NumSensors();
  vecEntries.ResizeTo(nsensors);
  vecMedian.ResizeTo(nsensors);
  vecMean.ResizeTo(nsensors);
  vecRMS.ResizeTo(nsensors);
  TVectorF values;
  for (Int_t isensor=0; isensor<goofieArray->NumSensors();isensor++){
    AliDCSSensor *gsensor = goofieArray->GetSensor(isensor);
    if (gsensor &&  gsensor->GetGraph()){
      Int_t npoints = gsensor->GetGraph()->GetN();
      // filter zeroes
      values.ResizeTo(npoints);
      Int_t nused =0;
      for (Int_t ipoint=0; ipoint<npoints; ipoint++){
	if (TMath::Abs(gsensor->GetGraph()->GetY()[ipoint])>kEpsilon && 
	   TMath::Abs(gsensor->GetGraph()->GetY()[ipoint])<kBig ){
	  values[nused]=gsensor->GetGraph()->GetY()[ipoint];
	  nused++;
	}
      }
      //
      vecEntries[isensor]= nused;      
      if (nused>1){
	vecMedian[isensor] = TMath::Median(nused,values.GetMatrixArray());
	vecMean[isensor]   = TMath::Mean(nused,values.GetMatrixArray());
	vecRMS[isensor]    = TMath::RMS(nused,values.GetMatrixArray());
      }
    }
  }
}


void FilterMag(const char * runList){
  //
  //
  //
  //  AliTPCcalibDB * calibDB = AliTPCcalibDB::Instance();
  ifstream in;
  in.open(runList);
  Int_t irun=0;
  while(in.good()) {
    in >> irun;
    if (irun==0) continue;
    AliGRPObject *grp = AliTPCcalibDB::GetGRP(irun);
    Float_t current = -1;
    Float_t bz      = -1;
    Float_t press   =  0;
    if (grp){
      current = grp->GetL3Current((AliGRPObject::Stats)0);
      bz = 5*current/30000.;
      printf("Run%d\tL3 current%f\tBz\t%f\n",irun,current,bz);
    }
    else{
      printf("Run%d\tL3 current%f\tBz\t%f\n",irun,current,bz);
    }
  }

}

/*

AliDCSSensor * sensorPressure = AliTPCcalibDB::Instance()->GetPressureSensor(62084);
entry = AliCDBManager::Instance()->Get("TPC/Calib/Temperature",run);
AliTPCSensorTempArray * tempArray = (AliTPCSensorTempArray *)entry->GetObject();
AliTPCSensorTempArray * tempArray = (AliTPCSensorTempArray *)AliTPCcalibDB::Instance()->GetTemperatureSensor(62084)
AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray);
TLinearFitter * fitter = tempMap->GetLinearFitter(0,0,tempArray->GetStartTime());

AliDCSSensorArray* goofieArray = AliTPCcalibDB::Instance()->GetGoofieSensors(62084);

*/
Commit	Line	Data
d47d42ee	1	/*
d47d42ee	2	gSystem->AddIncludePath("-I$ALICE_ROOT/TPC");
e2914767	3
	4	gSystem->Load("libXrdClient.so");
	5	gSystem->Load("libNetx.so");
	6	if (!gGrid) TGrid::Connect("alien://",0,0,"t");
	7
	8
	9	.L CalibEnv.C++
d47d42ee	10	Init();
e2914767	11	CalibEnv("listAll.txt");
e79211e8	12	TFile f("dcsTime.root")
d47d42ee	13
e2914767	14
d47d42ee	15	*/
	16
	17	#include <iostream>
	18	#include <fstream>
	19	#include <AliCDBManager.h>
	20	#include <AliCDBEntry.h>
	21	#include <AliLog.h>
	22	#include <AliMagF.h>
	23	#include "AliTPCcalibDB.h"
	24	#include "AliTPCAltroMapping.h"
	25	#include "AliTPCExB.h"
	26	#include "AliTPCCalROC.h"
	27	#include "AliTPCCalPad.h"
	28	#include "AliTPCSensorTempArray.h"
	29	#include "AliGRPObject.h"
	30	#include "AliTPCTransform.h"
	31	#include "TFile.h"
	32	#include "TKey.h"
	33	#include "TObjArray.h"
	34	#include "TObjString.h"
	35	#include "TString.h"
	36	#include "AliTPCCalPad.h"
	37	#include "AliTPCCalibPulser.h"
	38	#include "AliTPCCalibPedestal.h"
	39	#include "AliTPCCalibCE.h"
	40	#include "AliTPCExBFirst.h"
	41	#include "TTreeStream.h"
	42	#include "AliTPCTempMap.h"
	43
	44	void ProcessGoofie( AliDCSSensorArray* goofieArray, TVectorD & vecEntries, TVectorD & vecMedian, TVectorD &vecMean, TVectorD &vecRMS);
	45
	46	void Init(){
	47	//
	48	//
	49	//
162637e4	50	AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
162637e4	51	AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/Parameters","local://$ALICE_ROOT/OCDB");
d47d42ee	52	AliCDBManager::Instance()->SetSpecificStorage("GRP/GRP/Data","local:///lustre_alpha/alice/alien/alice/data/2008/LHC08d/OCDB/");
d47d42ee	53	AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/Temperature","local:///lustre_alpha/alice/alien/alice/data/2008/LHC08d/OCDB/");
e2914767	54	AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/HighVoltage","local:///lustre_alpha/alice/alien/alice/data/2008/LHC08d/OCDB/");
d47d42ee	55	AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/Goofie","local:///lustre_alpha/alice/alien/alice/data/2008/LHC08d/OCDB/");
d47d42ee	56	AliCDBManager::Instance()->SetRun(1);
e2914767	57	}
e2914767	58
d47d42ee	59
e2914767	60	void InitAlien(const char *path="LHC08b"){
	61	//
	62	//
	63	//
	64	TString alpath="alien://folder=/alice/data/2008/";
	65	alpath+=path;
	66	alpath+="/OCDB";
	67
162637e4	68	AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
162637e4	69	AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/Parameters","local://$ALICE_ROOT/OCDB");
e2914767	70	AliCDBManager::Instance()->SetSpecificStorage("GRP/GRP/Data",alpath.Data());
	71	AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/Temperature",alpath.Data());
	72	AliCDBManager::Instance()->SetSpecificStorage("TPC/Calib/Goofie",alpath.Data());
	73	AliCDBManager::Instance()->SetRun(1);
d47d42ee	74	}
	75
	76
	77	void CalibEnv(const char * runList){
	78	//
	79	//
	80	//
e79211e8	81	AliTPCcalibDB * calibDB = AliTPCcalibDB::Instance();
d47d42ee	82	ifstream in;
	83	in.open(runList);
	84	Int_t irun=0;
e79211e8	85	TTreeSRedirector *pcstream = new TTreeSRedirector("dcsTime.root");
d47d42ee	86	// for (Int_t irun=startRun; irun<stopRun; irun++){
	87	while(in.good()) {
	88	in >> irun;
	89	if (irun==0) continue;
e2914767	90	printf("Processing run %d ...\n",irun);
d47d42ee	91	AliDCSSensor * sensorPressure = AliTPCcalibDB::Instance()->GetPressureSensor(irun);
	92	if (!sensorPressure) continue;
	93	AliTPCSensorTempArray * tempArray = AliTPCcalibDB::Instance()->GetTemperatureSensor(irun);
	94	AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray);
	95	AliDCSSensorArray* goofieArray = AliTPCcalibDB::Instance()->GetGoofieSensors(irun);
	96	//
	97	Int_t startTime = sensorPressure->GetStartTime();
	98	Int_t endTime = sensorPressure->GetEndTime();
	99	Int_t dtime = TMath::Max((endTime-startTime)/20,10*60);
	100	for (Int_t itime=startTime; itime<endTime; itime+=dtime){
	101	//
e2914767	102	TTimeStamp tstamp(itime);
e79211e8	103	Float_t valuePressure = calibDB->GetPressure(tstamp,irun,0);
e79211e8	104	Float_t valuePressure2 = calibDB->GetPressure(tstamp,irun,1);
d47d42ee	105
	106	TLinearFitter * fitter = 0;
	107	TVectorD vecTemp[10];
e79211e8	108	for (Int_t itype=0; itype<5; itype++)
e2914767	109	for (Int_t iside=0; iside<2; iside++){
e2914767	110	fitter= tempMap->GetLinearFitter(itype,iside,tstamp);
e79211e8	111	if (!fitter) continue;
e2914767	112	fitter->Eval();
e2914767	113	fitter->GetParameters(vecTemp[itype+iside*5]);
e79211e8	114	delete fitter;
	115	}
	116
d47d42ee	117
	118	TVectorD vecGoofie, vecEntries, vecMean, vecMedian,vecRMS;
	119	if (goofieArray){
	120	vecGoofie.ResizeTo(goofieArray->NumSensors());
	121	ProcessGoofie(goofieArray, vecEntries ,vecMedian, vecMean, vecRMS);
e2914767	122	//
d47d42ee	123	for (Int_t isensor=0; isensor<goofieArray->NumSensors();isensor++){
	124	AliDCSSensor *gsensor = goofieArray->GetSensor(isensor);
	125	if (gsensor){
	126	vecGoofie[isensor] = gsensor->GetValue(tstamp);
	127	}
	128	}
	129	}
e79211e8	130	Double_t ptrelative0 = AliTPCcalibDB::GetPTRelative(tstamp,irun,0);
e79211e8	131	Double_t ptrelative1 = AliTPCcalibDB::GetPTRelative(tstamp,irun,1);
e2914767	132	//
	133	Double_t voltagesIROC[36];
	134	Double_t voltagesOROC[36];
	135	for(Int_t j=1; j<36; j++) voltagesIROC[j-1] = AliTPCcalibDB::Instance()->GetChamberHighVoltage(startTime, irun, j);
	136	for(Int_t j=36; j<72; j++) voltagesOROC[j-36] = AliTPCcalibDB::Instance()->GetChamberHighVoltage(startTime, irun, j);
	137	Double_t voltIROC = TMath::Median(36, voltagesIROC);
	138	Double_t voltOROC = TMath::Median(36, voltagesOROC);
d47d42ee	139
e2914767	140	//tempMap->GetLinearFitter(0,0,itime);
d47d42ee	141	(*pcstream)<<"dcs"<<
	142	"run="<<irun<<
	143	"time="<<itime<<
e2914767	144	"voltageIROC="<<voltIROC<<
e2914767	145	"voltageOROC="<<voltOROC<<
e79211e8	146	"ptrel0="<<ptrelative0<<
e79211e8	147	"ptrel1="<<ptrelative1<<
d47d42ee	148	"goofie.="<<&vecGoofie<<
	149	"goofieE.="<<&vecEntries<<
	150	"goofieMean.="<<&vecMean<<
	151	"goofieMedian.="<<&vecMedian<<
	152	"goofieRMS.="<<&vecRMS<<
	153	"press="<<valuePressure<<
e79211e8	154	"press2="<<valuePressure2<<
d47d42ee	155	"temp00.="<<&vecTemp[0]<<
	156	"temp10.="<<&vecTemp[1]<<
	157	"temp20.="<<&vecTemp[2]<<
	158	"temp30.="<<&vecTemp[3]<<
	159	"temp40.="<<&vecTemp[4]<<
	160	"temp01.="<<&vecTemp[5]<<
	161	"temp11.="<<&vecTemp[6]<<
	162	"temp21.="<<&vecTemp[7]<<
	163	"temp31.="<<&vecTemp[8]<<
	164	"temp41.="<<&vecTemp[9]<<
	165	"\n";
	166	}
	167	}
	168	delete pcstream;
	169	}
	170
	171
	172	void ProcessGoofie( AliDCSSensorArray* goofieArray, TVectorD & vecEntries, TVectorD & vecMedian, TVectorD &vecMean, TVectorD &vecRMS){
	173	/*
	174
	175	1 TPC_ANODE_I_A00_STAT
	176	2 TPC_DVM_CO2
	177	3 TPC_DVM_DriftVelocity
	178	4 TPC_DVM_FCageHV
	179	5 TPC_DVM_GainFar
	180	6 TPC_DVM_GainNear
	181	7 TPC_DVM_N2
	182	8 TPC_DVM_NumberOfSparks
	183	9 TPC_DVM_PeakAreaFar
	184	10 TPC_DVM_PeakAreaNear
	185	11 TPC_DVM_PeakPosFar
	186	12 TPC_DVM_PeakPosNear
	187	13 TPC_DVM_PickupHV
	188	14 TPC_DVM_Pressure
	189	15 TPC_DVM_T1_Over_P
	190	16 TPC_DVM_T2_Over_P
	191	17 TPC_DVM_T_Over_P
	192	18 TPC_DVM_TemperatureS1
	193	*/
	194	//
	195	//
	196	// TVectorD vecMedian; TVectorD vecEntries; TVectorD vecMean; TVectorD vecRMS;
	197	Double_t kEpsilon=0.0000000001;
	198	Double_t kBig=100000000000.;
	199	Int_t nsensors = goofieArray->NumSensors();
	200	vecEntries.ResizeTo(nsensors);
	201	vecMedian.ResizeTo(nsensors);
	202	vecMean.ResizeTo(nsensors);
	203	vecRMS.ResizeTo(nsensors);
	204	TVectorF values;
	205	for (Int_t isensor=0; isensor<goofieArray->NumSensors();isensor++){
	206	AliDCSSensor *gsensor = goofieArray->GetSensor(isensor);
	207	if (gsensor && gsensor->GetGraph()){
	208	Int_t npoints = gsensor->GetGraph()->GetN();
	209	// filter zeroes
	210	values.ResizeTo(npoints);
	211	Int_t nused =0;
	212	for (Int_t ipoint=0; ipoint<npoints; ipoint++){
	213	if (TMath::Abs(gsensor->GetGraph()->GetY()[ipoint])>kEpsilon &&
	214	TMath::Abs(gsensor->GetGraph()->GetY()[ipoint])<kBig ){
	215	values[nused]=gsensor->GetGraph()->GetY()[ipoint];
	216	nused++;
	217	}
	218	}
219	//
220	vecEntries[isensor]= nused;
221	if (nused>1){
222	vecMedian[isensor] = TMath::Median(nused,values.GetMatrixArray());
223	vecMean[isensor] = TMath::Mean(nused,values.GetMatrixArray());
224	vecRMS[isensor] = TMath::RMS(nused,values.GetMatrixArray());
225	}
226	}
227	}
228	}
229
e2914767	230
	231	void FilterMag(const char * runList){
	232	//
	233	//
	234	//
	235	// AliTPCcalibDB * calibDB = AliTPCcalibDB::Instance();
	236	ifstream in;
	237	in.open(runList);
	238	Int_t irun=0;
	239	while(in.good()) {
	240	in >> irun;
	241	if (irun==0) continue;
	242	AliGRPObject *grp = AliTPCcalibDB::GetGRP(irun);
	243	Float_t current = -1;
	244	Float_t bz = -1;
	245	Float_t press = 0;
	246	if (grp){
	247	current = grp->GetL3Current((AliGRPObject::Stats)0);
	248	bz = 5*current/30000.;
	249	printf("Run%d\tL3 current%f\tBz\t%f\n",irun,current,bz);
	250	}
	251	else{
	252	printf("Run%d\tL3 current%f\tBz\t%f\n",irun,current,bz);
	253	}
	254	}
	255
	256	}
	257
d47d42ee	258	/*
	259
	260	AliDCSSensor * sensorPressure = AliTPCcalibDB::Instance()->GetPressureSensor(62084);
	261	entry = AliCDBManager::Instance()->Get("TPC/Calib/Temperature",run);
	262	AliTPCSensorTempArray * tempArray = (AliTPCSensorTempArray *)entry->GetObject();
	263	AliTPCSensorTempArray * tempArray = (AliTPCSensorTempArray *)AliTPCcalibDB::Instance()->GetTemperatureSensor(62084)
	264	AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray);
e79211e8	265	TLinearFitter * fitter = tempMap->GetLinearFitter(0,0,tempArray->GetStartTime());
d47d42ee	266
	267	AliDCSSensorArray* goofieArray = AliTPCcalibDB::Instance()->GetGoofieSensors(62084);
	268
	269	*/