[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 "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 Z positions";

  
  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,"data/CFD-Amp.txt");
    //    calibda->SetSlewingLED(ipmt,"data/CFD-LED.txt");
    //  calibda->SetSlewingRec(ipmt,"data/CFD-LED.txt");
    calibda->SetWalk(ipmt);
    calibda->SetSlewingLED(ipmt);
    calibda->SetSlewingRec(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->GetWalk(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");

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