Using AliGeomManager in the macros (Raffaele)

diff --git a/EMCAL/MakeEMCALFullMisAlignment.C b/EMCAL/MakeEMCALFullMisAlignment.C
index 3436d84ed1405983af844de3453093a74ddb5f45..ee4a92fb1f13f43498011bc180bbcf75d0ca17be 100644 (file)
--- a/EMCAL/MakeEMCALFullMisAlignment.C
+++ b/EMCAL/MakeEMCALFullMisAlignment.C
@@ -4,9 +4,12 @@ void MakeEMCALFullMisAlignment(){
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
   TClonesArray &alobj = *array;
 
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
-  // needed for the constructors with local coordinates not to fail
-
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   AliAlignObjAngles a;
 
   Double_t dx, dy, dz, dpsi, dtheta, dphi;
@@ -51,23 +54,39 @@ void MakeEMCALFullMisAlignment(){
     new(alobj[j++]) AliAlignObjAngles(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
   }
 
+  const char* macroname = "MakeEMCALFullMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("EMCALfullMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "EMCALfullMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"T0FullObjs ","kSingleKey");
+    f.WriteObject(array,"EMCALAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+         Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Jennifer Clay");
     md->SetComment("Full misalignment for EMCAL");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("EMCAL/Align/Data",0,9999999);
+    AliCDBId id("EMCAL/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/EMCAL/MakeEMCALResMisAlignment.C b/EMCAL/MakeEMCALResMisAlignment.C
index ff1dbc3871d1b491e54db3e9824edf70f2f4fccc..721e6010f1d1ab4c43a8af2f9abdb95996cd1212 100644 (file)
--- a/EMCAL/MakeEMCALResMisAlignment.C
+++ b/EMCAL/MakeEMCALResMisAlignment.C
@@ -4,9 +4,12 @@ void MakeEMCALResMisAlignment(){
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
   TClonesArray &alobj = *array;
 
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
-  // needed for the constructors with local coordinates not to fail
-
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   AliAlignObjAngles a;
 
   Double_t dx, dy, dz, dpsi, dtheta, dphi;
@@ -53,23 +56,39 @@ void MakeEMCALResMisAlignment(){
     new(alobj[j++]) AliAlignObjAngles(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
   }
 
+  const char* macroname = "MakeEMCALResMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("EMCALresidualMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "EMCALresidualMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"T0ResidualObjs ","kSingleKey");
+    f.WriteObject(array,"EMCALAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Jennifer Clay");
     md->SetComment("Residual misalignment for EMCAL, produced with sigmatr=0.05 and sigmarot=0.3 in the local RS");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("EMCAL/Align/Data",0,9999999);
+    AliCDBId id("EMCAL/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/EMCAL/MakeEMCALZeroMisAlignment.C b/EMCAL/MakeEMCALZeroMisAlignment.C
index c0db87e90403920b8b53541db9f274501ee2c381..41ed85d2710381d5dfcb999555be0f13af698894 100644 (file)
--- a/EMCAL/MakeEMCALZeroMisAlignment.C
+++ b/EMCAL/MakeEMCALZeroMisAlignment.C
@@ -4,9 +4,12 @@ void MakeEMCALZeroMisAlignment(){
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
   TClonesArray &alobj = *array;
 
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
-  // needed for the constructors with local coordinates not to fail
-
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   AliAlignObjAngles a;
 
   Double_t dx=0., dy=0., dz=0., dpsi=0., dtheta=0., dphi=0.;
@@ -34,23 +37,39 @@ void MakeEMCALZeroMisAlignment(){
     new(alobj[j++]) AliAlignObjAngles(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
   }
 
+  const char* macroname = "MakeEMCALZeroMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("EMCALzeroMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "EMCALzeroMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(array,"EMCALAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+      Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Jennifer Clay");
     md->SetComment("Zero misalignment for EMCAL");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("EMCAL/Align/Data",0,9999999);
+    AliCDBId id("EMCAL/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/FMD/MakeFMDFullMisAlignment.C b/FMD/MakeFMDFullMisAlignment.C
index 3703439377775e606abab7e75376b5257f4ed47f..c37269dc7637e5aef815ff95f21e63cc17c0a86d 100644 (file)
--- a/FMD/MakeFMDFullMisAlignment.C
+++ b/FMD/MakeFMDFullMisAlignment.C
@@ -1,7 +1,12 @@
 void MakeFMDFullMisAlignment(){
   // Create TClonesArray of full misalignment objects for FMD
   //
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
   
   gSystem->Load("libFMDutil.so");

diff --git a/FMD/MakeFMDResMisAlignment.C b/FMD/MakeFMDResMisAlignment.C
index f3fc50c6d21896e9f7b14b558b8c85995f16473e..276cd5bb25a5037bd96366fd9ade99e8f86c8a89 100644 (file)
--- a/FMD/MakeFMDResMisAlignment.C
+++ b/FMD/MakeFMDResMisAlignment.C
@@ -2,7 +2,12 @@ void MakeFMDResMisAlignment()
 {
   // Create TClonesArray of residual misalignment objects for FMD
   //
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+    AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   
   gSystem->Load("libFMDutil.so");
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){

diff --git a/FMD/MakeFMDZeroMisAlignment.C b/FMD/MakeFMDZeroMisAlignment.C
index 5dd40746bc7adc529be9c1090ef70cb4aaa1c71d..678c4a4b7931dc8b10bd1e38033acb5e45234b87 100644 (file)
--- a/FMD/MakeFMDZeroMisAlignment.C
+++ b/FMD/MakeFMDZeroMisAlignment.C
@@ -2,7 +2,12 @@ void MakeFMDZeroMisAlignment()
 {
   // Create TClonesArray of zero-misalignment objects for FMD
   //
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   
   gSystem->Load("libFMDutil.so");
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){

diff --git a/HMPID/MakeHMPIDFullMisAlignment.C b/HMPID/MakeHMPIDFullMisAlignment.C
index 66bf6897d32bed65bf916b8f9384ae73f025ae32..6f5546c75558db9b762fef2cb341482ffb2a8a79 100644 (file)
--- a/HMPID/MakeHMPIDFullMisAlignment.C
+++ b/HMPID/MakeHMPIDFullMisAlignment.C
@@ -20,24 +20,40 @@ void MakeHMPIDFullMisAlignment(){
   }
 
 //   pCA->Print();
-  
+
+  const char* macroname = "MakeHMPIDResMisAlignment.C"; 
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("HMPIDfullMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "HMPIDresidualMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(pCA,"HMPIDAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData *pMeta= new AliCDBMetaData();  
     pMeta->SetResponsible("HMPID Expert");
     pMeta->SetComment("Full alignment objects for HMPID produced with sigmaTrans=1mm and sigmaRot=1mrad");
     pMeta->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("HMPID/Align/Data",0,9999999);
+    AliCDBId id("HMPID/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(pCA,id,pMeta);
   }
   

diff --git a/HMPID/MakeHMPIDResMisAlignment.C b/HMPID/MakeHMPIDResMisAlignment.C
index 3ac26aa11ec9434063a73d750c09c1b46438457a..a9aac1403d49ef63e14d61efdde413c30f6d6b96 100644 (file)
--- a/HMPID/MakeHMPIDResMisAlignment.C
+++ b/HMPID/MakeHMPIDResMisAlignment.C
@@ -20,23 +20,39 @@ void MakeHMPIDResMisAlignment(){
 
 //   pCA->Print();
   
+  const char* macroname = "MakeHMPIDResMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("HMPIDresidualMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "HMPIDresidualMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(pCA,"HMPIDAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData *pMeta= new AliCDBMetaData();  
     pMeta->SetResponsible("HMPID Expert");
     pMeta->SetComment("Residual alignment objects for HMPID produced with sigmaTrans=1mm and sigmaRot=1mrad");
     pMeta->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("HMPID/Align/Data",0,9999999);
+    AliCDBId id("HMPID/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(pCA,id,pMeta);
   }
   

diff --git a/HMPID/MakeHMPIDZeroMisAlignment.C b/HMPID/MakeHMPIDZeroMisAlignment.C
index e6e40fe71dd9bca8538f1e7a1d2a868445f40ac3..609efb58c3b13fa7af18cbae8527056cbc46ade3 100644 (file)
--- a/HMPID/MakeHMPIDZeroMisAlignment.C
+++ b/HMPID/MakeHMPIDZeroMisAlignment.C
@@ -13,24 +13,39 @@ void MakeHMPIDZeroMisAlignment(){
   }
 
 //   pCA->Print();
-  
+  const char* macroname = "MakeHMPIDZeroMisAlignment.C";  
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("HMPIDzeroMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "HMPIDzeroMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(pCA,"HMPIDAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+      Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData *pMeta= new AliCDBMetaData();  
     pMeta->SetResponsible("HMPID Expert");
     pMeta->SetComment("Zero alignment objects for HMPID");
     pMeta->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("HMPID/Align/Data",0,9999999);
+    AliCDBId id("HMPID/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(pCA,id,pMeta);
   }
   

diff --git a/ITS/MakeITSFullMisAlignment.C b/ITS/MakeITSFullMisAlignment.C
index 8e3ad7c1a5d720222257251284febf502f3a4182..742bdcf8dfe5a6c1789d76be32c553ad77eb6c7c 100644 (file)
--- a/ITS/MakeITSFullMisAlignment.C
+++ b/ITS/MakeITSFullMisAlignment.C
@@ -4,7 +4,12 @@ void MakeITSFullMisAlignment(){
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",4000);
   TClonesArray &alobj = *array;
    
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   Double_t globalZ = 0.015; // in cm, = 150 microns
@@ -87,22 +92,39 @@ void MakeITSFullMisAlignment(){
     }
   }
 
+  const char* macroname = "MakeITSFullMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("ITSfullMisalignment.root","RECREATE");
-    if(!f) {cerr<<"cannot open file for output\n";}
+    const char* filename = "ITSfullMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
+    f.cd();
     f.WriteObject(array,"ITSAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
-    AliCDBManager *CDB = AliCDBManager::Instance();
-    AliCDBStorage* storage = CDB->GetStorage(Storage);
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData *md= new AliCDBMetaData();
     md->SetResponsible("Ludovic Gaudichet");
     md->SetComment("Alignment objects with actual ITS misalignment");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("ITS/Align/Data",0,9999999);
+    AliCDBId id("ITS/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id, md);
   }
 

diff --git a/ITS/MakeITSResMisAlignment.C b/ITS/MakeITSResMisAlignment.C
index c8771761cf15fdcf7a752d74d633b4545e19be18..60327e6a40b7cb5b1f6e982ee6ef9535479b9f56 100644 (file)
--- a/ITS/MakeITSResMisAlignment.C
+++ b/ITS/MakeITSResMisAlignment.C
@@ -4,7 +4,12 @@ void MakeITSResMisAlignment(){
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",4000);
   TClonesArray &alobj = *array;
    
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   Double_t globalZ = 0.005; // in cm, = 50 microns
@@ -89,22 +94,39 @@ void MakeITSResMisAlignment(){
     }
   }
 
+  const char* macroname = "MakeITSResMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("ITSresidualMisalignment.root","RECREATE");
-    if(!f) {cerr<<"cannot open file for output\n";}
+    const char* filename = "ITSresidualMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
+    f.cd();
     f.WriteObject(array,"ITSAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
-    AliCDBManager *CDB = AliCDBManager::Instance();
-    AliCDBStorage* storage = CDB->GetStorage(Storage);
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData *md= new AliCDBMetaData();
     md->SetResponsible("Ludovic Gaudichet");
     md->SetComment("Alignment objects with actual ITS misalignment");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("ITS/Align/Data",0,9999999);
+    AliCDBId id("ITS/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id, md);
   }
 

diff --git a/ITS/MakeITSZeroMisAlignment.C b/ITS/MakeITSZeroMisAlignment.C
index e10d17b18ff05b7f7f27369d01088467e41e48bf..0fa7324dcbbc42b9a59fa839708cb2f9962d9a48 100644 (file)
--- a/ITS/MakeITSZeroMisAlignment.C
+++ b/ITS/MakeITSZeroMisAlignment.C
@@ -4,7 +4,12 @@ void MakeITSZeroMisAlignment(){
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",4000);
   TClonesArray &alobj = *array;
    
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   AliAlignObjAngles a;
@@ -54,22 +59,39 @@ void MakeITSZeroMisAlignment(){
     }
   }
 
+  const char* macroname = "MakeITSZeroMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("ITSzeroMisalignment.root","RECREATE");
-    if(!f) {cerr<<"cannot open file for output\n";}
+    const char* filename = "ITSzeroMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
+    f.cd();
     f.WriteObject(array,"ITSAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
-    AliCDBManager *CDB = AliCDBManager::Instance();
-    AliCDBStorage* storage = CDB->GetStorage(Storage);
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData *md= new AliCDBMetaData();
     md->SetResponsible("Ludovic Gaudichet");
     md->SetComment("Alignment objects with zero ITS misalignment");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("ITS/Align/Data",0,9999999);
+    AliCDBId id("ITS/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id, md);
   }
 

diff --git a/MUON/MakeMUONFullMisAlignment.C b/MUON/MakeMUONFullMisAlignment.C
index d4bce05742f114beb03512d9e9145bba90fd703a..07bf9872d73d97db9826ec7e17d88931e3c0d900 100644 (file)
--- a/MUON/MakeMUONFullMisAlignment.C
+++ b/MUON/MakeMUONFullMisAlignment.C
@@ -42,8 +42,12 @@
 void MakeMUONFullMisAlignment()
 {
   // Load geometry, if not yet loaded,
-  if ( ! AliGeomManager::GetGeometry() )
-    AliGeomManager::LoadGeometry("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+    AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
 
   AliMUONGeometryTransformer transformer;
   transformer.LoadGeometryData();
@@ -53,32 +57,38 @@ void MakeMUONFullMisAlignment()
     = misAligner.MisAlign(&transformer, true);
   const TClonesArray* array = newTransform->GetMisAlignmentData();
   
+  const char* macroname = "MakeMUONFullMisAlignment.C";
   if ( TString(gSystem->Getenv("TOCDB")) != TString("kTRUE") ) {
-    cout << "Generating full misalignment data in a file" << endl;
-
-    // Create a File to store the alignment data
-    TFile f("MUONfullMisalignment.root","RECREATE");
-    if ( !f.IsOpen() ) {
-      cerr << "cannot open file for output" << endl;
+    const char* filename = "MUONfullMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
     }
-    
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"MUONAlignObjs ","kSingleKey");
+    f.WriteObject(array,"MUONAlignObjs","kSingleKey");
     f.Close();
   }
   else {
-    cout << "Generating full misalignment data in CDB" << endl;
-
-    // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
-    
-    AliCDBManager* cdbManager = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdbManager->GetStorage(Storage);
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* cdbData = new AliCDBMetaData();
     cdbData->SetResponsible("Dimuon Offline project");
     cdbData->SetComment("MUON alignment objects with full misalignment");
     cdbData->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("MUON/Align/Data", 0, 9999999); 
+    AliCDBId id("MUON/Align/Data", 0, AliCDBRunRange::Infinity()); 
     storage->Put(const_cast<TClonesArray*>(array), id, cdbData);
   }   
   delete newTransform;

diff --git a/MUON/MakeMUONResMisAlignment.C b/MUON/MakeMUONResMisAlignment.C
index b2d514a99d1a1abe3ee37fe4651a7d2c4e268597..bcc9fc08c2b524b5eb464f5bb103599621b37277 100644 (file)
--- a/MUON/MakeMUONResMisAlignment.C
+++ b/MUON/MakeMUONResMisAlignment.C
@@ -41,8 +41,12 @@
 void MakeMUONResMisAlignment()
 {
   // Load geometry, if not yet loaded,
-  if ( ! AliGeomManager::GetGeometry() )
-    AliGeomManager::LoadGeometry("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+    AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
 
   AliMUONGeometryTransformer transformer;
   transformer.LoadGeometryData();
@@ -52,30 +56,38 @@ void MakeMUONResMisAlignment()
     = misAligner.MisAlign(&transformer, true);
   const TClonesArray* array = newTransform->GetMisAlignmentData();
 
+  const char* macroname = "MakeMUONResMisAlignment.C";
   if ( TString(gSystem->Getenv("TOCDB")) != TString("kTRUE") ) {
-    cout << "Generating residual misalignment data in a file" << endl;
-  
-    // Create a File to store the alignment data
-    TFile f("MUONresidualMisalignment.root","RECREATE");
-    if( !f.IsOpen() ) {
-      cerr << "cannot open file for output" << endl;
+    const char* filename = "MUONresidualMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
     }
-    
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"MUONAlignObjs ","kSingleKey");
+    f.WriteObject(array,"MUONAlignObjs","kSingleKey");
     f.Close();
   }
   else {
-    cout << "Generating residual misalignment data in CDB" << endl;
-    // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
-    AliCDBManager* cdbManager = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdbManager->GetStorage(Storage);
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* cdbData = new AliCDBMetaData();
     cdbData->SetResponsible("Dimuon Offline project");
     cdbData->SetComment("MUON alignment objects with residual misalignment");
     cdbData->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("MUON/Align/Data", 0, 9999999); 
+    AliCDBId id("MUON/Align/Data", 0, AliCDBRunRange::Infinity()); 
     storage->Put(const_cast<TClonesArray*>(array), id, cdbData);
   }
   delete newTransform;

diff --git a/MUON/MakeMUONZeroMisAlignment.C b/MUON/MakeMUONZeroMisAlignment.C
index c159a217eee3a99fafc8bb6d2805ba7198e2d888..8de69b7da355518dd263ae4a728e1ae700a42a2a 100644 (file)
--- a/MUON/MakeMUONZeroMisAlignment.C
+++ b/MUON/MakeMUONZeroMisAlignment.C
@@ -39,39 +39,50 @@
 void MakeMUONZeroMisAlignment()
 {
   // Load geometry, if not yet loaded,
-  if ( ! AliGeomManager::GetGeometry() )
-    AliGeomManager::LoadGeometry("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
 
   AliMUONGeometryTransformer transformer;
   transformer.LoadGeometryData();
   TClonesArray* array = transformer.CreateZeroAlignmentData();;
 
+  const char* macroname = "MakeMUONZeroMisAlignment.C";
   if ( TString(gSystem->Getenv("TOCDB")) != TString("kTRUE") ) {
-    // save in file
-    cout << "Generating zero misalignment data in a file ..." << endl;
-
     // Create a file to store the alignment data
-    TFile f("MUONzeroMisalignment.root", "RECREATE");
-    if( !f.IsOpen() ) {
-      cerr<<"cannot open file for output\n";
+    const char* filename = "MUONZeroMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
     }
-    
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"MUONAlignObjs ","kSingleKey");
+    f.WriteObject(array,"MUONAlignObjs","kSingleKey");
     f.Close();
-  }
-  else {
-    cout << "Generating zero misalignment data in CDB ..." << endl;
-
+  } else {
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
-    AliCDBManager* cdbManager = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdbManager->GetStorage(Storage);
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* cdbData = new AliCDBMetaData();
     cdbData->SetResponsible("Dimuon Offline project");
     cdbData->SetComment("MUON alignment objects with zero misalignment");
     cdbData->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("MUON/Align/Data", 0, 9999999); 
+    AliCDBId id("MUON/Align/Data", 0, AliCDBRunRange::Infinity()); 
     storage->Put(array, id, cdbData);
   }
 }   

diff --git a/PHOS/MakePHOSFullMisAlignment.C b/PHOS/MakePHOSFullMisAlignment.C
index 8ce9a7232519ae081cd2fcf3d7f99493640de091..88c8694880c88346b2a9dd6645c0581669d0e6aa 100644 (file)
--- a/PHOS/MakePHOSFullMisAlignment.C
+++ b/PHOS/MakePHOSFullMisAlignment.C
@@ -68,23 +68,39 @@ void MakePHOSFullMisAlignment(){
 
   // *************************    2nd step    ***************
 
-  if(!gSystem->Getenv("TOCDB")){
+  const char* macroname = "MakePHOSFullMisAlignment.C";
+  if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("PHOSfullMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "PHOSfullMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"PHOSFullObjs ","kSingleKey");
+    f.WriteObject(array,"PHOSAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
-    AliCDBManager *CDB = AliCDBManager::Instance();
-    AliCDBStorage* storage = CDB->GetStorage(Storage);
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData *md= new AliCDBMetaData();
     md->SetResponsible("Yuri Kharlov");
     md->SetComment("Alignment objects for fully misaligned geometry");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("PHOS/Align/Data",0,9999999);
+    AliCDBId id("PHOS/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id, md);
   }
 

diff --git a/PHOS/MakePHOSResMisAlignment.C b/PHOS/MakePHOSResMisAlignment.C
index 5b4bee37fc12af5d9dc99c895bf316a6a90013c1..5bdd22b51009e1075732b1bb27d43196eeddfc86 100644 (file)
--- a/PHOS/MakePHOSResMisAlignment.C
+++ b/PHOS/MakePHOSResMisAlignment.C
@@ -64,23 +64,39 @@ void MakePHOSResMisAlignment(){
   AliPHOSSurvey geodesicData("phos_mod3_survey.txt");
   geodesicData.CreateAliAlignObjAngles(alobj);
 
-  if(!gSystem->Getenv("TOCDB")){
+  const char* macroname = "MakePHOSResMisAlignment.C";
+  if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("PHOSresidualMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "PHOSresidualMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"PHOSResidualObjs ","kSingleKey");
+    f.WriteObject(array,"PHOSAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
-    AliCDBManager *CDB = AliCDBManager::Instance();
-    AliCDBStorage* storage = CDB->GetStorage(Storage);
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData *md= new AliCDBMetaData();
     md->SetResponsible("Yuri Kharlov");
     md->SetComment("Alignment objects for slightly misaligned geometry (residual misalignment");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("PHOS/Align/Data",0,9999999);
+    AliCDBId id("PHOS/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id, md);
   }
 

diff --git a/PHOS/MakePHOSZeroMisAlignment.C b/PHOS/MakePHOSZeroMisAlignment.C
index 86a9d54fcc63bd6fbae29707aec30bbe1e6cde58..307f8380e2c29e24958c8a45dc2ae783dea861b1 100644 (file)
--- a/PHOS/MakePHOSZeroMisAlignment.C
+++ b/PHOS/MakePHOSZeroMisAlignment.C
@@ -62,23 +62,39 @@ void MakePHOSZeroMisAlignment(){
   AliPHOSSurvey geodesicData;
   geodesicData.CreateNullObjects(alobj, phosGeom);
 
-  if(!gSystem->Getenv("TOCDB")){
+  const char* macroname = "MakePHOSZeroMisAlignment.C";
+  if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("PHOSzeroMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "PHOSzeroMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(array,"PHOSAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
-    AliCDBManager *CDB = AliCDBManager::Instance();
-    AliCDBStorage* storage = CDB->GetStorage(Storage);
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData *md= new AliCDBMetaData();
     md->SetResponsible("Yuri Kharlov");
     md->SetComment("Zero misalignment objects");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("PHOS/Align/Data",0,9999999);
+    AliCDBId id("PHOS/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id, md);
   }
 

diff --git a/PMD/MakePMDFullMisAlignment.C b/PMD/MakePMDFullMisAlignment.C
index 5a943859df997f05f9e2593c32ad080aae9a490a..cbea35def7b94e305709c718a84315295033f903 100644 (file)
--- a/PMD/MakePMDFullMisAlignment.C
+++ b/PMD/MakePMDFullMisAlignment.C
@@ -35,7 +35,12 @@ void MakePMDFullMisAlignment(){
     // Steel plate 
  */
   
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   Float_t max_trans=0.1;
@@ -102,23 +107,39 @@ void MakePMDFullMisAlignment(){
   new(alobj[2]) AliAlignObjAngles(Sector3, volid, dx23, dy23, dz23, dpsi23, dtheta23, dphi23, kFALSE);
   new(alobj[3]) AliAlignObjAngles(Sector4, volid, dx23, dy23, dz23, dpsi23, dtheta23, dphi23, kFALSE);
   
+  const char* macroname = "MakePMDFullMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // Create a File to store the alignment data
-    TFile f("PMDfullMisalignment.root","RECREATE");
-    if(!f) {cerr<<"cannot open file for output\n";}    
+    const char* filename = "PMDfullMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"PMDAlignObjs ","kSingleKey");
+    f.WriteObject(array,"PMDAlignObjs","kSingleKey");
     f.Close();
   }else{
   // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("");
     md->SetComment("Full misalignment for PMD, produced with sigmatr=0.1 and sigmarot=0.1 in the local RS");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("PMD/Align/Data",0,9999999);
+    AliCDBId id("PMD/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
   array->Delete();

diff --git a/PMD/MakePMDResMisAlignment.C b/PMD/MakePMDResMisAlignment.C
index ff658f9dc991ca9b5b25fdf9ab5bcbfa9604ae66..63918985aad87d4c7d6fc06e52cf4e32815772e0 100644 (file)
--- a/PMD/MakePMDResMisAlignment.C
+++ b/PMD/MakePMDResMisAlignment.C
@@ -34,7 +34,12 @@ void MakePMDResMisAlignment(){
     // Steel plate 
  */
   
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   Float_t max_trans=0.1;
@@ -101,24 +106,39 @@ void MakePMDResMisAlignment(){
   new(alobj[2]) AliAlignObjAngles(Sector3, volid, dx23, dy23, dz23, dpsi23, dtheta23, dphi23, kFALSE);
   new(alobj[3]) AliAlignObjAngles(Sector4, volid, dx23, dy23, dz23, dpsi23, dtheta23, dphi23, kFALSE);
   
+  const char* macroname = "MakePMDResMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // Create a File to store the alignment data
-    TFile f("PMDresidualMisalignment.root","RECREATE");
-    if(!f) {cerr<<"cannot open file for output\n";}
-    
+    const char* filename = "PMDresidualMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"PMDAlignObjs ","kSingleKey");
+    f.WriteObject(array,"PMDAlignObjs","kSingleKey");
     f.Close();
   }else{
   // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("");
     md->SetComment("Residual misalignment for PMD, produced with sigmatr=0.1 and sigmarot=0.1 in the local RS");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("PMD/Align/Data",0,9999999);
+    AliCDBId id("PMD/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
   array->Delete();

diff --git a/PMD/MakePMDZeroMisAlignment.C b/PMD/MakePMDZeroMisAlignment.C
index b178f3fe0282f5cadf9a208c58ad06aa1de17453..7687b4961d96434281e31df82e72861131eae22c 100644 (file)
--- a/PMD/MakePMDZeroMisAlignment.C
+++ b/PMD/MakePMDZeroMisAlignment.C
@@ -34,7 +34,12 @@ void MakePMDZeroMisAlignment(){
     // Steel plate 
  */
   
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   //Create a TClonesArray of Align Object to store displacement Angles
@@ -54,24 +59,39 @@ void MakePMDZeroMisAlignment(){
     new(alobj[j++]) AliAlignObjAngles(snSector.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
   }
 
+  const char* macroname = "MakePMDZeroMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // Create a File to store the alignment data
-    TFile f("PMDzeroMisalignment.root","RECREATE");
-    if(!f) {cerr<<"cannot open file for output\n";}
-    
+    const char* filename = "PMDzeroMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"PMDAlignObjs ","kSingleKey");
+    f.WriteObject(array,"PMDAlignObjs","kSingleKey");
     f.Close();
   }else{
   // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("");
     md->SetComment("Zero misalignment for PMD");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("PMD/Align/Data",0,9999999);
+    AliCDBId id("PMD/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
   array->Delete();

diff --git a/T0/MakeT0FullMisAlignment.C b/T0/MakeT0FullMisAlignment.C
index 0ea0274927f1d445a57d87e3e3654f6fcb8d38ce..c356ef777e236822bf1c1ab95927d2ef35d99cf0 100644 (file)
--- a/T0/MakeT0FullMisAlignment.C
+++ b/T0/MakeT0FullMisAlignment.C
@@ -4,7 +4,12 @@ void MakeT0FullMisAlignment(){
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",30);
   TClonesArray &alobj = *array;
 
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+    AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
 
   AliAlignObjAngles a;
 
@@ -39,23 +44,39 @@ void MakeT0FullMisAlignment(){
     new(alobj[j++]) AliAlignObjAngles(symName.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
   }
   
-  if(!gSystem->Getenv("$TOCDB")){
+  const char* macroname = "MakeT0FullMisAlignment.C";
+  if( TString(gSystem->Getenv("TOCDB")) != TString("kTRUE") ){
     // save on file
-    TFile f("T0fullMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "T0fullMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"T0FullObjs ","kSingleKey");
-    f.Close();
+    f.WriteObject(array,"T0AlignObjs","kSingleKey");
+    f.Close();    TFile f(filename,"RECREATE");
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("$STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Tomasz Malkiewicz");
     md->SetComment("Full misalignment for T0, produced with sigmatr=0.05 and sigmarot=0.3 in the local RS");
     md->SetAliRootVersion(gSystem->Getenv("$ARVERSION"));
-    AliCDBId id("T0/Align/Data",0,9999999);
+    AliCDBId id("T0/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/T0/MakeT0ResMisAlignment.C b/T0/MakeT0ResMisAlignment.C
index db62a31ac36353c3417c9cd7d699158c57636b89..650267f7cc2f6abaa9e774eac4292d646032a153 100644 (file)
--- a/T0/MakeT0ResMisAlignment.C
+++ b/T0/MakeT0ResMisAlignment.C
@@ -4,7 +4,12 @@ void MakeT0ResMisAlignment(){
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",30);
   TClonesArray &alobj = *array;
 
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   AliAlignObjAngles a;
@@ -40,23 +45,39 @@ void MakeT0ResMisAlignment(){
     new(alobj[j++]) AliAlignObjAngles(symName.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
   }
   
-  if(!gSystem->Getenv("$TOCDB")){
+  const char* macroname = "MakeT0ResMisAlignment.C";
+  if( TString(gSystem->Getenv("TOCDB")) != TString("kTRUE") ){
     // save on file
-    TFile f("T0residualMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "T0residualMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"T0ResidualObjs ","kSingleKey");
+    f.WriteObject(array,"T0AlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("$STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Tomasz Malkiewicz");
     md->SetComment("Residual misalignment for T0, produced with sigmatr=0.05 and sigmarot=0.3 in the local RS");
     md->SetAliRootVersion(gSystem->Getenv("$ARVERSION"));
-    AliCDBId id("T0/Align/Data",0,9999999);
+    AliCDBId id("T0/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/T0/MakeT0ZeroMisAlignment.C b/T0/MakeT0ZeroMisAlignment.C
index eded0620e17a2f69e42261b316e4ee4ce1b5dd04..fd435e70f5348da17e2e540af0f66b300fb8716a 100644 (file)
--- a/T0/MakeT0ZeroMisAlignment.C
+++ b/T0/MakeT0ZeroMisAlignment.C
@@ -28,23 +28,39 @@ void MakeT0ZeroMisAlignment(){
       new(alobj[j++]) AliAlignObjAngles(symName.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
     }
 
-  if(!gSystem->Getenv("$TOCDB")){
+  const char* macroname = "MakeT0ZeroMisAlignment.C";
+  if( TString(gSystem->Getenv("TOCDB")) != TString("kTRUE") ){
     // save on file
-    TFile f("T0zeroMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "T0zeroMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"T0ZeroObjs","kSingleKey");
+    f.WriteObject(array,"T0AlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("$STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Tomasz Malkiewicz");
     md->SetComment("Zero misalignment for T0, produced with sigmatr=0.05 and sigmarot=0.3 in the local RS");
     md->SetAliRootVersion(gSystem->Getenv("$ARVERSION"));
-    AliCDBId id("T0/Align/Data",0,9999999);
+    AliCDBId id("T0/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/TOF/MakeTOFFullMisAlignment.C b/TOF/MakeTOFFullMisAlignment.C
index 327584ce2369b9af13a93207ed80476beb288557..ce80e90672270d8b4b5942bced1a5754a06f30a7 100644 (file)
--- a/TOF/MakeTOFFullMisAlignment.C
+++ b/TOF/MakeTOFFullMisAlignment.C
@@ -4,7 +4,12 @@ void MakeTOFFullMisAlignment(){
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",2000);
   TClonesArray &alobj = *array;
    
-  if(!gGeoManager) TGeoManager::Import("/home/rgrosso/Prove/AliRoot/geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+    AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
 
   AliAlignObjAngles a;
   Double_t sfdpsi=0.,sfdtheta=0.,sfdphi=0.;
@@ -102,9 +107,9 @@ void MakeTOFFullMisAlignment(){
       return;
     }
   }
-  gGeoManager->Export("/home/rgrosso/MacroAllineamento010207/geom_misalBSEGMO.root");
-  gGeoManager=0x0;
-  TGeoManager::Import("/home/rgrosso/MacroAllineamento010207/geom_misalBSEGMO.root");
+  gGeoManager->Export("./geom_misalBSEGMO.root");
+  
+  AliGeomManager::LoadGeometry("./geom_misalBSEGMO.root");
 
   // TOF part !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
   Int_t nSMTOF = 18;
@@ -132,11 +137,9 @@ void MakeTOFFullMisAlignment(){
       return;
     }
   }
-  gGeoManager->Export("/home/rgrosso/MacroAllineamento010207/geom_misalBSEGMO_tofSM.root");
-
+  gGeoManager->Export("./geom_misalBSEGMO_tofSM.root");
 
-  gGeoManager=0x0;
-  TGeoManager::Import("/home/rgrosso/MacroAllineamento010207/geom_misalBSEGMO_tofSM.root");
+  AliGeomManager::LoadGeometry("./geom_misalBSEGMO_tofSM.root");
   // tof strips as in residual
   AliGeomManager::ELayerID idTOF = AliGeomManager::kTOF;
 
@@ -157,27 +160,44 @@ void MakeTOFFullMisAlignment(){
     new(alobj[j++]) AliAlignObjAngles(AliGeomManager::SymName(idTOF,i), AliGeomManager::LayerToVolUID(idTOF,i), sdx, sdy, sdz, sdpsi, sdtheta, sdphi, kFALSE);
   }
 
+  const char* macroname = "MakeTOFFullMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("TOFfullMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "TOFfullMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(array,"TOFAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Silvia Arcelli");
     md->SetComment("Full misalignment for TOF and FRAME");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("TOF/Align/Data",0,9999999);
+    AliCDBId id("TOF/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 
   array->Delete();
+  gGeoManager = 0x0;
 
 }
 

diff --git a/TOF/MakeTOFResMisAlignment.C b/TOF/MakeTOFResMisAlignment.C
index 5b3150dce089f877856dd61827c71b09edaf3068..7a788e42a86676e7c21fc0e47e71cc64d5720d72 100644 (file)
--- a/TOF/MakeTOFResMisAlignment.C
+++ b/TOF/MakeTOFResMisAlignment.C
@@ -4,7 +4,12 @@ void MakeTOFResMisAlignment(){
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",2000);
   TClonesArray &alobj = *array;
    
-  if(!gGeoManager) TGeoManager::Import("/home/rgrosso/Prove/AliRoot/geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   AliAlignObjAngles a;
@@ -30,23 +35,39 @@ void MakeTOFResMisAlignment(){
     j++;
   }
 
+  const char* macroname = "MakeTOFResMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("TOFresidualMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "TOFresidualMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(array,"TOFAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Silvia Arcelli");
     md->SetComment("Residual misalignment for TOF, sigmatr=1mm in the local RS");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("TOF/Align/Data",0,9999999);
+    AliCDBId id("TOF/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/TOF/MakeTOFZeroMisAlignment.C b/TOF/MakeTOFZeroMisAlignment.C
index 93f5d98baca390a6b890d04192a3a816c5ab59cb..7c9cfcee6bbd62d9d5bdb17df7e389cef69e030a 100644 (file)
--- a/TOF/MakeTOFZeroMisAlignment.C
+++ b/TOF/MakeTOFZeroMisAlignment.C
@@ -4,7 +4,12 @@ void MakeTOFZeroMisAlignment(){
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",2000);
   TClonesArray &alobj = *array;
    
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   AliAlignObjAngles a;
@@ -18,23 +23,39 @@ void MakeTOFZeroMisAlignment(){
     new(alobj[j++]) AliAlignObjAngles(AliGeomManager::SymName(idTOF,i), AliGeomManager::LayerToVolUID(idTOF,i), dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
   }
 
+  const char* macroname = "MakeTOFZeroMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("TOFzeroMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "TOFzeroMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(array,"TOFAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Silvia Arcelli");
     md->SetComment("Zero misalignment for TOF");
     md->SetAliRootVersion("HEAD");
-    AliCDBId id("TOF/Align/Data",0,9999999);
+    AliCDBId id("TOF/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/TPC/MakeTPCFullMisAlignment.C b/TPC/MakeTPCFullMisAlignment.C
index 7e864fffc156cd7f68669d2384555be30bd90779..a5df8b18a5690aa72bdaa88220725be876d2360a 100644 (file)
--- a/TPC/MakeTPCFullMisAlignment.C
+++ b/TPC/MakeTPCFullMisAlignment.C
@@ -1,7 +1,12 @@
 void MakeTPCFullMisAlignment(){
   // Create TClonesArray of full misalignment objects for TPC
   //
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",100);
@@ -35,23 +40,39 @@ void MakeTPCFullMisAlignment(){
   }
 
 
+  const char* macroname = "MakeTPCFullMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("TPCfullMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "TPCfullMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(array,"TPCAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Marian Ivanov");
     md->SetComment("Full misalignment for TPC, sigmatr=0.01 and sigmarot=0.6 in the local RS");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("TPC/Align/Data",0,9999999);
+    AliCDBId id("TPC/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/TPC/MakeTPCResMisAlignment.C b/TPC/MakeTPCResMisAlignment.C
index f6f635ea7513ee57f94b239683cc87340e049eca..0fa4084f79bcb96e3270ac9c96e3c08c23b25f40 100644 (file)
--- a/TPC/MakeTPCResMisAlignment.C
+++ b/TPC/MakeTPCResMisAlignment.C
@@ -1,7 +1,12 @@
 void MakeTPCResMisAlignment(){
   // Create TClonesArray of residual misalignment objects for TPC
   //
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",100);
@@ -35,23 +40,39 @@ void MakeTPCResMisAlignment(){
   }
 
 
+  const char* macroname = "MakeTPCResMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("TPCresidualMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "TPCresidualMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(array,"TPCAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Marian Ivanov");
     md->SetComment("Residual misalignment for TPC, sigmatr=0.01 and sigmarot=0.6 in the local RS");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("TPC/Align/Data",0,9999999);
+    AliCDBId id("TPC/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/TPC/MakeTPCZeroMisAlignment.C b/TPC/MakeTPCZeroMisAlignment.C
index 3af90ecbda182b012c42decbb9ff568c7d61a627..b700beed65e8030279f0b90c370d0ec42615a750 100644 (file)
--- a/TPC/MakeTPCZeroMisAlignment.C
+++ b/TPC/MakeTPCZeroMisAlignment.C
@@ -1,7 +1,12 @@
 void MakeTPCZeroMisAlignment(){
   // Create TClonesArray of zero misalignment objects for TPC
   //
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",100);
@@ -23,23 +28,39 @@ void MakeTPCZeroMisAlignment(){
   }
 
 
+  const char* macroname = "MakeTPCZeroMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("TPCzeroMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "TPCzeroMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(array,"TPCAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Marian Ivanov");
     md->SetComment("Zero misalignment for TPC");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("TPC/Align/Data",0,9999999);
+    AliCDBId id("TPC/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/TRD/MakeTRDFullMisAlignment.C b/TRD/MakeTRDFullMisAlignment.C
index 271b606cfd289dc0cee7c0f544c37498c9e7540f..be4be7ca97e3cf80380a1398152ccfb02fd0be17 100644 (file)
--- a/TRD/MakeTRDFullMisAlignment.C
+++ b/TRD/MakeTRDFullMisAlignment.C
@@ -30,7 +30,7 @@ void MakeTRDFullMisAlignment(){
   UShort_t volid;
   const char *symname;
 
-  TGeoManager::Import("/home/rgrosso/MacroAllineamento010207/geom_misalBSEGMO.root"); // geometry where the BSEGMO volumes have been misaligned
+  AliGeomManager::LoadGeometry("./geom_misalBSEGMO.root"); // geometry where the BSEGMO volumes have been misaligned
 
   // create the supermodules' alignment objects
   for (int i; i<18; i++) {
@@ -54,9 +54,8 @@ void MakeTRDFullMisAlignment(){
       return;
     }
   }
-  gGeoManager->Export("/home/rgrosso/MacroAllineamento010207/geom_misalBSEGMO_trdSM.root");
-  gGeoManager=0x0;
-  TGeoManager::Import("/home/rgrosso/MacroAllineamento010207/geom_misalBSEGMO_trdSM.root");
+  gGeoManager->Export("./geom_misalBSEGMO_trdSM.root");
+  AliGeomManager::LoadGeometry("./geom_misalBSEGMO_trdSM.root");
   // create the chambers' alignment objects
   ran = new TRandom(4357);
   for (Int_t iLayer = AliGeomManager::kTRD1; iLayer <= AliGeomManager::kTRD6; iLayer++) {
@@ -76,28 +75,44 @@ void MakeTRDFullMisAlignment(){
     }
   }
 
+  const char* macroname = "MakeTRDFullMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("TRDfullMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "TRDfullMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(array,"TRDAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Dariusz Miskowiec");
     md->SetComment("Full misalignment for TRD");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("TRD/Align/Data",0,9999999);
+    AliCDBId id("TRD/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 
   array->Delete();
-
+  gGeoManager = 0x0;
 }
 
 

diff --git a/TRD/MakeTRDResMisAlignment.C b/TRD/MakeTRDResMisAlignment.C
index 420ed9bd9a0334b477bedbe03f2156d86289c43f..3b2ea18ee54ead4c665b7e7f410fe03c92a72408 100644 (file)
--- a/TRD/MakeTRDResMisAlignment.C
+++ b/TRD/MakeTRDResMisAlignment.C
@@ -4,7 +4,12 @@ void MakeTRDResMisAlignment(){
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",1000);
   TClonesArray &alobj = *array;
    
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   AliAlignObjAngles a;
@@ -42,23 +47,39 @@ void MakeTRDResMisAlignment(){
     }
   }
 
+  const char* macroname = "MakeTRDResMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("TRDresidualMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "TRDresidualMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(array,"TRDAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Dariusz Miskowiec");
     md->SetComment("Residual misalignment for TRD");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("TRD/Align/Data",0,9999999);
+    AliCDBId id("TRD/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/TRD/MakeTRDZeroMisAlignment.C b/TRD/MakeTRDZeroMisAlignment.C
index e226f6df0166717f57e2c915ab6a56df46b45f98..523e640521e02e8b8a09c0d81ea4a2e90a2f332d 100644 (file)
--- a/TRD/MakeTRDZeroMisAlignment.C
+++ b/TRD/MakeTRDZeroMisAlignment.C
@@ -4,7 +4,12 @@ void MakeTRDZeroMisAlignment(){
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",1000);
   TClonesArray &alobj = *array;
    
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   AliAlignObjAngles a;
@@ -24,23 +29,39 @@ void MakeTRDZeroMisAlignment(){
     }
   }
 
+  const char* macroname = "MakeTRDZeroMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("TRDzeroMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "TRDzeroMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
     f.WriteObject(array,"TRDAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Dariusz Miskowiec");
     md->SetComment("Zero misalignment for TRD");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("TRD/Align/Data",0,9999999);
+    AliCDBId id("TRD/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/VZERO/MakeVZEROFullMisAlignment.C b/VZERO/MakeVZEROFullMisAlignment.C
index 6a61de0774dd1a8e5a040fb3c7f0ad178ec7f19e..1cbb06e41eb194f0d401fb71ca65b04b7860ccc4 100644 (file)
--- a/VZERO/MakeVZEROFullMisAlignment.C
+++ b/VZERO/MakeVZEROFullMisAlignment.C
@@ -1,7 +1,12 @@
 void MakeVZEROFullMisAlignment(){
   // Create TClonesArray of full misalignment objects for VZERO
   // 
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
@@ -40,23 +45,39 @@ void MakeVZEROFullMisAlignment(){
   new(alobj[1]) AliAlignObjAngles(V0left, volid, dx, dy, dz, dpsi, dtheta,
                                   dphi,kFALSE);
 
+  const char* macroname = "MakeVZEROFullMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("V0fullMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "VZEROfullMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"V0FullObjs ","kSingleKey");
+    f.WriteObject(array,"VZEROAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Brigitte Cheynis");
     md->SetComment("Alignment objects for V0 full misalignment");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("VZERO/Align/Data",0,9999999);
+    AliCDBId id("VZERO/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/VZERO/MakeVZEROResMisAlignment.C b/VZERO/MakeVZEROResMisAlignment.C
index 1d746a9dd0d5c1dfc26a6267966904a67ccc3d51..615828636928c9d5bb5cc030ad1417c04e7b9d2e 100644 (file)
--- a/VZERO/MakeVZEROResMisAlignment.C
+++ b/VZERO/MakeVZEROResMisAlignment.C
@@ -1,7 +1,12 @@
 void MakeVZEROResMisAlignment(){
   // Create TClonesArray of residual misalignment objects for VZERO
   //
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
@@ -36,23 +41,39 @@ void MakeVZEROResMisAlignment(){
   dphi = rnd->Gaus(0.,sigmarot);
   new(alobj[1]) AliAlignObjAngles(V0left, volid, dx, dy, dz, dpsi, dtheta, dphi,kFALSE);
 
+  const char* macroname = "MakeVZEROResMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("V0residualMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "VZEROresidualMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"V0ResidualObjs ","kSingleKey");
+    f.WriteObject(array,"VZEROAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Brigitte Cheynis");
     md->SetComment("Alignment objects for V0 residual misalignment");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("VZERO/Align/Data",0,9999999);
+    AliCDBId id("VZERO/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/VZERO/MakeVZEROZeroMisAlignment.C b/VZERO/MakeVZEROZeroMisAlignment.C
index 6acae820061ec4170bbf4625210a96fda73f2626..5a1b64be778a6219651a0717538e88431694423e 100644 (file)
--- a/VZERO/MakeVZEROZeroMisAlignment.C
+++ b/VZERO/MakeVZEROZeroMisAlignment.C
@@ -1,7 +1,12 @@
 void MakeVZEROZeroMisAlignment(){
   // Create TClonesArray of zero misalignment objects for VZERO
   //
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
@@ -20,23 +25,39 @@ void MakeVZEROZeroMisAlignment(){
   TString V0left("VZERO/V0A");
   new(alobj[1]) AliAlignObjAngles(V0left.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi,kTRUE);
 
+  const char* macroname = "MakeVZEROZeroMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save on file
-    TFile f("V0zeroMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "VZEROzeroMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"V0ZeroAlObjs ","kSingleKey");
+    f.WriteObject(array,"VZEROAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Brigitte Cheynis");
     md->SetComment("Alignment objects for V0 zero-misalignment");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("VZERO/Align/Data",0,9999999);
+    AliCDBId id("VZERO/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/ZDC/MakeZDCFullMisAlignment.C b/ZDC/MakeZDCFullMisAlignment.C
index 0f369282e97c19bb85501ae791ee6498df1ee902..4fa6a0130e879e06688a78fe6a775d3896fcaf00 100644 (file)
--- a/ZDC/MakeZDCFullMisAlignment.C
+++ b/ZDC/MakeZDCFullMisAlignment.C
@@ -1,7 +1,12 @@
 void MakeZDCFullMisAlignment(){
   // Create TClonesArray of full misalignment objects for ZDC
   //
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
@@ -22,23 +27,39 @@ void MakeZDCFullMisAlignment(){
   new(alobj[0]) AliAlignObjAngles(ZDCn, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
   new(alobj[1]) AliAlignObjAngles(ZDCp, volid, dx, dy, dz, dpsi, dtheta, dphi,kTRUE);
 
+  const char* macroname = "MakeZDCFullMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save in file
-    TFile f("ZDCfullMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "ZDCfullMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"ZDCFullObjs ","kSingleKey");
+    f.WriteObject(array,"ZDCAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Chiara Oppedisano");
     md->SetComment("Alignment objects for ZDC full misalignment");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("ZDC/Align/Data",0,9999999);
+    AliCDBId id("ZDC/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/ZDC/MakeZDCResMisAlignment.C b/ZDC/MakeZDCResMisAlignment.C
index f87e7c644b9cc735d6c7e8f24df40fc61657a18f..820c11b7e2fdfb8c41a2884bdd2c4464c6a92f99 100644 (file)
--- a/ZDC/MakeZDCResMisAlignment.C
+++ b/ZDC/MakeZDCResMisAlignment.C
@@ -1,7 +1,12 @@
 void MakeZDCResMisAlignment(){
   // Create TClonesArray of residual misalignment objects for ZDC
   // 
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
@@ -22,23 +27,39 @@ void MakeZDCResMisAlignment(){
   new(alobj[0]) AliAlignObjAngles(ZDCn, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
   new(alobj[1]) AliAlignObjAngles(ZDCp, volid, dx, dy, dz, dpsi, dtheta, dphi,kTRUE);
 
+  const char* macroname = "MakeZDCResMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save in file
-    TFile f("ZDCresidualMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "ZDCresidualMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"ZDCResidualObjs ","kSingleKey");
+    f.WriteObject(array,"ZDCAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Chiara Oppedisano");
     md->SetComment("Alignment objects for ZDC residual misalignment");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("ZDC/Align/Data",0,9999999);
+    AliCDBId id("ZDC/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/ZDC/MakeZDCZeroMisAlignment.C b/ZDC/MakeZDCZeroMisAlignment.C
index 4fe27992faccefcf7399232a720c3fd6217e5aac..a0204af81089eb7f9547848587f4201e438f5485 100644 (file)
--- a/ZDC/MakeZDCZeroMisAlignment.C
+++ b/ZDC/MakeZDCZeroMisAlignment.C
@@ -1,7 +1,12 @@
 void MakeZDCZeroMisAlignment(){
   // Create TClonesArray of zero misalignment objects for ZDC
   // 
-  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
+  }
   // needed for the constructors with local coordinates not to fail
 
   TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
@@ -22,23 +27,39 @@ void MakeZDCZeroMisAlignment(){
   new(alobj[0]) AliAlignObjAngles(ZDCn, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
   new(alobj[1]) AliAlignObjAngles(ZDCp, volid, dx, dy, dz, dpsi, dtheta, dphi,kTRUE);
 
+  const char* macroname = "MakeZDCZeroMisAlignment.C";
   if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
     // save in file
-    TFile f("ZDCzeroMisalignment.root","RECREATE");
-    if(!f) cerr<<"cannot open file for output\n";
+    const char* filename = "ZDCzeroMisalignment.root";
+    TFile f(filename,"RECREATE");
+    if(!f){
+      Error(macroname,"cannot open file for output\n");
+      return;
+    }
+    Info(macroname,"Saving alignment objects to the file %s", filename);
     f.cd();
-    f.WriteObject(array,"ZDCZeroAlObjs ","kSingleKey");
+    f.WriteObject(array,"ZDCAlignObjs","kSingleKey");
     f.Close();
   }else{
     // save in CDB storage
-    const char* Storage = gSystem->Getenv("STORAGE");
+    TString Storage = gSystem->Getenv("STORAGE");
+    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
+      Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
+      return;
+    }
+    Info(macroname,"Saving alignment objects in CDB storage %s",
+        Storage.Data());
     AliCDBManager* cdb = AliCDBManager::Instance();
-    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
+    if(!storage){
+      Error(macroname,"Unable to open storage %s\n",Storage.Data());
+      return;
+    }
     AliCDBMetaData* md = new AliCDBMetaData();
     md->SetResponsible("Chiara Oppedisano");
     md->SetComment("Alignment objects for ZDC zero misalignment");
     md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
-    AliCDBId id("ZDC/Align/Data",0,9999999);
+    AliCDBId id("ZDC/Align/Data",0,AliCDBRunRange::Infinity());
     storage->Put(array,id,md);
   }
 

diff --git a/macros/MakeAllDETsFullMisAlignment.C b/macros/MakeAllDETsFullMisAlignment.C
index 3a9cf544c4f6a507512dfcf9865ad035c3ee0a87..cb08f64fea46c0c8a002131614689c85cee39be0 100644 (file)
--- a/macros/MakeAllDETsFullMisAlignment.C
+++ b/macros/MakeAllDETsFullMisAlignment.C
@@ -16,13 +16,11 @@ void MakeAllDETsFullMisAlignment(Char_t* CDBstorage = "local://$HOME/Full"){
     gSystem->Setenv("ARVERSION","v4-05-08");
   }
 
-  // if not already present, create geometry file needed by those detectors
-  // producing their objects in the local RS
-  if(gSystem->AccessPathName("./geometry.root")){
-    gAlice->Init();
-    gGeoManager->Export("geometry.root");
-  }else{
-    TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
   }
 
   TString dets = "EMCAL,FMD,ITS,MUON,PHOS,PMD,HMPID,T0,TOF,TPC,TRD,VZERO,ZDC";

diff --git a/macros/MakeAllDETsResMisAlignment.C b/macros/MakeAllDETsResMisAlignment.C
index 59c71f1fedc69e116a5ba4f68aae4dda2c18ccef..fb9a284c0905e0a022776be41e3c40ac7fd17b3b 100644 (file)
--- a/macros/MakeAllDETsResMisAlignment.C
+++ b/macros/MakeAllDETsResMisAlignment.C
@@ -16,13 +16,11 @@ void MakeAllDETsResMisAlignment(Char_t* CDBstorage = "local://$HOME/Residual"){
     gSystem->Setenv("ARVERSION","v4-05-08");
   }
 
-  // if not already present, create geometry file needed by those detectors
-  // producing their objects in the local RS
-  if(gSystem->AccessPathName("./geometry.root")){
-    gAlice->Init();
-    gGeoManager->Export("geometry.root");
-  }else{
-    TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
   }
 
   TString dets="EMCAL,FMD,HMPID,ITS,MUON,PHOS,PMD,T0,TOF,TPC,TRD,VZERO,ZDC";

diff --git a/macros/MakeAllDETsZeroMisAlignment.C b/macros/MakeAllDETsZeroMisAlignment.C
index 5f74035a8a721a10959f2eb52743cee1ace61898..8d426053dd6d0fa4c2f112ecce9c6786ddbf5be9 100644 (file)
--- a/macros/MakeAllDETsZeroMisAlignment.C
+++ b/macros/MakeAllDETsZeroMisAlignment.C
@@ -13,15 +13,14 @@ void MakeAllDETsZeroMisAlignment(Char_t* CDBstorage = "local://$HOME/Zero"){
     gSystem->Setenv("ARVERSION","v4-05-08");
   }
 
-  // if not already present, create geometry file needed by those detectors
-  // producing their objects in the local RS
-  if(gSystem->AccessPathName("./geometry.root")){
-    gAlice->Init();
-    gGeoManager->Export("geometry.root");
-  }else{
-    TGeoManager::Import("geometry.root");
+  if(!AliGeomManager::GetGeometry()){
+    if(!(AliCDBManager::Instance())->IsDefaultStorageSet())
+      AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+      AliCDBManager::Instance()->SetRun(0);
+    AliGeomManager::LoadGeometry();
   }
 
+
   TString dets="EMCAL,FMD,HMPID,ITS,MUON,PMD,PHOS,T0,TRD,TPC,TOF,VZERO,ZDC";
   TObjArray *detArray = dets.Tokenize(',');
   TIter iter(detArray);