[u/mrichter/AliRoot.git] / T0 / AliT0SetCDB.C

/* $Id$ */

// Script to create calibration parameters and store them into CDB
// Two sets of calibration parameters can be created:
// 1) equal parameters
// 2) randomly distributed parameters for decalibrated detector silumations

#if !defined(__CINT__)
#include "TControlBar.h"
#include "TString.h"
#include "TRandom.h"
#include "TH1F.h"
#include "TF1.h"
#include "TCanvas.h"

#include "AliRun.h"
#include "AliT0CalibData.h"
//#include "AliT0AlignData.h"
#include "AliT0Align.h"
#include "AliCDBMetaData.h"
#include "AliCDBId.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"
#endif


void AliT0SetCDB()
{
  TControlBar *menu = new TControlBar("vertical","T0 CDB");
  menu->AddButton("Set time delay","SetTimeDelay()",
		  "Set time dalay");
  menu->AddButton("Set walk","SetWalk()",
		  "Set slewing coorection");
  menu->AddButton("Set Align","SetAC()",
		  "Set alignment coefficients");
  menu->AddButton("Set LookUpTable","SetLookUp()",
                  "Set LookUp table");
  menu->AddButton("Read time delay","GetTimeDelay()",
		  "Read time delay");
  menu->AddButton("Read walk","GetWalk()",
		  "Read amplitude-time correction");
  menu->AddButton("Read alignment CC","GetAC()",
		  "Read face detector position ");
  menu->AddButton("Read Lookup","GetLookUp()",
		  "Read Lookup table ");
  menu->Show();
}


//------------------------------------------------------------------------
void SetAC()
{
  // Writing alignment coefficients into the Condition DB
  // Arguments:
  
  TString DBFolder;
  Int_t firstRun   =  0;
  Int_t lastRun    = 10;
  Int_t beamPeriod =  1;
  char* objFormat  = "";

  DBFolder  ="local://Align";
  firstRun  =  0;
  lastRun   =  10;
  objFormat = "T0 array  positions";

  AliT0Align *al = new AliT0Align(1,835615);
  al->Run();

   /* 
  AliT0AlignData *alignda=new AliT0AlignData("T0");
  alignda-> SetZposition (67.9,373);
  alignda->Print();
  
  //Store calibration data into database
  AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
   AliCDBManager::Instance()->SetSpecificStorage("T0",DBFolder.Data());
  
  AliCDBMetaData md;
  md.SetComment(objFormat);
  md.SetBeamPeriod(beamPeriod);
  md.SetResponsible("Alla");
  TString fPath="T0/Align/Positions";


  //  AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("T0");
  AliCDBStorage* storage = AliCDBManager::Instance()->GetDefaultStorage();
  if(storage) {
   AliCDBId id(fPath.Data(),firstRun,lastRun);

   storage->Put(alignda, id, &md);
 }
   */
}
//------------------------------------------------------------------------
void SetTimeDelay()
{
  // Writing calibration coefficients into the Calibration DB
  // Arguments:

  TString DBFolder;
  Int_t firstRun   =  0;
  Int_t lastRun    = 10;
  Int_t beamPeriod =  1;
  char* objFormat  = "";

  DBFolder  ="local://Calib";
  firstRun  =  0;
  lastRun   =  10;
  objFormat = "T0 initial time delay";

  AliT0CalibData *calibda=new AliT0CalibData("T0");
  
   Float_t fTimeDelay  = 1000;

   //for timeDelayDA now we are using Int mean time (+-3RMS fit) 
   //in number of channel for time in each chanel for 
   //1000 Hijingpara nparticles=500 & zvertex=0 produced by readDigits.C
   // this is way to simulate time positon for vertex=0 
   //with unknown time delay in channel
   /*
   Int_t timedelayDA[24] = {501, 509, 511,510 ,510, 510, 509, 509, 510,
			    510, 509, 508, 511, 510, 509, 508,510,
			    510, 511, 510, 510, 510, 509, 510};
 
   */
  for(Int_t ipmt=0; ipmt<24; ipmt++) {
    calibda->SetTimeDelayCFD(fTimeDelay+ipmt*100,ipmt);
       //   calibda->SetTimeDelayLED(fTimeDelay,ipmt);
//    calibda->SetTimeDelayDA(timedelayDA[ipmt],ipmt);
    calibda->SetTimeDelayDA(500,ipmt);
  }
  calibda->SetMeanT0(499);
  calibda->Print();
  //Store calibration data into database
  AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");

  //  AliCDBManager::Instance()->SetSpecificStorage("T0",DBFolder.Data());
  
  AliCDBMetaData md;
  md.SetComment(objFormat);
  md.SetBeamPeriod(beamPeriod);
  md.SetResponsible("Alla");
  TString fPath="T0/Calib/TimeDelay";


  // AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("T0");
  AliCDBStorage* storage = AliCDBManager::Instance()->GetDefaultStorage();
  if(storage) {
    AliCDBId id(fPath.Data(),firstRun,lastRun);
    storage->Put(calibda, id, &md);
  }
}

//------------------------------------------------------------------------
void SetWalk()
{
  // Writing calibration coefficients into the Calibration DB
  // Arguments:

  TString DBFolder;
  Int_t firstRun   =  0;
  Int_t lastRun    = 10;
  Int_t beamPeriod =  1;
  char* objFormat  = "";

  DBFolder  ="local://Calib";
  firstRun  =  0;
  lastRun   =  10;
  objFormat = "T0 initial slewnig correction";

  AliT0CalibData *calibda=new AliT0CalibData("T0");
  
   
  TRandom rn;
  
  for(Int_t ipmt=0; ipmt<24; ipmt++) {
    calibda->SetWalk(ipmt);
    calibda->SetAmpLEDRec(ipmt);
  }
  //Store calibration data into database
  AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");

  //  AliCDBManager::Instance()->SetSpecificStorage("T0",DBFolder.Data());
  
  AliCDBMetaData md;
  md.SetComment(objFormat);
  md.SetBeamPeriod(beamPeriod);
  md.SetResponsible("Alla");
  TString fPath="T0/Calib/Slewing_Walk";


  // AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("T0");
  AliCDBStorage* storage = AliCDBManager::Instance()->GetDefaultStorage();
  if(storage) {
    AliCDBId id(fPath.Data(),firstRun,lastRun);
    storage->Put(calibda, id, &md);
  }
}

//------------------------------------------------------------------------
void GetTimeDelay()
{
  // Read calibration coefficients into the Calibration DB
  // Arguments:
  
  TString DBFolder;
  
  DBFolder  ="local://Calib";
  Int_t nRun=gAlice->GetRunNumber();
  
  AliCDBStorage *stor =AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
  AliCDBEntry* entry = stor->Get("T0/Calib/TimeDelay",0);
  
  AliT0CalibData *clb = (AliT0CalibData*)entry->GetObject();
  clb->Print();
  for (Int_t i=0; i<24; i++) {
   cout<<clb->GetTimeDelayCFD(i)<<" "<<clb->GetTimeDelayDA(i)<<endl;
   cout<<" equalizing CFD "<<(clb->GetTimeDelayCFD(i)-clb->GetTimeDelayCFD(0))<<endl;
  cout<<" equalizing DA "<<(clb->GetTimeDelayDA(i)-clb->GetTimeDelayDA(0))<<endl;
  }
  
}
//------------------------------------------------------------------------
void GetWalk()
{
  // Read calibration coefficients into the Calibration DB
  // Arguments:
  
  TString DBFolder;
  
  DBFolder  ="local://Calib";
  Int_t nRun=gAlice->GetRunNumber();
  
   AliCDBStorage *stor =AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
   AliCDBEntry* entry = stor->Get("T0/Calib/Slewing_Walk",0);
   
   AliT0CalibData *clb = (AliT0CalibData*)entry->GetObject();
   Int_t ipmt=0;
   //  cin>>" enter channel number">>ipmt;
   TGraph *gr = clb->GetAmpLEDRec(ipmt); 
   gr->Draw("AP");
}
//------------------------------------------------------------------------
void GetAC()
{
  // Read align coefficients into the Calibration DB
  // Arguments:
  
  TString DBFolder;
  
  DBFolder  ="local://Align";
  Int_t nRun=gAlice->GetRunNumber();
  
  AliCDBManager *man = AliCDBManager::Instance();
  AliCDBStorage *stor2 = man->GetStorage("local://Align");
  AliCDBEntry *entry;
  entry = stor2->Get("T0/Align/Positions", nRun);
   
  AliT0AlignData *aln = (AliT0AlignData*)entry->GetObject();
  aln->Print();
}
//------------------------------------------------------------------------
void SetLookUp()
{
  // Writing Lookup table into the Calibration DB
  // Arguments:

  TString DBFolder;
  Int_t firstRun   =  0;
  Int_t lastRun    = 10;
  Int_t beamPeriod =  1;
  char* objFormat  = "";

  DBFolder  ="local://Calib";
  firstRun  =  0;
  lastRun   =  10;
  objFormat = "T0 Lookup Table";

  AliT0CalibData *calibda=new AliT0CalibData("T0");

//  calibda->ReadAsciiLookup("lookUpTable.txt");
  calibda->ReadAsciiLookup("lookUpTable_tanay.txt");

  //Store calibration data into database
  AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");

  //  AliCDBManager::Instance()->SetSpecificStorage("T0",DBFolder.Data());

  AliCDBMetaData md;
  md.SetComment(objFormat);
  md.SetBeamPeriod(beamPeriod);
  md.SetResponsible("Alla");
  TString fPath="T0/Calib/LookUp_Table";


  // AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("T0");
  AliCDBStorage* storage = AliCDBManager::Instance()->GetDefaultStorage();
  if(storage) {
    AliCDBId id(fPath.Data(),firstRun,lastRun);
    storage->Put(calibda, id, &md);
  }
}
//------------------------------------------------------------------------
void GetLookUp()
{
  // Read calibration coefficients into the Calibration DB
  // Arguments:

  TString DBFolder;

  //  DBFolder  ="local://Calib";
  //   Int_t nRun=gAlice->GetRunNumber();
  AliCDBManager* cdb      = AliCDBManager::Instance();
  AliCDBStorage *stor = cdb->GetStorage("local://$ALICE_ROOT");
  // cout<<" GetLookUp :: "<<stor<<endl;
  AliCDBEntry *entry;
  //entry = stor->Get("T0/Calib/LookUp_Table",2,0,0);
  entry = stor->Get("T0/Calib/LookUp_Table",1);
  //cout<<"entry="<<entry<<endl;
   cout<<" AliT0CalibData ::GetLookUp :: "<<entry<<endl;
  AliT0CalibData *clb = (AliT0CalibData*)entry->GetObject();
  cout<<" AliT0CalibData *clb "<<clb <<endl;
  //cout<<"clb->a="<<clb->GetA()<<endl;
  //  clb->Dump();
  for (Int_t i=0; i<20; i++) 
    clb->PrintLookupNames("all",i);

}
Commit	Line	Data
dc7ca31d	1	/* $Id$ */
	2
	3	// Script to create calibration parameters and store them into CDB
	4	// Two sets of calibration parameters can be created:
	5	// 1) equal parameters
	6	// 2) randomly distributed parameters for decalibrated detector silumations
	7
	8	#if !defined(__CINT__)
	9	#include "TControlBar.h"
	10	#include "TString.h"
	11	#include "TRandom.h"
	12	#include "TH1F.h"
	13	#include "TF1.h"
	14	#include "TCanvas.h"
	15
	16	#include "AliRun.h"
	17	#include "AliT0CalibData.h"
ec7c616e	18	//#include "AliT0AlignData.h"
ec7c616e	19	#include "AliT0Align.h"
dc7ca31d	20	#include "AliCDBMetaData.h"
	21	#include "AliCDBId.h"
	22	#include "AliCDBEntry.h"
	23	#include "AliCDBManager.h"
	24	#include "AliCDBStorage.h"
	25	#endif
	26
	27
	28	void AliT0SetCDB()
	29	{
	30	TControlBar *menu = new TControlBar("vertical","T0 CDB");
c41ceaac	31	menu->AddButton("Set time delay","SetTimeDelay()",
	32	"Set time dalay");
	33	menu->AddButton("Set walk","SetWalk()",
	34	"Set slewing coorection");
5325480c	35	menu->AddButton("Set Align","SetAC()",
dc7ca31d	36	"Set alignment coefficients");
6ba20b30	37	menu->AddButton("Set LookUpTable","SetLookUp()",
6ba20b30	38	"Set LookUp table");
c41ceaac	39	menu->AddButton("Read time delay","GetTimeDelay()",
c41ceaac	40	"Read time delay");
5325480c	41	menu->AddButton("Read walk","GetWalk()",
c41ceaac	42	"Read amplitude-time correction");
dc7ca31d	43	menu->AddButton("Read alignment CC","GetAC()",
dc7ca31d	44	"Read face detector position ");
6ba20b30	45	menu->AddButton("Read Lookup","GetLookUp()",
6ba20b30	46	"Read Lookup table ");
dc7ca31d	47	menu->Show();
	48	}
	49
	50
	51	//------------------------------------------------------------------------
	52	void SetAC()
	53	{
	54	// Writing alignment coefficients into the Condition DB
	55	// Arguments:
	56
	57	TString DBFolder;
	58	Int_t firstRun = 0;
	59	Int_t lastRun = 10;
	60	Int_t beamPeriod = 1;
	61	char* objFormat = "";
	62
	63	DBFolder ="local://Align";
	64	firstRun = 0;
	65	lastRun = 10;
ec7c616e	66	objFormat = "T0 array positions";
dc7ca31d	67
ec7c616e	68	AliT0Align *al = new AliT0Align(1,835615);
	69	al->Run();
	70
	71	/*
dc7ca31d	72	AliT0AlignData *alignda=new AliT0AlignData("T0");
	73	alignda-> SetZposition (67.9,373);
	74	alignda->Print();
	75
	76	//Store calibration data into database
	77	AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
	78	AliCDBManager::Instance()->SetSpecificStorage("T0",DBFolder.Data());
	79
	80	AliCDBMetaData md;
	81	md.SetComment(objFormat);
	82	md.SetBeamPeriod(beamPeriod);
	83	md.SetResponsible("Alla");
	84	TString fPath="T0/Align/Positions";
	85
	86
	87	// AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("T0");
	88	AliCDBStorage* storage = AliCDBManager::Instance()->GetDefaultStorage();
6ba20b30	89	if(storage) {
dc7ca31d	90	AliCDBId id(fPath.Data(),firstRun,lastRun);
	91
	92	storage->Put(alignda, id, &md);
	93	}
ec7c616e	94	*/
dc7ca31d	95	}
dc7ca31d	96	//------------------------------------------------------------------------
c41ceaac	97	void SetTimeDelay()
dc7ca31d	98	{
	99	// Writing calibration coefficients into the Calibration DB
	100	// Arguments:
	101
	102	TString DBFolder;
	103	Int_t firstRun = 0;
	104	Int_t lastRun = 10;
	105	Int_t beamPeriod = 1;
	106	char* objFormat = "";
	107
	108	DBFolder ="local://Calib";
	109	firstRun = 0;
	110	lastRun = 10;
c41ceaac	111	objFormat = "T0 initial time delay";
dc7ca31d	112
	113	AliT0CalibData *calibda=new AliT0CalibData("T0");
	114
c41ceaac	115	Float_t fTimeDelay = 1000;
d530f23a	116
	117	//for timeDelayDA now we are using Int mean time (+-3RMS fit)
	118	//in number of channel for time in each chanel for
	119	//1000 Hijingpara nparticles=500 & zvertex=0 produced by readDigits.C
	120	// this is way to simulate time positon for vertex=0
	121	//with unknown time delay in channel
	122	/*
	123	Int_t timedelayDA[24] = {501, 509, 511,510 ,510, 510, 509, 509, 510,
	124	510, 509, 508, 511, 510, 509, 508,510,
	125	510, 511, 510, 510, 510, 509, 510};
	126
	127	*/
c41ceaac	128	for(Int_t ipmt=0; ipmt<24; ipmt++) {
c41ceaac	129	calibda->SetTimeDelayCFD(fTimeDelay+ipmt*100,ipmt);
d530f23a	130	// calibda->SetTimeDelayLED(fTimeDelay,ipmt);
	131	// calibda->SetTimeDelayDA(timedelayDA[ipmt],ipmt);
	132	calibda->SetTimeDelayDA(500,ipmt);
c41ceaac	133	}
d530f23a	134	calibda->SetMeanT0(499);
c41ceaac	135	calibda->Print();
	136	//Store calibration data into database
	137	AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
	138
	139	// AliCDBManager::Instance()->SetSpecificStorage("T0",DBFolder.Data());
	140
	141	AliCDBMetaData md;
	142	md.SetComment(objFormat);
	143	md.SetBeamPeriod(beamPeriod);
	144	md.SetResponsible("Alla");
	145	TString fPath="T0/Calib/TimeDelay";
	146
	147
	148	// AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("T0");
	149	AliCDBStorage* storage = AliCDBManager::Instance()->GetDefaultStorage();
	150	if(storage) {
	151	AliCDBId id(fPath.Data(),firstRun,lastRun);
	152	storage->Put(calibda, id, &md);
	153	}
	154	}
	155
	156	//------------------------------------------------------------------------
	157	void SetWalk()
	158	{
	159	// Writing calibration coefficients into the Calibration DB
	160	// Arguments:
	161
	162	TString DBFolder;
	163	Int_t firstRun = 0;
	164	Int_t lastRun = 10;
	165	Int_t beamPeriod = 1;
	166	char* objFormat = "";
	167
	168	DBFolder ="local://Calib";
	169	firstRun = 0;
	170	lastRun = 10;
	171	objFormat = "T0 initial slewnig correction";
	172
	173	AliT0CalibData *calibda=new AliT0CalibData("T0");
	174
	175
dc7ca31d	176	TRandom rn;
	177
	178	for(Int_t ipmt=0; ipmt<24; ipmt++) {
5325480c	179	calibda->SetWalk(ipmt);
29d3e0eb	180	calibda->SetAmpLEDRec(ipmt);
dc7ca31d	181	}
dc7ca31d	182	//Store calibration data into database
	183	AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
	184
	185	// AliCDBManager::Instance()->SetSpecificStorage("T0",DBFolder.Data());
	186
	187	AliCDBMetaData md;
	188	md.SetComment(objFormat);
	189	md.SetBeamPeriod(beamPeriod);
	190	md.SetResponsible("Alla");
c41ceaac	191	TString fPath="T0/Calib/Slewing_Walk";
dc7ca31d	192
	193
	194	// AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("T0");
	195	AliCDBStorage* storage = AliCDBManager::Instance()->GetDefaultStorage();
	196	if(storage) {
	197	AliCDBId id(fPath.Data(),firstRun,lastRun);
	198	storage->Put(calibda, id, &md);
	199	}
	200	}
	201
	202	//------------------------------------------------------------------------
c41ceaac	203	void GetTimeDelay()
dc7ca31d	204	{
	205	// Read calibration coefficients into the Calibration DB
	206	// Arguments:
	207
	208	TString DBFolder;
	209
	210	DBFolder ="local://Calib";
	211	Int_t nRun=gAlice->GetRunNumber();
	212
c41ceaac	213	AliCDBStorage *stor =AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
	214	AliCDBEntry* entry = stor->Get("T0/Calib/TimeDelay",0);
	215
dc7ca31d	216	AliT0CalibData clb = (AliT0CalibData)entry->GetObject();
dc7ca31d	217	clb->Print();
d530f23a	218	for (Int_t i=0; i<24; i++) {
	219	cout<<clb->GetTimeDelayCFD(i)<<" "<<clb->GetTimeDelayDA(i)<<endl;
	220	cout<<" equalizing CFD "<<(clb->GetTimeDelayCFD(i)-clb->GetTimeDelayCFD(0))<<endl;
	221	cout<<" equalizing DA "<<(clb->GetTimeDelayDA(i)-clb->GetTimeDelayDA(0))<<endl;
	222	}
	223
dc7ca31d	224	}
dc7ca31d	225	//------------------------------------------------------------------------
c41ceaac	226	void GetWalk()
	227	{
	228	// Read calibration coefficients into the Calibration DB
	229	// Arguments:
	230
	231	TString DBFolder;
	232
	233	DBFolder ="local://Calib";
	234	Int_t nRun=gAlice->GetRunNumber();
	235
	236	AliCDBStorage *stor =AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
	237	AliCDBEntry* entry = stor->Get("T0/Calib/Slewing_Walk",0);
	238
	239	AliT0CalibData clb = (AliT0CalibData)entry->GetObject();
	240	Int_t ipmt=0;
	241	// cin>>" enter channel number">>ipmt;
29d3e0eb	242	TGraph *gr = clb->GetAmpLEDRec(ipmt);
c41ceaac	243	gr->Draw("AP");
	244	}
	245	//------------------------------------------------------------------------
dc7ca31d	246	void GetAC()
	247	{
	248	// Read align coefficients into the Calibration DB
	249	// Arguments:
	250
	251	TString DBFolder;
	252
	253	DBFolder ="local://Align";
	254	Int_t nRun=gAlice->GetRunNumber();
	255
	256	AliCDBManager *man = AliCDBManager::Instance();
	257	AliCDBStorage *stor2 = man->GetStorage("local://Align");
	258	AliCDBEntry *entry;
	259	entry = stor2->Get("T0/Align/Positions", nRun);
	260
	261	AliT0AlignData aln = (AliT0AlignData)entry->GetObject();
	262	aln->Print();
	263	}
6ba20b30	264	//------------------------------------------------------------------------
	265	void SetLookUp()
	266	{
	267	// Writing Lookup table into the Calibration DB
	268	// Arguments:
	269
	270	TString DBFolder;
	271	Int_t firstRun = 0;
	272	Int_t lastRun = 10;
	273	Int_t beamPeriod = 1;
	274	char* objFormat = "";
	275
	276	DBFolder ="local://Calib";
	277	firstRun = 0;
	278	lastRun = 10;
	279	objFormat = "T0 Lookup Table";
	280
	281	AliT0CalibData *calibda=new AliT0CalibData("T0");
	282
ec7c616e	283	// calibda->ReadAsciiLookup("lookUpTable.txt");
ec7c616e	284	calibda->ReadAsciiLookup("lookUpTable_tanay.txt");
5325480c	285
6ba20b30	286	//Store calibration data into database
	287	AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
	288
	289	// AliCDBManager::Instance()->SetSpecificStorage("T0",DBFolder.Data());
	290
	291	AliCDBMetaData md;
	292	md.SetComment(objFormat);
	293	md.SetBeamPeriod(beamPeriod);
	294	md.SetResponsible("Alla");
	295	TString fPath="T0/Calib/LookUp_Table";
	296
	297
	298	// AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("T0");
	299	AliCDBStorage* storage = AliCDBManager::Instance()->GetDefaultStorage();
	300	if(storage) {
	301	AliCDBId id(fPath.Data(),firstRun,lastRun);
	302	storage->Put(calibda, id, &md);
	303	}
	304	}
	305	//------------------------------------------------------------------------
	306	void GetLookUp()
	307	{
	308	// Read calibration coefficients into the Calibration DB
	309	// Arguments:
	310
	311	TString DBFolder;
	312
	313	// DBFolder ="local://Calib";
	314	// Int_t nRun=gAlice->GetRunNumber();
	315	AliCDBManager* cdb = AliCDBManager::Instance();
	316	AliCDBStorage *stor = cdb->GetStorage("local://$ALICE_ROOT");
	317	// cout<<" GetLookUp :: "<<stor<<endl;
	318	AliCDBEntry *entry;
	319	//entry = stor->Get("T0/Calib/LookUp_Table",2,0,0);
	320	entry = stor->Get("T0/Calib/LookUp_Table",1);
	321	//cout<<"entry="<<entry<<endl;
	322	cout<<" AliT0CalibData ::GetLookUp :: "<<entry<<endl;
	323	AliT0CalibData clb = (AliT0CalibData)entry->GetObject();
	324	cout<<" AliT0CalibData *clb "<<clb <<endl;
	325	//cout<<"clb->a="<<clb->GetA()<<endl;
	326	// clb->Dump();
d530f23a	327	for (Int_t i=0; i<20; i++)
d530f23a	328	clb->PrintLookupNames("all",i);
6ba20b30	329
6ba20b30	330	}