Macros for residual and full misalignment, collected by Raffaele
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 11 Oct 2006 07:39:49 +0000 (07:39 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 11 Oct 2006 07:39:49 +0000 (07:39 +0000)
28 files changed:
EMCAL/MakeEMCALFullMisAlignment.C [new file with mode: 0644]
EMCAL/MakeEMCALResMisAlignment.C [new file with mode: 0644]
FMD/MakeFMDFullMisAlignment.C [new file with mode: 0644]
FMD/MakeFMDResMisAlignment.C [new file with mode: 0644]
ITS/MakeITSFullMisAlignment.C [new file with mode: 0644]
ITS/MakeITSResMisAlignment.C [new file with mode: 0644]
MUON/MakeMUONFullMisAlignment.C [new file with mode: 0644]
MUON/MakeMUONResMisAlignment.C [new file with mode: 0644]
PHOS/MakePHOSFullMisAlignment.C [new file with mode: 0644]
PHOS/MakePHOSResMisAlignment.C [new file with mode: 0644]
PMD/MakePMDFullMisAlignment.C [new file with mode: 0644]
PMD/MakePMDResMisAlignment.C [new file with mode: 0644]
RICH/MakeRICHFullMisAlignment.C [new file with mode: 0644]
RICH/MakeRICHResMisAlignment.C [new file with mode: 0644]
START/MakeSTARTFullMisAlignment.C [new file with mode: 0644]
START/MakeSTARTResMisAlignment.C [new file with mode: 0644]
TOF/MakeTOFFullMisAlignment.C [new file with mode: 0644]
TOF/MakeTOFResMisAlignment.C [new file with mode: 0644]
TPC/MakeTPCFullMisAlignment.C [new file with mode: 0644]
TPC/MakeTPCResMisAlignment.C [new file with mode: 0644]
TRD/MakeTRDFullMisAlignment.C [new file with mode: 0644]
TRD/MakeTRDResMisAlignment.C [new file with mode: 0644]
VZERO/MakeVZEROFullMisAlignment.C [new file with mode: 0644]
VZERO/MakeVZEROResMisAlignment.C [new file with mode: 0644]
ZDC/MakeZDCFullMisAlignment.C [new file with mode: 0644]
ZDC/MakeZDCResMisAlignment.C [new file with mode: 0644]
macros/MakeAllDETsFullMisAlignment.C [new file with mode: 0644]
macros/MakeAllDETsResMisAlignment.C [new file with mode: 0644]

diff --git a/EMCAL/MakeEMCALFullMisAlignment.C b/EMCAL/MakeEMCALFullMisAlignment.C
new file mode 100644 (file)
index 0000000..0d19e90
--- /dev/null
@@ -0,0 +1,64 @@
+void MakeEMCALFullMisAlignment(){
+  // Create TClonesArray of full misalignment objects for EMCAL
+  //
+  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
+
+  AliAlignObjAngles a;
+
+  Double_t dx, dy, dz, dpsi, dtheta, dphi;
+  TRandom *rnd   = new TRandom(4321);
+  Double_t sigmatr = 0.1; // max shift in cm w.r.t. local RS
+  Double_t sigmarot = 0.1; // max rot in degrees w.r.t. local RS
+
+  // null shifts and rotations
+
+  const TString basepath = "ALIC_1/XEN1_1/SMOD_";
+  TString pathstr;
+
+  Int_t iIndex=0; //let all modules have index=0 in a layer with no LUT
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iIndex); //dummy volume identity
+  Int_t i;
+
+  for(i=0; i<10; i++){
+
+    dx = rnd->Gaus(0.,sigmatr);
+    dy = rnd->Gaus(0.,sigmatr);
+    dz = rnd->Gaus(0.,sigmatr);
+    dpsi = rnd->Gaus(0.,sigmarot);
+    dtheta = rnd->Gaus(0.,sigmarot);
+    dphi = rnd->Gaus(0.,sigmarot);
+    pathstr=basepath;
+    pathstr+=(i+1);
+    cout<<pathstr<<"  "<<dx<<"  "<<dy<<"  "<<dz<<"  "<<dpsi<<"  "<<dtheta<<"  "<<dphi<<"\n";
+    new(alobj[i]) AliAlignObjAngles(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+  }
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("EMCALfullMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"T0FullObjs ","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
diff --git a/EMCAL/MakeEMCALResMisAlignment.C b/EMCAL/MakeEMCALResMisAlignment.C
new file mode 100644 (file)
index 0000000..7c49a2f
--- /dev/null
@@ -0,0 +1,64 @@
+void MakeEMCALResMisAlignment(){
+  // Create TClonesArray of residual misalignment objects for EMCAL
+  //
+  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
+
+  AliAlignObjAngles a;
+
+  Double_t dx, dy, dz, dpsi, dtheta, dphi;
+
+  const TString basepath = "ALIC_1/XEN1_1/SMOD_";
+  TString pathstr;
+
+  Int_t iIndex=0; // let all modules have index=0 in a layer with no LUT
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iIndex);
+
+  Int_t i;
+
+  // RS = local
+  // sigma translation = 1mm
+  // sigma rotation = 0.1 degree
+  TRandom *rnd   = new TRandom(4321);
+  Double_t sigmatr = 0.1; // max shift in cm w.r.t. local RS
+  Double_t sigmarot = 0.1; // max rot in degrees w.r.t. local RS
+  for(i=0; i<10; i++){
+    dx = rnd->Gaus(0.,sigmatr);
+    dy = rnd->Gaus(0.,sigmatr);
+    dz = rnd->Gaus(0.,sigmatr);
+    dpsi = rnd->Gaus(0.,sigmarot);
+    dtheta = rnd->Gaus(0.,sigmarot);
+    dphi = rnd->Gaus(0.,sigmarot);
+    pathstr=basepath;
+    pathstr+=(i+1);
+    new(alobj[i]) AliAlignObjAngles(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+  }
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("EMCALresidualMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"T0ResidualObjs ","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
diff --git a/FMD/MakeFMDFullMisAlignment.C b/FMD/MakeFMDFullMisAlignment.C
new file mode 100644 (file)
index 0000000..bc8c6bb
--- /dev/null
@@ -0,0 +1,25 @@
+void MakeFMDFullMisAlignment(){
+  // Create TClonesArray of full misalignment objects for FMD
+  //
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+  
+  gSystem->Load("libFMDutil.so");
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    AliFMDAlignFaker faker(AliFMDAlignFaker::kAll, "geometry.root","FMDfullMisalignment.root");
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliFMDAlignFaker faker(AliFMDAlignFaker::kAll, "geometry.root", Storage);
+  }
+
+  // fRunMax should be changed in the constructor
+
+  faker.SetSensorDisplacement(-0.005, -0.005, -0.005, 0.005, 0.005, 0.005);
+  faker.SetSensorRotation(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5);
+  faker.SetHalfDisplacement(-0.25, -0.25, -0.25, 0.25, 0.25, 0.25);
+  faker.SetHalfRotation(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5);
+  faker.Exec();
+
+}
diff --git a/FMD/MakeFMDResMisAlignment.C b/FMD/MakeFMDResMisAlignment.C
new file mode 100644 (file)
index 0000000..db465ef
--- /dev/null
@@ -0,0 +1,26 @@
+void MakeFMDResMisAlignment()
+{
+  // Create TClonesArray of residual misalignment objects for FMD
+  //
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  
+  gSystem->Load("libFMDutil.so");
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    AliFMDAlignFaker faker(AliFMDAlignFaker::kAll, "geometry.root","");
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliFMDAlignFaker faker(AliFMDAlignFaker::kAll, "geometry.root", Storage);
+  }
+
+  // fRunMax should be changed in the constructor
+
+  faker.SetSensorDisplacement(-0.005, -0.005, -0.005, 0.005, 0.005, 0.005);
+  faker.SetSensorRotation(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5);
+  faker.SetHalfDisplacement(-0.25, -0.25, -0.25, 0.25, 0.25, 0.25);
+  faker.SetHalfRotation(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5);
+  faker.Exec();
+
+
+}
diff --git a/ITS/MakeITSFullMisAlignment.C b/ITS/MakeITSFullMisAlignment.C
new file mode 100644 (file)
index 0000000..4563364
--- /dev/null
@@ -0,0 +1,110 @@
+void MakeITSFullMisAlignment(){
+  // Create TClonesArray of full misalignment objects for ITS
+  //
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",4000);
+  TClonesArray &alobj = *array;
+   
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+
+  Double_t globalZ = 0.005; // in cm, = 50 microns
+  Double_t resFact = 0.7;
+  Double_t spdXY   = 0.0015*resFact;
+  Double_t sddXYZ  = 0.0030*resFact;
+  Double_t ssdXY   = 0.0020*resFact;
+  Double_t rot     = 0.018;
+  Double_t spdZ    = 0.002;
+  Double_t ssdZ    = 0.010;
+
+  TRandom *rnd   = new TRandom(65416087);
+  AliAlignObjAngles a;
+
+  Double_t dx=0., dy=0., dz=0., dpsi=0., dtheta=0., dphi=0.;
+
+  Int_t j = 0;
+  new(alobj[j]) AliAlignObjAngles("ALIC_1/ITSV_1", 0, dx, dy, globalZ, dpsi, dtheta, dphi, kTRUE);
+  j++;
+
+  for ( Int_t l = AliAlignObj::kSPD1; l <= AliAlignObj::kSSD2; l++) {
+    
+    printf("%i modules in layer %i\n", AliAlignObj::LayerSize(l), l);
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(l); iModule++) {
+
+      dpsi   = rnd->Gaus(0., rot);
+      dtheta = rnd->Gaus(0., rot);
+      dphi   = rnd->Gaus(0., rot);
+
+      AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer; 
+      switch (l) {
+      case 1: {
+       iLayer = AliAlignObj::kSPD1;
+       dx = rnd->Gaus(0., spdXY);
+       dy = rnd->Gaus(0., spdXY);
+       dz = rnd->Gaus(0., spdZ);
+      }; break;
+      case 2: {
+       iLayer = AliAlignObj::kSPD2;
+       dx = rnd->Gaus(0., spdXY);
+       dy = rnd->Gaus(0., spdXY);
+       dz = rnd->Gaus(0., spdZ);
+      }; break;
+      case 3: {
+       iLayer = AliAlignObj::kSDD1;
+       dx = rnd->Gaus(0., sddXYZ);
+       dy = rnd->Gaus(0., sddXYZ);
+       dz = rnd->Gaus(0., sddXYZ);
+      }; break;
+      case 4: {
+       iLayer = AliAlignObj::kSDD2;
+       dx = rnd->Gaus(0., sddXYZ);
+       dy = rnd->Gaus(0., sddXYZ);
+       dz = rnd->Gaus(0., sddXYZ);
+      }; break;
+      case 5: {
+       iLayer = AliAlignObj::kSSD1;
+       dx = rnd->Gaus(0., ssdXY);
+       dy = rnd->Gaus(0., ssdXY);
+       dz = rnd->Gaus(0., ssdZ);
+      }; break;
+      case 6: {
+       iLayer = AliAlignObj::kSSD2;
+       dx = rnd->Gaus(0., ssdXY);
+       dy = rnd->Gaus(0., ssdXY);
+       dz = rnd->Gaus(0., ssdZ);
+      }; break;
+      default: Printf("Wrong layer index in ITS (%d) !",l);
+      };
+      UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iModule);
+      const char *path = AliAlignObj::SymName(volid);
+
+      new(alobj[j]) AliAlignObjAngles(path, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+      j++;
+
+    }
+  }
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("ITSfullMisalignment.root","RECREATE");
+    if(!f) {cerr<<"cannot open file for output\n";}
+    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);
+    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);
+    storage->Put(array,id, md);
+  }
+
+  array->Delete();
+
+}
+
+
diff --git a/ITS/MakeITSResMisAlignment.C b/ITS/MakeITSResMisAlignment.C
new file mode 100644 (file)
index 0000000..cfbd0d8
--- /dev/null
@@ -0,0 +1,112 @@
+void MakeITSResMisAlignment(){
+  // Create TClonesArray of residual misalignment objects for ITS
+  //
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",4000);
+  TClonesArray &alobj = *array;
+   
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+
+  Double_t globalZ = 0.005; // in cm, = 50 microns
+  Double_t resFact = 0.7;
+  Double_t spdXY   = 0.0015*resFact;
+  Double_t sddXYZ  = 0.0030*resFact;
+  Double_t ssdXY   = 0.0020*resFact;
+  Double_t rot     = 0.018;
+  Double_t spdZ    = 0.002;
+  Double_t ssdZ    = 0.010;
+
+  TRandom *rnd   = new TRandom(65416087);
+  AliAlignObjAngles a;
+
+  Double_t dx=0., dy=0., dz=0., dpsi=0., dtheta=0., dphi=0.;
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer; 
+
+  Int_t j = 0;
+  new(alobj[j]) AliAlignObjAngles("ALIC_1/ITSV_1", 0, dx, dy, globalZ, dpsi, dtheta, dphi, kTRUE);
+  j++;
+
+  for ( Int_t l = AliAlignObj::kSPD1; l <= AliAlignObj::kSSD2; l++) {
+    
+    printf("%i modules in layer %i\n", AliAlignObj::LayerSize(l), l);
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(l); iModule++) {
+
+      dpsi   = rnd->Gaus(0., rot);
+      dtheta = rnd->Gaus(0., rot);
+      dphi   = rnd->Gaus(0., rot);
+
+      iLayer = AliAlignObj::kInvalidLayer; 
+
+      switch (l) {
+      case 1: {
+       iLayer = AliAlignObj::kSPD1;
+       dx = rnd->Gaus(0., spdXY);
+       dy = rnd->Gaus(0., spdXY);
+       dz = rnd->Gaus(0., spdZ);
+      }; break;
+      case 2: {
+       iLayer = AliAlignObj::kSPD2;
+       dx = rnd->Gaus(0., spdXY);
+       dy = rnd->Gaus(0., spdXY);
+       dz = rnd->Gaus(0., spdZ);
+      }; break;
+      case 3: {
+       iLayer = AliAlignObj::kSDD1;
+       dx = rnd->Gaus(0., sddXYZ);
+       dy = rnd->Gaus(0., sddXYZ);
+       dz = rnd->Gaus(0., sddXYZ);
+      }; break;
+      case 4: {
+       iLayer = AliAlignObj::kSDD2;
+       dx = rnd->Gaus(0., sddXYZ);
+       dy = rnd->Gaus(0., sddXYZ);
+       dz = rnd->Gaus(0., sddXYZ);
+      }; break;
+      case 5: {
+       iLayer = AliAlignObj::kSSD1;
+       dx = rnd->Gaus(0., ssdXY);
+       dy = rnd->Gaus(0., ssdXY);
+       dz = rnd->Gaus(0., ssdZ);
+      }; break;
+      case 6: {
+       iLayer = AliAlignObj::kSSD2;
+       dx = rnd->Gaus(0., ssdXY);
+       dy = rnd->Gaus(0., ssdXY);
+       dz = rnd->Gaus(0., ssdZ);
+      }; break;
+      default: Printf("Wrong layer index in ITS (%d) !",l);
+      };
+      UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iModule);
+      const char *path = AliAlignObj::SymName(volid);
+
+      new(alobj[j]) AliAlignObjAngles(path, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+      j++;
+
+    }
+  }
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("ITSresidualMisalignment.root","RECREATE");
+    if(!f) {cerr<<"cannot open file for output\n";}
+    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);
+    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);
+    storage->Put(array,id, md);
+  }
+
+  array->Delete();
+
+}
+
+
diff --git a/MUON/MakeMUONFullMisAlignment.C b/MUON/MakeMUONFullMisAlignment.C
new file mode 100644 (file)
index 0000000..39c1bc1
--- /dev/null
@@ -0,0 +1,76 @@
+void MakeMUONFullMisAlignment(Bool_t volpaths = true,
+                              Bool_t transforms = true, 
+                              Bool_t svmaps = true)
+// Macro for generating the geometry data files:
+// (volpath.dat, transform.dat, svmap.dat)
+// and local CDB storage with full misalignment
+//
+// The generated files do not replace the existing ones
+// but have different names (with extension ".out").
+//
+//  Author: I. Hrivnacova, IPN Orsay
+//
+{
+  // Initialize
+  gAlice->Init("$ALICE_ROOT/MUON/Config.C");
+  cout << "Init done " << endl;
+
+  // Get MUON detector
+  AliMUON* muon = (AliMUON*)gAlice->GetModule("MUON");
+  if (!muon) {
+    AliFatal("MUON detector not defined.");
+    return 0;
+  }  
+
+  // Get geometry builder
+  AliMUONGeometryBuilder* builder = muon ->GetGeometryBuilder();
+  
+  if (volpaths) {
+    cout << "Generating volpath file ..." << endl;
+    builder->GetTransformer()->WriteVolumePaths("volpath.dat.out");
+  }  
+
+  if (transforms) {
+    cout << "Generating transformation file ..." << endl;
+    builder->GetTransformer()->WriteTransformations("transform.dat.out");
+  }  
+  
+  if (svmaps) {
+    cout << "Generating svmaps file ..." << endl;
+    builder->WriteSVMaps();
+  }  
+  
+  cout << "Generating full misalignment data in  MUON/FullMisAlignCDB/Data..." << endl;
+  
+  AliMUONGeometryMisAligner misAligner(0.0, 0.03, 0.0, 0.03, 0.0, 0.03);
+  AliMUONGeometryTransformer* newTransform 
+    = misAligner.MisAlign(builder->GetTransformer(), true);
+  TClonesArray* array = newTransform->GetMisAlignmentData();
+  
+  if(!gSystem->Getenv("$TOCDB")){
+    // Create a File to store the alignment data
+    TFile f("MUONfullMisalignment.root","RECREATE");
+    if(!f) {cerr<<"cannot open file for output\n";}
+    
+    f.cd();
+    f.WriteObject(array,"MUONAlignObjs ","kSingleKey");
+    f.Close();
+    array->Delete();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    
+    AliCDBManager* cdbManager = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdbManager->GetStorage(Storage);
+    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); 
+    storage->Put(array, id, cdbData);
+    
+    delete newTransform;
+  }   
+  
+  
+}
diff --git a/MUON/MakeMUONResMisAlignment.C b/MUON/MakeMUONResMisAlignment.C
new file mode 100644 (file)
index 0000000..ecc57a6
--- /dev/null
@@ -0,0 +1,73 @@
+void MakeMUONResMisAlignment(Bool_t volpaths = true,
+                             Bool_t transforms = true, 
+                             Bool_t svmaps = true)
+// Macro for generating the geometry data files:
+// (volpath.dat, transform.dat, svmap.dat)
+// and local CDB storage with zero, residual and full misalignment
+//
+// The generated files do not replace the existing ones
+// but have different names (with extension ".out").
+//
+//  Author: I. Hrivnacova, IPN Orsay
+//
+{
+  // Initialize
+  gAlice->Init("$ALICE_ROOT/MUON/Config.C");
+  cout << "Init done " << endl;
+
+  // Get MUON detector
+  AliMUON* muon = (AliMUON*)gAlice->GetModule("MUON");
+  if (!muon) {
+    AliFatal("MUON detector not defined.");
+    return 0;
+  }  
+
+  // Get geometry builder
+  AliMUONGeometryBuilder* builder = muon ->GetGeometryBuilder();
+  
+  if (volpaths) {
+    cout << "Generating volpath file ..." << endl;
+    builder->GetTransformer()->WriteVolumePaths("volpath.dat.out");
+  }  
+
+  if (transforms) {
+    cout << "Generating transformation file ..." << endl;
+    builder->GetTransformer()->WriteTransformations("transform.dat.out");
+  }  
+
+  if (svmaps) {
+    cout << "Generating svmaps file ..." << endl;
+    builder->WriteSVMaps();
+  }  
+
+  cout << "Generating residual misalignment data in  MUON/ResMisAlignCDB/Data..." << endl;
+  
+  AliMUONGeometryMisAligner misAligner(0.0, 0.004, 0.0, 0.003, 0.0, 0.0023);
+  AliMUONGeometryTransformer* newTransform 
+    = misAligner.MisAlign(builder->GetTransformer(), true);
+  TClonesArray* array = newTransform->GetMisAlignmentData();
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // Create a File to store the alignment data
+    TFile f("MUONresidualMisalignment.root","RECREATE");
+    if(!f) {cerr<<"cannot open file for output\n";}
+    
+    f.cd();
+    f.WriteObject(array,"MUONAlignObjs ","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdbManager = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdbManager->GetStorage(Storage);
+    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); 
+    storage->Put(array, id, cdbData);
+  }
+  
+  delete newTransform;
+}   
+
diff --git a/PHOS/MakePHOSFullMisAlignment.C b/PHOS/MakePHOSFullMisAlignment.C
new file mode 100644 (file)
index 0000000..9e07379
--- /dev/null
@@ -0,0 +1,69 @@
+void MakePHOSFullMisAlignment(){
+  // Create TClonesArray of full misalignment objects for PHOS
+  //
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",11);
+  TClonesArray &alobj = *array;
+   
+  AliAlignObjAngles a;
+
+  Double_t dpsi=0., dtheta=0., dphi=0.;
+  Double_t displacement = 10;
+
+  Int_t iIndex=0; //let all modules have index=0 in a layer with no LUT
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iIndex);
+
+
+  // Alignment for 5 PHOS modules
+  new(alobj[0]) AliAlignObjAngles("/ALIC_1/PHOS_1",
+         volid, -20., -10.,   0., dpsi, dtheta, 5, kTRUE);
+  new(alobj[1]) AliAlignObjAngles("/ALIC_1/PHOS_2",
+         volid, -10.,   0., -10., dpsi, dtheta, 2, kTRUE);
+  new(alobj[2]) AliAlignObjAngles("/ALIC_1/PHOS_3",
+         volid,   5., -10.,  10., dpsi, dtheta, 0, kTRUE);
+  new(alobj[3]) AliAlignObjAngles("/ALIC_1/PHOS_4",
+         volid, +10.,  -0., -10., dpsi, dtheta, 2, kTRUE);
+  new(alobj[4]) AliAlignObjAngles("/ALIC_1/PHOS_5",
+         volid, +20., -10.,   0., dpsi, dtheta, 5, kTRUE);
+
+  // Alignment for PHOS cradle
+  new(alobj[5]) AliAlignObjAngles("/ALIC_1/PCRA_0",
+         volid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
+  new(alobj[6]) AliAlignObjAngles("/ALIC_1/PCRA_1",
+         volid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
+
+  // Alignment for cradle wheels
+  new(alobj[7]) AliAlignObjAngles("/ALIC_1/PWHE_0",
+         volid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
+  new(alobj[8]) AliAlignObjAngles("/ALIC_1/PWHE_1",
+         volid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
+  new(alobj[9]) AliAlignObjAngles("/ALIC_1/PWHE_2",
+         volid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
+  new(alobj[10]) AliAlignObjAngles("/ALIC_1/PWHE_3",
+         volid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
+
+  // *************************    2nd step    ***************
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("PHOSfullMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"PHOSFullObjs ","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager *CDB = AliCDBManager::Instance();
+    AliCDBStorage* storage = CDB->GetStorage(Storage);
+    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);
+    storage->Put(array,id, md);
+  }
+
+  array->Delete();
+
+}
diff --git a/PHOS/MakePHOSResMisAlignment.C b/PHOS/MakePHOSResMisAlignment.C
new file mode 100644 (file)
index 0000000..01aad31
--- /dev/null
@@ -0,0 +1,67 @@
+void MakePHOSResMisAlignment(){
+  // Create TClonesArray of residual misalignment objects for PHOS
+  //
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",11);
+  TClonesArray &alobj = *array;
+   
+  AliAlignObjAngles a;
+
+  Double_t dpsi=0., dtheta=0., dphi=0.;
+  Double_t displacement = 0.2;
+
+  Int_t iIndex=0; // let all modules have index=0 in a layer with no LUT
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iIndex);
+
+  // Alignment for 5 PHOS modules
+  new(alobj[0]) AliAlignObjAngles("/ALIC_1/PHOS_1",
+        volid, -0.20, -0.1, +0.0, dpsi, dtheta, 0.2, kTRUE);
+  new(alobj[1]) AliAlignObjAngles("/ALIC_1/PHOS_2",
+       volid, -0.10, +0.0, -0.2, dpsi, dtheta, 0.2, kTRUE);
+  new(alobj[2]) AliAlignObjAngles("/ALIC_1/PHOS_3",
+       volid,  0.05, -0.1,  0.2, dpsi, dtheta, 0.0, kTRUE);
+  new(alobj[3]) AliAlignObjAngles("/ALIC_1/PHOS_4",
+       volid, +0.10, -0.0, -0.1, dpsi, dtheta, 0.1, kTRUE);
+  new(alobj[4]) AliAlignObjAngles("/ALIC_1/PHOS_5",
+       volid, +0.20, -0.1,  0.1, dpsi, dtheta, 0.2, kTRUE);
+
+  // Alignment for PHOS cradle
+  new(alobj[5]) AliAlignObjAngles("/ALIC_1/PCRA_0",
+       volid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
+  new(alobj[6]) AliAlignObjAngles("/ALIC_1/PCRA_1",
+       volid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
+
+  // Alignment for cradle wheels
+  new(alobj[7])  AliAlignObjAngles("/ALIC_1/PWHE_0",
+       volid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
+  new(alobj[8])  AliAlignObjAngles("/ALIC_1/PWHE_1",
+       volid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
+  new(alobj[9])  AliAlignObjAngles("/ALIC_1/PWHE_2",
+       volid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
+  new(alobj[10]) AliAlignObjAngles("/ALIC_1/PWHE_3",
+       volid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
+
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("PHOSresidualMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"PHOSResidualObjs ","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager *CDB = AliCDBManager::Instance();
+    AliCDBStorage* storage = CDB->GetStorage(Storage);
+    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);
+    storage->Put(array,id, md);
+  }
+
+  array->Delete();
+
+}
diff --git a/PMD/MakePMDFullMisAlignment.C b/PMD/MakePMDFullMisAlignment.C
new file mode 100644 (file)
index 0000000..62becb6
--- /dev/null
@@ -0,0 +1,126 @@
+void MakePMDFullMisAlignment(){
+  // Create TClonesArray of full misalignment objects for PMD
+  //
+
+  // Macro to randomly displace the 4 sectors of the PMD
+  // in each plane. Each sector (to be misaligned) 
+  // of PMD houses the following :
+  // (a) 6 modules of preshower plane
+  // (b) 6 modules of veto plane
+  // (c) The FEE boards on back plane of each module
+  // (d) 6 modules of convertor plates
+  // The clustering is done module-wise
+  // The actual amount displacement will be provided
+  // by the survey data and has to be converted into
+  // displacement in x,y,z,theta, phi and psi 
+  
+  
+  // Now specify the path of the module to be misaligned
+  // as followed in the PMD geant
+  
+  /*
+     _____________
+    |    |        |
+    | 1  |   3    |
+    |    |________|
+    |____|___|    |
+    |        | 2  |
+    |   4    |    |
+    |________|____|
+    
+    // Misalignment Matrix is expected to be
+    // same for sectors 1 and 4 
+    // and for the sectors 2 and 3
+    // As these will be mounted on the same
+    // Steel plate 
+ */
+  
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+
+  Float_t max_trans=0.1;
+  Float_t max_rot=0.1;
+
+  TString path;
+  const char *Sector1="/ALIC_1/EPM1_1"; 
+  const char *Sector2="/ALIC_1/EPM2_1"; 
+  const char *Sector3="/ALIC_1/EPM3_1"; 
+  const char *Sector4="/ALIC_1/EPM4_1"; 
+  
+  
+  //Sectors 1 and 4
+  Double_t dx14, dy14, dz14;          // Misalignment in X,Y and Z
+  Double_t dpsi14, dtheta14, dphi14; //  Angular displacements
+  //Sectors 2 and 3
+  Double_t dx23, dy23, dz23;          // Misalignment in X,Y and Z
+  Double_t dpsi23, dtheta23, dphi23; //  Angular displacements
+  
+  
+  
+  // At present give some random shifts
+  // generated by random numbers
+  // max_trans : Maximun shifts in X,Y,Z  in centimeters
+  // max_rot   : Maximum shifts in angles in degrees
+  // Double_t max_trans, max_rot;
+  
+  
+  TRandom *rnd   = new TRandom(4357);
+  
+  // For sectors 1 and 4
+  // Translation displacement
+  dx14     = (rnd->Uniform()-0.5)*max_trans;
+  dy14     = (rnd->Uniform()-0.5)*max_trans;
+  dz14     = (rnd->Uniform()-0.5)*max_trans;
+  //Rotation angles
+  dpsi14   = (rnd->Uniform()-0.5)*max_rot;
+  dtheta14 = (rnd->Uniform()-0.5)*max_rot;
+  dphi14   = (rnd->Uniform()-0.5)*max_rot;
+  
+  // For sectors 2 and 3
+  // Translation displacement
+  dx23     = (rnd->Uniform()-0.5)*max_trans;
+  dy23     = (rnd->Uniform()-0.5)*max_trans;
+  dz23     = (rnd->Uniform()-0.5)*max_trans;
+  //Rotation angles
+  dpsi23   = (rnd->Uniform()-0.5)*max_rot;
+  dtheta23 = (rnd->Uniform()-0.5)*max_rot;
+  dphi23   = (rnd->Uniform()-0.5)*max_rot;
+  
+  
+  //Create a TClonesArray of Align Object to store displacement Angles
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+  TClonesArray &alobj = *array;
+  
+  AliAlignObjAngles o;
+  
+  Int_t iIndex=0; //let all modules have index=0 in a layer with no LUT
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iIndex);
+
+  new(alobj[0]) AliAlignObjAngles(Sector1, volid, dx14, dy14, dz14, dpsi14, dtheta14, dphi14, kFALSE);
+  new(alobj[1]) AliAlignObjAngles(Sector2, volid, dx14, dy14, dz14, dpsi14, dtheta14, dphi14, kFALSE);
+  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);
+  
+  if(!gSystem->Getenv("$TOCDB")){
+    // Create a File to store the alignment data
+    TFile f("PMDfullMisalignment.root","RECREATE");
+    if(!f) {cerr<<"cannot open file for output\n";}    
+    f.cd();
+    f.WriteObject(array,"PMDAlignObjs ","kSingleKey");
+    f.Close();
+  }else{
+  // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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);
+    storage->Put(array,id,md);
+  }
+  array->Delete();
+
+}
diff --git a/PMD/MakePMDResMisAlignment.C b/PMD/MakePMDResMisAlignment.C
new file mode 100644 (file)
index 0000000..fcc8ad5
--- /dev/null
@@ -0,0 +1,126 @@
+void MakePMDResMisAlignment(){
+  // Create TClonesArray of residual misalignment objects for PMD
+  //
+  // Macro to randomly displace the 4 sectors of the PMD
+  // in each plane. Each sector (to be misaligned) 
+  // of PMD houses the following :
+  // (a) 6 modules of preshower plane
+  // (b) 6 modules of veto plane
+  // (c) The FEE boards on back plane of each module
+  // (d) 6 modules of convertor plates
+  // The clustering is done module-wise
+  // The actual amount displacement will be provided
+  // by the survey data and has to be converted into
+  // displacement in x,y,z,theta, phi and psi 
+  
+  
+  // Now specify the path of the module to be misaligned
+  // as followed in the PMD geant
+  
+  /*
+     _____________
+    |    |        |
+    | 1  |   3    |
+    |    |________|
+    |____|___|    |
+    |        | 2  |
+    |   4    |    |
+    |________|____|
+    
+    // Misalignment Matrix is expected to be
+    // same for sectors 1 and 4 
+    // and for the sectors 2 and 3
+    // As these will be mounted on the same
+    // Steel plate 
+ */
+  
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+
+  Float_t max_trans=0.1;
+  Float_t max_rot=0.1;
+
+  TString path;
+  const char *Sector1="/ALIC_1/EPM1_1"; 
+  const char *Sector2="/ALIC_1/EPM2_1"; 
+  const char *Sector3="/ALIC_1/EPM3_1"; 
+  const char *Sector4="/ALIC_1/EPM4_1"; 
+  
+  
+  //Sectors 1 and 4
+  Double_t dx14, dy14, dz14;          // Misalignment in X,Y and Z
+  Double_t dpsi14, dtheta14, dphi14; //  Angular displacements
+  //Sectors 2 and 3
+  Double_t dx23, dy23, dz23;          // Misalignment in X,Y and Z
+  Double_t dpsi23, dtheta23, dphi23; //  Angular displacements
+  
+  
+  
+  // At present give some random shifts
+  // generated by random numbers
+  // max_trans : Maximun shifts in X,Y,Z  in centimeters
+  // max_rot   : Maximum shifts in angles in degrees
+  // Double_t max_trans, max_rot;
+  
+  
+  TRandom *rnd   = new TRandom(4357);
+  
+  // For sectors 1 and 4
+  // Translation displacement
+  dx14     = (rnd->Uniform()-0.5)*max_trans;
+  dy14     = (rnd->Uniform()-0.5)*max_trans;
+  dz14     = (rnd->Uniform()-0.5)*max_trans;
+  //Rotation angles
+  dpsi14   = (rnd->Uniform()-0.5)*max_rot;
+  dtheta14 = (rnd->Uniform()-0.5)*max_rot;
+  dphi14   = (rnd->Uniform()-0.5)*max_rot;
+  
+  // For sectors 2 and 3
+  // Translation displacement
+  dx23     = (rnd->Uniform()-0.5)*max_trans;
+  dy23     = (rnd->Uniform()-0.5)*max_trans;
+  dz23     = (rnd->Uniform()-0.5)*max_trans;
+  //Rotation angles
+  dpsi23   = (rnd->Uniform()-0.5)*max_rot;
+  dtheta23 = (rnd->Uniform()-0.5)*max_rot;
+  dphi23   = (rnd->Uniform()-0.5)*max_rot;
+  
+  
+  //Create a TClonesArray of Align Object to store displacement Angles
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+  TClonesArray &alobj = *array;
+  
+  AliAlignObjAngles o;
+  
+  Int_t iIndex=0; //  let all modules have index=0 in a layer with no LUT
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iIndex);
+
+  new(alobj[0]) AliAlignObjAngles(Sector1, volid, dx14, dy14, dz14, dpsi14, dtheta14, dphi14, kFALSE);
+  new(alobj[1]) AliAlignObjAngles(Sector2, volid, dx14, dy14, dz14, dpsi14, dtheta14, dphi14, kFALSE);
+  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);
+  
+  if(!gSystem->Getenv("$TOCDB")){
+    // Create a File to store the alignment data
+    TFile f("PMDresidualMisalignment.root","RECREATE");
+    if(!f) {cerr<<"cannot open file for output\n";}
+    
+    f.cd();
+    f.WriteObject(array,"PMDAlignObjs ","kSingleKey");
+    f.Close();
+  }else{
+  // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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);
+    storage->Put(array,id,md);
+  }
+  array->Delete();
+
+}
diff --git a/RICH/MakeRICHFullMisAlignment.C b/RICH/MakeRICHFullMisAlignment.C
new file mode 100644 (file)
index 0000000..c5bacef
--- /dev/null
@@ -0,0 +1,45 @@
+void MakeRICHFullMisAlignment(){
+  // Create TClonesArray of full misalignment objects for RICH
+  //
+  Float_t sigmaTrans=0.1; // 1mm
+  Float_t sigmaRot=0.001*180/TMath::Pi(); // 1 mrad
+  Float_t dX, dY, dX;          Float_t dPsi, dTheta, dPhi;   //displacements
+
+  TClonesArray *pCA = new TClonesArray("AliAlignObjMatrix",10);
+  
+  TRandom *pRnd   = new TRandom(4357);
+
+  AliAlignObjMatrix o;
+  Int_t idRICH =  AliAlignObj::kRICH;
+  for (Int_t iCh = 0; iCh < 7; iCh++) {
+    dX     = (pRnd->Uniform()-0.5)*sigmaTrans;    dY     = (pRnd->Uniform()-0.5)*sigmaTrans;    dZ     = (pRnd->Uniform()-0.5)*sigmaTrans;
+    dPsi   = (pRnd->Uniform()-0.5)*sigmaRot;    dTheta = (pRnd->Uniform()-0.5)*sigmaRot;    dPhi   = (pRnd->Uniform()-0.5)*sigmaRot;
+    new((*pCA)[iCh]) AliAlignObjMatrix(AliAlignObj::SymName(idRICH,iCh),
+       AliAlignObj::LayerToVolUID(idRICH,iCh),dX,dY,dZ,dPsi,dTheta,dPhi,kTRUE);
+  }
+
+//   pCA->Print();
+  
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("RICHfullMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(pCA,"RICHAlignObjs","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBMetaData *pMeta= new AliCDBMetaData();  
+    pMeta->SetResponsible("RICH Expert");
+    pMeta->SetComment("Full alignment objects for RICH produced with sigmaTrans=1mm and sigmaRot=1mrad");
+    pMeta->SetAliRootVersion(gSystem->Getenv("$ARVERSION"));
+    AliCDBId id("RICH/Align/Data",0,9999999);
+    storage->Put(pCA,id,pMeta);
+  }
+  
+  pCA->Delete();
+}
diff --git a/RICH/MakeRICHResMisAlignment.C b/RICH/MakeRICHResMisAlignment.C
new file mode 100644 (file)
index 0000000..2a798f0
--- /dev/null
@@ -0,0 +1,44 @@
+void MakeRICHResMisAlignment(){
+  // Create TClonesArray of residual misalignment objects for RICH
+  //
+  Float_t sigmaTrans=0.1; // 1mm
+  Float_t sigmaRot=0.001*180/TMath::Pi(); // 1 mrad
+  Float_t dX, dY, dX;          Float_t dPsi, dTheta, dPhi;   //displacements
+
+  TClonesArray *pCA = new TClonesArray("AliAlignObjMatrix",10);
+  
+  TRandom *pRnd   = new TRandom(4357);
+
+  AliAlignObjMatrix o;
+  Int_t idRICH =  AliAlignObj::kRICH;
+  for (Int_t iCh = 0; iCh < 7; iCh++) {
+    dX     = (pRnd->Uniform()-0.5)*sigmaTrans;    dY     = (pRnd->Uniform()-0.5)*sigmaTrans;    dZ     = (pRnd->Uniform()-0.5)*sigmaTrans;
+    dPsi   = (pRnd->Uniform()-0.5)*sigmaRot;    dTheta = (pRnd->Uniform()-0.5)*sigmaRot;    dPhi   = (pRnd->Uniform()-0.5)*sigmaRot;
+    new((*pCA)[iCh]) AliAlignObjMatrix(AliAlignObj::SymName(idRICH,iCh),AliAlignObj::LayerToVolUID(idRICH,iCh),dX,dY,dZ,dPsi,dTheta,dPhi,kTRUE);
+  }
+
+//   pCA->Print();
+  
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("RICHresidualMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(pCA,"RICHAlignObjs","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBMetaData *pMeta= new AliCDBMetaData();  
+    pMeta->SetResponsible("RICH Expert");
+    pMeta->SetComment("Residual alignment objects for RICH produced with sigmaTrans=1mm and sigmaRot=1mrad");
+    pMeta->SetAliRootVersion(gSystem->Getenv("$ARVERSION"));
+    AliCDBId id("RICH/Align/Data",0,9999999);
+    storage->Put(pCA,id,pMeta);
+  }
+  
+  pCA->Delete();
+}
diff --git a/START/MakeSTARTFullMisAlignment.C b/START/MakeSTARTFullMisAlignment.C
new file mode 100644 (file)
index 0000000..b2fc97e
--- /dev/null
@@ -0,0 +1,69 @@
+void MakeSTARTFullMisAlignment(){
+  // Create TClonesArray of full misalignment objects for T0
+  //
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+  TClonesArray &alobj = *array;
+
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+
+  AliAlignObjAngles a;
+
+  Double_t dx, dy, dz, dpsi, dtheta, dphi;
+  TRandom *rnd   = new TRandom(4321);
+  Double_t sigmatr = 0.05; // max shift in cm w.r.t. RS
+  Double_t sigmarot = 0.3; // max rot in degrees w.r.t. RS
+
+  // null shifts and rotations
+
+  const char *T0right="/ALIC_1/0STR_1";
+  const char *T0left="/ALIC_1/0STL_1";
+
+  Int_t iIndex=0; //let all modules have index=0 in a layer with no LUT
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iIndex);
+
+  dx = rnd->Gaus(0.,sigmatr);
+  dy = rnd->Gaus(0.,sigmatr);
+  dz = rnd->Gaus(0.,sigmatr);
+  dpsi = rnd->Gaus(0.,sigmarot);
+  dtheta = rnd->Gaus(0.,sigmarot);
+  dphi = rnd->Gaus(0.,sigmarot);
+  cout<<dx<<"  "<<dy<<"  "<<dz<<"  "<<dpsi<<"  "<<dtheta<<"  "<<dphi<<"\n";
+  new(alobj[0]) AliAlignObjAngles(T0right, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+  dx = rnd->Gaus(0.,sigmatr);
+  dy = rnd->Gaus(0.,sigmatr);
+  dz = rnd->Gaus(0.,sigmatr);
+  dpsi = rnd->Gaus(0.,sigmarot);
+  dtheta = rnd->Gaus(0.,sigmarot);
+  dphi = rnd->Gaus(0.,sigmarot);
+  cout<<dx<<"  "<<dy<<"  "<<dz<<"  "<<dpsi<<"  "<<dtheta<<"  "<<dphi<<"\n";
+  new(alobj[1]) AliAlignObjAngles(T0left, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+
+  // just save in a file you will send me
+  // or you will put in your afs public dir ...
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("T0fullMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"T0FullObjs ","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    // save in CDB storage
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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("START/Align/Data",0,9999999);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
diff --git a/START/MakeSTARTResMisAlignment.C b/START/MakeSTARTResMisAlignment.C
new file mode 100644 (file)
index 0000000..846fb50
--- /dev/null
@@ -0,0 +1,64 @@
+void MakeSTARTResMisAlignment(){
+  // Create TClonesArray of residual misalignment objects for T0
+  //
+  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
+
+  AliAlignObjAngles a;
+
+  Double_t dx, dy, dz, dpsi, dtheta, dphi;
+  TRandom *rnd   = new TRandom(4321);
+  Double_t sigmatr = 0.05; // max shift in cm
+  Double_t sigmarot = 0.3; // max rot in degrees
+
+  const char *T0right="/ALIC_1/0STR_1";
+  const char *T0left="/ALIC_1/0STL_1";
+
+  Int_t iIndex=0;
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iIndex);
+
+  dx = rnd->Gaus(0.,sigmatr);
+  dy = rnd->Gaus(0.,sigmatr);
+  dz = rnd->Gaus(0.,sigmatr);
+  dpsi = rnd->Gaus(0.,sigmarot);
+  dtheta = rnd->Gaus(0.,sigmarot);
+  dphi = rnd->Gaus(0.,sigmarot);
+  cout<<dx<<"  "<<dy<<"  "<<dz<<"  "<<dpsi<<"  "<<dtheta<<"  "<<dphi<<"\n";
+  new(alobj[0]) AliAlignObjAngles(T0right, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+  dx = rnd->Gaus(0.,sigmatr);
+  dy = rnd->Gaus(0.,sigmatr);
+  dz = rnd->Gaus(0.,sigmatr);
+  dpsi = rnd->Gaus(0.,sigmarot);
+  dtheta = rnd->Gaus(0.,sigmarot);
+  dphi = rnd->Gaus(0.,sigmarot);
+  cout<<dx<<"  "<<dy<<"  "<<dz<<"  "<<dpsi<<"  "<<dtheta<<"  "<<dphi<<"\n";
+  new(alobj[1]) AliAlignObjAngles(T0left, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("T0residualMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"T0ResidualObjs ","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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("START/Align/Data",0,9999999);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
diff --git a/TOF/MakeTOFFullMisAlignment.C b/TOF/MakeTOFFullMisAlignment.C
new file mode 100644 (file)
index 0000000..fe2fa98
--- /dev/null
@@ -0,0 +1,62 @@
+void MakeTOFFullMisAlignment(){
+  // Create TClonesArray of full misalignment objects for TOF
+  // 
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",100);
+  TClonesArray &alobj = *array;
+   
+  if(!gGeoManager) TGeoManager::Import("geometry.root"); //needed for
+  // the constructors with local coordinates not to fail
+
+  AliAlignObjAngles a;
+
+  Int_t nSMTOF = 18;
+  Int_t iIndex=0; //let all modules have index=0 in a layer with no LUT
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iIndex);
+  
+  Int_t i;
+  Int_t j=0;
+  Double_t dx, dy, dz, dpsi, dtheta, dphi;
+  TRandom *rnd   = new TRandom(2345);
+  Double_t sigmatr = 0.4; // max shift in cm w.r.t. local ideal RS
+  Double_t sigmarot = 0.06; // max rot in deg w.r.t. local ideal RS (~ 1 mrad)
+
+  for(i=0; i<18; i++) {
+    Char_t  path[100];
+    sprintf(path,"/ALIC_1/B077_1/BSEGMO%i_1/BTOF%i_1/FTOA_0",i,i);
+    dx = rnd->Gaus(0.,sigmatr);
+    dy = 0;
+    dz = rnd->Gaus(0.,sigmatr);
+    dpsi = 0;
+    dtheta = rnd->Gaus(0.,sigmarot);
+    dphi = 0.;
+    new(alobj[j]) AliAlignObjAngles(path, volid, dx, dy, dz, dpsi, dtheta, dphi,kFALSE);
+    alobj[j]->Print();
+    j++;
+  }
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("TOFfullMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"TOFAlignObjs","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    AliCDBMetaData* md = new AliCDBMetaData();
+    md->SetResponsible("Silvia Arcelli");
+    md->SetComment("Full misalignment for TOF");
+    md->SetAliRootVersion(gSystem->Getenv("$ARVERSION"));
+    AliCDBId id("TOF/Align/Data",0,9999999);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
+
diff --git a/TOF/MakeTOFResMisAlignment.C b/TOF/MakeTOFResMisAlignment.C
new file mode 100644 (file)
index 0000000..5197d24
--- /dev/null
@@ -0,0 +1,57 @@
+void MakeTOFResMisAlignment(){
+  // Create TClonesArray of residual misalignment objects for TOF
+  //
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",2000);
+  TClonesArray &alobj = *array;
+   
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+
+  AliAlignObjAngles a;
+
+  AliAlignObj::ELayerID idTOF = AliAlignObj::kTOF;
+  Int_t i;
+  Int_t j=0;
+  Double_t dx=0.; 
+  Double_t dy=0.; 
+  Double_t dz=0.;
+  Double_t  dpsi, dtheta, dphi;
+  TRandom *rnd   = new TRandom(4357);
+  Double_t sigmatr = 0.1; // max shift in cm w.r.t. local ideal RS
+
+  for(i=0; i<AliAlignObj::LayerSize(idTOF); i++) {
+    dx = 0;
+    dy = rnd->Gaus(0.,sigmatr);
+    dz = rnd->Gaus(0.,sigmatr);
+    dpsi = 0.;
+    dtheta = 0.;
+    dphi = 0.;
+    new(alobj[j]) AliAlignObjAngles(AliAlignObj::SymName(idTOF,i), AliAlignObj::LayerToVolUID(idTOF,i), dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+    j++;
+  }
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("TOFresidualMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"TOFAlignObjs","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
+
diff --git a/TPC/MakeTPCFullMisAlignment.C b/TPC/MakeTPCFullMisAlignment.C
new file mode 100644 (file)
index 0000000..f0b423b
--- /dev/null
@@ -0,0 +1,59 @@
+void MakeTPCFullMisAlignment(){
+  // Create TClonesArray of full misalignment objects for TPC
+  //
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",100);
+  TClonesArray &alobj = *array;
+  
+  TRandom *rnd   = new TRandom(4357);
+  AliAlignObjAngles o;
+  Int_t j = 0;
+  // RS = local
+  // sigma translation = 1mm
+  // sigma rotation = 1mrad
+  Float_t sigmatr=0.01;
+  Float_t sigmarot = 0.06;
+  for (Int_t iLayer = AliAlignObj::kTPC1; iLayer <= AliAlignObj::kTPC2; iLayer++) {
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
+
+      Float_t dx = (rnd->Uniform()-0.5)*sigmatr;
+      Float_t dy = (rnd->Uniform()-0.5)*sigmatr;
+      Float_t dz = (rnd->Uniform()-0.5)*sigmatr;
+      Float_t dpsi = (rnd->Uniform()-0.5)*sigmarot;
+      Float_t dtheta = (rnd->Uniform()-0.5)*sigmarot;
+      Float_t dphi = (rnd->Uniform()-0.5)*sigmarot;
+
+      UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iModule);
+      const char *path = AliAlignObj::SymName(volid);
+      new(alobj[j]) AliAlignObjAngles(path, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+      j++;
+    }
+  }
+
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("TPCfullMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"TPCAlignObjs","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
diff --git a/TPC/MakeTPCResMisAlignment.C b/TPC/MakeTPCResMisAlignment.C
new file mode 100644 (file)
index 0000000..8d170c1
--- /dev/null
@@ -0,0 +1,61 @@
+void MakeTPCResMisAlignment(){
+  // Create TClonesArray of residual misalignment objects for TPC
+  //
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",100);
+  TClonesArray &alobj = *array;
+  
+  TRandom *rnd   = new TRandom(4357);
+  AliAlignObjAngles o;
+  Double_t dx, dy, dz, dpsi, dtheta, dphi;
+  Int_t j = 0;
+
+  // RS = local
+  // sigma translation = 0.1mm
+  // sigma rotation = 1mrad
+  Float_t sigmatr=0.01;
+  Float_t sigmarot = 0.06;
+  for (Int_t iLayer = AliAlignObj::kTPC1; iLayer <= AliAlignObj::kTPC2; iLayer++) {
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
+
+      dx = (rnd->Uniform()-0.5)*sigmatr;
+      dy = (rnd->Uniform()-0.5)*sigmatr;
+      dz = (rnd->Uniform()-0.5)*sigmatr;
+      dpsi = (rnd->Uniform()-0.5)*sigmarot;
+      dtheta = (rnd->Uniform()-0.5)*sigmarot;
+      dphi = (rnd->Uniform()-0.5)*sigmarot;
+
+      UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iModule);
+      const char *path = AliAlignObj::SymName(volid);
+      new(alobj[j]) AliAlignObjAngles(path, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+      j++;
+    }
+  }
+
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("TPCresidualMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"TPCAlignObjs","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
diff --git a/TRD/MakeTRDFullMisAlignment.C b/TRD/MakeTRDFullMisAlignment.C
new file mode 100644 (file)
index 0000000..6a05178
--- /dev/null
@@ -0,0 +1,77 @@
+void MakeTRDFullMisAlignment(){
+  // Create TClonesArray of full misalignment objects for TRD
+  // 
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",1000);
+  TClonesArray &alobj = *array;
+   
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+
+  AliAlignObjAngles a;
+
+  // sigmas for the chambers
+  Double_t chdx=1; // 1 cm
+  Double_t chdy=1; // 1 cm
+  Double_t chdz=1; // 1 cm
+  Double_t chrx=1.0/1000/TMath::Pi()*180; // 1 mrad
+  Double_t chry=1.0/1000/TMath::Pi()*180; // 1 mrad
+  Double_t chrz=0.7/1000/TMath::Pi()*180; // 0.7 mrad
+
+  Double_t dx,dy,dz,rx,ry,rz;
+
+  Int_t j=0;
+  TRandom *ran = new TRandom(4357);
+  UShort_t volid;
+  const char *path;
+
+  //generate the paths for the 18 supermodules
+  Double_t r=325.;
+  Double_t phi;
+  Int_t isec;
+  TString ts0;
+  TString* sm_path = new TString[18];
+  TRegexp regexp(".*BTRD[0-9][^/]*");
+
+  // create the chambers' alignment objects
+  for (Int_t iLayer = AliAlignObj::kTRD1; iLayer <= AliAlignObj::kTRD6; iLayer++) {
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
+      ran.Rannor(dx,rx);
+      ran.Rannor(dy,ry);
+      ran.Rannor(dz,rz);
+      dx*=chdx;
+      dy*=chdy;
+      dz*=chdz;
+      rx*=chrx;
+      ry*=chry;
+      rz*=chrz;
+      volid = AliAlignObj::LayerToVolUID(iLayer,iModule);
+      path = AliAlignObj::SymName(volid);
+      new(alobj[j++]) AliAlignObjAngles(path,volid,dx,dy,dz,rx,ry,rz,kFALSE);
+    }
+  }
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("TRDfullMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"TRDAlignObjs","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
+
diff --git a/TRD/MakeTRDResMisAlignment.C b/TRD/MakeTRDResMisAlignment.C
new file mode 100644 (file)
index 0000000..a4db0f9
--- /dev/null
@@ -0,0 +1,107 @@
+void MakeTRDResMisAlignment(){
+  // Create TClonesArray of residual misalignment objects for TRD
+  //
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",1000);
+  TClonesArray &alobj = *array;
+   
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+
+  AliAlignObjAngles a;
+
+  // sigmas for the supermodules
+  Double_t smdx=3; // 300 microns
+  Double_t smdy=3; // 300 microns
+  Double_t smdz=3; // 300 microns
+  Double_t smrx=0.4/1000/TMath::Pi()*180; // 0.4 mrad
+  Double_t smry=2.0/1000/TMath::Pi()*180; // 2 mrad
+  Double_t smrz=0.4/1000/TMath::Pi()*180; // 0.4 mrad
+
+  // sigmas for the chambers
+  Double_t chdx=0.02; // 200 microns
+  Double_t chdy=0.03; // 300 microns
+  Double_t chdz=0.07; // 700 microns
+  Double_t chrx=0.3/1000/TMath::Pi()*180; // 0.3 mrad
+  Double_t chry=0.3/1000/TMath::Pi()*180; // 0.3 mrad
+  Double_t chrz=0.1/1000/TMath::Pi()*180; // 0.1 mrad
+
+  Double_t dx,dy,dz,rx,ry,rz;
+
+  Int_t j=0;
+  TRandom *ran = new TRandom(4357);
+  UShort_t volid;
+  const char *path;
+
+  //generate the paths for the 18 supermodules
+  Double_t r=325.;
+  Double_t phi;
+  Int_t isec;
+  TString ts0;
+  TString* sm_path = new TString[18];
+  TRegexp regexp(".*BTRD[0-9][^/]*");
+
+  for (isec=0; isec<18; isec++) {
+    phi=(isec+0.5)/18*2*TMath::Pi();
+    gGeoManager->FindNode(r*cos(phi),r*sin(phi),0.);
+    ts0 = gGeoManager->GetPath();
+    sm_path[isec] = ts0(regexp);
+    sm_path[isec] +='\0';
+  }
+
+  // create the supermodules' alignment objects
+  for (int i; i<18; i++) {
+    ran.Rannor(dx,rx);
+    ran.Rannor(dy,ry);
+    ran.Rannor(dz,rz);
+    dx*=smdx;
+    dy*=smdy;
+    dz*=smdz;
+    rx*=smrx;
+    ry*=smry;
+    rz*=smrz;
+    new(alobj[j++]) AliAlignObjAngles(sm_path[i].Data(),0,dx,dy,dz,rx,ry,rz,kFALSE);
+  }
+
+  // create the chambers' alignment objects
+  for (Int_t iLayer = AliAlignObj::kTRD1; iLayer <= AliAlignObj::kTRD6; iLayer++) {
+    for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
+      ran.Rannor(dx,rx);
+      ran.Rannor(dy,ry);
+      ran.Rannor(dz,rz);
+      dx*=chdx;
+      dy*=chdy;
+      dz*=chdz;
+      rx*=chrx;
+      ry*=chry;
+      rz*=chrz;
+      volid = AliAlignObj::LayerToVolUID(iLayer,iModule);
+      path = AliAlignObj::SymName(volid);
+      new(alobj[j++]) AliAlignObjAngles(path,volid,dx,dy,dz,rx,ry,rz,kFALSE);
+    }
+  }
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("TRDresidualMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"TRDAlignObjs","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
+
diff --git a/VZERO/MakeVZEROFullMisAlignment.C b/VZERO/MakeVZEROFullMisAlignment.C
new file mode 100644 (file)
index 0000000..cf1d683
--- /dev/null
@@ -0,0 +1,66 @@
+void MakeVZEROFullMisAlignment(){
+  // Create TClonesArray of full misalignment objects for VZERO
+  // 
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+  TClonesArray &alobj = *array;
+
+  AliAlignObjAngles a;
+
+  Double_t dx, dy, dz, dpsi, dtheta, dphi;
+  TRandom *rnd   = new TRandom(4321);
+  Double_t sigmatr = 0.1; // max shift in cm w.r.t. RS
+  Double_t sigmarot = 0.5; // max rot in degrees w.r.t. RS
+
+  // null shifts and rotations
+
+  const char *V0right="/ALIC_1/VZERO_1/V0RI_1";
+  const char *V0left="/ALIC_1/VZERO_1/V0LE_1";
+
+  Int_t iIndex=0; //let all modules have index=0 in a layer with no LUT
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iIndex);
+
+  dx = rnd->Gaus(0.,sigmatr);
+  dy = rnd->Gaus(0.,sigmatr);
+  dz = rnd->Gaus(0.,sigmatr);
+  dpsi = rnd->Gaus(0.,sigmarot);
+  dtheta = rnd->Gaus(0.,sigmarot);
+  dphi = rnd->Gaus(0.,sigmarot);
+  new(alobj[0]) AliAlignObjAngles(V0right, volid, dx, dy, dz, dpsi, dtheta,
+                                  dphi, kFALSE);
+  dx = rnd->Gaus(0.,sigmatr);
+  dy = rnd->Gaus(0.,sigmatr);
+  dz = rnd->Gaus(0.,sigmatr);
+  dpsi = rnd->Gaus(0.,sigmarot);
+  dtheta = rnd->Gaus(0.,sigmarot);
+  dphi = rnd->Gaus(0.,sigmarot);
+  new(alobj[1]) AliAlignObjAngles(V0left, volid, dx, dy, dz, dpsi, dtheta,
+                                  dphi,kFALSE);
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("V0fullMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"V0FullObjs ","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
diff --git a/VZERO/MakeVZEROResMisAlignment.C b/VZERO/MakeVZEROResMisAlignment.C
new file mode 100644 (file)
index 0000000..6729931
--- /dev/null
@@ -0,0 +1,62 @@
+void MakeVZEROResMisAlignment(){
+  // Create TClonesArray of residual misalignment objects for VZERO
+  //
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+  TClonesArray &alobj = *array;
+
+  AliAlignObjAngles a;
+
+  Double_t dx, dy, dz, dpsi, dtheta, dphi;
+  TRandom *rnd   = new TRandom(4321);
+  Double_t sigmatr = 0.1; // max shift in cm
+  Double_t sigmarot = 0.5; // max rot in degrees
+
+  const char *V0right="/ALIC_1/VZERO_1/V0RI_1";
+  const char *V0left="/ALIC_1/VZERO_1/V0LE_1";
+
+  Int_t iIndex=0;
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iIndex);
+
+  dx = rnd->Gaus(0.,sigmatr);
+  dy = rnd->Gaus(0.,sigmatr);
+  dz = rnd->Gaus(0.,sigmatr);
+  dpsi = rnd->Gaus(0.,sigmarot);
+  dtheta = rnd->Gaus(0.,sigmarot);
+  dphi = rnd->Gaus(0.,sigmarot);
+  new(alobj[0]) AliAlignObjAngles(V0right, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+  dx = rnd->Gaus(0.,sigmatr);
+  dy = rnd->Gaus(0.,sigmatr);
+  dz = rnd->Gaus(0.,sigmatr);
+  dpsi = rnd->Gaus(0.,sigmarot);
+  dtheta = rnd->Gaus(0.,sigmarot);
+  dphi = rnd->Gaus(0.,sigmarot);
+  new(alobj[1]) AliAlignObjAngles(V0left, volid, dx, dy, dz, dpsi, dtheta, dphi,kFALSE);
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save on file
+    TFile f("V0residualMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"V0ResidualObjs ","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
diff --git a/ZDC/MakeZDCFullMisAlignment.C b/ZDC/MakeZDCFullMisAlignment.C
new file mode 100644 (file)
index 0000000..9c63d8c
--- /dev/null
@@ -0,0 +1,48 @@
+void MakeZDCFullMisAlignment(){
+  // Create TClonesArray of full misalignment objects for ZDC
+  //
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+  TClonesArray &alobj = *array;
+
+  AliAlignObjAngles a;
+
+  Double_t dx=0., dy=2., dz=0.;
+  Double_t dpsi=0., dtheta=0., dphi=0.;
+
+  const char *ZDC_N="ALIC_1/ZDC_1/ZNEU_1";
+  const char *ZDC_P="ALIC_1/ZDC_1/ZPRO_1";
+
+  Int_t iIndex=0; //let all modules have index=0 in a layer with no LUT
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iIndex);
+
+  new(alobj[0]) AliAlignObjAngles(ZDC_N, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+  new(alobj[1]) AliAlignObjAngles(ZDC_P, volid, dx, dy, dz, dpsi, dtheta, dphi,kTRUE);
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save in file
+    TFile f("ZDCfullMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"ZDCFullObjs ","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
diff --git a/ZDC/MakeZDCResMisAlignment.C b/ZDC/MakeZDCResMisAlignment.C
new file mode 100644 (file)
index 0000000..b4779c7
--- /dev/null
@@ -0,0 +1,48 @@
+void MakeZDCResMisAlignment(){
+  // Create TClonesArray of residual misalignment objects for ZDC
+  // 
+  if(!gGeoManager) TGeoManager::Import("geometry.root");
+  // needed for the constructors with local coordinates not to fail
+
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+  TClonesArray &alobj = *array;
+
+  AliAlignObjAngles a;
+
+  Double_t dx=0., dy=0.05, dz=0.;
+  Double_t dpsi=0., dtheta=0., dphi=0.;
+
+  const char *ZDC_N="ALIC_1/ZDC_1/ZNEU_1";
+  const char *ZDC_P="ALIC_1/ZDC_1/ZPRO_1";
+
+  UShort_t iIndex=0;
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iIndex);
+
+  new(alobj[0]) AliAlignObjAngles(ZDC_N, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+  new(alobj[1]) AliAlignObjAngles(ZDC_P, volid, dx, dy, dz, dpsi, dtheta, dphi,kTRUE);
+
+  if(!gSystem->Getenv("$TOCDB")){
+    // save in file
+    TFile f("ZDCresidualMisalignment.root","RECREATE");
+    if(!f) cerr<<"cannot open file for output\n";
+    f.cd();
+    f.WriteObject(array,"ZDCResidualObjs ","kSingleKey");
+    f.Close();
+  }else{
+    // save in CDB storage
+    const char* Storage = gSystem->Getenv("$STORAGE");
+    AliCDBManager* cdb = AliCDBManager::Instance();
+    AliCDBStorage* storage = cdb->GetStorage(Storage);
+    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);
+    storage->Put(array,id,md);
+  }
+
+  array->Delete();
+
+}
+
diff --git a/macros/MakeAllDETsFullMisAlignment.C b/macros/MakeAllDETsFullMisAlignment.C
new file mode 100644 (file)
index 0000000..0e6eb33
--- /dev/null
@@ -0,0 +1,47 @@
+void MakeAllDETsFullMisAlignment(Char_t* CDBstorage = "local://$HOME/Full"){
+  // Make full misalignment objects for all detectors
+  // Pass different "CDBstorage" argument if needed (e.g. to fill
+  // conditions' data base on alien) or set it to null string to have
+  // the objects saved locally on file 
+  // This macro defines the default name and place for the detector-macros
+  // in charge of producing the full misalignment objects as 
+  // $ALICE_ROOT/DET/MakeDETFullMisAlignment.C
+  //
+  TString strStorage(CDBstorage);
+  if(strStorage.IsNull()){
+    gSystem->Setenv("$TOCDB","kFALSE");
+  }else{  
+    gSystem->Setenv("$TOCDB","kTRUE");
+    gSystem->Setenv("$STORAGE",strStorage.Data());
+    gSystem->Setenv("$ARVERSION","v4-04-Release");
+  }
+
+  // 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");
+  }
+
+  TString dets = "EMCAL,FMD,ITS,MUON,PHOS,PMD,RICH,START,TOF,TPC,TRD,VZERO,ZDC";
+//   TString dets = "ABSO,DIPO,FMD,FRAME,HALL,ITS,MAG,MUON,PHOS,PIPE,PMD,RICH,SHIL,START,TOF,TPC,TRD,ZDC,EMCAL,CRT,VZERO";
+  TObjArray *detArray = dets.Tokenize(',');
+  TIter iter(detArray);
+  TObjString *ostr;
+  TString exec_det_macro;
+
+  while((ostr = (TObjString*) iter.Next())){
+    TString str(ostr->String());
+    exec_det_macro="aliroot -b -q $ALICE_ROOT/";
+    exec_det_macro+=str;
+    exec_det_macro+="/Make";
+    exec_det_macro+=str;
+    exec_det_macro+="FullMisAlignment.C";
+    
+    gSystem->Exec(exec_det_macro.Data());
+  }
+
+  return;
+}
diff --git a/macros/MakeAllDETsResMisAlignment.C b/macros/MakeAllDETsResMisAlignment.C
new file mode 100644 (file)
index 0000000..e57ccda
--- /dev/null
@@ -0,0 +1,46 @@
+void MakeAllDETsResMisAlignment(Char_t* CDBstorage = "local://$HOME/Residual"){
+  // Make residual misalignment objects for all detectors
+  // Pass different "CDBstorage" argument if needed (e.g. to fill
+  // conditions' data base on alien) or set it to null string to have
+  // the objects saved locally on file 
+  // This macro defines the default name and place for the detector-macros
+  // in charge of producing the full misalignment objects as 
+  // $ALICE_ROOT/DET/MakeDETResidualMisAlignment.C
+  //
+  TString strStorage(CDBstorage);
+  if(strStorage.IsNull()){
+    gSystem->Setenv("$TOCDB","kFALSE");
+  }else{  
+    gSystem->Setenv("$TOCDB","kTRUE");
+    gSystem->Setenv("$STORAGE",strStorage.Data());
+    gSystem->Setenv("$ARVERSION","v4-04-Release");
+  }
+
+  // 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");
+  }
+
+  TString dets="EMCAL,FMD,ITS,MUON,PHOS,PMD,RICH,START,TOF,TPC,TRD,VZERO,ZDC";
+  TObjArray *detArray = dets.Tokenize(',');
+  TIter iter(detArray);
+  TObjString *ostr;
+  TString exec_det_macro;
+
+  while((ostr = (TObjString*) iter.Next())){
+    TString str(ostr->String());
+    exec_det_macro="aliroot -b -q $ALICE_ROOT/";
+    exec_det_macro+=str;
+    exec_det_macro+="/Make";
+    exec_det_macro+=str;
+    exec_det_macro+="ResMisAlignment.C";
+    
+    gSystem->Exec(exec_det_macro.Data());
+  }
+
+  return;
+}