void MakeEMCALFullMisAlignment(){
// Create TClonesArray of full misalignment objects for EMCAL
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
if(!AliGeomManager::GetGeometry()){
AliCDBManager::Instance()->SetRun(0);
AliGeomManager::LoadGeometry();
}
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx, dy, dz, dpsi, dtheta, dphi;
TRandom *rnd = new TRandom(4321);
pathstr=basepath;
pathstr+=(i+1);
cout<<pathstr<<" "<<dx<<" "<<dy<<" "<<dz<<" "<<dpsi<<" "<<dtheta<<" "<<dphi<<"\n";
- new(alobj[j++]) AliAlignObjAngles(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+ new(alobj[j++]) AliAlignObjParams(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
}
for(i=0; i<2; i++){
dphi = rnd->Gaus(0.,sigmarot);
pathstr=hbasepath;
pathstr+=(i+1);
- new(alobj[j++]) AliAlignObjAngles(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[j++]) AliAlignObjParams(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
}
const char* macroname = "MakeEMCALFullMisAlignment.C";
void MakeEMCALResMisAlignment(){
// Create TClonesArray of residual misalignment objects for EMCAL
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
if(!AliGeomManager::GetGeometry()){
AliCDBManager::Instance()->SetRun(0);
AliGeomManager::LoadGeometry();
}
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx, dy, dz, dpsi, dtheta, dphi;
dphi = rnd->Gaus(0.,sigmarot);
pathstr=basepath;
pathstr+=(i+1);
- new(alobj[j++]) AliAlignObjAngles(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+ new(alobj[j++]) AliAlignObjParams(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
}
for(i=0; i<2; i++){
dphi = rnd->Gaus(0.,sigmarot);
pathstr=hbasepath;
pathstr+=(i+1);
- new(alobj[j++]) AliAlignObjAngles(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[j++]) AliAlignObjParams(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
}
const char* macroname = "MakeEMCALResMisAlignment.C";
void MakeEMCALZeroMisAlignment(){
// Create TClonesArray of zero misalignment objects for EMCAL
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
if(!AliGeomManager::GetGeometry()){
AliCDBManager::Instance()->SetRun(0);
AliGeomManager::LoadGeometry();
}
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx=0., dy=0., dz=0., dpsi=0., dtheta=0., dphi=0.;
for(i=0; i<10; i++){
pathstr=fbasepath;
pathstr+=(i+1);
- new(alobj[j++]) AliAlignObjAngles(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[j++]) AliAlignObjParams(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
}
for(i=0; i<2; i++){
pathstr=hbasepath;
pathstr+=(i+1);
- new(alobj[j++]) AliAlignObjAngles(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[j++]) AliAlignObjParams(pathstr, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
}
const char* macroname = "MakeEMCALZeroMisAlignment.C";
#include "TRandom.h"
#include "TClonesArray.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
#include "AliCDBMetaData.h"
#include "AliCDBId.h"
#include "AliCDBEntry.h"
// ************************* 1st step ***************
// Create TClonesArray of alignment objects for EMCAL
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",12);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",12);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx=0., dy=0., dz=0., dpsi=0., dtheta=0., dphi=0.;
// null shifts and rotations
for (Int_t iModule = 0; iModule < nModules; iModule++) {
TString newPath = basePath;
newPath += iModule+1;
- new(alobj[iModule]) AliAlignObjAngles(newPath.Data(),
+ new(alobj[iModule]) AliAlignObjParams(newPath.Data(),
dvoluid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
}
//half SMs
- new(alobj[10]) AliAlignObjAngles("EMCAL/HalfSupermodule1",
+ new(alobj[10]) AliAlignObjParams("EMCAL/HalfSupermodule1",
dvoluid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[11]) AliAlignObjAngles("EMCAL/HalfSupermodule2",
+ new(alobj[11]) AliAlignObjParams("EMCAL/HalfSupermodule2",
dvoluid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
// ************************* 1st step ***************
// Create TClonesArray of alignment objects for EMCAL
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",12);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",12);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
UShort_t iIndex=0;
AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
dpsi = pRnd->Gaus(0,sigmaRot); dtheta = pRnd->Gaus(0,sigmaRot); dphi = pRnd->Gaus(0,sigmaRot);
TString newPath = basePath;
newPath += iSM + 1;
- new(alobj[iSM]) AliAlignObjAngles(newPath.Data(),
+ new(alobj[iSM]) AliAlignObjParams(newPath.Data(),
dvoluid, dx,dy,dz,dpsi,dtheta,dphi, kTRUE);
}
dx = pRnd->Gaus(0,sigmaTrans); dy = pRnd->Gaus(0,sigmaTrans); dz = pRnd->Gaus(0,sigmaTrans);
dpsi = pRnd->Gaus(0,sigmaRot); dtheta = pRnd->Gaus(0,sigmaRot); dphi = pRnd->Gaus(0,sigmaRot);
- new(alobj[10]) AliAlignObjAngles("EMCAL/HalfSupermodule1",
+ new(alobj[10]) AliAlignObjParams("EMCAL/HalfSupermodule1",
dvoluid, dx,dy,dz,dpsi,dtheta,dphi, kTRUE);
dx = pRnd->Gaus(0,sigmaTrans); dy = pRnd->Gaus(0,sigmaTrans); dz = pRnd->Gaus(0,sigmaTrans);
dpsi = pRnd->Gaus(0,sigmaRot); dtheta = pRnd->Gaus(0,sigmaRot); dphi = pRnd->Gaus(0,sigmaRot);
- new(alobj[11]) AliAlignObjAngles("EMCAL/HalfSupermodule2",
+ new(alobj[11]) AliAlignObjParams("EMCAL/HalfSupermodule2",
dvoluid, dx,dy,dz,dpsi,dtheta,dphi, kTRUE);
// ************************* 2nd step ***************
// ************************* 1st step ***************
// Create TClonesArray of alignment objects for EMCAL
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",12);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",12);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
UShort_t iIndex=0;
AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
dpsi = pRnd->Gaus(0,sigmaRot); dtheta = pRnd->Gaus(0,sigmaRot); dphi = pRnd->Gaus(0,sigmaRot);
TString newPath = basePath;
newPath += iSM + 1;
- new(alobj[iSM]) AliAlignObjAngles(newPath.Data(),
+ new(alobj[iSM]) AliAlignObjParams(newPath.Data(),
dvoluid, dx,dy,dz,dpsi,dtheta,dphi, kTRUE);
}
dx = pRnd->Gaus(0,sigmaTrans); dy = pRnd->Gaus(0,sigmaTrans); dz = pRnd->Gaus(0,sigmaTrans);
dpsi = pRnd->Gaus(0,sigmaRot); dtheta = pRnd->Gaus(0,sigmaRot); dphi = pRnd->Gaus(0,sigmaRot);
- new(alobj[10]) AliAlignObjAngles("EMCAL/HalfSupermodule1",
+ new(alobj[10]) AliAlignObjParams("EMCAL/HalfSupermodule1",
dvoluid, dx,dy,dz,dpsi,dtheta,dphi, kTRUE);
dx = pRnd->Gaus(0,sigmaTrans); dy = pRnd->Gaus(0,sigmaTrans); dz = pRnd->Gaus(0,sigmaTrans);
dpsi = pRnd->Gaus(0,sigmaRot); dtheta = pRnd->Gaus(0,sigmaRot); dphi = pRnd->Gaus(0,sigmaRot);
- new(alobj[11]) AliAlignObjAngles("EMCAL/HalfSupermodule2",
+ new(alobj[11]) AliAlignObjParams("EMCAL/HalfSupermodule2",
dvoluid, dx,dy,dz,dpsi,dtheta,dphi, kTRUE);
// ************************* 2nd step ***************
#include <AliCDBStorage.h> // ALICDBSTORAGE_H
#include <AliCDBEntry.h> // ALICDBMANAGER_H
// #include <AliAlignObj.h>
-#include <AliAlignObjAngles.h>
+#include <AliAlignObjParams.h>
// #include <Riostream.h>
#include <TSystem.h>
// #include <TMath.h>
return;
}
// Make container of transforms
- if (!fArray) fArray = new TClonesArray("AliAlignObjAngles");
+ if (!fArray) fArray = new TClonesArray("AliAlignObjParams");
fArray->Clear();
// Make an iterator
path.Data(), id, transX, transY, transZ, rotX, rotY, rotZ));
Int_t nAlign = fArray->GetEntries();
id = 0;
- AliAlignObjAngles* obj =
- new ((*fArray)[nAlign]) AliAlignObjAngles(path.Data(),
+ AliAlignObjParams* obj =
+ new ((*fArray)[nAlign]) AliAlignObjParams(path.Data(),
id,0,0,0,0,0,0,kTRUE);
if (!obj) {
AliError(Form("Failed to create alignment object for %s", path.Data()));
#include <AliESDFMD.h>
#include <AliCDBManager.h>
#include <AliCDBEntry.h>
-#include <AliAlignObjAngles.h>
+#include <AliAlignObjParams.h>
#include <TTree.h> // ROOT_TTree
#include <TChain.h> // ROOT_TChain
#include <TParticle.h> // ROOT_TParticle
else {
Int_t nAlign = array->GetEntries();
for (Int_t i = 0; i < nAlign; i++) {
- AliAlignObjAngles* a = static_cast<AliAlignObjAngles*>(array->At(i));
+ AliAlignObjParams* a = static_cast<AliAlignObjParams*>(array->At(i));
if (!a->ApplyToGeometry()) {
AliWarning(Form("Failed to apply alignment to %s",
a->GetSymName()));
else {
Int_t nAlign = array->GetEntries();
for (Int_t i = 0; i < nAlign; i++) {
- AliAlignObjAngles* a = static_cast<AliAlignObjAngles*>(array->At(i));
+ AliAlignObjParams* a = static_cast<AliAlignObjParams*>(array->At(i));
if (!a->ApplyToGeometry()) {
Warning("ApplyAlignement", "Failed to apply alignment to %s",
a->GetVolPath());
}
Int_t nAlign = array->GetEntries();
for (Int_t i = 0; i < nAlign; i++) {
- AliAlignObjAngles* a = static_cast<AliAlignObjAngles*>(array->At(i));
+ AliAlignObjParams* a = static_cast<AliAlignObjParams*>(array->At(i));
Double_t ang[3];
Double_t trans[3];
a->GetAngles(ang);
void MakeITSFullMisAlignment(){
// Create TClonesArray of full misalignment objects for ITS
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",4000);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",4000);
TClonesArray &alobj = *array;
if(!AliGeomManager::GetGeometry()){
TRandom *rnd = new TRandom(65416087);
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx=0., dy=0., dz=0., dpsi=0., dtheta=0., dphi=0.;
Int_t j = 0;
- new(alobj[j++]) AliAlignObjAngles("ITS", 0, dx, dy, globalZ, dpsi, dtheta, dphi, kTRUE);
- AliAlignObjAngles* its_alobj = (AliAlignObjAngles*) array->UncheckedAt(0);
+ new(alobj[j++]) AliAlignObjParams("ITS", 0, dx, dy, globalZ, dpsi, dtheta, dphi, kTRUE);
+ AliAlignObjParams* its_alobj = (AliAlignObjParams*) array->UncheckedAt(0);
its_alobj->ApplyToGeometry();
for ( Int_t l = AliGeomManager::kSPD1; l <= AliGeomManager::kSSD2; l++) {
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
const char *symname = AliGeomManager::SymName(volid);
- new(alobj[j++]) AliAlignObjAngles(symname, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+ new(alobj[j++]) AliAlignObjParams(symname, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
}
}
void MakeITSResMisAlignment(){
// Create TClonesArray of residual misalignment objects for ITS
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",4000);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",4000);
TClonesArray &alobj = *array;
if(!AliGeomManager::GetGeometry()){
Double_t ssdZ = 0.010;
TRandom *rnd = new TRandom(65416087);
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx=0., dy=0., dz=0., dpsi=0., dtheta=0., dphi=0.;
AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
Int_t j = 0;
- new(alobj[j++]) AliAlignObjAngles("ITS", 0, dx, dy, globalZ, dpsi, dtheta, dphi, kTRUE);
- AliAlignObjAngles* its_alobj = (AliAlignObjAngles*) array->UncheckedAt(0);
+ new(alobj[j++]) AliAlignObjParams("ITS", 0, dx, dy, globalZ, dpsi, dtheta, dphi, kTRUE);
+ AliAlignObjParams* its_alobj = (AliAlignObjParams*) array->UncheckedAt(0);
its_alobj->ApplyToGeometry();
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
const char *symname = AliGeomManager::SymName(volid);
- new(alobj[j]) AliAlignObjAngles(symname, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+ new(alobj[j]) AliAlignObjParams(symname, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
j++;
}
void MakeITSZeroMisAlignment(){
// Create TClonesArray of zero misalignment objects for ITS
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",4000);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",4000);
TClonesArray &alobj = *array;
if(!AliGeomManager::GetGeometry()){
}
// needed for the constructors with local coordinates not to fail
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx=0., dy=0., dz=0., dpsi=0., dtheta=0., dphi=0., globalZ=0.;
AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
Int_t j = 0;
- new(alobj[j]) AliAlignObjAngles("ITS", 0, dx, dy, globalZ, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[j]) AliAlignObjParams("ITS", 0, dx, dy, globalZ, dpsi, dtheta, dphi, kTRUE);
j++;
for ( Int_t l = AliGeomManager::kSPD1; l <= AliGeomManager::kSSD2; l++) {
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
const char *symname = AliGeomManager::SymName(volid);
- new(alobj[j]) AliAlignObjAngles(symname, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[j]) AliAlignObjParams(symname, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
j++;
}
class AliGeomManager {};
class AliAlignObj {};
- class AliAlignObjAngles {};
+ class AliAlignObjParams {};
class AliAlignObjMatrix {};
class AliTrackFitter {};
/* History of cvs commits:
*
* $Log$
+ * Revision 1.5 2007/07/10 12:41:38 kharlov
+ * Added a new class AliPHOSSurvet1 which read survey data from EDMS files
+ *
* Revision 1.4 2007/05/17 17:34:54 kharlov
* Merging differences if v1.2 and 1.3
*
*/
// Objects of this class read txt file with survey (photogrammetry) data
-// and convert the data into AliAlignObjAngles of alignable PHOS volumes.
+// and convert the data into AliAlignObjParams of alignable PHOS volumes.
// It can be used as a base class, you need to override GetStripTransformation.
// AliPHOSSurvey inherits TObject only to use AliLog "functions".
// Author: Timur Pocheptsov (JINR)
#include "AliSurveyObj.h"
#include "AliPHOSEMCAGeometry.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
#include "AliPHOSGeometry.h"
#include "AliPHOSSurvey.h"
#include "AliLog.h"
}
//____________________________________________________________________________
-void AliPHOSSurvey::CreateAliAlignObjAngles(TClonesArray &array)
+void AliPHOSSurvey::CreateAliAlignObjParams(TClonesArray &array)
{
- //Create AliAlignObjAngles.
+ //Create AliAlignObjParams.
const AliPHOSGeometry * phosGeom = AliPHOSGeometry::GetInstance("IHEP", "IHEP");
if (!phosGeom) {
AliError("Cannot obtain AliPHOSGeometry instance.");
TString stripName(TString::Format("PHOS/Module%d/Strip_%d_%d", module, i, j));
AliPHOSStripDelta t(GetStripTransformation(stripNum++, module));
new(array[arrayInd])
- AliAlignObjAngles(
+ AliAlignObjParams(
stripName.Data(), volid,
t.fXShift, t.fYShift, t.fZShift,
-t.fPsi, -t.fTheta, -t.fPhi,
for (Int_t i = 0; i < emcaGeom->GetNStripX(); ++i)
for (Int_t j = 0; j < emcaGeom->GetNStripZ(); ++j) {
TString stripName(TString::Format("PHOS/Module%d/Strip_%d_%d", module, i, j));
- new(array[arrayInd]) AliAlignObjAngles(stripName.Data(), volid, 0., 0., 0., 0., 0., 0., true);
+ new(array[arrayInd]) AliAlignObjParams(stripName.Data(), volid, 0., 0., 0., 0., 0., 0., true);
++arrayInd;
}
}
/* History of cvs commits:
*
* $Log$
+ * Revision 1.3 2007/07/10 12:41:38 kharlov
+ * Added a new class AliPHOSSurvet1 which read survey data from EDMS files
+ *
* Revision 1.2 2007/05/17 17:13:32 kharlov
* Coding convensions satisfied (T.Pocheptsov)
*
/*
Objects of this class read txt file with survey (photogrammetry) data
- and convert the data into AliAlignObjAngles of alignable PHOS volumes.
+ and convert the data into AliAlignObjParams of alignable PHOS volumes.
It can be used as a base class, you need to override GetStripTransformation.
AliPHOSSurvey inherits TObject only to use AliLog "functions".
*/
virtual ~AliPHOSSurvey();
- //Create AliAlignObjAngles for strips.
- void CreateAliAlignObjAngles(TClonesArray &array);
- //Create AliAlignObjAngles with null shifts and rotations.
+ //Create AliAlignObjParams for strips.
+ void CreateAliAlignObjParams(TClonesArray &array);
+ //Create AliAlignObjParams with null shifts and rotations.
void CreateNullObjects(TClonesArray &alObj, const AliPHOSGeometry *geom)const;
protected:
}
AliPHOSEMCAGeometry *emca = phosGeom->GetEMCAGeometry();
- TClonesArray *array = new TClonesArray("AliAlignObjAngles", 16 + phosGeom->GetNModules() *
+ TClonesArray *array = new TClonesArray("AliAlignObjParams", 16 + phosGeom->GetNModules() *
emca->GetNStripX() * emca->GetNStripZ());
TClonesArray &alobj = *array;
Int_t i=0 ;
// Alignment for 5 PHOS modules
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module1",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module1",
volid, -20., -10., 0., dpsi, dtheta, 5, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module2",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module2",
volid, -10., 0., -10., dpsi, dtheta, 2, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module3",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module3",
volid, 5., -10., 10., dpsi, dtheta, 0, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module4",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module4",
volid, +10., -0., -10., dpsi, dtheta, 2, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module5",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module5",
volid, +20., -10., 0., dpsi, dtheta, 5, kTRUE);
Double_t dx=0., dy=0., dz=0. ;
// Alignment of CPV modules
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module1/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module1/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module2/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module2/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module3/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module3/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module4/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module4/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module5/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module5/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
// Alignment for PHOS cradle
- new(alobj[i++]) AliAlignObjAngles("PHOS/Cradle0",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Cradle0",
volid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Cradle1",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Cradle1",
volid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
// Alignment for cradle wheels
- new(alobj[i++]) AliAlignObjAngles("PHOS/Wheel0",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Wheel0",
volid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Wheel1",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Wheel1",
volid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Wheel2",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Wheel2",
volid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Wheel3",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Wheel3",
volid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
// AliPHOSSurvey geodesicData("phos_mod3_survey.txt");
-// geodesicData.CreateAliAlignObjAngles(alobj);
+// geodesicData.CreateAliAlignObjParams(alobj);
AliPHOSSurvey1 geodesicData("phos_mod3_survey_EDMS.txt", "T1_");
- geodesicData.CreateAliAlignObjAngles(alobj);
+ geodesicData.CreateAliAlignObjParams(alobj);
// ************************* 2nd step ***************
}
AliPHOSEMCAGeometry *emca = phosGeom->GetEMCAGeometry();
- TClonesArray *array = new TClonesArray("AliAlignObjAngles", 16 + phosGeom->GetNModules() *
+ TClonesArray *array = new TClonesArray("AliAlignObjParams", 16 + phosGeom->GetNModules() *
emca->GetNStripX() * emca->GetNStripZ());
TClonesArray &alobj = *array;
Int_t i=0 ;
// Alignment for 5 PHOS modules
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module1",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module1",
volid, -0.20, -0.1, +0.0, dpsi, dtheta, 0.2, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module2",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module2",
volid, -0.10, +0.0, -0.2, dpsi, dtheta, 0.2, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module3",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module3",
volid, 0.05, -0.1, 0.2, dpsi, dtheta, 0.0, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module4",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module4",
volid, +0.10, -0.0, -0.1, dpsi, dtheta, 0.1, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module5",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module5",
volid, +0.20, -0.1, 0.1, dpsi, dtheta, 0.2, kTRUE);
Double_t dx=0., dy=0., dz=0. ;
// Alignment of CPV modules
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module1/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module1/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module2/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module2/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module3/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module3/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module4/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module4/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module5/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module5/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
// Alignment for PHOS cradle
- new(alobj[i++]) AliAlignObjAngles("PHOS/Cradle0",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Cradle0",
volid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Cradle1",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Cradle1",
volid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
// Alignment for cradle wheels
- new(alobj[i++]) AliAlignObjAngles("PHOS/Wheel0",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Wheel0",
volid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Wheel1",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Wheel1",
volid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Wheel2",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Wheel2",
volid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Wheel3",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Wheel3",
volid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
AliPHOSSurvey geodesicData("phos_mod3_survey.txt");
- geodesicData.CreateAliAlignObjAngles(alobj);
+ geodesicData.CreateAliAlignObjParams(alobj);
const char* macroname = "MakePHOSResMisAlignment.C";
if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
}
AliPHOSEMCAGeometry *emca = phosGeom->GetEMCAGeometry();
- TClonesArray *array = new TClonesArray("AliAlignObjAngles", 16 + phosGeom->GetNModules() *
+ TClonesArray *array = new TClonesArray("AliAlignObjParams", 16 + phosGeom->GetNModules() *
emca->GetNStripX() * emca->GetNStripZ());
TClonesArray &alobj = *array;
Int_t i=0 ;
// Alignment for 5 PHOS modules
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module1",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module1",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module2",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module2",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module3",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module3",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module4",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module4",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module5",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module5",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
// Alignment of CPV modules
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module1/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module1/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module2/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module2/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module3/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module3/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module4/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module4/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Module5/CPV",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Module5/CPV",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
// Alignment for PHOS cradle
- new(alobj[i++]) AliAlignObjAngles("PHOS/Cradle0",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Cradle0",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Cradle1",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Cradle1",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
// Alignment for cradle wheels
- new(alobj[i++]) AliAlignObjAngles("PHOS/Wheel0",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Wheel0",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Wheel1",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Wheel1",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Wheel2",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Wheel2",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[i++]) AliAlignObjAngles("PHOS/Wheel3",
+ new(alobj[i++]) AliAlignObjParams("PHOS/Wheel3",
volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
AliPHOSSurvey geodesicData;
#include "TRandom.h"
#include "TClonesArray.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
#include "AliCDBMetaData.h"
#include "AliCDBId.h"
#include "AliCDBEntry.h"
// ************************* 1st step ***************
// Create TClonesArray of alignment objects for PHOS
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",11);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",11);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx=0., dy=0., dz=0., dpsi=0., dtheta=0., dphi=0.;
// null shifts and rotations
for (Int_t iModule = 1; iModule<=nModules; iModule++) {
TString newPath = basePath;
newPath += iModule;
- new(alobj[iModule-1]) AliAlignObjAngles(newPath.Data(),
+ new(alobj[iModule-1]) AliAlignObjParams(newPath.Data(),
dvoluid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
}
// ************************* 1st step ***************
// Create TClonesArray of alignment objects for PHOS
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",11);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",11);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dpsi=0., dtheta=0., dphi=0.;
Double_t displacement = 0.2;
UShort_t dvoluid = AliGeomManager::LayerToVolUID(iLayer,iIndex); //dummy volume identity
// Alignment for 5 PHOS modules
- new(alobj[0]) AliAlignObjAngles("PHOS/Module1",
+ new(alobj[0]) AliAlignObjParams("PHOS/Module1",
dvoluid, -0.20, -0.1, +0.0, dpsi, dtheta, 0.2, kTRUE);
- new(alobj[1]) AliAlignObjAngles("PHOS/Module2",
+ new(alobj[1]) AliAlignObjParams("PHOS/Module2",
dvoluid, -0.10, +0.0, -0.2, dpsi, dtheta, 0.2, kTRUE);
- new(alobj[2]) AliAlignObjAngles("PHOS/Module3",
+ new(alobj[2]) AliAlignObjParams("PHOS/Module3",
dvoluid, 0.05, -0.1, 0.2, dpsi, dtheta, 0.0, kTRUE);
- new(alobj[3]) AliAlignObjAngles("PHOS/Module4",
+ new(alobj[3]) AliAlignObjParams("PHOS/Module4",
dvoluid, +0.10, -0.0, -0.1, dpsi, dtheta, 0.1, kTRUE);
- new(alobj[4]) AliAlignObjAngles("PHOS/Module5",
+ new(alobj[4]) AliAlignObjParams("PHOS/Module5",
dvoluid, +0.20, -0.1, 0.1, dpsi, dtheta, 0.2, kTRUE);
// Alignment for PHOS cradle
- new(alobj[5]) AliAlignObjAngles("PHOS/Cradle0",
+ new(alobj[5]) AliAlignObjParams("PHOS/Cradle0",
dvoluid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[6]) AliAlignObjAngles("PHOS/Cradle1",
+ new(alobj[6]) AliAlignObjParams("PHOS/Cradle1",
dvoluid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
// Alignment for cradle wheels
- new(alobj[7]) AliAlignObjAngles("PHOS/Wheel0",
+ new(alobj[7]) AliAlignObjParams("PHOS/Wheel0",
dvoluid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[8]) AliAlignObjAngles("PHOS/Wheel1",
+ new(alobj[8]) AliAlignObjParams("PHOS/Wheel1",
dvoluid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[9]) AliAlignObjAngles("PHOS/Wheel2",
+ new(alobj[9]) AliAlignObjParams("PHOS/Wheel2",
dvoluid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[10]) AliAlignObjAngles("PHOS/Wheel3",
+ new(alobj[10]) AliAlignObjParams("PHOS/Wheel3",
dvoluid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
// ************************* 2nd step ***************
// ************************* 1st step ***************
// Create TClonesArray of alignment objects for PHOS
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",11);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",11);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dpsi=0., dtheta=0., dphi=0.;
Double_t displacement = 10;
UShort_t dvoluid = AliGeomManager::LayerToVolUID(iLayer,iIndex); //dummy volume identity
// Alignment for 5 PHOS modules
- new(alobj[0]) AliAlignObjAngles("PHOS/Module1",
+ new(alobj[0]) AliAlignObjParams("PHOS/Module1",
dvoluid, -20., -10., 0., dpsi, dtheta, 5, kTRUE);
- new(alobj[1]) AliAlignObjAngles("PHOS/Module2",
+ new(alobj[1]) AliAlignObjParams("PHOS/Module2",
dvoluid, -10., 0., -10., dpsi, dtheta, 2, kTRUE);
- new(alobj[2]) AliAlignObjAngles("PHOS/Module3",
+ new(alobj[2]) AliAlignObjParams("PHOS/Module3",
dvoluid, 5., -10., 10., dpsi, dtheta, 0, kTRUE);
- new(alobj[3]) AliAlignObjAngles("PHOS/Module4",
+ new(alobj[3]) AliAlignObjParams("PHOS/Module4",
dvoluid, +10., -0., -10., dpsi, dtheta, 2, kTRUE);
- new(alobj[4]) AliAlignObjAngles("PHOS/Module5",
+ new(alobj[4]) AliAlignObjParams("PHOS/Module5",
dvoluid, +20., -10., 0., dpsi, dtheta, 5, kTRUE);
// Alignment for PHOS cradle
- new(alobj[5]) AliAlignObjAngles("PHOS/Cradle0",
+ new(alobj[5]) AliAlignObjParams("PHOS/Cradle0",
dvoluid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[6]) AliAlignObjAngles("PHOS/Cradle1",
+ new(alobj[6]) AliAlignObjParams("PHOS/Cradle1",
dvoluid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
// Alignment for cradle wheels
- new(alobj[7]) AliAlignObjAngles("PHOS/Wheel0",
+ new(alobj[7]) AliAlignObjParams("PHOS/Wheel0",
dvoluid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[8]) AliAlignObjAngles("PHOS/Wheel1",
+ new(alobj[8]) AliAlignObjParams("PHOS/Wheel1",
dvoluid, 0., 0., -displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[9]) AliAlignObjAngles("PHOS/Wheel2",
+ new(alobj[9]) AliAlignObjParams("PHOS/Wheel2",
dvoluid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
- new(alobj[10]) AliAlignObjAngles("PHOS/Wheel3",
+ new(alobj[10]) AliAlignObjParams("PHOS/Wheel3",
dvoluid, 0., 0., +displacement, dpsi, dtheta, dphi, kTRUE);
// ************************* 2nd step ***************
//Create a TClonesArray of Align Object to store displacement Angles
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10000);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10000);
TClonesArray &alobj = *array;
// Create a File to store the alignment data
TFile f("PMD_rnd_alobj.root","RECREATE");
if(!f) {cerr<<"cannot open file for output\n";}
- AliAlignObjAngles o;
+ AliAlignObjParams o;
UShort_t iIndex=0;
// AliGeomManager::ELayerID iLayer = AliGeomManager::kTOF;
// UShort_t dvoluid = AliGeomManager::LayerToVolUID(iLayer,iIndex); //dummy volume identity
- new(alobj[0]) AliAlignObjAngles(Sector1, iIndex, dx14, dy14, dz14, dpsi14, dtheta14, dphi14);
- new(alobj[1]) AliAlignObjAngles(Sector2, iIndex, dx14, dy14, dz14, dpsi14, dtheta14, dphi14);
- new(alobj[2]) AliAlignObjAngles(Sector3, iIndex, dx23, dy23, dz23, dpsi23, dtheta23, dphi23);
- new(alobj[3]) AliAlignObjAngles(Sector4, iIndex, dx23, dy23, dz23, dpsi23, dtheta23, dphi23);
+ new(alobj[0]) AliAlignObjParams(Sector1, iIndex, dx14, dy14, dz14, dpsi14, dtheta14, dphi14);
+ new(alobj[1]) AliAlignObjParams(Sector2, iIndex, dx14, dy14, dz14, dpsi14, dtheta14, dphi14);
+ new(alobj[2]) AliAlignObjParams(Sector3, iIndex, dx23, dy23, dz23, dpsi23, dtheta23, dphi23);
+ new(alobj[3]) AliAlignObjParams(Sector4, iIndex, dx23, dy23, dz23, dpsi23, dtheta23, dphi23);
// This part needs to be understood
f.cd();
//Create a TClonesArray of Align Object to store displacement Angles
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
- AliAlignObjAngles o;
+ AliAlignObjParams o;
Int_t iIndex=0; //let all modules have index=0 in a layer with no LUT
AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
UShort_t volid = AliGeomManager::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);
+ new(alobj[0]) AliAlignObjParams(Sector1, volid, dx14, dy14, dz14, dpsi14, dtheta14, dphi14, kFALSE);
+ new(alobj[1]) AliAlignObjParams(Sector2, volid, dx14, dy14, dz14, dpsi14, dtheta14, dphi14, kFALSE);
+ new(alobj[2]) AliAlignObjParams(Sector3, volid, dx23, dy23, dz23, dpsi23, dtheta23, dphi23, kFALSE);
+ new(alobj[3]) AliAlignObjParams(Sector4, volid, dx23, dy23, dz23, dpsi23, dtheta23, dphi23, kFALSE);
const char* macroname = "MakePMDFullMisAlignment.C";
if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
//Create a TClonesArray of Align Object to store displacement Angles
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
- AliAlignObjAngles o;
+ AliAlignObjParams o;
Int_t iIndex=0; // let all modules have index=0 in a layer with no LUT
AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
UShort_t volid = AliGeomManager::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);
+ new(alobj[0]) AliAlignObjParams(Sector1, volid, dx14, dy14, dz14, dpsi14, dtheta14, dphi14, kFALSE);
+ new(alobj[1]) AliAlignObjParams(Sector2, volid, dx14, dy14, dz14, dpsi14, dtheta14, dphi14, kFALSE);
+ new(alobj[2]) AliAlignObjParams(Sector3, volid, dx23, dy23, dz23, dpsi23, dtheta23, dphi23, kFALSE);
+ new(alobj[3]) AliAlignObjParams(Sector4, volid, dx23, dy23, dz23, dpsi23, dtheta23, dphi23, kFALSE);
const char* macroname = "MakePMDResMisAlignment.C";
if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
// needed for the constructors with local coordinates not to fail
//Create a TClonesArray of Align Object to store displacement Angles
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
- AliAlignObjAngles o;
+ AliAlignObjParams o;
Int_t iIndex=0; // let all modules have index=0 in a layer with no LUT
AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
for(i=1; i<=4; i++){
TString snSector(Form("PMD/Sector%d",i));
- new(alobj[j++]) AliAlignObjAngles(snSector.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[j++]) AliAlignObjParams(snSector.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
}
const char* macroname = "MakePMDZeroMisAlignment.C";
// Implementation of the alignment object class, holding the alignment
// constants for a single volume, through the abstract class AliAlignObj.
// From it two derived concrete representation of alignment object class
-// (AliAlignObjAngles, AliAlignObjMatrix) are derived in separate files.
+// (AliAlignObjParams, AliAlignObjMatrix) are derived in separate files.
//-----------------------------------------------------------------
#include <TClass.h>
#include "AliAlignObj.h"
#include "AliTrackPointArray.h"
#include "AliLog.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
ClassImp(AliAlignObj)
fVolUID(0)
{
// default constructor
- // InitSymNames();
+ for(Int_t i=0; i<6; i++) fDiag[i]=-999.;
+ for(Int_t i=0; i<21; i++) fODia[i]=-999.;
}
//_____________________________________________________________________________
{
// standard constructor
//
+ for(Int_t i=0; i<6; i++) fDiag[i]=-999.;
+ for(Int_t i=0; i<21; i++) fODia[i]=-999.;
+}
+
+//_____________________________________________________________________________
+AliAlignObj::AliAlignObj(const char* symname, UShort_t voluid, Double_t* cmat) :
+ TObject(),
+ fVolPath(symname),
+ fVolUID(voluid)
+{
+ // standard constructor
+ //
+ SetCorrMatrix(cmat);
}
//_____________________________________________________________________________
fVolUID(theAlignObj.GetVolUID())
{
//copy constructor
+ for(Int_t i=0; i<6; i++) fDiag[i]=theAlignObj.fDiag[i];
+ for(Int_t i=0; i<21; i++) fODia[i]=theAlignObj.fODia[i];
}
//_____________________________________________________________________________
if(this==&theAlignObj) return *this;
fVolPath = theAlignObj.GetSymName();
fVolUID = theAlignObj.GetVolUID();
+ for(Int_t i=0; i<6; i++) fDiag[i]=theAlignObj.fDiag[i];
+ for(Int_t i=0; i<21; i++) fODia[i]=theAlignObj.fODia[i];
return *this;
}
theAlignObj.GetMatrix(m2);
m1.MultiplyLeft(&m2);
SetMatrix(m1);
+ // temporary solution: consider parameters indipendent
+ for(Int_t i=0; i<6; i++) fDiag[i] = TMath::Sqrt((fDiag[i]*fDiag[i])+(theAlignObj.fDiag[i]*theAlignObj.fDiag[i]));
return *this;
}
return ((level > level2) ? 1 : -1);
}
+//______________________________________________________________________________
+void AliAlignObj::GetCovMatrix(Double_t *cmat) const
+{
+ // Fills the cmat argument with the coefficients of the external cov matrix (21 elements)
+ // calculating them from the correlation matrix data member
+ //
+
+ for(Int_t i=0; i<6; ++i) {
+ // Off diagonal elements
+ for(Int_t j=0; j<i; ++j) {
+ cmat[i*(i+1)/2+j] = (fDiag[j] >= 0. && fDiag[i] >= 0.) ? fODia[(i-1)*i/2+j]*fDiag[j]*fDiag[i]: -999.;
+ }
+
+ // Diagonal elements
+ cmat[i*(i+1)/2+i] = (fDiag[i] >= 0.) ? fDiag[i]*fDiag[i] : -999.;
+ }
+}
+
+//______________________________________________________________________________
+void AliAlignObj::SetCorrMatrix(Double_t *cmat)
+{
+ // Sets the correlation matrix data member from the coefficients of the external covariance
+ // matrix (21 elements passed as argument).
+ //
+ if(cmat) {
+
+ // Diagonal elements first
+ for(Int_t i=0; i<6; ++i) {
+ fDiag[i] = (cmat[i*(i+1)/2+i] >= 0.) ? TMath::Sqrt(cmat[i*(i+1)/2+i]) : -999.;
+ }
+
+ // ... then the ones off diagonal
+ for(Int_t i=0; i<6; ++i)
+ // Off diagonal elements
+ for(Int_t j=0; j<i; ++j) {
+ fODia[(i-1)*i/2+j] = (fDiag[i] > 0. && fDiag[j] > 0.) ? cmat[i*(i+1)/2+j]/(fDiag[j]*fDiag[i]) : 0.; // check for division by zero (due to diagonal element of 0) and for fDiag != -999. (due to negative input diagonal element).
+ if (fODia[(i-1)*i/2+j]>1.) fODia[(i-1)*i/2+j] = 1.; // check upper boundary
+ if (fODia[(i-1)*i/2+j]<-1.) fODia[(i-1)*i/2+j] = -1.; // check lower boundary
+ }
+ } else {
+ for(Int_t i=0; i< 6; ++i) fDiag[i]=-999.;
+ for(Int_t i=0; i< 6*(6-1)/2; ++i) fODia[i]=0.;
+ }
+
+ return;
+}
+
//_____________________________________________________________________________
void AliAlignObj::AnglesToMatrix(const Double_t *angles, Double_t *rot) const
{
#include "TObject.h"
#include "TString.h"
#include "TGeoMatrix.h"
+#include <Rtypes.h>
+#include <TMath.h>
#include "AliGeomManager.h"
AliAlignObj();
AliAlignObj(const char* symname, UShort_t voluid);
+ AliAlignObj(const char* symname, UShort_t voluid, Double_t* cmat);
AliAlignObj(const char* symname, AliGeomManager::ELayerID detId, Int_t modId);
AliAlignObj(const AliAlignObj& theAlignObj);
AliAlignObj& operator= (const AliAlignObj& theAlignObj);
void SetSymName(const TString& symname) {fVolPath=symname;}
void SetVolUID(UShort_t voluid) {fVolUID=voluid;}
void SetVolUID(AliGeomManager::ELayerID layerId, Int_t modId);
+ void SetCorrMatrix(Double_t *cov);
//Getters
const char *GetSymName() const {return fVolPath.Data();}
virtual Bool_t GetLocalPars(Double_t transl[], Double_t angles[]) const;
virtual void GetMatrix(TGeoHMatrix& m) const=0;
virtual Bool_t GetLocalMatrix(TGeoHMatrix& m) const;
+ void GetCovMatrix(Double_t *cov) const;
Bool_t IsSortable() const {return kTRUE;}
Int_t GetLevel() const;
// the volume path inside TGeo geometry (for non-alignable volumes)
UShort_t fVolUID; // Unique volume ID
- ClassDef(AliAlignObj, 2)
+ Double32_t fDiag[6]; // diagonal elements of the correlation matrix for shifts and rotations (dx,dy,dz,dpsi,dtheta,dphi)
+ Double32_t fODia[15]; // [-1, 1,8] off-diagonal elements (in 8 bit precision) of the correlation matrix
+
+ ClassDef(AliAlignObj, 3)
};
#endif
//-----------------------------------------------------------------
// Implementation of the alignment object class through
// the concrete representation of alignment object class
-// AliAlignObjAngles derived from the base class AliAlignObj
+// AliAlignObjParams derived from the base class AliAlignObj
//-----------------------------------------------------------------
#include "AliAlignObj.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
-ClassImp(AliAlignObjAngles)
+ClassImp(AliAlignObjParams)
//_____________________________________________________________________________
-AliAlignObjAngles::AliAlignObjAngles() : AliAlignObj()
+AliAlignObjParams::AliAlignObjParams() : AliAlignObj()
{
// default constructor
//
}
//_____________________________________________________________________________
-AliAlignObjAngles::AliAlignObjAngles(const char* symname, UShort_t volUId, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi, Bool_t global) throw (const Char_t *) : AliAlignObj(symname,volUId)
+AliAlignObjParams::AliAlignObjParams(const char* symname, UShort_t volUId, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi, Bool_t global) throw (const Char_t *) : AliAlignObj(symname,volUId)
{
// standard constructor with 3 translation + 3 rotation parameters
// If the user explicitly sets the global variable to kFALSE then the
}
//_____________________________________________________________________________
-AliAlignObjAngles::AliAlignObjAngles(const char* symname, UShort_t volUId, TGeoMatrix& m, Bool_t global) throw (const Char_t *) : AliAlignObj(symname,volUId)
+AliAlignObjParams::AliAlignObjParams(const char* symname, UShort_t volUId, TGeoMatrix& m, Bool_t global) throw (const Char_t *) : AliAlignObj(symname,volUId)
{
// standard constructor with TGeoMatrix
// If the user explicitly sets the global variable to kFALSE then the
}
//_____________________________________________________________________________
-AliAlignObjAngles::AliAlignObjAngles(const AliAlignObj& theAlignObj) :
+AliAlignObjParams::AliAlignObjParams(const AliAlignObj& theAlignObj) :
AliAlignObj(theAlignObj)
{
// copy constructor
}
//_____________________________________________________________________________
-AliAlignObjAngles &AliAlignObjAngles::operator =(const AliAlignObj& theAlignObj)
+AliAlignObjParams &AliAlignObjParams::operator =(const AliAlignObj& theAlignObj)
{
// assignment operator
//
}
//_____________________________________________________________________________
-AliAlignObjAngles::~AliAlignObjAngles()
+AliAlignObjParams::~AliAlignObjParams()
{
// default destructor
//
}
//_____________________________________________________________________________
-void AliAlignObjAngles::SetTranslation(const TGeoMatrix& m)
+void AliAlignObjParams::SetTranslation(const TGeoMatrix& m)
{
// set the translation parameters extracting them from the matrix
// passed as argument
}
//_____________________________________________________________________________
-Bool_t AliAlignObjAngles::SetRotation(const TGeoMatrix& m)
+Bool_t AliAlignObjParams::SetRotation(const TGeoMatrix& m)
{
// set the rotation parameters extracting them from the matrix
// passed as argument
}
//_____________________________________________________________________________
-void AliAlignObjAngles::GetMatrix(TGeoHMatrix& m) const
+void AliAlignObjParams::GetMatrix(TGeoHMatrix& m) const
{
// get the transformation matrix from the data memebers parameters
m.SetTranslation(&fTranslation[0]);
}
//_____________________________________________________________________________
-AliAlignObj& AliAlignObjAngles::Inverse() const
+AliAlignObj& AliAlignObjParams::Inverse() const
{
// Return a temporary "inverse" of the alignment object, that is return
// an object with inverted transformation matrix.
//
- static AliAlignObjAngles a;
+ static AliAlignObjParams a;
a = *this;
TGeoHMatrix m;
#define ALIALIGNOBJANGLES_H
/*****************************************************************************
- * AliAlignObjAngles: derived alignment class storing alignment information *
+ * AliAlignObjParams: derived alignment class storing alignment information *
* for a single volume in form of three doubles for the translation *
* and three doubles for the rotation expressed with the euler angles *
* in the xyz-convention (http://mathworld.wolfram.com/EulerAngles.html), *
#include "AliAlignObj.h"
-class AliAlignObjAngles : public AliAlignObj{
+class AliAlignObjParams : public AliAlignObj{
public:
- AliAlignObjAngles();
- AliAlignObjAngles(const char* symname, UShort_t volUId, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi, Bool_t global) throw (const Char_t *);
- AliAlignObjAngles(const char* symname, UShort_t volUId, TGeoMatrix& m, Bool_t global) throw (const Char_t *);
- AliAlignObjAngles(const AliAlignObj& theAlignObj);
- AliAlignObjAngles& operator= (const AliAlignObj& theAlignObj);
- virtual ~AliAlignObjAngles();
+ AliAlignObjParams();
+ AliAlignObjParams(const char* symname, UShort_t volUId, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi, Bool_t global) throw (const Char_t *);
+ AliAlignObjParams(const char* symname, UShort_t volUId, TGeoMatrix& m, Bool_t global) throw (const Char_t *);
+ AliAlignObjParams(const AliAlignObj& theAlignObj);
+ AliAlignObjParams& operator= (const AliAlignObj& theAlignObj);
+ virtual ~AliAlignObjParams();
//Setters
virtual void SetTranslation(Double_t x, Double_t y, Double_t z){
Double_t fTranslation[3]; // Translation vector
Double_t fRotation[3]; // Roll-pitch-yaw angles
- ClassDef(AliAlignObjAngles, 1)
+ ClassDef(AliAlignObjParams, 1)
};
#endif
#include "AliAlignmentTracks.h"
#include "AliTrackPointArray.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
#include "AliTrackFitterRieman.h"
#include "AliTrackResidualsChi2.h"
#include "AliESD.h"
// Dummy object is created in order
// to initialize the volume paths
- AliAlignObjAngles alobj;
+ AliAlignObjParams alobj;
fPointsFile = TFile::Open(fPointsFilename);
if (!fPointsFile || !fPointsFile->IsOpen()) {
fAlignObjs[iLayer] = new AliAlignObj*[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)];
for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer+ AliGeomManager::kFirstLayer,iModule);
- fAlignObjs[iLayer][iModule] = new AliAlignObjAngles(AliGeomManager::SymName(volid),volid,0,0,0,0,0,0,kTRUE);
+ fAlignObjs[iLayer][iModule] = new AliAlignObjParams(AliGeomManager::SymName(volid),volid,0,0,0,0,0,0,kTRUE);
}
}
}
#include "AliGeomManager.h"
#include "AliLog.h"
#include "AliAlignObj.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"
#include "AliCDBEntry.h"
fgAlignObjs[iLayer-kFirstLayer] = new AliAlignObj*[LayerSize(iLayer)];
for (Int_t iModule = 0; iModule < LayerSize(iLayer); iModule++) {
UShort_t volid = LayerToVolUID(iLayer,iModule);
- fgAlignObjs[iLayer-kFirstLayer][iModule] = new AliAlignObjAngles("",volid,0,0,0,0,0,0,kTRUE);
+ fgAlignObjs[iLayer-kFirstLayer][iModule] = new AliAlignObjParams("",volid,0,0,0,0,0,0,kTRUE);
const char *symname = SymName(volid);
if (!GetFromGeometry(symname, *fgAlignObjs[iLayer-kFirstLayer][iModule]))
AliErrorClass(Form("Failed to extract the alignment object for the volume (ID=%d and path=%s) !",volid,symname));
#include "AliTrackResiduals.h"
#include "AliAlignObj.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
#include "AliTrackPointArray.h"
ClassImp(AliTrackResiduals)
// Create the alignment object
// to be updated
if (fAlignObj) delete fAlignObj;
- fAlignObj = new AliAlignObjAngles;
+ fAlignObj = new AliAlignObjParams;
}
#include "TObject.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
class AliTrackPointArray;
#pragma link C++ class AliGeomManager+;
#pragma link C++ class AliAlignObj+;
-#pragma link C++ class AliAlignObjAngles+;
+#pragma link C++ class AliAlignObjParams+;
#pragma link C++ class AliAlignObjMatrix+;
#pragma link C++ class AliTrackFitter+;
AliMC.cxx AliSimulation.cxx AliReconstruction.cxx AliVertexGenFile.cxx \
AliReconstructor.cxx TTreeStream.cxx\
AliGeomManager.cxx \
-AliAlignObj.cxx AliAlignObjAngles.cxx AliAlignObjMatrix.cxx \
+AliAlignObj.cxx AliAlignObjParams.cxx AliAlignObjMatrix.cxx \
AliTriggerInput.cxx \
AliTriggerDetector.cxx \
AliTriggerCondition.cxx \
void MakeT0FullMisAlignment(){
// Create TClonesArray of full misalignment objects for T0
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",30);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",30);
TClonesArray &alobj = *array;
if(!AliGeomManager::GetGeometry()){
AliGeomManager::LoadGeometry();
}
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx, dy, dz, dpsi, dtheta, dphi;
TRandom *rnd = new TRandom(4321);
dtheta = rnd->Gaus(0.,sigmarot);
dphi = rnd->Gaus(0.,sigmarot);
- new(alobj[j++]) AliAlignObjAngles(symName.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[j++]) AliAlignObjParams(symName.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
}
const char* macroname = "MakeT0FullMisAlignment.C";
void MakeT0ResMisAlignment(){
// Create TClonesArray of residual misalignment objects for T0
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",30);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",30);
TClonesArray &alobj = *array;
if(!AliGeomManager::GetGeometry()){
}
// needed for the constructors with local coordinates not to fail
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx, dy, dz, dpsi, dtheta, dphi;
TRandom *rnd = new TRandom(4321);
dtheta = rnd->Gaus(0.,sigmarot);
dphi = rnd->Gaus(0.,sigmarot);
- new(alobj[j++]) AliAlignObjAngles(symName.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[j++]) AliAlignObjParams(symName.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
}
const char* macroname = "MakeT0ResMisAlignment.C";
void MakeT0ZeroMisAlignment(){
// Create TClonesArray of zero misalignment objects for T0
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx=0, dy=0, dz=0, dpsi=0, dtheta=0, dphi=0;
symName = sn;
symName += imod+1;
- new(alobj[j++]) AliAlignObjAngles(symName.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[j++]) AliAlignObjParams(symName.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
}
const char* macroname = "MakeT0ZeroMisAlignment.C";
/*
$Log$
+Revision 1.17 2007/06/06 16:26:46 arcelli
+remove fall-back call to local CDB storage
+
Revision 1.16 2007/05/15 16:25:44 cvetan
Moving the alignment-related static methods from AliAlignObj to the new geometry steering class AliGeomManager (macro from Raffaele)
#include "AliLog.h"
#include "AliAlignObj.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
#include "AliAlignObjMatrix.h"
#include "AliCDBManager.h"
#include "AliCDBMetaData.h"
dpsi = rot[0];
dtheta = rot[1];
dphi = rot[2];
- AliAlignObjAngles *o =new AliAlignObjAngles(path, dvoluid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ AliAlignObjParams *o =new AliAlignObjParams(path, dvoluid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
fTOFAlignObjArray->Add(o);
}
dtheta = rot[1];
dphi = rot[2];
- AliAlignObjAngles *o =new AliAlignObjAngles(path, dvoluid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ AliAlignObjParams *o =new AliAlignObjParams(path, dvoluid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
fTOFAlignObjArray->Add(o);
}
fNTOFAlignObj=fTOFAlignObjArray->GetEntries();
void MakeTOFFullMisAlignment(){
// Create TClonesArray of full misalignment objects for TOF
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",2000);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",2000);
TClonesArray &alobj = *array;
if(!AliGeomManager::GetGeometry()){
AliGeomManager::LoadGeometry();
}
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t sfdpsi=0.,sfdtheta=0.,sfdphi=0.;
Int_t iIndex=0; //let all modules have index=0 in a layer with no LUT
AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
segmpath+=sm;
segmpath+="_1";
cout<<segmpath.Data()<<" "<<dvoluid<<" "<<mean_dx[sm]*0.1<<" "<<mean_dy[sm]*0.1<<" "<<dz<<" "<<sfdpsi<<" "<<sfdtheta<<" "<<sfdphi<<endl;
- new(alobj[sm]) AliAlignObjAngles(segmpath.Data(), dvoluid, mean_dx[sm]*0.1,
+ new(alobj[sm]) AliAlignObjParams(segmpath.Data(), dvoluid, mean_dx[sm]*0.1,
mean_dy[sm]*0.1, dz, sfdpsi, sfdtheta, sfdphi, kTRUE);
}
for(Int_t k=0; k<18; k++){
- AliAlignObjAngles* smobj = (AliAlignObjAngles*)array->UncheckedAt(k);
+ AliAlignObjParams* smobj = (AliAlignObjParams*)array->UncheckedAt(k);
if(!smobj->ApplyToGeometry()){
cout<<"application of object "<<k<<" failed!"<<endl;
return;
dpsi = 0.;
dtheta = rnd->Gaus(0.,sigmarot);
dphi = 0.;
- new(alobj[j++]) AliAlignObjAngles(symname.Data(), dvoluid, tofdx, tofdy, tofdz, dpsi, dtheta, dphi, kFALSE);
+ new(alobj[j++]) AliAlignObjParams(symname.Data(), dvoluid, tofdx, tofdy, tofdz, dpsi, dtheta, dphi, kFALSE);
}
for(Int_t k=18; k<36; k++){
- AliAlignObjAngles* smobj = (AliAlignObjAngles*)array->UncheckedAt(k);
+ AliAlignObjParams* smobj = (AliAlignObjParams*)array->UncheckedAt(k);
if(!smobj->ApplyToGeometry()){
cout<<"application of object "<<k<<" failed!"<<endl;
return;
sdpsi = 0.;
sdtheta = 0.;
sdphi = 0.;
- new(alobj[j++]) AliAlignObjAngles(AliGeomManager::SymName(idTOF,i), AliGeomManager::LayerToVolUID(idTOF,i), sdx, sdy, sdz, sdpsi, sdtheta, sdphi, kFALSE);
+ new(alobj[j++]) AliAlignObjParams(AliGeomManager::SymName(idTOF,i), AliGeomManager::LayerToVolUID(idTOF,i), sdx, sdy, sdz, sdpsi, sdtheta, sdphi, kFALSE);
}
const char* macroname = "MakeTOFFullMisAlignment.C";
void MakeTOFResMisAlignment(){
// Create TClonesArray of residual misalignment objects for TOF
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",2000);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",2000);
TClonesArray &alobj = *array;
if(!AliGeomManager::GetGeometry()){
}
// needed for the constructors with local coordinates not to fail
- AliAlignObjAngles a;
+ AliAlignObjParams a;
AliGeomManager::ELayerID idTOF = AliGeomManager::kTOF;
Int_t i;
dpsi = 0.;
dtheta = 0.;
dphi = 0.;
- new(alobj[j]) AliAlignObjAngles(AliGeomManager::SymName(idTOF,i), AliGeomManager::LayerToVolUID(idTOF,i), dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+ new(alobj[j]) AliAlignObjParams(AliGeomManager::SymName(idTOF,i), AliGeomManager::LayerToVolUID(idTOF,i), dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
j++;
}
void MakeTOFZeroMisAlignment(){
// Create TClonesArray of zero misalignment objects for TOF
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",2000);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",2000);
TClonesArray &alobj = *array;
if(!AliGeomManager::GetGeometry()){
}
// needed for the constructors with local coordinates not to fail
- AliAlignObjAngles a;
+ AliAlignObjParams a;
AliGeomManager::ELayerID idTOF = AliGeomManager::kTOF;
Int_t i;
Double_t dx=0., dy=0., dz=0., dpsi=0., dtheta=0., dphi=0.;
for(i=0; i<AliGeomManager::LayerSize(idTOF); i++) {
- new(alobj[j++]) AliAlignObjAngles(AliGeomManager::SymName(idTOF,i), AliGeomManager::LayerToVolUID(idTOF,i), dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[j++]) AliAlignObjParams(AliGeomManager::SymName(idTOF,i), AliGeomManager::LayerToVolUID(idTOF,i), dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
}
const char* macroname = "MakeTOFZeroMisAlignment.C";
#include <TGeoManager.h>
#include <TGeoPhysicalNode.h>
#include "AliAlignObj.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
#include "AliLog.h"
ClassImp(AliTPCParam)
if (!gGeoManager){
AliFatal("Geo manager not initialized\n");
}
- AliAlignObjAngles o;
+ AliAlignObjParams o;
//
if (fTrackingMatrix) delete [] fTrackingMatrix;
fTrackingMatrix = new TGeoHMatrix*[fNSector];
#include <AliAlignObj.h>
-#include <AliAlignObjAngles.h>
+#include <AliAlignObjParams.h>
#include <AliCDBManager.h>
#include <AliCDBStorage.h>
#include <AliCDBEntry.h>
void GenerateRndTPC(Float_t sigmatrx=0., Float_t sigmatry=0, Float_t sigmatrz=0, Float_t sigmarot = 0.){
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10000);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10000);
TClonesArray &alobj = *array;
TFile f("TPC_alignment.root","RECREATE");
TRandom *rnd = new TRandom(4357);
- AliAlignObjAngles o;
+ AliAlignObjParams o;
Int_t j = 0;
for (Int_t iLayer = AliGeomManager::kTPC1; iLayer <= AliGeomManager::kTPC2; iLayer++) {
for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer); iModule++) {
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
const char *path = AliGeomManager::GetVolPath(volid);
- new(alobj[j]) AliAlignObjAngles(path, volid, dx, dy, dz, dpsi, dtheta, dphi);
+ new(alobj[j]) AliAlignObjParams(path, volid, dx, dy, dz, dpsi, dtheta, dphi);
j++;
}
}
}
// needed for the constructors with local coordinates not to fail
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",100);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",100);
TClonesArray &alobj = *array;
TRandom *rnd = new TRandom(4357);
- AliAlignObjAngles o;
+ AliAlignObjParams o;
Int_t j = 0;
Double_t dx, dy, dz, dpsi, dtheta, dphi;
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
const char *symname = AliGeomManager::SymName(volid);
- new(alobj[j++]) AliAlignObjAngles(symname, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+ new(alobj[j++]) AliAlignObjParams(symname, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
}
}
}
// needed for the constructors with local coordinates not to fail
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",100);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",100);
TClonesArray &alobj = *array;
TRandom *rnd = new TRandom(4357);
- AliAlignObjAngles o;
+ AliAlignObjParams o;
Double_t dx, dy, dz, dpsi, dtheta, dphi;
Int_t j = 0;
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
const char *symname = AliGeomManager::SymName(volid);
- new(alobj[j]) AliAlignObjAngles(symname, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
+ new(alobj[j]) AliAlignObjParams(symname, volid, dx, dy, dz, dpsi, dtheta, dphi, kFALSE);
j++;
}
}
}
// needed for the constructors with local coordinates not to fail
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",100);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",100);
TClonesArray &alobj = *array;
- AliAlignObjAngles o;
+ AliAlignObjParams o;
Double_t dx=0., dy=0., dz=0., dpsi=0., dtheta=0., dphi=0.;
Int_t j = 0;
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
const char *symname = AliGeomManager::SymName(volid);
- new(alobj[j]) AliAlignObjAngles(symname, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[j]) AliAlignObjParams(symname, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
j++;
}
}
#include "AliLog.h"
#include "AliAlignObj.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"
#include "AliCDBMetaData.h"
if (!IsGeoLoaded()) return 0;
printf("Survey of supermodule %d\n",i);
- AliAlignObjAngles al(GetSmName(i),0,a[0],a[1],a[2],a[3],a[4],a[5],0);
+ AliAlignObjParams al(GetSmName(i),0,a[0],a[1],a[2],a[3],a[4],a[5],0);
TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(GetSmName(i));
if (!pne) AliError(Form("no such physical node entry: %s",GetSmName(i)));
TGeoPhysicalNode *node = pne->GetPhysicalNode();
// store the alignment data on root file
//
- TClonesArray *ar = new TClonesArray("AliAlignObjAngles",10000);
+ TClonesArray *ar = new TClonesArray("AliAlignObjParams",10000);
NumbersToAr(ar);
TFile fo(filename,"RECREATE");
if (fo.IsOpen()) {
// dumping on a DB-like file
//
- TClonesArray *ar = new TClonesArray("AliAlignObjAngles",10000);
+ TClonesArray *ar = new TClonesArray("AliAlignObjParams",10000);
NumbersToAr(ar);
char *path = "TRD/Align/Data";
AliCDBId id(path,run0,run1);
// store the alignment data in database
//
- TClonesArray *ar = new TClonesArray("AliAlignObjAngles",10000);
+ TClonesArray *ar = new TClonesArray("AliAlignObjParams",10000);
NumbersToAr(ar);
AliCDBManager *cdb = AliCDBManager::Instance();
AliCDBStorage *storLoc = cdb->GetStorage(db);
// resulting geometry on a root file
//
- TClonesArray *ar = new TClonesArray("AliAlignObjAngles",10000);
+ TClonesArray *ar = new TClonesArray("AliAlignObjParams",10000);
NumbersToAr(ar);
delete ar;
gGeoManager->Export(filename);
TClonesArray &alobj = *ar;
int nobj = 0;
for (int i = 0; i < 18; i++) {
- new(alobj[nobj]) AliAlignObjAngles(GetSmName(i)
+ new(alobj[nobj]) AliAlignObjParams(GetSmName(i)
,0
,fSm[i][0],fSm[i][1],fSm[i][2]
,fSm[i][3],fSm[i][4],fSm[i][5]
}
for (int i = 0; i < 540; i++) {
- new(alobj[nobj]) AliAlignObjAngles(GetChName(i)
+ new(alobj[nobj]) AliAlignObjParams(GetChName(i)
,GetVoi(i)
,fCh[i][0],fCh[i][1],fCh[i][2]
,fCh[i][3],fCh[i][4],fCh[i][5]
#include "AliLog.h"
#include "AliRunLoader.h"
#include "AliAlignObj.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
#include "AliRun.h"
#include "AliTRD.h"
fMatrixArray = new TObjArray(kNdet);
fMatrixCorrectionArray = new TObjArray(kNdet);
fMatrixGeo = new TObjArray(kNdet);
- AliAlignObjAngles o;
+ AliAlignObjParams o;
for (Int_t iLayer = AliGeomManager::kTRD1; iLayer <= AliGeomManager::kTRD6; iLayer++) {
for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer); iModule++) {
void MakeTRDFullMisAlignment(){
// Create TClonesArray of full misalignment objects for TRD
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",1000);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",1000);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
// sigmas for the supermodules
Double_t smdx=0.3; // 3 mm
rx*=smrx;
ry*=smry;
rz*=smrz;
- new(alobj[j++]) AliAlignObjAngles(sm_symname.Data(),0,dx,dy,dz,rx,ry,rz,kFALSE);
+ new(alobj[j++]) AliAlignObjParams(sm_symname.Data(),0,dx,dy,dz,rx,ry,rz,kFALSE);
}
for(Int_t k=0; k<18; k++){
- AliAlignObjAngles* smobj = (AliAlignObjAngles*)array->UncheckedAt(k);
+ AliAlignObjParams* smobj = (AliAlignObjParams*)array->UncheckedAt(k);
if(!smobj->ApplyToGeometry()){
cout<<"application of object "<<k<<" failed!"<<endl;
return;
rz*=chrz;
volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
symname = AliGeomManager::SymName(volid);
- new(alobj[j++]) AliAlignObjAngles(symname,volid,dx,dy,dz,rx,ry,rz,kFALSE);
+ new(alobj[j++]) AliAlignObjParams(symname,volid,dx,dy,dz,rx,ry,rz,kFALSE);
}
}
void MakeTRDResMisAlignment(){
// Create TClonesArray of residual misalignment objects for TRD
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",1000);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",1000);
TClonesArray &alobj = *array;
if(!AliGeomManager::GetGeometry()){
}
// needed for the constructors with local coordinates not to fail
- AliAlignObjAngles a;
+ AliAlignObjParams a;
// sigmas for the chambers
Double_t chdx=0.002; // 20 microns
rz*=chrz;
volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
symname = AliGeomManager::SymName(volid);
- new(alobj[j++]) AliAlignObjAngles(symname,volid,dx,dy,dz,rx,ry,rz,kFALSE);
+ new(alobj[j++]) AliAlignObjParams(symname,volid,dx,dy,dz,rx,ry,rz,kFALSE);
}
}
void MakeTRDZeroMisAlignment(){
// Create TClonesArray of zero misalignment objects for TRD
//
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",1000);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",1000);
TClonesArray &alobj = *array;
if(!AliGeomManager::GetGeometry()){
}
// needed for the constructors with local coordinates not to fail
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx=0.,dy=0.,dz=0.,rx=0.,ry=0.,rz=0.;
for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer); iModule++) {
volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
symname = AliGeomManager::SymName(volid);
- new(alobj[j++]) AliAlignObjAngles(symname,volid,dx,dy,dz,rx,ry,rz,kTRUE);
+ new(alobj[j++]) AliAlignObjParams(symname,volid,dx,dy,dz,rx,ry,rz,kTRUE);
}
}
}
// needed for the constructors with local coordinates not to fail
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx, dy, dz, dpsi, dtheta, dphi;
TRandom *rnd = new TRandom(4321);
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,
+ new(alobj[0]) AliAlignObjParams(V0right, volid, dx, dy, dz, dpsi, dtheta,
dphi, kFALSE);
dx = rnd->Gaus(0.,sigmatr);
dy = 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,
+ new(alobj[1]) AliAlignObjParams(V0left, volid, dx, dy, dz, dpsi, dtheta,
dphi,kFALSE);
const char* macroname = "MakeVZEROFullMisAlignment.C";
}
// needed for the constructors with local coordinates not to fail
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx, dy, dz, dpsi, dtheta, dphi;
TRandom *rnd = new TRandom(4321);
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);
+ new(alobj[0]) AliAlignObjParams(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);
+ new(alobj[1]) AliAlignObjParams(V0left, volid, dx, dy, dz, dpsi, dtheta, dphi,kFALSE);
const char* macroname = "MakeVZEROResMisAlignment.C";
if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
}
// needed for the constructors with local coordinates not to fail
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx, dy, dz, dpsi, dtheta, dphi;
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iIndex);
TString V0right("VZERO/V0C");
- new(alobj[0]) AliAlignObjAngles(V0right.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[0]) AliAlignObjParams(V0right.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
TString V0left("VZERO/V0A");
- new(alobj[1]) AliAlignObjAngles(V0left.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi,kTRUE);
+ new(alobj[1]) AliAlignObjParams(V0left.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi,kTRUE);
const char* macroname = "MakeVZEROZeroMisAlignment.C";
if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
#include "AliCDBMetaData.h"
#include "AliDCSValue.h"
#include "AliAlignObj.h"
-#include "AliAlignObjAngles.h"
+#include "AliAlignObjParams.h"
#include "AliLog.h"
#include "AliZDCDataDCS.h"
#include "AliZDCCalibData.h"
//dcsAliasMap->Print("");
//
// --- Writing ZDC table positions into alignment object
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx=0., dz=0., dpsi=0., dtheta=0., dphi=0.;
// Vertical table position in mm from DCS
Double_t dyZN1 = (Double_t) (DCSValues[0]/10.);
AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iIndex);
//
- new(alobj[0]) AliAlignObjAngles(ZDCn1, volid, dx, dyZN1, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[1]) AliAlignObjAngles(ZDCp1, volid, dx, dyZP1, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[2]) AliAlignObjAngles(ZDCn2, volid, dx, dyZN2, dz, dpsi, dtheta, dphi, kTRUE);
- new(alobj[3]) AliAlignObjAngles(ZDCp2, volid, dx, dyZP2, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[0]) AliAlignObjParams(ZDCn1, volid, dx, dyZN1, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[1]) AliAlignObjParams(ZDCp1, volid, dx, dyZP1, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[2]) AliAlignObjParams(ZDCn2, volid, dx, dyZN2, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[3]) AliAlignObjParams(ZDCp2, volid, dx, dyZP2, dz, dpsi, dtheta, dphi, kTRUE);
// save in CDB storage
AliCDBMetaData md;
md.SetResponsible("Chiara Oppedisano");
}
// needed for the constructors with local coordinates not to fail
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx=0., dy=2., dz=0.;
Double_t dpsi=0., dtheta=0., dphi=0.;
AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iIndex);
- 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);
+ new(alobj[0]) AliAlignObjParams(ZDCn, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[1]) AliAlignObjParams(ZDCp, volid, dx, dy, dz, dpsi, dtheta, dphi,kTRUE);
const char* macroname = "MakeZDCFullMisAlignment.C";
if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
}
// needed for the constructors with local coordinates not to fail
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx=0., dy=0.05, dz=0.;
Double_t dpsi=0., dtheta=0., dphi=0.;
AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iIndex);
- 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);
+ new(alobj[0]) AliAlignObjParams(ZDCn, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[1]) AliAlignObjParams(ZDCp, volid, dx, dy, dz, dpsi, dtheta, dphi,kTRUE);
const char* macroname = "MakeZDCResMisAlignment.C";
if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
}
// needed for the constructors with local coordinates not to fail
- TClonesArray *array = new TClonesArray("AliAlignObjAngles",10);
+ TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
- AliAlignObjAngles a;
+ AliAlignObjParams a;
Double_t dx=0., dy=0., dz=0.;
Double_t dpsi=0., dtheta=0., dphi=0.;
AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iIndex);
- 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);
+ new(alobj[0]) AliAlignObjParams(ZDCn, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
+ new(alobj[1]) AliAlignObjParams(ZDCp, volid, dx, dy, dz, dpsi, dtheta, dphi,kTRUE);
const char* macroname = "MakeZDCZeroMisAlignment.C";
if( gSystem->Getenv("TOCDB") != TString("kTRUE") ){
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff