Using AliGeomManager in the macros (Raffaele)

diff --git a/EMCAL/MakeEMCALFullMisAlignment.C b/EMCAL/MakeEMCALFullMisAlignment.C
index 3436d84..ee4a92f 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 ff1dbc3..721e601 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 c0db87e..41ed85d 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 3703439..c37269d 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 f3fc50c..276cd5b 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 5dd4074..678c4a4 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 66bf689..6f5546c 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 3ac26aa..a9aac14 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 e6e40fe..609efb5 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 8e3ad7c..742bdcf 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 c877176..60327e6 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 e10d17b..0fa7324 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 d4bce05..07bf987 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 b2d514a..bcc9fc0 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 c159a21..8de69b7 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 8ce9a72..88c8694 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 5b4bee3..5bdd22b 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 86a9d54..307f838 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 5a94385..cbea35d 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 ff658f9..6391898 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 b178f3f..7687b49 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 0ea0274..c356ef7 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 db62a31..650267f 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 eded062..fd435e7 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 327584c..ce80e90 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 5b3150d..7a788e4 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 93f5d98..7c9cfce 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 7e864ff..a5df8b1 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 f6f635e..0fa4084 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 3af90ec..b700bee 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 271b606..be4be7c 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 420ed9b..3b2ea18 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 e226f6d..523e640 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 6a61de0..1cbb06e 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 1d746a9..6158286 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 6acae82..5a1b64b 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 0f36928..4fa6a01 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 f87e7c6..820c11b 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 4fe2799..a0204af 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 3a9cf54..cb08f64 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 59c71f1..fb9a284 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 5f74035..8d42605 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);