--- /dev/null
+/**************************************************************************
+ * Copyright(c) 2007-2010, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/* $Id$ */
+
+//========================================================================
+//
+// This class is a helper, producing ITS aligmnent objects.
+// It provides also some useful functions
+// See the parameters of the misalignment at the end of this script.
+//
+// Main author: L. Gaudichet
+// Contact: andrea.dainese@lnl.infn.it
+//
+//========================================================================
+
+#include <TClonesArray.h>
+#include <TMath.h>
+#include <TClass.h>
+#include <TGeoManager.h>
+#include "AliLog.h"
+#include "AliAlignObjParams.h"
+#include "AliITSMisAligner.h"
+#include "AliITSSurveyToAlign.h"
+#include "AliMathBase.h"
+
+ClassImp(AliITSMisAligner)
+
+const Int_t AliITSMisAligner::fgkNLadders[AliITSMisAligner::kNLayers] = {20,40,14,22,34,38};
+const Int_t AliITSMisAligner::fgkNDetectors[AliITSMisAligner::kNLayers] = {4,4,6,8,22,25};
+
+const Double_t kRadToDeg = 180./TMath::Pi();
+
+//________________________________________________________________________
+AliITSMisAligner::AliITSMisAligner():
+ AliMisAligner(),
+ fRnd(),
+ fInd(0),
+ fAlignObjArray(NULL),
+ fStrSPD("ITS/SPD"),
+ fStrSDD("ITS/SDD"),
+ fStrSSD("ITS/SSD"),
+ fStrStave("/Stave"),
+ fStrHalfStave("/HalfStave"),
+ fStrLadder("/Ladder"),
+ fStrSector("/Sector"),
+ fStrSensor("/Sensor"),
+ fUnifSPDSector(kFALSE),
+ fUnifSPDHS(kFALSE),
+ fUnifSDDLadder(kFALSE),
+ fUnifSSDLadder(kFALSE),
+ fUnifSPDLadder(kFALSE),
+ fUnifSDDModule(kFALSE),
+ fUnifSSDModule(kFALSE)
+{
+ //
+ // defaul constructor
+ //
+ fRnd.SetSeed(38217945);
+ fAlignObjArray = new TClonesArray("AliAlignObjParams",4000);
+ for(Int_t ii=0; ii<6; ii++)
+ {
+ fWholeITS[ii]=0.;
+ fSPDSector[ii]=0.;
+ fSPDHB[ii]=0.;
+ fSPDBarrel[ii]=0.;
+ fSPDHS[ii]=0.;
+ fSPDLadder[ii]=0.;
+ fSDDLayer[ii]=0.;
+ fSDDBarrel[ii]=0.;
+ fSDDLadder[ii]=0.;
+ fSDDModule[ii]=0.;
+ fSSDBarrel[ii]=0.;
+ fSSDLayer[ii]=0.;
+ fSSDLadder[ii]=0.;
+ fSSDModule[ii]=0.;
+ fSPDLadderShiftT[ii]=0.;
+ fSPDLadderShiftB[ii]=0.;
+ fSDDLadderShift1[ii]=0.;
+ fSDDLadderShift2[ii]=0.;
+ fSSDLadderShift1[ii]=0.;
+ fSSDLadderShift2[ii]=0.;
+ }
+}
+
+//________________________________________________________________________
+AliITSMisAligner::AliITSMisAligner(const AliITSMisAligner &mAligner):
+ fRnd(mAligner.fRnd),
+ fInd(0),
+ fAlignObjArray(mAligner.fAlignObjArray),
+ fStrSPD("ITS/SPD"),
+ fStrSDD("ITS/SDD"),
+ fStrSSD("ITS/SSD"),
+ fStrStave("/Stave"),
+ fStrHalfStave("/HalfStave"),
+ fStrLadder("/Ladder"),
+ fStrSector("/Sector"),
+ fStrSensor("/Sensor"),
+ fUnifSPDSector(kFALSE),
+ fUnifSPDHS(kFALSE),
+ fUnifSDDLadder(kFALSE),
+ fUnifSSDLadder(kFALSE),
+ fUnifSPDLadder(kFALSE),
+ fUnifSDDModule(kFALSE),
+ fUnifSSDModule(kFALSE)
+{
+ //
+ // copy constructor
+ //
+}
+
+//________________________________________________________________________
+AliITSMisAligner &AliITSMisAligner::operator= (const AliITSMisAligner &mAligner)
+{
+ //
+ // assignment operator
+ //
+ fRnd = mAligner.fRnd,
+ fInd = 0;
+ fAlignObjArray = mAligner.fAlignObjArray;
+ fStrSPD = "ITS/SPD";
+ fStrSDD = "ITS/SDD";
+ fStrSSD = "ITS/SSD";
+ fStrStave = "/Stave";
+ fStrHalfStave = "/HalfStave";
+ fStrLadder = "/Ladder";
+ fStrSector = "/Sector";
+ fStrSensor = "/Sensor";
+ fUnifSPDSector = mAligner.fUnifSPDSector;
+ fUnifSPDHS = kFALSE;
+ fUnifSDDLadder = kFALSE;
+ fUnifSSDLadder = kFALSE;
+ fUnifSPDLadder = kFALSE;
+ fUnifSDDModule = kFALSE;
+ fUnifSSDModule = kFALSE;
+ return (*this);
+}
+
+//_______________________________________________________________________________________
+TClonesArray* AliITSMisAligner::MakeAlObjsArray() {
+ // Make the array of alignment objects, depending on the misalignment scenario (Zero, Residual, Full)
+ //
+
+ // Setting default values for ideal, residual or full misalignment
+ SetWholeITSMisAlignment();
+ SetSPDMisAlignment();
+ SetSDDMisAlignment();
+ SetSSDMisAlignment();
+
+ // Get array of alignment objects from survey (based on which we build later the SSD objects)
+ AliITSSurveyToAlign* s2a = new AliITSSurveyToAlign();
+ s2a->Run();
+ TClonesArray* surveyArray = dynamic_cast<TClonesArray*> (s2a->GetAlignObjsArray());
+ if(!surveyArray){
+ Printf("SSD survey array was not build! Probably you missed to connect to alien");
+ return 0;
+ }else{
+ Printf("survey array contains %d entries", surveyArray->GetEntriesFast());
+ }
+ (AliGeomManager::GetGeometry())->UnlockGeometry();
+
+ AddAlignObj("ITS",fWholeITS[0],fWholeITS[1],fWholeITS[2],fWholeITS[3],fWholeITS[4],fWholeITS[5],"fixed");
+
+ AddSectorAlignObj(1,5,fSPDSector[0],fSPDSector[1],fSPDSector[2],fSPDSector[3],fSPDSector[4],fSPDSector[5],
+ fSPDLadderShiftT[0],fSPDLadderShiftT[1],fSPDLadderShiftT[2],fSPDLadderShiftT[3],fSPDLadderShiftT[4],fSPDLadderShiftT[5],fUnifSPDSector);
+ AddSectorAlignObj(6,10,fSPDSector[0],fSPDSector[1],fSPDSector[2],fSPDSector[3],fSPDSector[4],fSPDSector[5],
+ fSPDLadderShiftB[0],fSPDLadderShiftB[1],fSPDLadderShiftB[2],fSPDLadderShiftB[3],fSPDLadderShiftB[4],fSPDLadderShiftB[5],fUnifSPDSector);
+
+ //=****************************************
+ // misalignment at the level of half-staves (SPD)/ladders (SDD,SSD) :
+ //=****************************************
+ AddAlignObj(0,-1,fSPDHS[0],fSPDHS[1],fSPDHS[2],fSPDHS[3],fSPDHS[4],fSPDHS[5],
+ 0,0,0,0,0,0,fUnifSPDHS); // all SPD1 half-staves
+ AddAlignObj(1,-1,fSPDHS[0],fSPDHS[1],fSPDHS[2],fSPDHS[3],fSPDHS[4],fSPDHS[5],
+ 0,0,0,0,0,0,fUnifSPDHS); // all SPD2 half-staves
+
+ AddAlignObj(2,-1,fSDDLadder[0],fSDDLadder[1],fSDDLadder[2],fSDDLadder[3],
+ fSDDLadder[4],fSDDLadder[5],fSDDLadderShift1[0],fSDDLadderShift1[1],fSDDLadderShift1[2],fSDDLadderShift1[3],fSDDLadderShift1[4],fSDDLadderShift1[5],fUnifSDDLadder); // all SDD1 ladders
+ AddAlignObj(3,-1,fSDDLadder[0],fSDDLadder[1],fSDDLadder[2],fSDDLadder[3],
+ fSDDLadder[4],fSDDLadder[5],fSDDLadderShift2[0],fSDDLadderShift2[1],fSDDLadderShift2[2],fSDDLadderShift2[3],fSDDLadderShift2[4],fSDDLadderShift2[5],fUnifSDDLadder); // all SDD2 ladders
+
+ // all SSD ladders
+ for(Int_t ii=0; ii<surveyArray->GetEntriesFast(); ii++)
+ {
+ AliAlignObjParams* aop = dynamic_cast<AliAlignObjParams*> (surveyArray->UncheckedAt(ii));
+// if(!aop){
+// Printf("Unexpected missing object at %d!", ii);
+// continue;
+// }
+ TString sName(aop->GetSymName());
+
+ // First we shift all SSD ladders by the same quantity to reproduce a barrel shift
+ ShiftAlignObj(*aop,fSSDBarrel[0],fSSDBarrel[1],fSSDBarrel[2],fSSDBarrel[3],fSSDBarrel[4],fSSDBarrel[5]);
+ if(sName.Contains("SSD4") && !sName.Contains("Sensor")){
+ // we correct with the factor 1.13 for the fact that, in the inner SSD layer, z lever arm is 45.135cm instead of 51cm
+ SmearAlignObj(*aop,fSSDLadder[0],fSSDLadder[1],fSSDLadder[2],fSSDLadder[3]*1.13,fSSDLadder[4]*1.13,fSSDLadder[5]);
+ new((*fAlignObjArray)[fInd++]) AliAlignObjParams(*aop);
+ }else if(sName.Contains("SSD5") && !sName.Contains("Sensor")){
+ SmearAlignObj(*aop,fSSDLadder[0],fSSDLadder[1],fSSDLadder[2],fSSDLadder[3],fSSDLadder[4],fSSDLadder[5]);
+ new((*fAlignObjArray)[fInd++]) AliAlignObjParams(*aop);
+ }
+ aop->ApplyToGeometry();
+ }
+
+ //=****************************************
+ // misalignment at the level of ladders (SPD)/modules (SDD,SSD) :
+ //=****************************************
+ AddAlignObj(0,fSPDLadder[0],fSPDLadder[1],fSPDLadder[2],fSPDLadder[3],fSPDLadder[4],fSPDLadder[5],fUnifSPDLadder);// all SPD1 ladders
+ AddAlignObj(1,fSPDLadder[0],fSPDLadder[1],fSPDLadder[2],fSPDLadder[3],fSPDLadder[4],fSPDLadder[5],fUnifSPDLadder);// all SPD2 ladders
+
+ AddAlignObj(2,fSDDModule[0],fSDDModule[1],fSDDModule[2],fSDDModule[3],fSDDModule[4],fSDDModule[5],fUnifSDDModule);// all SDD1 modules
+ AddAlignObj(3,fSDDModule[0],fSDDModule[1],fSDDModule[2],fSDDModule[3],fSDDModule[4],fSDDModule[5],fUnifSDDModule);// all SDD2 modules
+
+ // all SSD modules
+ for(Int_t ii=0; ii<surveyArray->GetEntriesFast(); ii++)
+ {
+ AliAlignObjParams* aop = dynamic_cast<AliAlignObjParams*> (surveyArray->UncheckedAt(ii));
+ TString sName(aop->GetSymName());
+ if(sName.Contains("SSD") && sName.Contains("Sensor"))
+ {
+ SmearAlignObj(*aop,fSSDModule[0],fSSDModule[1],fSSDModule[2],fSSDModule[3],fSSDModule[4],fSSDModule[5]);
+ new((*fAlignObjArray)[fInd++]) AliAlignObjParams(*aop);
+ }
+ }
+
+ return fAlignObjArray;
+}
+
+//_______________________________________________________________________________________
+void AliITSMisAligner::ShiftAlignObj(AliAlignObjParams &alObj, Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+{
+ //
+ // Shift the parameters of the alignment object passed as first argument by the quantities defined by the arguments
+ //
+ Double_t shifts[3]; Double_t angles[3];
+ alObj.GetPars(shifts, angles);
+ alObj.SetPars(shifts[0]+dx, shifts[1]+dy, shifts[2]+dz, angles[0]+dpsi, angles[1]+dtheta, angles[2]+dphi);
+}
+
+//_______________________________________________________________________________________
+void AliITSMisAligner::SmearAlignObj(AliAlignObjParams &alObj, Double_t sx, Double_t sy, Double_t sz, Double_t spsi, Double_t stheta, Double_t sphi)
+{
+ //
+ // Smear the parameters of the alignment object passed as first argument in the range defined by the subsequent arguments
+ //
+ Double_t shifts[3]; Double_t angles[3];
+ alObj.GetLocalPars(shifts, angles);
+ Double_t x = AliMathBase::TruncatedGaus(shifts[0], sx, 3.*sx);
+ Double_t y = AliMathBase::TruncatedGaus(shifts[1], sy, 3.*sy);
+ Double_t z = AliMathBase::TruncatedGaus(shifts[2], sz, 3.*sz);
+ Double_t psi = AliMathBase::TruncatedGaus(angles[0], spsi, 3.*spsi);
+ Double_t theta = AliMathBase::TruncatedGaus(angles[1], stheta, 3.*stheta);
+ Double_t phi = AliMathBase::TruncatedGaus(angles[2], sphi, 3.*sphi);
+ alObj.SetLocalPars(x, y, z, psi, theta, phi);
+}
+
+//_______________________________________________________________________________________
+void AliITSMisAligner::SetWholeITSMisAlignment()
+{
+ // Set misalignment for the whole ITS for the standar scenarios (zero, residual, full)
+ // To make custom misalignments set directly the misalignments at each level (methods "SetS?D*Pars")
+ //
+ if(TString(GetMisalType())=="ideal")
+ {
+ // overall ITS misalignment according to survey as reported by Werner Riegler (18/07/2008)
+ SetWholeITSPars(-0.12, -0.07, 0.29, 0., 0.03, 0.04);
+ }else if(TString(GetMisalType())=="residual"){
+ // overall ITS misalignment according to survey as reported by Werner Riegler (18/07/2008)
+ // no smearing added (would clash with vertex constraint)
+ SetWholeITSPars(-0.12, -0.07, 0.29, 0., 0.03, 0.04);
+ }else if(TString(GetMisalType())=="full"){
+ // overall ITS misalignment according to survey as reported by Werner Riegler (18/07/2008) plus smearing
+ Double_t sigmatrW = 0.01;
+ Double_t sigmarotW = 0.006;
+ SetWholeITSPars(AliMathBase::TruncatedGaus(-0.12,sigmatrW,3.*sigmatrW),
+ AliMathBase::TruncatedGaus(-0.07,sigmatrW,3.*sigmatrW),
+ AliMathBase::TruncatedGaus(0.29,sigmatrW,3.*sigmatrW),
+ AliMathBase::TruncatedGaus(0.,sigmarotW,3.*sigmarotW),
+ AliMathBase::TruncatedGaus(0.03,sigmarotW,3.*sigmarotW),
+ AliMathBase::TruncatedGaus(0.04,sigmarotW,3.*sigmarotW));
+ }
+}
+
+//_______________________________________________________________________________________
+void AliITSMisAligner::SetSPDMisAlignment()
+{
+ // Set misalignment for SPD alignable volumes for the standar scenarios (zero, residual, full)
+ // To make custom misalignments set directly the misalignments at each level (methods "SetSPD*Pars")
+ //
+ if(TString(GetMisalType())=="ideal")
+ {
+ // misalignment for SPD at all levels equal to zero (identical transformations)
+ SetSPDBarrelSigmas(0., 0., 0., 0., 0., 0.);
+ SetSPDHBSigmas(0., 0., 0., 0., 0., 0.);
+ SetSPDSectorSigmas(0., 0., 0., 0., 0., 0.);
+ SetSPDHSSigmas(0., 0., 0., 0., 0., 0.);
+ SetSPDLadderSigmas(0., 0., 0., 0., 0., 0.);
+ }else if(TString(GetMisalType())=="residual"){
+ // misalignment at the level of SPD barrel and half-barrels left to zero
+ SetSPDBarrelSigmas(0., 0., 0., 0., 0., 0.);
+ SetSPDHBSigmas(0., 0., 0., 0., 0., 0.);
+
+ // misalignment at the level of SPD sectors (source: A.Pepato)
+ SetSPDSectorSigmas( 0.0050/5., // 50 micron (~tangetial, i.e. rphi)
+ 0.0100/5., // 100 micron (~radial)
+ 0.0100/5., // 100 micron
+ 0.0100/30.*kRadToDeg/5., // so as to have 100 micron difference at the two extremes
+ 0.0100/30.*kRadToDeg/5., // so as to have 100 micron difference at the two extremes
+ 0.0050/1.5*kRadToDeg/5.); // so as to have 50 micron difference at the two extremes
+ fUnifSPDSector=kFALSE;
+
+ // misalignment at the level of half-staves (SPD) (source: S.Moretto)
+ SetSPDHSSigmas( 0.0100/4., // 100 micron
+ 0.0020/4., // 20 micron
+ 0.0020/4., // 20 micron
+ 0.0020/7.*kRadToDeg/4., // so as to have 20 micron difference at the two extremes
+ 0.0050/7.*kRadToDeg/4., // so as to have 50 micron difference at the two extremes
+ 0.0050/0.7*kRadToDeg/4.);// so as to have 50 micron difference at the two extremes
+ fUnifSPDHS=kFALSE;
+
+ // misalignment at the level of ladders (SPD) (source: R.Santoro)
+ SetSPDLadderSigmas( 0.0010/5., // 10 micron
+ 0.0050/5., // 50 micron
+ 0.0010/5., // 10 micron
+ 0.0001*kRadToDeg/5., // 0.1 mrad
+ 0.0001*kRadToDeg/5., // 0.1 mrad
+ 0.0001*kRadToDeg/5.);// 0.1 mrad
+ fUnifSPDLadder=kFALSE;
+
+ }else if(TString(GetMisalType())=="full"){
+ // misalignment at the level of SPD barrel (source: A.Pepato)
+ SetSPDBarrelSigmas( 0.1000, // 1 mm (very pessimistic)
+ 0.1000, // 1 mm (very pessimistic)
+ 0.1000, // 1 mm (very pessimistic)
+ 0.0500/30.*kRadToDeg, // so as to have 500 micron difference at the two extremes
+ 0.0500/30.*kRadToDeg, // so as to have 500 micron difference at the two extremes
+ 0.0500/7.*kRadToDeg); // so as to have 500 micron difference at the two extremes
+
+ // misalignment at the level of SPD half-barrels (source: A.Pepato)
+ SetSPDHBSigmas( 0.0200, // 200 micron
+ 0.0200, // 200 micron
+ 0.0200, // 200 micron
+ 0.0100/30.*kRadToDeg, // so as to have 100 micron difference at the two extremes
+ 0.0100/30.*kRadToDeg, // so as to have 100 micron difference at the two extremes
+ 0.0100/7.*kRadToDeg); // so as to have 100 micron difference at the two extremes
+
+ // misalignment at the level of SPD sectors (source: A.Pepato)
+ SetSPDSectorSigmas( 0.0050, // 50 micron (~tangetial, i.e. rphi)
+ 0.0100, // 100 micron (~radial)
+ 0.0100, // 100 micron
+ 0.0100/30.*kRadToDeg, // so as to have 100 micron difference at the two extremes
+ 0.0100/30.*kRadToDeg, // so as to have 100 micron difference at the two extremes
+ 0.0050/1.5*kRadToDeg); // so as to have 50 micron difference at the two extremes
+ fUnifSPDSector=kTRUE;
+
+ // misalignment at the level of half-staves (SPD) (source: S.Moretto)
+ SetSPDHSSigmas( 0.0100, // 100 micron // normal to plane
+ 0.0020, // 20 micron
+ 0.0020, // 20 micron
+ 0.0020/7.*kRadToDeg, // so as to have 20 micron difference at the two extremes
+ 0.0050/7.*kRadToDeg, // so as to have 50 micron difference at the two extremes
+ 0.0050/0.7*kRadToDeg); // so as to have 50 micron difference at the two extremes
+ fUnifSPDHS=kTRUE;
+
+ // misalignment at the level of ladders (SPD) (source: R.Santoro)
+ SetSPDLadderSigmas( 0.0010, // 10 micron
+ 0.0030, // 50 micron
+ 0.0010, // 10 micron
+ 0.0001*kRadToDeg, // 0.1 mrad
+ 0.0001*kRadToDeg, // 0.1 mrad
+ 0.0001*kRadToDeg); // 0.1 mrad
+ fUnifSPDLadder=kTRUE;
+
+
+ // misalignment at the level of SPD barrel, half-barrels, and at the level
+ // of SPD sectors
+ Double_t shBtop[6], shBbot[6]; //top and bottom barrel shifts
+ for(Int_t ii=0; ii<6; ii++){
+ shBtop[ii] = AliMathBase::TruncatedGaus(0.,fSPDBarrel[ii]/3,fSPDBarrel[ii]);
+ shBbot[ii] = shBtop[ii];
+ }
+
+ for(Int_t ii=0; ii<6; ii++){
+ shBtop[ii] += AliMathBase::TruncatedGaus(0.,fSPDHB[ii]/3,fSPDHB[ii]);
+ shBbot[ii] += AliMathBase::TruncatedGaus(0.,fSPDHB[ii]/3,fSPDHB[ii]);
+ }
+ SetSPDLadderShiftT(shBtop);
+ SetSPDLadderShiftB(shBbot);
+ }
+}
+
+//_______________________________________________________________________________________
+void AliITSMisAligner::SetSDDMisAlignment()
+{
+ // Set misalignment for SDD alignable volumes for the standar scenarios (zero, residual, full)
+ // To make custom misalignments set directly the misalignments at each level (methods "SetSDD*Pars")
+ //
+ if(TString(GetMisalType())=="ideal")
+ {
+ // misalignment for SDD at all levels equal to zero
+ SetSDDLayerSigmas(0., 0., 0., 0., 0., 0.);
+ SetSDDBarrelSigmas(0., 0., 0., 0., 0., 0.);
+ SetSDDLadderSigmas(0., 0., 0., 0., 0., 0.);
+ SetSDDModuleSigmas(0., 0., 0., 0., 0., 0.);
+ }else if(TString(GetMisalType())=="residual"){
+ // misalignment at the level of SDD and SSD layers(source: B.Giraudo)
+ SetSDDLayerSigmas(0., 0., 0., 0., 0., 0.);
+ SetSDDBarrelSigmas(0., 0., 0., 0., 0., 0.);
+
+ // misalignment at the level of half-staves (SPD) (source: S.Moretto)
+ SetSDDLadderSigmas( 0.0005, // 5 micron
+ 0.0005, // 5 micron
+ 0.0005, // 5 micron
+ 0.00, // ?
+ 0.00, // ?
+ 0.00); // ?
+ fUnifSDDLadder=kFALSE;
+
+ // misalignment at the level of SDD modules(source: L.Gaudichet)
+ SetSDDModuleSigmas( 0.0045/5., // 45 micron
+ 0.0045/5., // 45 micron
+ 0.0105/5., // 105 micron
+ 0.00, // ?
+ 0.00, // ?
+ 0.00);// ?
+ fUnifSDDModule=kFALSE;
+
+ }else if(TString(GetMisalType())=="full"){
+ // misalignment at the level of SDD layers(source: B.Giraudo)
+ SetSDDBarrelSigmas( 0.0020, // 20 micron
+ 0.0020, // 20 micron
+ 0.0020, // 20 micron
+ 0.0020/52.*kRadToDeg, // so as to have 20 micron difference at the two extremes
+ 0.0020/52.*kRadToDeg, // so as to have 20 micron difference at the two extremes
+ 0.0020/20.*kRadToDeg); // so as to have 20 micron difference at the two extremes
+
+ SetSDDLayerSigmas( 0.0010, // 10 micron
+ 0.0010, // 10 micron
+ 0.0010, // 10 micron
+ 0.0010/52.*kRadToDeg, // so as to have 10 micron difference at the two extremes
+ 0.0010/52.*kRadToDeg, // so as to have 10 micron difference at the two extremes
+ 0.0010/20.*kRadToDeg); // so as to have 10 micron difference at the two extremes
+
+ // misalignment at the level of SDD ladders
+ SetSDDLadderSigmas( 0.0005, // 5 micron
+ 0.0005, // 5 micron
+ 0.0005, // 5 micron
+ 0.00, // ?
+ 0.00, // ?
+ 0.00);// ?
+ fUnifSDDLadder=kTRUE;
+
+ // misalignment at the level of SDD modules (source: L.Gaudichet)
+ SetSDDModuleSigmas( 0.0045, // 45 micron
+ 0.0045, // 45 micron
+ 0.0105, // 105 micron
+ 0.00, // ?
+ 0.00, // ?
+ 0.00);// ?
+ fUnifSDDModule=kTRUE;
+ }
+
+ fSDDLadderShift1[0] = GetUnif(-fSDDBarrel[0],fSDDBarrel[0]);
+ fSDDLadderShift1[1] = GetUnif(-fSDDBarrel[1],fSDDBarrel[1]);
+ fSDDLadderShift1[2] = GetUnif(-fSDDBarrel[2],fSDDBarrel[2]);
+ fSDDLadderShift1[3] = GetUnif(-fSDDBarrel[3],fSDDBarrel[3]);
+ fSDDLadderShift1[4] = GetUnif(-fSDDBarrel[4],fSDDBarrel[4]);
+ fSDDLadderShift1[5] = GetUnif(-fSDDBarrel[5],fSDDBarrel[5]);
+
+ for(Int_t ii=0; ii<6; ii++)
+ fSDDLadderShift2[ii] = fSDDLadderShift1[ii];
+
+ // layer SDD1
+ fSDDLadderShift1[0] += GetUnif(-fSDDLayer[0],fSDDLayer[0]);
+ fSDDLadderShift1[1] += GetUnif(-fSDDLayer[1],fSDDLayer[1]);
+ fSDDLadderShift1[2] += GetUnif(-fSDDLayer[2],fSDDLayer[2]);
+ fSDDLadderShift1[3] += GetUnif(-fSDDLayer[3],fSDDLayer[3]);
+ fSDDLadderShift1[4] += GetUnif(-fSDDLayer[4],fSDDLayer[4]);
+ fSDDLadderShift1[5] += GetUnif(-fSDDLayer[5],fSDDLayer[5]);
+
+ // layer SDD2
+ fSDDLadderShift2[0] += GetUnif(-fSDDLayer[0],fSDDLayer[0]);
+ fSDDLadderShift2[1] += GetUnif(-fSDDLayer[1],fSDDLayer[1]);
+ fSDDLadderShift2[2] += GetUnif(-fSDDLayer[2],fSDDLayer[2]);
+ fSDDLadderShift2[3] += GetUnif(-fSDDLayer[3],fSDDLayer[3]);
+ fSDDLadderShift2[4] += GetUnif(-fSDDLayer[4],fSDDLayer[4]);
+ fSDDLadderShift2[5] += GetUnif(-fSDDLayer[5],fSDDLayer[5]);
+
+}
+
+//_______________________________________________________________________________________
+void AliITSMisAligner::SetSSDMisAlignment()
+{
+ // Set misalignment for SSD alignable volumes for the standar scenarios (zero, residual, full)
+ // To make custom misalignments set directly the misalignments at each level (methods "SetSSD*Pars")
+ //
+ if(TString(GetMisalType())=="ideal"){
+
+ // zero misalignment at the level of SSD barrel
+ SetSSDBarrelPars(0.,0.,0.,0.,0.,0.);
+ // zero misalignment at the level of SSD ladders
+ SetSSDLadderSigmas(0.,0.,0.,0.,0.,0.);
+ // zero misalignment at the level of SSD modules
+ SetSSDModuleSigmas(0.,0.,0.,0.,0.,0.);
+
+ }else if(TString(GetMisalType())=="residual"){
+
+ // zero misalignment at the level of SSD barrel
+ SetSSDBarrelPars(0.,0.,0.,0.,0.,0.);
+ // misalignment at the level of SSD ladders (source: M. Van Leeuwen)
+ // values set so that overall maximum displacement (combined effect of shift and rotation
+ // of the ladder) for any point of the ladder cannot exceed 10um in x, 100 um in y, 50um in z
+ SetSSDLadderSigmas( 0.0005, // 5 microns
+ 0.0033, // 33 microns
+ 0.0050, // 50 microns
+ 0.000067*kRadToDeg, // 0.067 mrads
+ 0.00001*kRadToDeg, // 0.01 mrads
+ 0.001*kRadToDeg); // 1 mrad
+ fUnifSSDLadder=kTRUE;
+
+ // misalignment at the level of SSD modules (source: M. Van Leeuwen)
+ // values set so that overall maximum displacement (combined effect of shift and rotation
+ // of the ladder) for any point of the module cannot exceed 5um in x, 10 um in y, 5um in z
+ SetSSDModuleSigmas( 0.00025, // 2.5 microns
+ 0.00034, // 3.4 microns
+ 0.0005, // 5 microns
+ 0.00017*kRadToDeg, // 0.17 mrads
+ 0.000125*kRadToDeg, // 0.125 mrads
+ 0.0001*kRadToDeg); // 0.1 mrads
+ fUnifSSDModule=kTRUE;
+
+ }else if(TString(GetMisalType())=="full"){
+ // misalignment at the level of SSD layers (source: B. Giraudo)
+ SetSSDBarrelPars( GetUnif(-0.0020,0.0020), // 20 micron
+ GetUnif(-0.0020,0.0020), // 20 micron
+ GetUnif(-0.0020,0.0020), // 20 micron
+ GetUnif(-0.0020/90.*kRadToDeg,0.0020), // so as to have 20 micron difference at the two extremes
+ GetUnif(-0.0020/90.*kRadToDeg,0.0020), // so as to have 20 micron difference at the two extremes
+ GetUnif(-0.0020/40.*kRadToDeg,0.0020)); // so as to have 20 micron difference at the two extremes
+
+ // misalignment at the level of SSD ladders (source: M. Van Leeuwen)
+ // values set so that overall maximum displacement (combined effect of shift and rotation
+ // of the ladder) for any point of the ladder cannot exceed 20um in x, 100 um in y, 50um in z
+ SetSSDLadderSigmas( 0.0010, // 10 microns
+ 0.0033, // 33 microns
+ 0.0050, // 50 microns
+ 0.000067*kRadToDeg, // 0.067 mrads
+ 0.00002*kRadToDeg, // 0.02 mrads
+ 0.001*kRadToDeg); // 1 mrad
+ fUnifSSDLadder=kTRUE;
+
+ // misalignment at the level of SSD modules (source: M. Van Leeuwen)
+ // values set so that overall maximum displacement (combined effect of shift and rotation
+ // of the ladder) for any point of the module cannot exceed 5um in x, 10 um in y, 5um in z
+ SetSSDModuleSigmas( 0.00025, // 2.5 microns
+ 0.00034, // 3.4 microns
+ 0.0005, // 5 microns
+ 0.00017*kRadToDeg, // 0.17 mrads
+ 0.000125*kRadToDeg, // 0.125 mrads
+ 0.0001*kRadToDeg); // 0.1 mrads
+ fUnifSSDModule=kTRUE;
+ }
+
+
+ fSSDLadderShift1[0] = GetUnif(-fSSDBarrel[0],fSSDBarrel[0]);
+ fSSDLadderShift1[1] = GetUnif(-fSSDBarrel[1],fSSDBarrel[1]);
+ fSSDLadderShift1[2] = GetUnif(-fSSDBarrel[2],fSSDBarrel[2]);
+ fSSDLadderShift1[3] = GetUnif(-fSSDBarrel[3],fSSDBarrel[3]);
+ fSSDLadderShift1[4] = GetUnif(-fSSDBarrel[4],fSSDBarrel[4]);
+ fSSDLadderShift1[5] = GetUnif(-fSSDBarrel[5],fSSDBarrel[5]);
+
+ /*
+ for(Int_t ii=0; ii<6; ii++)
+ fSSDLadderShift2[ii] = fSSDLadderShift1[ii];
+
+ // layer SSD1
+ fSSDLadderShift1[0] += GetUnif(-fSSDLayer[0],fSSDLayer[0]);
+ fSSDLadderShift1[1] += GetUnif(-fSSDLayer[1],fSSDLayer[1]);
+ fSSDLadderShift1[2] += GetUnif(-fSSDLayer[2],fSSDLayer[2]);
+ fSSDLadderShift1[3] += GetUnif(-fSSDLayer[3],fSSDLayer[3]);
+ fSSDLadderShift1[4] += GetUnif(-fSSDLayer[4],fSSDLayer[4]);
+ fSSDLadderShift1[5] += GetUnif(-fSSDLayer[5],fSSDLayer[5]);
+
+ // layer SSD2
+ fSSDLadderShift2[0] += GetUnif(-fSSDLayer[0],fSSDLayer[0]);
+ fSSDLadderShift2[1] += GetUnif(-fSSDLayer[1],fSSDLayer[1]);
+ fSSDLadderShift2[2] += GetUnif(-fSSDLayer[2],fSSDLayer[2]);
+ fSSDLadderShift2[3] += GetUnif(-fSSDLayer[3],fSSDLayer[3]);
+ fSSDLadderShift2[4] += GetUnif(-fSSDLayer[4],fSSDLayer[4]);
+ fSSDLadderShift2[5] += GetUnif(-fSSDLayer[5],fSSDLayer[5]);
+ */
+
+}
+
+//_______________________________________________________________________________________
+AliCDBMetaData* AliITSMisAligner::GetCDBMetaData() const {
+ // Returns the AliCDBMetaData to be associated with AliCDBEntry which will contain
+ // the array of alignment objects for ITS misalignment
+ // Presently "responsible" and "comment" are filled.
+ //
+ AliCDBMetaData* md = new AliCDBMetaData();
+ md->SetResponsible("Andrea Dainese");
+
+ if(TString(GetMisalType())=="ideal")
+ md->SetComment("Alignment objects for ITS ideal misalignment");
+ if(TString(GetMisalType())=="residual")
+ md->SetComment("Alignment objects for ITS residual misalignment");
+ if(TString(GetMisalType())=="full")
+ md->SetComment("Alignment objects for ITS full misalignment");
+ return md;
+}
+
+//________________________________________________________________________
+Bool_t AliITSMisAligner::AddAlignObj(char* name,Double_t dx,Double_t dy,Double_t dz,
+ Double_t dpsi,Double_t dtheta,Double_t dphi,const char* distrib) {
+ //
+ // misalignment by symname
+ //
+ Double_t vx=0.,vy=0.,vz=0.,vpsi=0.,vtheta=0.,vphi=0.;
+
+ TString sdistrib(distrib);
+
+ if(sdistrib==TString("gaussian")) {
+ vx = AliMathBase::TruncatedGaus(0.,dx/3.,dx); // mean, sigma, max absolute value
+ vy = AliMathBase::TruncatedGaus(0.,dy/3.,dy);
+ vz = AliMathBase::TruncatedGaus(0.,dz/3.,dz);
+ vpsi = AliMathBase::TruncatedGaus(0.,dpsi/3., dpsi );
+ vtheta = AliMathBase::TruncatedGaus(0.,dtheta/3.,dtheta);
+ vphi = AliMathBase::TruncatedGaus(0.,dphi/3., dphi);
+ }else if(sdistrib==TString("uniform")){
+ vx = fRnd.Uniform(-dx,dx);
+ vy = fRnd.Uniform(-dy,dy);
+ vz = fRnd.Uniform(-dz,dz);
+ vpsi = fRnd.Uniform(-dpsi,dpsi);
+ vtheta = fRnd.Uniform(-dtheta,dtheta);
+ vphi = fRnd.Uniform(-dphi,dphi);
+ }else if(sdistrib==TString("fixed")){
+ vx=dx;
+ vy=dy;
+ vz=dz;
+ vpsi=dpsi;
+ vtheta=dtheta;
+ vphi=dphi;
+ }else{
+ AliFatal(Form("Invalid string \"%s\" specifying the misalignment type for the volume \"%s\""));
+ }
+
+ new((*fAlignObjArray)[fInd]) AliAlignObjParams(name,0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
+
+ AliAlignObjParams* itsalobj = (AliAlignObjParams*) fAlignObjArray->UncheckedAt(fInd);
+ itsalobj->ApplyToGeometry();
+
+ fInd++;
+
+ return kTRUE;
+}
+
+
+//________________________________________________________________________
+Bool_t AliITSMisAligner::AddAlignObj(Int_t lay,Double_t dx,Double_t dy,Double_t dz,
+ Double_t dpsi,Double_t dtheta,Double_t dphi,Bool_t unif) {
+ //
+ // misalignment at the level of sensitive alignable volumes (SPD ladders/ SDD,SSD modules)
+ // done for all ladders/modules of the given layer
+ //
+ lay+=1; // layers are numbered from 1 to 6 in AliGeomManager
+
+ printf("LAYER %d MODULES %d\n",lay,AliGeomManager::LayerSize(lay));
+
+ for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(lay); iModule++) {
+
+ Double_t vx,vy,vz,vpsi,vtheta,vphi;
+
+ if(!unif) {
+ vx = AliMathBase::TruncatedGaus(0.,dx/3.,dx); // mean, sigma, max absolute value
+ vy = AliMathBase::TruncatedGaus(0.,dy/3.,dy);
+ vz = AliMathBase::TruncatedGaus(0.,dz/3.,dz);
+ vpsi = AliMathBase::TruncatedGaus(0.,dpsi/3.,dpsi);
+ vtheta = AliMathBase::TruncatedGaus(0.,dtheta/3.,dtheta);
+ vphi = AliMathBase::TruncatedGaus(0.,dphi/3.,dphi);
+ } else {
+ vx = fRnd.Uniform(-dx,dx);
+ vy = fRnd.Uniform(-dy,dy);
+ vz = fRnd.Uniform(-dz,dz);
+ vpsi = fRnd.Uniform(-dpsi,dpsi);
+ vtheta = fRnd.Uniform(-dtheta,dtheta);
+ vphi = fRnd.Uniform(-dphi,dphi);
+ }
+
+ UShort_t volid = AliGeomManager::LayerToVolUID(lay,iModule);
+ const char *symname = AliGeomManager::SymName(volid);
+
+ new((*fAlignObjArray)[fInd]) AliAlignObjParams(symname,volid,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
+ fInd++;
+ }
+
+ return kTRUE;
+}
+
+//________________________________________________________________________
+Bool_t AliITSMisAligner::AddAlignObj(Int_t lay,Int_t ladd,Double_t dx,Double_t dy,Double_t dz,
+ Double_t dpsi,Double_t dtheta,Double_t dphi,
+ Double_t xShift,Double_t yShift,Double_t zShift,
+ Double_t psiShift,Double_t thetaShift,Double_t phiShift,
+ Bool_t unif) {
+ //
+ // misalignment at the level of half-staves/ladders (ladd=-1 means that all ladders are scanned)
+ //
+ Double_t vx,vy,vz,vpsi,vtheta,vphi;
+ Double_t tr[3],rot[3];
+
+ Int_t laddMin = ladd;
+ Int_t laddMax = laddMin+1;
+ if (ladd<0) {
+ laddMin = 0;
+ laddMax = fgkNLadders[lay];
+ }
+
+ for (Int_t iLadd=laddMin; iLadd<laddMax; iLadd++) {
+
+ Int_t nHS = 1;
+ if (lay<2) nHS = 2;
+ for (Int_t iHalfStave=0; iHalfStave<nHS; iHalfStave++) {
+
+ if(!unif) {
+ vx = AliMathBase::TruncatedGaus(0.,dx/3.,dx); // mean, sigma, max absolute value
+ vy = AliMathBase::TruncatedGaus(0.,dy/3.,dy);
+ vz = AliMathBase::TruncatedGaus(0.,dz/3.,dz);
+ vpsi = AliMathBase::TruncatedGaus(0.,dpsi/3.,dpsi);
+ vtheta = AliMathBase::TruncatedGaus(0.,dtheta/3.,dtheta);
+ vphi = AliMathBase::TruncatedGaus(0.,dphi/3.,dphi);
+ } else {
+ vx = fRnd.Uniform(-dx,dx);
+ vy = fRnd.Uniform(-dy,dy);
+ vz = fRnd.Uniform(-dz,dz);
+ vpsi = fRnd.Uniform(-dpsi,dpsi);
+ vtheta = fRnd.Uniform(-dtheta,dtheta);
+ vphi = fRnd.Uniform(-dphi,dphi);
+ }
+
+ TString name(GetHalfStaveLadderSymbName(lay,iLadd,iHalfStave));
+
+ // first apply half-stave / ladder level misalignment
+ AliAlignObjParams aaop(name.Data(),0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE); // set them as local
+ aaop.GetPars(tr,rot); // global
+
+ // then, apply layer-level misalignment (only for SDD and SSD)
+ if(lay>1) {
+ tr[0] += xShift;
+ tr[1] += yShift;
+ tr[2] += zShift;
+ rot[0] += psiShift;
+ rot[1] += thetaShift;
+ rot[2] += phiShift;
+ }
+ new((*fAlignObjArray)[fInd]) AliAlignObjParams(name.Data(),0,tr[0],tr[1],tr[2],rot[0],rot[1],rot[2],kTRUE); // set them as global
+
+ AliAlignObjParams* itsalobj = (AliAlignObjParams*) fAlignObjArray->UncheckedAt(fInd);
+ itsalobj->ApplyToGeometry();
+ fInd++;
+ }
+ }
+
+ return kTRUE;
+}
+
+
+//________________________________________________________________________
+Bool_t AliITSMisAligner::AddSectorAlignObj(Int_t sectMin,Int_t sectMax,
+ Double_t dx,Double_t dy,Double_t dz,
+ Double_t dpsi,Double_t dtheta,Double_t dphi,
+ Double_t xShift,Double_t yShift,Double_t zShift,
+ Double_t psiShift,Double_t thetaShift,Double_t phiShift,Bool_t unif) {
+ //
+ // misalignment at the level of SPD sectors and half-barrels
+ //
+
+ if ((sectMin<1) || (sectMax>10)) return kFALSE;
+ Double_t vx,vy,vz,vpsi,vtheta,vphi;
+ Double_t tr[3],rot[3];
+
+ for (Int_t iSect = sectMin-1; iSect<sectMax; iSect++) {
+
+ // first, apply sector level misalignment
+ if(!unif) {
+ vx = AliMathBase::TruncatedGaus(0.,dx/3.,dx); // mean, sigma, max absolute value
+ vy = AliMathBase::TruncatedGaus(0.,dy/3.,dy);
+ vz = AliMathBase::TruncatedGaus(0.,dz/3.,dz);
+ vpsi = AliMathBase::TruncatedGaus(0.,dpsi/3.,dpsi);
+ vtheta = AliMathBase::TruncatedGaus(0.,dtheta/3.,dtheta);
+ vphi = AliMathBase::TruncatedGaus(0.,dphi/3.,dphi);
+ } else {
+ vx = fRnd.Uniform(-dx,dx);
+ vy = fRnd.Uniform(-dy,dy);
+ vz = fRnd.Uniform(-dz,dz);
+ vpsi = fRnd.Uniform(-dpsi,dpsi);
+ vtheta = fRnd.Uniform(-dtheta,dtheta);
+ vphi = fRnd.Uniform(-dphi,dphi);
+ }
+
+ TString name(GetSymbName(0));
+ name += fStrSector;
+ name += iSect;
+
+
+ AliAlignObjParams aaop(name.Data(),0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE); // set them as local
+ aaop.GetPars(tr,rot); // global
+
+ // then, apply half-barrel level misalignment
+ tr[0] += xShift;
+ tr[1] += yShift;
+ tr[2] += zShift;
+ rot[0] += psiShift;
+ rot[1] += thetaShift;
+ rot[2] += phiShift;
+
+ new((*fAlignObjArray)[fInd]) AliAlignObjParams(name.Data(),0,tr[0],tr[1],tr[2],rot[0],rot[1],rot[2],kTRUE); // set them as global
+
+ AliAlignObjParams* itsalobj = (AliAlignObjParams*) fAlignObjArray->UncheckedAt(fInd);
+ itsalobj->ApplyToGeometry();
+ fInd++;
+ }
+ return kTRUE;
+}
+
+//________________________________________________________________________
+const char* AliITSMisAligner::GetSymbName(Int_t layer) const {
+ //
+ // be careful : SPD0 and SPD1 are not physically separated
+ //
+ TString name;
+ switch (layer) {
+ case 0:
+ case 1: name = fStrSPD; name += layer; break;
+ case 2:
+ case 3: name = fStrSDD; name += layer; break;
+ case 4:
+ case 5: name = fStrSSD; name += layer; break;
+ default: AliFatal("Wrong layer index");
+ }
+ return name.Data();
+}
+
+//________________________________________________________________________
+const char* AliITSMisAligner::GetSymbName(Int_t layer, Int_t ladder, Int_t det) const {
+ //
+ // symname from layer, ladder, detector
+ //
+ TString symname(GetHalfStaveLadderSymbName(layer,ladder,det));
+ if(layer<=2){
+ symname+="Ladder";
+ }else if(layer<=6){
+ symname+="Sensor";
+ }else{
+ AliError("Invalid layer!");
+ return 0;
+ }
+ symname+=det;
+ return symname.Data();
+}
+
+//________________________________________________________________________
+const char* AliITSMisAligner::GetSymbName(Int_t layer,Int_t ladd) const {
+ //
+ // Get logical names at the level of staves / ladders
+ //
+ TString name(GetSymbName(layer));
+ if (layer==0) { // SPD1
+
+ int sector = ladd/2;
+ name += fStrSector;
+ name += sector;
+ int stave = ladd-sector*2;
+ name += fStrStave;
+ name += stave;
+ }
+ else if (layer==1) { // SPD2
+
+ int sector = ladd/4;
+ name += fStrSector;
+ name += sector;
+ int stave = ladd-sector*4;
+ name += fStrStave;
+ name += stave;
+ }
+ else if (layer>=2 && layer<=5) { // SDD and SSD
+ name += fStrLadder;
+ name += ladd;
+ }
+ else {
+ AliFatal("Wrong layer index");
+ }
+ return name.Data();
+}
+
+//________________________________________________________________________
+const char* AliITSMisAligner::GetHalfStaveLadderSymbName(Int_t layer,Int_t ladd,Int_t halfStave) const {
+ //
+ // Get logical names at the level of half-staves (SPD) or ladders (SDD and SSD)
+ //
+ TString name(GetSymbName(layer));
+ if (layer==0) { // SPD1
+
+ int sector = ladd/2;
+ name += fStrSector;
+ name += sector;
+ int stave = ladd-sector*2;
+ name += fStrStave;
+ name += stave;
+ name += fStrHalfStave;
+ name += halfStave;
+ }
+ else if (layer==1) { // SPD2
+
+ int sector = ladd/4;
+ name += fStrSector;
+ name += sector;
+ int stave = ladd-sector*4;
+ name += fStrStave;
+ name += stave;
+ name += fStrHalfStave;
+ name += halfStave;
+ }
+ else if (layer>=2 && layer<=5) { // SDD and SSD
+ name += fStrLadder;
+ name += ladd;
+ }
+ else {
+ AliFatal("Wrong layer index");
+ }
+ return name.Data();
+}
+
+//________________________________________________________________________
+const char* AliITSMisAligner::GetParentSymName(const char* symname) {
+ //
+ // symnane of parent volume
+ //
+ TString parent(symname);
+ // Give the symname of
+ if(parent.BeginsWith('/')) parent.Remove(TString::kLeading,'/');
+ if(parent.EndsWith("/")) parent.Remove(TString::kTrailing,'/');
+
+ if(!parent.CountChar('/')) AliErrorClass("Not a valid symbolic name");
+
+ Int_t layer,level;
+ GetLayerAndLevel(symname,layer,level);
+ if(level==1) return "ITS";
+
+ parent.Remove(parent.Last('/'));
+
+ if((layer==0 || layer==1) && level==2){
+ parent.Remove(parent.Last('/'));
+ parent[7]='0';
+ }
+
+ return parent.Data();
+}
+
+//________________________________________________________________________
+Bool_t AliITSMisAligner::GetLayerAndLevel(const char* symname, Int_t &layer, Int_t &level) {
+ //
+ // given the symbolic name set layer and level
+ //
+ const char* basename[6] = {"ITS/SPD0/Sector","ITS/SPD1/Sector","ITS/SDD2/Ladder","ITS/SDD3/Ladder","ITS/SSD4/Ladder","ITS/SSD5/Ladder"};
+ TString strSym(symname);
+ if(strSym=="ITS"){
+ level=0;
+ layer=-1;
+ return kTRUE;
+ }
+ Int_t i;
+ for(i=0; i<6; i++){
+ if(strSym.BeginsWith(basename[i])) break;
+ }
+
+ if(i>=6){
+ AliErrorClass(Form("%s is not a valid symbolic name for an ITS alignable volume",strSym.Data()));
+ return kFALSE;
+ }
+
+ layer=i;
+ //The part above could be replaced by just
+ // TString seventh = strSym[7];
+ // layer = seventh.Atoi();
+ // if we don't need to check the validity of the symname
+
+ level=1;
+ switch(layer){
+ case 0:
+ case 1:
+ if(strSym.Contains("Stave")) level=2;
+ if(strSym.Contains("Ladder")) level=3;
+ break;
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ if(strSym.Contains("Sensor")) level=2;
+ }
+
+ return kTRUE;
+}
+
+//________________________________________________________________________
+Int_t AliITSMisAligner::GetNSisters(const char* symname) {
+ //
+ // number of volumes on same level
+ //
+ Int_t layer,level;
+ if(!GetLayerAndLevel(symname,layer,level)) return -1;
+ if(level==0) return -1;
+ if(level==1) return GetNLadders(layer);
+ if(level==2) return GetNDetectors(layer);
+ AliErrorClass(Form("Invalid layer and level"));
+ return -1;
+}
+
+//________________________________________________________________________
+Int_t AliITSMisAligner::GetNDaughters(const char* symname) {
+ //
+ // number of daughter volumes
+ //
+ Int_t layer,level;
+ if(!GetLayerAndLevel(symname,layer,level)) return -1;
+ if(level==0) {
+ Int_t nLadders = 0;
+ for(Int_t lay=0; lay<6; lay++) nLadders += GetNLadders(lay);
+ return nLadders;
+ }
+ if(level==1) return GetNDetectors(layer);
+ if(level==2){
+ AliWarningClass(Form("Volume %s is a sensitive volume and has no alignable dauthers",symname));
+ return -1;
+ }
+ AliErrorClass(Form("Invalid layer and level"));
+ return -1;
+}
+
+/*
+//________________________________________________________________________
+TString AliITSMisAligner::GetSymbName(Int_t layer,Int_t ladd,Int_t mod) const {
+
+ // Get logical names at the level of SPD ladders / SDD and SSD modules
+
+ Int_t halfStave = mod/2;
+ TString name = GetHalfStaveLadderSymbName(layer,ladd,halfStave);
+
+ if (layer<2) { // SPD
+ name += fStrLadder;
+ name += mod;
+ }
+ else if (layer>=2 && layer<=5) { // SDD and SSD
+ name += fStrSensor;
+ name += mod;
+ }
+ else {
+ AliFatal("Wrong layer index");
+ }
+ return name;
+}
+*/
--- /dev/null
+#ifndef ALIITSMISALIGNER_H
+#define ALIITSMISALIGNER_H
+
+// Class building the alignment objects for ITS (SPD, SDD, SSD)
+// It derives from AliMisAligner, thus providing the methods
+// MakeAlObjsArray (builds and returns the array of alignment objects)
+// and GetCDBMetaData (returns the metadata for the OCDB entry)
+//
+
+/* $Id$ */
+
+#include <TString.h>
+#include "AliMisAligner.h"
+#include <TRandom3.h>
+
+class TClonesArray;
+class AliAlignObjParams;
+
+//-------------------------------------------------------------------------
+class AliITSMisAligner : public AliMisAligner{
+ public:
+ AliITSMisAligner();
+ AliITSMisAligner(const AliITSMisAligner &mAligner);
+ AliITSMisAligner &operator= (const AliITSMisAligner &mAligner);
+ ~AliITSMisAligner() {};
+
+ TClonesArray* MakeAlObjsArray();
+ AliCDBMetaData* GetCDBMetaData() const;
+
+ void SetSeed(Int_t seed) {fRnd.SetSeed(seed); return;}
+
+ void SetWholeITSPars(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fWholeITS[0] = dx; fWholeITS[1] = dy; fWholeITS[2] = dz;
+ fWholeITS[3] = dpsi; fWholeITS[4] = dtheta; fWholeITS[5] = dphi;
+ }
+
+ void SetSPDSectorSigmas(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSPDSector[0] = dx; fSPDSector[1] = dy; fSPDSector[2] = dz;
+ fSPDSector[3] = dpsi; fSPDSector[4] = dtheta; fSPDSector[5] = dphi;
+ }
+
+ void SetSPDHSSigmas(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSPDHS[0] = dx; fSPDHS[1] = dy; fSPDHS[2] = dz;
+ fSPDHS[3] = dpsi; fSPDHS[4] = dtheta; fSPDHS[5] = dphi;
+ }
+
+ void SetSPDLadderSigmas(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSPDLadder[0] = dx; fSPDLadder[1] = dy; fSPDLadder[2] = dz;
+ fSPDLadder[3] = dpsi; fSPDLadder[4] = dtheta; fSPDLadder[5] = dphi;
+ }
+
+ void SetSPDHBSigmas(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSPDHB[0] = dx; fSPDHB[1] = dy; fSPDHB[2] = dz;
+ fSPDHB[3] = dpsi; fSPDHB[4] = dtheta; fSPDHB[5] = dphi;
+ }
+
+ void SetSPDBarrelSigmas(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSPDBarrel[0] = dx; fSPDBarrel[1] = dy; fSPDBarrel[2] = dz;
+ fSPDBarrel[3] = dpsi; fSPDBarrel[4] = dtheta; fSPDBarrel[5] = dphi;
+ }
+
+ void SetSDDLayerSigmas(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSDDLayer[0] = dx; fSDDLayer[1] = dy; fSDDLayer[2] = dz;
+ fSDDLayer[3] = dpsi; fSDDLayer[4] = dtheta; fSDDLayer[5] = dphi;
+ }
+
+ void SetSDDBarrelSigmas(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSDDBarrel[0] = dx; fSDDBarrel[1] = dy; fSDDBarrel[2] = dz;
+ fSDDBarrel[3] = dpsi; fSDDBarrel[4] = dtheta; fSDDBarrel[5] = dphi;
+ }
+
+ void SetSDDLadderSigmas(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSDDLadder[0] = dx; fSDDLadder[1] = dy; fSDDLadder[2] = dz;
+ fSDDLadder[3] = dpsi; fSDDLadder[4] = dtheta; fSDDLadder[5] = dphi;
+ }
+
+ void SetSDDModuleSigmas(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSDDModule[0] = dx; fSDDModule[1] = dy; fSDDModule[2] = dz;
+ fSDDModule[3] = dpsi; fSDDModule[4] = dtheta; fSDDModule[5] = dphi;
+ }
+
+ void SetSSDBarrelPars(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSSDBarrel[0] = dx; fSSDBarrel[1] = dy; fSSDBarrel[2] = dz;
+ fSSDBarrel[3] = dpsi; fSSDBarrel[4] = dtheta; fSSDBarrel[5] = dphi;
+ }
+
+ void SetSSDLadderSigmas(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSSDLadder[0] = dx; fSSDLadder[1] = dy; fSSDLadder[2] = dz;
+ fSSDLadder[3] = dpsi; fSSDLadder[4] = dtheta; fSSDLadder[5] = dphi;
+ }
+
+ void SetSSDModuleSigmas(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSSDModule[0] = dx; fSSDModule[1] = dy; fSSDModule[2] = dz;
+ fSSDModule[3] = dpsi; fSSDModule[4] = dtheta; fSSDModule[5] = dphi;
+ }
+
+ void SetSPDLadderShiftT(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSPDLadderShiftT[0] = dx; fSPDLadderShiftT[1] = dy; fSPDLadderShiftT[2] = dz;
+ fSPDLadderShiftT[3] = dpsi; fSPDLadderShiftT[4] = dtheta; fSPDLadderShiftT[5] = dphi;
+ }
+
+ void SetSPDLadderShiftB(Double_t dx, Double_t dy, Double_t dz, Double_t dpsi, Double_t dtheta, Double_t dphi)
+ {
+ fSPDLadderShiftB[0] = dx; fSPDLadderShiftB[1] = dy; fSPDLadderShiftB[2] = dz;
+ fSPDLadderShiftB[3] = dpsi; fSPDLadderShiftB[4] = dtheta; fSPDLadderShiftB[5] = dphi;
+ }
+
+ void SetSPDLadderShiftT(Double_t pars[6])
+ {
+ for(Int_t ii=0; ii<6; ii++)
+ fSPDLadderShiftT[ii] = pars[ii];
+ }
+
+ void SetSPDLadderShiftB(Double_t pars[6])
+ {
+ for(Int_t ii=0; ii<6; ii++)
+ fSPDLadderShiftB[ii] = pars[ii];
+ }
+
+ void SetWholeITSMisAlignment();
+ void SetSPDMisAlignment();
+ void SetSDDMisAlignment();
+ void SetSSDMisAlignment();
+
+ Double_t GetUnif(Double_t x1,Double_t x2) {return fRnd.Uniform(x1,x2);}
+
+ Bool_t AddAlignObj(char* name,Double_t dx,Double_t dy,Double_t dz,
+ Double_t dpsi,Double_t dtheta,Double_t dphi,
+ const char* distrib);
+
+ Bool_t AddAlignObj(Int_t lay,Double_t dx,Double_t dy,Double_t dz,
+ Double_t dpsi,Double_t dtheta,Double_t dphi,
+ Bool_t unif);
+
+ Bool_t AddAlignObj(Int_t lay,Int_t ladd,Double_t dx,Double_t dy,Double_t dz,
+ Double_t dpsi,Double_t dtheta,Double_t dphi,
+ Double_t xShift,Double_t yShift,Double_t zShift,
+ Double_t psiShift,Double_t thetaShift,Double_t phiShift,
+ Bool_t unif);
+
+ Bool_t AddSectorAlignObj(Int_t sectMin,Int_t sectMax,
+ Double_t dx,Double_t dy,Double_t dz,
+ Double_t dpsi,Double_t dtheta,Double_t dphi,
+ Double_t xShift,Double_t yShift,Double_t zShift,
+ Double_t psiShift,Double_t thetaShift,Double_t phiShift,
+ Bool_t unif);
+
+ void ShiftAlignObj(AliAlignObjParams &alObj,Double_t dx,Double_t dy,Double_t dz,Double_t dpsi,Double_t dtheta,Double_t dphi);
+ void SmearAlignObj(AliAlignObjParams &alObj,Double_t sx,Double_t sy,Double_t sz,Double_t spsi,Double_t stheta,Double_t sphi);
+
+ const char* GetSymbName(Int_t layer) const;
+ const char* GetSymbName(Int_t layer,Int_t ladd) const;
+ const char* GetSymbName(Int_t layer,Int_t ladd,Int_t mod) const;
+ const char* GetHalfStaveLadderSymbName(Int_t layer,Int_t ladd,Int_t halfStave) const;
+ static const char* GetParentSymName(const char* symname) ;
+ // const char* GetSistersSymName(const char* symname) const;
+ static Bool_t GetLayerAndLevel(const char* symname, Int_t &layer, Int_t &level);
+
+ static Int_t GetNLayers() {return kNLayers;}
+ static Int_t GetNLadders(Int_t lay) {return fgkNLadders[lay];}
+ static Int_t GetNDetectors(Int_t lay) {return fgkNDetectors[lay];}
+ static Int_t GetNSisters(const char* symname);
+ static Int_t GetNDaughters(const char* symname);
+
+ protected:
+ TRandom3 fRnd; // TRandom3 object
+ //TRandom fRnd; // TRandom object
+ Int_t fInd; // index of current AliAlignObjParams in fAlignObjArray
+ TClonesArray *fAlignObjArray; // array of AliAlignObjParams
+ TString fStrSPD; // name of SPD
+ TString fStrSDD; // name of SDD
+ TString fStrSSD; // name of SSD
+ TString fStrStave; // name of SPD stave
+ TString fStrHalfStave; // name of SPD half-stave
+ TString fStrLadder; // name of SPD ladder
+ TString fStrSector; // name of SPD sector
+ TString fStrSensor; // name of sensitive volume
+
+ private:
+ enum {kNLayers = 6}; // The number of layers.
+ static const Int_t fgkNLadders[kNLayers]; // Array of the number of ladders/layer(layer)
+ static const Int_t fgkNDetectors[kNLayers];// Array of the number of detector/ladder(layer)
+
+ // Parameters setting the misalignment at all SPD/SDD/SSD levels
+ Double_t fWholeITS[6];
+ Double_t fSPDSector[6];
+ Double_t fSPDHB[6];
+ Double_t fSPDBarrel[6];
+ Double_t fSPDHS[6];
+ Double_t fSPDLadder[6];
+ Double_t fSDDLayer[6];
+ Double_t fSDDBarrel[6];
+ Double_t fSDDLadder[6];
+ Double_t fSDDModule[6];
+ Double_t fSSDBarrel[6];
+ Double_t fSSDLayer[6];
+ Double_t fSSDLadder[6];
+ Double_t fSSDModule[6];
+
+ // Parameters setting common shifts (used for "full" misalignment)
+ Double_t fSPDLadderShiftT[6]; // for top half-barrel ladders
+ Double_t fSPDLadderShiftB[6]; // for bottom half-barrel ladders
+ Double_t fSDDLadderShift1[6];
+ Double_t fSDDLadderShift2[6];
+ Double_t fSSDLadderShift1[6];
+ Double_t fSSDLadderShift2[6];
+
+ // Choice between uniform (kTRUE) or gaussian (kFALSE) distribution in the smearing
+ Bool_t fUnifSPDSector, fUnifSPDHS, fUnifSDDLadder, fUnifSSDLadder, fUnifSPDLadder, fUnifSDDModule, fUnifSSDModule;
+
+ ClassDef(AliITSMisAligner,0) //ITS MisAligner
+};
+
+
+#endif
+++ /dev/null
-/**************************************************************************
- * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Author: The ALICE Off-line Project. *
- * Contributors are mentioned in the code where appropriate. *
- * *
- * Permission to use, copy, modify and distribute this software and its *
- * documentation strictly for non-commercial purposes is hereby granted *
- * without fee, provided that the above copyright notice appears in all *
- * copies and that both the copyright notice and this permission notice *
- * appear in the supporting documentation. The authors make no claims *
- * about the suitability of this software for any purpose. It is *
- * provided "as is" without express or implied warranty. *
- **************************************************************************/
-
-/* $Id$ */
-
-//========================================================================
-//
-// This class is a helper, producing ITS aligmnent objects.
-// It provides also some useful functions
-// See the parameters of the misalignment at the end of this script.
-//
-// Main author: L. Gaudichet
-// Contact: andrea.dainese@lnl.infn.it
-//
-//========================================================================
-
-#include <TRandom3.h>
-#include <TClonesArray.h>
-#include <TClass.h>
-
-
-#include "AliLog.h"
-#include "AliAlignObjParams.h"
-#include "AliITSMisalignMaker.h"
-
-
-ClassImp(AliITSMisalignMaker)
-
-const Int_t AliITSMisalignMaker::fgkNLadders[AliITSMisalignMaker::kNLayers] = {20,40,14,22,34,38};
-const Int_t AliITSMisalignMaker::fgkNDetectors[AliITSMisalignMaker::kNLayers] = {4,4,6,8,22,25};
-
-
-//________________________________________________________________________
-AliITSMisalignMaker::AliITSMisalignMaker():
- fRnd(),
- fInd(0),
- fAlobj(TClonesArray("AliAlignObjParams",4000)),
- fStrSPD("ITS/SPD"),
- fStrSDD("ITS/SDD"),
- fStrSSD("ITS/SSD"),
- fStrStave("/Stave"),
- fStrHalfStave("/HalfStave"),
- fStrLadder("/Ladder"),
- fStrSector("/Sector"),
- fStrSensor("/Sensor")
-{
- //
- // defaul constructor
- //
- fRnd.SetSeed(38217945);
-}
-//________________________________________________________________________
-Int_t AliITSMisalignMaker::AddAlignObj(char* name,Double_t dx,Double_t dy,Double_t dz,
- Double_t dpsi,Double_t dtheta,Double_t dphi,const char* distrib) {
- //
- // misalignment by symname
- //
- Double_t vx=0.,vy=0.,vz=0.,vpsi=0.,vtheta=0.,vphi=0.;
-
- TString sdistrib(distrib);
-
- if(sdistrib==TString("gaussian")) {
- vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
- vy = GaussCut(0,dy/3.,dy);
- vz = GaussCut(0,dz/3.,dz);
- vpsi = GaussCut(0,dpsi/3., dpsi );
- vtheta = GaussCut(0,dtheta/3.,dtheta);
- vphi = GaussCut(0,dphi/3., dphi);
- }else if(sdistrib==TString("uniform")){
- vx = fRnd.Uniform(-dx,dx);
- vy = fRnd.Uniform(-dy,dy);
- vz = fRnd.Uniform(-dz,dz);
- vpsi = fRnd.Uniform(-dpsi,dpsi);
- vtheta = fRnd.Uniform(-dtheta,dtheta);
- vphi = fRnd.Uniform(-dphi,dphi);
- }else if(sdistrib==TString("fixed")){
- vx=dx;
- vy=dy;
- vz=dz;
- vpsi=dpsi;
- vtheta=dtheta;
- vphi=dphi;
- }else{
- AliFatal(Form("Invalid string \"%s\" specifying the misalignment type for the volume \"%s\""));
- }
-
- new(fAlobj[fInd]) AliAlignObjParams(name,0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
-
- AliAlignObjParams* itsalobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
- itsalobj->ApplyToGeometry();
-
- fInd++;
-
- return kTRUE;
-}
-
-
-//________________________________________________________________________
-Int_t AliITSMisalignMaker::AddAlignObj(Int_t lay,Double_t dx,Double_t dy,Double_t dz,
- Double_t dpsi,Double_t dtheta,Double_t dphi,Bool_t unif) {
- //
- // misalignment at the level of ladders/modules
- //
- lay+=1; // layers are numbered from 1 to 6 in AliGeomManager
-
- printf("LAYER %d MODULES %d\n",lay,AliGeomManager::LayerSize(lay));
-
- for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(lay); iModule++) {
-
- Double_t vx,vy,vz,vpsi,vtheta,vphi;
-
- if(!unif) {
- vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
- vy = GaussCut(0,dy/3.,dy);
- vz = GaussCut(0,dz/3.,dz);
- vpsi = GaussCut(0,dpsi/3., dpsi );
- vtheta = GaussCut(0,dtheta/3.,dtheta);
- vphi = GaussCut(0,dphi/3., dphi);
- } else {
- vx = fRnd.Uniform(-dx,dx);
- vy = fRnd.Uniform(-dy,dy);
- vz = fRnd.Uniform(-dz,dz);
- vpsi = fRnd.Uniform(-dpsi,dpsi);
- vtheta = fRnd.Uniform(-dtheta,dtheta);
- vphi = fRnd.Uniform(-dphi,dphi);
- }
-
- UShort_t volid = AliGeomManager::LayerToVolUID(lay,iModule);
- const char *symname = AliGeomManager::SymName(volid);
-
- new(fAlobj[fInd]) AliAlignObjParams(symname,volid,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
- AliAlignObjParams* itsalobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
- itsalobj->ApplyToGeometry();
- fInd++;
- }
-
- return kTRUE;
-}
-
-//________________________________________________________________________
-Int_t AliITSMisalignMaker::AddAlignObj(Int_t lay,Int_t ladd,Double_t dx,Double_t dy,Double_t dz,
- Double_t dpsi,Double_t dtheta,Double_t dphi,
- Double_t xShift,Double_t yShift,Double_t zShift,
- Double_t psiShift,Double_t thetaShift,Double_t phiShift,
- Bool_t unif) {
- //
- // misalignment at the level of half-staves/ladders (ladd=-1 means that all ladders are scanned)
- //
- Double_t vx,vy,vz,vpsi,vtheta,vphi;
- Double_t tr[3],rot[3];
-
- Int_t laddMin = ladd;
- Int_t laddMax = laddMin+1;
- if (ladd<0) {
- laddMin = 0;
- laddMax = fgkNLadders[lay];
- }
-
- for (Int_t iLadd=laddMin; iLadd<laddMax; iLadd++) {
-
- Int_t nHS = 1;
- if (lay<2) nHS = 2;
- for (Int_t iHalfStave=0; iHalfStave<nHS; iHalfStave++) {
-
- if(!unif) {
- vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
- vy = GaussCut(0,dy/3.,dy);
- vz = GaussCut(0,dz/3.,dz);
- vpsi = GaussCut(0,dpsi/3., dpsi );
- vtheta = GaussCut(0,dtheta/3.,dtheta);
- vphi = GaussCut(0,dphi/3., dphi);
- } else {
- vx = fRnd.Uniform(-dx,dx);
- vy = fRnd.Uniform(-dy,dy);
- vz = fRnd.Uniform(-dz,dz);
- vpsi = fRnd.Uniform(-dpsi,dpsi);
- vtheta = fRnd.Uniform(-dtheta,dtheta);
- vphi = fRnd.Uniform(-dphi,dphi);
- }
-
- TString name(GetHalfStaveLadderSymbName(lay,iLadd,iHalfStave));
-
- // first apply half-stave / ladder level misalignment
- AliAlignObjParams aaop(name.Data(),0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE); // set them as local
- aaop.GetPars(tr,rot); // global
-
- // then, apply layer-level misalignment (only for SDD and SSD)
- if(lay>1) {
- tr[0] += xShift;
- tr[1] += yShift;
- tr[2] += zShift;
- rot[0] += psiShift;
- rot[1] += thetaShift;
- rot[2] += phiShift;
- }
- new(fAlobj[fInd]) AliAlignObjParams(name.Data(),0,tr[0],tr[1],tr[2],rot[0],rot[1],rot[2],kTRUE); // set them as global
-
- AliAlignObjParams* itsalobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
- itsalobj->ApplyToGeometry();
- fInd++;
- }
- }
-
- return kTRUE;
-}
-
-
-//________________________________________________________________________
-Int_t AliITSMisalignMaker::AddSectorAlignObj(Int_t sectMin,Int_t sectMax,
- Double_t dx,Double_t dy,Double_t dz,
- Double_t dpsi,Double_t dtheta,Double_t dphi,
- Double_t xShift,Double_t yShift,Double_t zShift,
- Double_t psiShift,Double_t thetaShift,Double_t phiShift,Bool_t unif) {
- //
- // misalignment at the level of SPD sectors and half-barrels
- //
-
- if ((sectMin<1) || (sectMax>10)) return kFALSE;
- Double_t vx,vy,vz,vpsi,vtheta,vphi;
- Double_t tr[3],rot[3];
-
- for (Int_t iSect = sectMin-1; iSect<sectMax; iSect++) {
-
- // first, apply sector level misalignment
- if(!unif) {
- vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
- vy = GaussCut(0,dy/3.,dy);
- vz = GaussCut(0,dz/3.,dz);
- vpsi = GaussCut(0,dpsi/3., dpsi );
- vtheta = GaussCut(0,dtheta/3.,dtheta);
- vphi = GaussCut(0,dphi/3., dphi);
- } else {
- vx = fRnd.Uniform(-dx,dx);
- vy = fRnd.Uniform(-dy,dy);
- vz = fRnd.Uniform(-dz,dz);
- vpsi = fRnd.Uniform(-dpsi,dpsi);
- vtheta = fRnd.Uniform(-dtheta,dtheta);
- vphi = fRnd.Uniform(-dphi,dphi);
- }
-
- TString name(GetSymbName(0));
- name += fStrSector;
- name += iSect;
-
-
- AliAlignObjParams aaop(name.Data(),0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE); // set them as local
- aaop.GetPars(tr,rot); // global
-
- // then, apply half-barrel level misalignment
- tr[0] += xShift;
- tr[1] += yShift;
- tr[2] += zShift;
- rot[0] += psiShift;
- rot[1] += thetaShift;
- rot[2] += phiShift;
-
- new(fAlobj[fInd]) AliAlignObjParams(name.Data(),0,tr[0],tr[1],tr[2],rot[0],rot[1],rot[2],kTRUE); // set them as global
-
- AliAlignObjParams* itsalobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
- itsalobj->ApplyToGeometry();
- fInd++;
- }
- return kTRUE;
-}
-
-//________________________________________________________________________
-Double_t AliITSMisalignMaker::GaussCut(Double_t mean,Double_t sigma,Double_t absMax) {
- //
- // random from gaussian with cut on tails
- //
- Double_t val = fRnd.Gaus(mean,sigma);
- while (TMath::Abs(val-mean)>absMax)
- val = fRnd.Gaus(mean,sigma);
- return val;
-}
-
-//________________________________________________________________________
-const char* AliITSMisalignMaker::GetSymbName(Int_t layer) const {
- //
- // be careful : SPD0 and SPD1 are not physically separated
- //
- TString name;
- switch (layer) {
- case 0:
- case 1: name = fStrSPD; name += layer; break;
- case 2:
- case 3: name = fStrSDD; name += layer; break;
- case 4:
- case 5: name = fStrSSD; name += layer; break;
- default: AliFatal("Wrong layer index");
- }
- return name.Data();
-}
-
-//________________________________________________________________________
-const char* AliITSMisalignMaker::GetSymbName(Int_t layer, Int_t ladder, Int_t det) const {
- //
- // symname from layer, ladder, detector
- //
- TString symname(GetHalfStaveLadderSymbName(layer,ladder,det));
- if(layer<=2){
- symname+="Ladder";
- }else if(layer<=6){
- symname+="Sensor";
- }else{
- AliError("Invalid layer!");
- return 0;
- }
- symname+=det;
- return symname.Data();
-}
-
-//________________________________________________________________________
-const char* AliITSMisalignMaker::GetSymbName(Int_t layer,Int_t ladd) const {
- //
- // Get logical names at the level of staves / ladders
- //
- TString name(GetSymbName(layer));
- if (layer==0) { // SPD1
-
- int sector = ladd/2;
- name += fStrSector;
- name += sector;
- int stave = ladd-sector*2;
- name += fStrStave;
- name += stave;
- }
- else if (layer==1) { // SPD2
-
- int sector = ladd/4;
- name += fStrSector;
- name += sector;
- int stave = ladd-sector*4;
- name += fStrStave;
- name += stave;
- }
- else if (layer>=2 && layer<=5) { // SDD and SSD
- name += fStrLadder;
- name += ladd;
- }
- else {
- AliFatal("Wrong layer index");
- }
- return name.Data();
-}
-
-//________________________________________________________________________
-const char* AliITSMisalignMaker::GetHalfStaveLadderSymbName(Int_t layer,Int_t ladd,Int_t halfStave) const {
- //
- // Get logical names at the level of half-staves (SPD) or ladders (SDD and SSD)
- //
- TString name(GetSymbName(layer));
- if (layer==0) { // SPD1
-
- int sector = ladd/2;
- name += fStrSector;
- name += sector;
- int stave = ladd-sector*2;
- name += fStrStave;
- name += stave;
- name += fStrHalfStave;
- name += halfStave;
- }
- else if (layer==1) { // SPD2
-
- int sector = ladd/4;
- name += fStrSector;
- name += sector;
- int stave = ladd-sector*4;
- name += fStrStave;
- name += stave;
- name += fStrHalfStave;
- name += halfStave;
- }
- else if (layer>=2 && layer<=5) { // SDD and SSD
- name += fStrLadder;
- name += ladd;
- }
- else {
- AliFatal("Wrong layer index");
- }
- return name.Data();
-}
-
-//________________________________________________________________________
-const char* AliITSMisalignMaker::GetParentSymName(const char* symname) {
- //
- // symnane of parent volume
- //
- TString parent(symname);
- // Give the symname of
- if(parent.BeginsWith('/')) parent.Remove(TString::kLeading,'/');
- if(parent.EndsWith("/")) parent.Remove(TString::kTrailing,'/');
-
- if(!parent.CountChar('/')) AliErrorClass("Not a valid symbolic name");
-
- Int_t layer,level;
- GetLayerAndLevel(symname,layer,level);
- if(level==1) return "ITS";
-
- parent.Remove(parent.Last('/'));
-
- if((layer==0 || layer==1) && level==2){
- parent.Remove(parent.Last('/'));
- parent[7]='0';
- }
-
- return parent.Data();
-}
-
-//________________________________________________________________________
-Bool_t AliITSMisalignMaker::GetLayerAndLevel(const char* symname, Int_t &layer, Int_t &level) {
- //
- // given the symbolic name set layer and level
- //
- const char* basename[6] = {"ITS/SPD0/Sector","ITS/SPD1/Sector","ITS/SDD2/Ladder","ITS/SDD3/Ladder","ITS/SSD4/Ladder","ITS/SSD5/Ladder"};
- TString strSym(symname);
- if(strSym=="ITS"){
- level=0;
- layer=-1;
- return kTRUE;
- }
- Int_t i;
- for(i=0; i<6; i++){
- if(strSym.BeginsWith(basename[i])) break;
- }
-
- if(i>=6){
- AliErrorClass(Form("%s is not a valid symbolic name for an ITS alignable volume",strSym.Data()));
- return kFALSE;
- }
-
- layer=i;
- //The part above could be replaced by just
- // TString seventh = strSym[7];
- // layer = seventh.Atoi();
- // if we don't need to check the validity of the symname
-
- level=1;
- switch(layer){
- case 0:
- case 1:
- if(strSym.Contains("Stave")) level=2;
- if(strSym.Contains("Ladder")) level=3;
- break;
- case 2:
- case 3:
- case 4:
- case 5:
- if(strSym.Contains("Sensor")) level=2;
- }
-
- return kTRUE;
-}
-
-//________________________________________________________________________
-Int_t AliITSMisalignMaker::GetNSisters(const char* symname) {
- //
- // number of volumes on same level
- //
- Int_t layer,level;
- if(!GetLayerAndLevel(symname,layer,level)) return -1;
- if(level==0) return -1;
- if(level==1) return GetNLadders(layer);
- if(level==2) return GetNDetectors(layer);
- AliErrorClass(Form("Invalid layer and level"));
- return -1;
-}
-
-//________________________________________________________________________
-Int_t AliITSMisalignMaker::GetNDaughters(const char* symname) {
- //
- // number of daughter volumes
- //
- Int_t layer,level;
- if(!GetLayerAndLevel(symname,layer,level)) return -1;
- if(level==0) {
- Int_t nLadders = 0;
- for(Int_t lay=0; lay<6; lay++) nLadders += GetNLadders(lay);
- return nLadders;
- }
- if(level==1) return GetNDetectors(layer);
- if(level==2){
- AliWarningClass(Form("Volume %s is a sensitive volume and has no alignable dauthers",symname));
- return -1;
- }
- AliErrorClass(Form("Invalid layer and level"));
- return -1;
-}
-
-/*
-//________________________________________________________________________
-TString AliITSMisalignMaker::GetSymbName(Int_t layer,Int_t ladd,Int_t mod) const {
-
- // Get logical names at the level of SPD ladders / SDD and SSD modules
-
- Int_t halfStave = mod/2;
- TString name = GetHalfStaveLadderSymbName(layer,ladd,halfStave);
-
- if (layer<2) { // SPD
- name += fStrLadder;
- name += mod;
- }
- else if (layer>=2 && layer<=5) { // SDD and SSD
- name += fStrSensor;
- name += mod;
- }
- else {
- AliFatal("Wrong layer index");
- }
- return name;
-}
-*/
-
+++ /dev/null
-#ifndef ALIITSMISALIGNMAKER_H
-#define ALIITSMISALIGNMAKER_H
-/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice */
-
-/* $Id$ */
-//------------------------------------------------------------------------
-//
-// This class is a helper, producing ITS aligmnent objects.
-// It provides also some useful functions
-// See the parameters of the misalignment at the end of this script.
-//
-// Main author: L. Gaudichet
-// Contact: andrea.dainese@lnl.infn.it
-//
-//------------------------------------------------------------------------
-
-#include <TRandom3.h>
-#include <TString.h>
-#include <TClonesArray.h>
-
-
-//-------------------------------------------------------------------------
-class AliITSMisalignMaker : public TObject {
-
-public:
- AliITSMisalignMaker();
-
- ~AliITSMisalignMaker() {};
-
- TClonesArray* GetArray() {return &fAlobj;}
-
- void SetSeed(Int_t seed) {fRnd.SetSeed(seed); return;}
-
- Double_t GetUnif(Double_t x1,Double_t x2) {return fRnd.Uniform(x1,x2);}
-
- Int_t AddAlignObj(char* name,Double_t dx,Double_t dy,Double_t dz,
- Double_t dpsi,Double_t dtheta,Double_t dphi,
- const char* distrib);
-
- Int_t AddAlignObj(Int_t lay,Double_t dx,Double_t dy,Double_t dz,
- Double_t dpsi,Double_t dtheta,Double_t dphi,
- Bool_t unif);
-
- Int_t AddAlignObj(Int_t lay,Int_t ladd,Double_t dx,Double_t dy,Double_t dz,
- Double_t dpsi,Double_t dtheta,Double_t dphi,
- Double_t xShift,Double_t yShift,Double_t zShift,
- Double_t psiShift,Double_t thetaShift,Double_t phiShift,
- Bool_t unif);
-
- Int_t AddSectorAlignObj(Int_t sectMin,Int_t sectMax,
- Double_t dx,Double_t dy,Double_t dz,
- Double_t dpsi,Double_t dtheta,Double_t dphi,
- Double_t xShift,Double_t yShift,Double_t zShift,
- Double_t psiShift,Double_t thetaShift,Double_t phiShift,
- Bool_t unif);
-
- const char* GetSymbName(Int_t layer) const;
- const char* GetSymbName(Int_t layer,Int_t ladd) const;
- const char* GetSymbName(Int_t layer,Int_t ladd,Int_t mod) const;
- const char* GetHalfStaveLadderSymbName(Int_t layer,Int_t ladd,Int_t halfStave) const;
- Double_t GaussCut(Double_t mean,Double_t sigma,Double_t cutn);
- static const char* GetParentSymName(const char* symname) ;
- // const char* GetSistersSymName(const char* symname) const;
- static Bool_t GetLayerAndLevel(const char* symname, Int_t &layer, Int_t &level);
-
- static Int_t GetNLayers() {return kNLayers;}
- static Int_t GetNLadders(Int_t lay) {return fgkNLadders[lay];}
- static Int_t GetNDetectors(Int_t lay) {return fgkNDetectors[lay];}
- static Int_t GetNSisters(const char* symname);
- static Int_t GetNDaughters(const char* symname);
-
-protected:
- TRandom3 fRnd; // TRandom object
- Int_t fInd; // index of current AliAlignObjParams in fAlobj
- TClonesArray fAlobj; // array of AliAlignObjParams
- TString fStrSPD; // name of SPD
- TString fStrSDD; // name of SDD
- TString fStrSSD; // name of SSD
- TString fStrStave; // name of SPD stave
- TString fStrHalfStave; // name of SPD half-stave
- TString fStrLadder; // name of SPD ladder
- TString fStrSector; // name of SPD sector
- TString fStrSensor; // name of sensitive volume
-
-private:
- enum {kNLayers = 6}; // The number of layers.
- static const Int_t fgkNLadders[kNLayers]; // Array of the number of ladders/layer(layer)
- static const Int_t fgkNDetectors[kNLayers];// Array of the number of detector/ladder(layer)
-
- ClassDef(AliITSMisalignMaker,1) //ITS Misalign Maker
-};
-
-
-#endif
AliITSMap.cxx
AliITSMapA1.cxx
AliITSMapA2.cxx
- AliITSMisalignMaker.cxx
+ AliITSMisAligner.cxx
AliITSpList.cxx
AliITSpListItem.cxx
AliITSsegmentation.cxx
#pragma link C++ class AliITSMap+;
#pragma link C++ class AliITSMapA1+;
#pragma link C++ class AliITSMapA2+;
-#pragma link C++ class AliITSMisalignMaker+;
+#pragma link C++ class AliITSMisAligner+;
#pragma link C++ class AliITSsegmentation+;
#pragma link C++ class AliITSsegmentationSPD+;
#pragma link C++ class AliITSsegmentationSDD+;
+++ /dev/null
-#if !defined(__CINT__) || defined(__MAKECINT__)
-#include <TError.h>
-#include <TFile.h>
-#include <TGeoManager.h>
-#include <TMath.h>
-#include <TString.h>
-#include <TSystem.h>
-#include "AliCDBPath.h"
-#include "AliCDBEntry.h"
-#include "AliCDBManager.h"
-#include "AliCDBStorage.h"
-#include "AliGeomManager.h"
-#include "AliITSMisalignMaker.h"
-#endif
-
-
-TRandom3 rnd;
-rnd.SetSeed(23457856);
-
-void MakeITSFullMisAlignment() {
-//========================================================================
-//
-// Macro for ITS full (realistic) misalignment
-//
-// Main author: L. Gaudichet
-// Contact: andrea.dainese@lnl.infn.it
-//
-//========================================================================
-
-
- const char* macroname = "MakeITSFullMisAlignment.C";
-
- // Activate CDB storage and load geometry from CDB
- AliCDBManager* cdb = AliCDBManager::Instance();
- if(!cdb->IsDefaultStorageSet()) cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
- cdb->SetRun(0);
-
- AliCDBStorage* storage = NULL;
-
- if(TString(gSystem->Getenv("TOCDB")) == TString("kTRUE")){
- TString Storage = gSystem->Getenv("STORAGE");
- if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
- Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
- return;
- }
- storage = cdb->GetStorage(Storage.Data());
- if(!storage){
- Error(macroname,"Unable to open storage %s\n",Storage.Data());
- return;
- }
- AliCDBPath path("GRP","Geometry","Data");
- AliCDBEntry *entry = storage->Get(path.GetPath(),cdb->GetRun());
- if(!entry) Fatal(macroname,"Could not get the specified CDB entry!");
- entry->SetOwner(0);
- TGeoManager* geom = (TGeoManager*) entry->GetObject();
- AliGeomManager::SetGeometry(geom);
- }else{
- AliGeomManager::LoadGeometry("geometry.root"); //load geom from default CDB storage
- }
-
- // SETTINGS:
- // - tranformations are defined by the "maximum transformation"
- // dx,dy,dz,dpsi,dtheta,dphi: then we take a Gaussian with sigma=dx/3
- // and we cut it at +- 3*sigma = dx
- // (the option "unif" allows to sample from a uniform distr.)
- // - units are cm and deg
- // - transformations are defined in the local frame of the volume
- // being misaligned
- //
- const Float_t kRadToDeg = 180./TMath::Pi();
-
-
- //=****************************************
- // misalignment of the whole ITS according to survey as reported by Werner Riegler (18/07/2008)
- // + 100um smearing for translations and 0.1mrad smearing for rotations
- //=****************************************
- Double_t sigmatrW = 0.01;
- Double_t sigmarotW = 0.006;
- Double_t its_dx = AliMathBase::TruncatedGaus(-0.12,sigmatrW,3.*sigmatrW);
- Double_t its_dy = AliMathBase::TruncatedGaus(-0.07,sigmatrW,3.*sigmatrW);
- Double_t its_dz = AliMathBase::TruncatedGaus(0.29,sigmatrW,3.*sigmatrW);
- Double_t its_dpsi = AliMathBase::TruncatedGaus(0.,sigmarotW,3.*sigmarotW);
- Double_t its_dtheta = AliMathBase::TruncatedGaus(0.03,sigmarotW,3.*sigmarotW);
- Double_t its_dphi = AliMathBase::TruncatedGaus(0.04,sigmarotW,3.*sigmarotW);
- const char* unifits="fixed";
-
- //=****************************************
- // misalignment at the level of SPD sectors : source - A.Pepato
- //=****************************************
- Float_t spdsector_dx = 0.0050; // 50 micron (~tangetial, i.e. rphi)
- Float_t spdsector_dy = 0.0100; // 100 micron (~radial)
- Float_t spdsector_dz = 0.0100; // 100 micron
- Float_t spdsector_dpsi = 0.0100/30.*kRadToDeg;; // so as to have 100 micron difference at the two extremes
- Float_t spdsector_dtheta = 0.0100/30.*kRadToDeg;; // so as to have 100 micron difference at the two extremes
- Float_t spdsector_dphi = 0.0050/1.5*kRadToDeg;; // so as to have 50 micron difference at the two extremes
- Bool_t unifspdsector=kTRUE;
-
- //=****************************************
- // misalignment at the level of SPD half-barrels : source - A.Pepato
- //=****************************************
- Float_t spdhalfbarrel_dx = 0.0200; // 200 micron
- Float_t spdhalfbarrel_dy = 0.0200; // 200 micron
- Float_t spdhalfbarrel_dz = 0.0200; // 200 micron
- Float_t spdhalfbarrel_dpsi = 0.0100/30.*kRadToDeg; // so as to have 100 micron difference at the two extremes
- Float_t spdhalfbarrel_dtheta = 0.0100/30.*kRadToDeg; // so as to have 100 micron difference at the two extremes
- Float_t spdhalfbarrel_dphi = 0.0100/7.*kRadToDeg; // so as to have 100 micron difference at the two extremes
-
- //=****************************************
- // misalignment at the level of SPD barrel : source - A.Pepato
- //=****************************************
- Float_t spdbarrel_dx = 0.1000; // 1 mm (very pessimistic)
- Float_t spdbarrel_dy = 0.1000; // 1 mm (very pessimistic)
- Float_t spdbarrel_dz = 0.1000; // 1 mm (very pessimistic)
- Float_t spdbarrel_dpsi = 0.0500/30.*kRadToDeg; // so as to have 500 micron difference at the two extremes
- Float_t spdbarrel_dtheta = 0.0500/30.*kRadToDeg; // so as to have 500 micron difference at the two extremes
- Float_t spdbarrel_dphi = 0.0500/7.*kRadToDeg; // so as to have 500 micron difference at the two extremes
-
-
- //=****************************************
- // misalignment at the level of SDD and SSD layers: source - B.Giraudo
- //=****************************************
- Float_t sddlayer_dx = 0.0010; // 10 micron
- Float_t sddlayer_dy = 0.0010; // 10 micron
- Float_t sddlayer_dz = 0.0010; // 10 micron
- Float_t sddlayer_dpsi = 0.0010/52.*kRadToDeg; // so as to have 10 micron difference at the two extremes
- Float_t sddlayer_dtheta = 0.0010/52.*kRadToDeg; // so as to have 10 micron difference at the two extremes
- Float_t sddlayer_dphi = 0.0010/20.*kRadToDeg; // so as to have 10 micron difference at the two extremes
-
- Float_t ssdlayer_dx = 0.0010; // 10 micron
- Float_t ssdlayer_dy = 0.0010; // 10 micron
- Float_t ssdlayer_dz = 0.0010; // 10 micron
- Float_t ssdlayer_dpsi = 0.0010/90.*kRadToDeg; // so as to have 10 micron difference at the two extremes
- Float_t ssdlayer_dtheta = 0.0010/90.*kRadToDeg; // so as to have 10 micron difference at the two extremes
- Float_t ssdlayer_dphi = 0.0010/40.*kRadToDeg; // so as to have 10 micron difference at the two extremes
-
- Float_t sddbarrel_dx = 0.0020; // 20 micron
- Float_t sddbarrel_dy = 0.0020; // 20 micron
- Float_t sddbarrel_dz = 0.0020; // 20 micron
- Float_t sddbarrel_dpsi = 0.0020/52.*kRadToDeg; // so as to have 20 micron difference at the two extremes
- Float_t sddbarrel_dtheta = 0.0020/52.*kRadToDeg; // so as to have 20 micron difference at the two extremes
- Float_t sddbarrel_dphi = 0.0020/20.*kRadToDeg; // so as to have 20 micron difference at the two extremes
-
- Float_t ssdbarrel_dx = 0.0020; // 20 micron
- Float_t ssdbarrel_dy = 0.0020; // 20 micron
- Float_t ssdbarrel_dz = 0.0020; // 20 micron
- Float_t ssdbarrel_dpsi = 0.0020/90.*kRadToDeg; // so as to have 20 micron difference at the two extremes
- Float_t ssdbarrel_dtheta = 0.0020/90.*kRadToDeg; // so as to have 20 micron difference at the two extremes
- Float_t ssdbarrel_dphi = 0.0020/40.*kRadToDeg; // so as to have 20 micron difference at the two extremes
-
- //=****************************************
- // misalignment at the level of half-staves (SPD) : source - S.Moretto
- // ladders (SDD,SSD) : source -
- //=****************************************
- Float_t spdhalfstave_dx = 0.0100; // 100 micron // normal to plane
- Float_t spdhalfstave_dy = 0.0020; // 20 micron
- Float_t spdhalfstave_dz = 0.0020; // 20 micron
- Float_t spdhalfstave_dpsi = 0.0020/7.*kRadToDeg; // so as to have 20 micron difference at the two extremes
- Float_t spdhalfstave_dtheta = 0.0050/7.*kRadToDeg; // so as to have 50 micron difference at the two extremes
- Float_t spdhalfstave_dphi = 0.0050/0.7*kRadToDeg; // so as to have 50 micron difference at the two extremes
- Bool_t unifspdhalfstave=kTRUE;
-
- Float_t sddladder_dx = 0.0005; // 5 micron
- Float_t sddladder_dy = 0.0005; // 5 micron
- Float_t sddladder_dz = 0.0005; // 5 micron
- Float_t sddladder_dpsi = 0.00; // ?
- Float_t sddladder_dtheta = 0.00; // ?
- Float_t sddladder_dphi = 0.00; // ?
-
- Float_t ssdladder_dx = 0.0005; // 5 micron
- Float_t ssdladder_dy = 0.0005; // 5 micron
- Float_t ssdladder_dz = 0.0005; // 5 micron
- Float_t ssdladder_dpsi = 0.00; // ?
- Float_t ssdladder_dtheta = 0.00; // ?
- Float_t ssdladder_dphi = 0.00; // ?
-
-
- //=****************************************
- // misalignment at the level of ladders (SPD) : source - R.Santoro
- // modules (SDD) : source - L.Gaudichet
- // modules (SSD) : source -
- //=****************************************
- Float_t spdladder_dx = 0.0010; // 10 micron
- Float_t spdladder_dy = 0.0030; // 50 micron
- Float_t spdladder_dz = 0.0010; // 10 micron
- Float_t spdladder_dpsi = 0.0001*kRadToDeg; // 0.1 mrad
- Float_t spdladder_dtheta = 0.0001*kRadToDeg; // 0.1 mrad
- Float_t spdladder_dphi = 0.0001*kRadToDeg; // 0.1 mrad
-
- Float_t sddmodule_dx = 0.0045; // 45 micron
- Float_t sddmodule_dy = 0.0045; // 45 micron
- Float_t sddmodule_dz = 0.0105; // 105 micron
- Float_t sddmodule_dpsi = 0.00; // ?
- Float_t sddmodule_dtheta = 0.00; // ?
- Float_t sddmodule_dphi = 0.00; // ?
-
- Float_t ssdmodule_dx = 0.0050; // 50 micron
- Float_t ssdmodule_dy = 0.0050; // 50 micron
- Float_t ssdmodule_dz = 0.0050; // 50 micron
- Float_t ssdmodule_dpsi = 0.00; // ?
- Float_t ssdmodule_dtheta = 0.00; // ?
- Float_t ssdmodule_dphi = 0.00; // ?
- //
- // END SETTINGS
-
-
- AliITSMisalignMaker alignMaker;
-
- //=****************************************
- // overall ITS misalignment :
- //=****************************************
-
- alignMaker.AddAlignObj("ITS",its_dx,its_dy,its_dz,its_dpsi,its_dtheta,its_dphi,unifits);
-
- //=****************************************
- // misalignment at the level of SPD barrel, half-barrels, and at the level
- // of SPD sectors
- //=****************************************
-
- Double_t vx,vy,vz,vpsi,vtheta,vphi;
- Double_t vxbarrel,vybarrel,vzbarrel,vpsibarrel,vthetabarrel,vphibarrel;
-
- // barrel
- vxbarrel = AliMathBase::TruncatedGaus(0,spdbarrel_dx/3,spdbarrel_dx);
- vybarrel = AliMathBase::TruncatedGaus(0,spdbarrel_dy/3,spdbarrel_dy);
- vzbarrel = AliMathBase::TruncatedGaus(0,spdbarrel_dz/3,spdbarrel_dz);
- vpsibarrel = AliMathBase::TruncatedGaus(0,spdbarrel_dpsi/3,spdbarrel_dpsi);
- vthetabarrel = AliMathBase::TruncatedGaus(0,spdbarrel_dtheta/3,spdbarrel_dtheta);
- vphibarrel = AliMathBase::TruncatedGaus(0,spdbarrel_dphi/3,spdbarrel_dphi);
-
- // top half-barrel
- vx = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dx/3,spdhalfbarrel_dx);
- vy = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dy/3,spdhalfbarrel_dy);
- vz = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dz/3,spdhalfbarrel_dz);
- vpsi = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dpsi/3,spdhalfbarrel_dpsi);
- vtheta = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dtheta/3,spdhalfbarrel_dtheta);
- vphi = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dphi/3,spdhalfbarrel_dphi);
-
- vx += vxbarrel;
- vy += vybarrel;
- vz += vzbarrel;
- vpsi += vpsibarrel;
- vtheta += vthetabarrel;
- vphi += vphibarrel;
-
- alignMaker.AddSectorAlignObj(1,5,spdsector_dx,spdsector_dy,spdsector_dz,
- spdsector_dpsi,spdsector_dtheta,spdsector_dphi,
- vx,vy,vz,vpsi,vtheta,vphi,unifspdsector);
-
- // bottom half-barrel
- vx = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dx/3,spdhalfbarrel_dx);
- vy = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dy/3,spdhalfbarrel_dy);
- vz = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dz/3,spdhalfbarrel_dz);
- vpsi = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dpsi/3,spdhalfbarrel_dpsi);
- vtheta = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dtheta/3,spdhalfbarrel_dtheta);
- vphi = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dphi/3,spdhalfbarrel_dphi);
-
- vx += vxbarrel;
- vy += vybarrel;
- vz += vzbarrel;
- vpsi += vpsibarrel;
- vtheta += vthetabarrel;
- vphi += vphibarrel;
-
- alignMaker.AddSectorAlignObj(6,10,spdsector_dx,spdsector_dy,spdsector_dz,
- spdsector_dpsi,spdsector_dtheta,spdsector_dphi,
- vx,vy,vz,vpsi,vtheta,vphi,unifspdsector);
-
-
-
- //=****************************************
- // misalignment at the level of half-staves (SPD)/ladders&layers (SDD,SSD) :
- //=****************************************
-
- // SPD
- alignMaker.AddAlignObj(0,-1,spdhalfstave_dx,spdhalfstave_dy,spdhalfstave_dz,spdhalfstave_dpsi,spdhalfstave_dtheta,spdhalfstave_dphi,0,0,0,0,0,0,unifspdhalfstave); // all SPD1 half-staves
- alignMaker.AddAlignObj(1,-1,spdhalfstave_dx,spdhalfstave_dy,spdhalfstave_dz,spdhalfstave_dpsi,spdhalfstave_dtheta,spdhalfstave_dphi,0,0,0,0,0,0,unifspdhalfstave); // all SPD2 half-staves
-
- // SDD
- // barrel
- vxbarrel = alignMaker.GetUnif(-sddbarrel_dx,sddbarrel_dx);
- vybarrel = alignMaker.GetUnif(-sddbarrel_dy,sddbarrel_dy);
- vzbarrel = alignMaker.GetUnif(-sddbarrel_dz,sddbarrel_dz);
- vpsibarrel = alignMaker.GetUnif(-sddbarrel_dpsi,sddbarrel_dpsi);
- vthetabarrel = alignMaker.GetUnif(-sddbarrel_dtheta,sddbarrel_dtheta);
- vphibarrel = alignMaker.GetUnif(-sddbarrel_dphi,sddbarrel_dphi);
-
- // layer SDD1
- vx = alignMaker.GetUnif(-sddlayer_dx,sddlayer_dx);
- vy = alignMaker.GetUnif(-sddlayer_dy,sddlayer_dy);
- vz = alignMaker.GetUnif(-sddlayer_dz,sddlayer_dz);
- vpsi = alignMaker.GetUnif(-sddlayer_dpsi,sddlayer_dpsi);
- vtheta = alignMaker.GetUnif(-sddlayer_dtheta,sddlayer_dtheta);
- vphi = alignMaker.GetUnif(-sddlayer_dphi,sddlayer_dphi);
-
- vx += vxbarrel;
- vy += vybarrel;
- vz += vzbarrel;
- vpsi += vpsibarrel;
- vtheta += vthetabarrel;
- vphi += vphibarrel;
-
- alignMaker.AddAlignObj(2,-1,sddladder_dx,sddladder_dy,sddladder_dz,sddladder_dpsi,sddladder_dtheta,sddladder_dphi,vx,vy,vz,vpsi,vtheta,vphi,kFALSE); // all SDD1 ladders
-
- // layer SDD2
- vx = alignMaker.GetUnif(-sddlayer_dx,sddlayer_dx);
- vy = alignMaker.GetUnif(-sddlayer_dy,sddlayer_dy);
- vz = alignMaker.GetUnif(-sddlayer_dz,sddlayer_dz);
- vpsi = alignMaker.GetUnif(-sddlayer_dpsi,sddlayer_dpsi);
- vtheta = alignMaker.GetUnif(-sddlayer_dtheta,sddlayer_dtheta);
- vphi = alignMaker.GetUnif(-sddlayer_dphi,sddlayer_dphi);
-
- vx += vxbarrel;
- vy += vybarrel;
- vz += vzbarrel;
- vpsi += vpsibarrel;
- vtheta += vthetabarrel;
- vphi += vphibarrel;
-
- alignMaker.AddAlignObj(3,-1,sddladder_dx,sddladder_dy,sddladder_dz,sddladder_dpsi,sddladder_dtheta,sddladder_dphi,vx,vy,vz,vpsi,vtheta,vphi,kFALSE); // all SDD2 ladders
-
- // SSD
- // barrel
- vxbarrel = alignMaker.GetUnif(-ssdbarrel_dx,ssdbarrel_dx);
- vybarrel = alignMaker.GetUnif(-ssdbarrel_dy,ssdbarrel_dy);
- vzbarrel = alignMaker.GetUnif(-ssdbarrel_dz,ssdbarrel_dz);
- vpsibarrel = alignMaker.GetUnif(-ssdbarrel_dpsi,ssdbarrel_dpsi);
- vthetabarrel = alignMaker.GetUnif(-ssdbarrel_dtheta,ssdbarrel_dtheta);
- vphibarrel = alignMaker.GetUnif(-ssdbarrel_dphi,ssdbarrel_dphi);
-
- // layer SSD1
- vx = alignMaker.GetUnif(-ssdlayer_dx,ssdlayer_dx);
- vy = alignMaker.GetUnif(-ssdlayer_dy,ssdlayer_dy);
- vz = alignMaker.GetUnif(-ssdlayer_dz,ssdlayer_dz);
- vpsi = alignMaker.GetUnif(-ssdlayer_dpsi,ssdlayer_dpsi);
- vtheta = alignMaker.GetUnif(-ssdlayer_dtheta,ssdlayer_dtheta);
- vphi = alignMaker.GetUnif(-ssdlayer_dphi,ssdlayer_dphi);
-
- vx += vxbarrel;
- vy += vybarrel;
- vz += vzbarrel;
- vpsi += vpsibarrel;
- vtheta += vthetabarrel;
- vphi += vphibarrel;
-
- alignMaker.AddAlignObj(4,-1,ssdladder_dx,ssdladder_dy,ssdladder_dz,ssdladder_dpsi,ssdladder_dtheta,ssdladder_dphi,vx,vy,vz,vpsi,vtheta,vphi,kFALSE); // all SSD1 ladders
-
- // layer SSD2
- vx = alignMaker.GetUnif(-ssdlayer_dx,ssdlayer_dx);
- vy = alignMaker.GetUnif(-ssdlayer_dy,ssdlayer_dy);
- vz = alignMaker.GetUnif(-ssdlayer_dz,ssdlayer_dz);
- vpsi = alignMaker.GetUnif(-ssdlayer_dpsi,ssdlayer_dpsi);
- vtheta = alignMaker.GetUnif(-ssdlayer_dtheta,ssdlayer_dtheta);
- vphi = alignMaker.GetUnif(-ssdlayer_dphi,ssdlayer_dphi);
-
- vx += vxbarrel;
- vy += vybarrel;
- vz += vzbarrel;
- vpsi += vpsibarrel;
- vtheta += vthetabarrel;
- vphi += vphibarrel;
-
- alignMaker.AddAlignObj(5,-1,ssdladder_dx,ssdladder_dy,ssdladder_dz,ssdladder_dpsi,ssdladder_dtheta,ssdladder_dphi,vx,vy,vz,vpsi,vtheta,vphi,kFALSE); // all SSD2 ladders
-
- //=****************************************
- // misalignment at the level of ladders (SPD)/modules (SDD,SSD) :
- //=****************************************
-
- alignMaker.AddAlignObj(0,spdladder_dx,spdladder_dy,spdladder_dz,spdladder_dpsi,spdladder_dtheta,spdladder_dphi,kFALSE); // all SPD1 ladders
- alignMaker.AddAlignObj(1,spdladder_dx,spdladder_dy,spdladder_dz,spdladder_dpsi,spdladder_dtheta,spdladder_dphi,kFALSE); // all SPD2 ladders
-
- alignMaker.AddAlignObj(2,sddmodule_dx,sddmodule_dy,sddmodule_dz,sddmodule_dpsi,sddmodule_dtheta,sddmodule_dphi,kFALSE); // all SDD1 modules
- alignMaker.AddAlignObj(3,sddmodule_dx,sddmodule_dy,sddmodule_dz,sddmodule_dpsi,sddmodule_dtheta,sddmodule_dphi,kFALSE); // all SDD2 modules
-
- alignMaker.AddAlignObj(4,ssdmodule_dx,ssdmodule_dy,ssdmodule_dz,ssdmodule_dpsi,ssdmodule_dtheta,ssdmodule_dphi,kFALSE); // all SSD1 modules
- alignMaker.AddAlignObj(5,ssdmodule_dx,ssdmodule_dy,ssdmodule_dz,ssdmodule_dpsi,ssdmodule_dtheta,ssdmodule_dphi,kFALSE); // all SSD2 modules
-
-
-
- if(TString(gSystem->Getenv("TOCDB")) != TString("kTRUE")){
- // save on file
- const char* filename = "ITSfullMisalignment.root";
- TFile f(filename,"RECREATE");
- if(!f.IsOpen()){
- Error(macroname,"cannot open file for output\n");
- return;
- }
- Info(macroname,"Saving alignment objects to the file %s",filename);
- f.cd();
- f.WriteObject(alignMaker.GetArray(),"ITSAlignObjs","kSingleKey");
- f.Close();
- }else{
- // save in CDB storage
- AliCDBMetaData *md= new AliCDBMetaData();
- md->SetResponsible("Andrea Dainese");
- md->SetComment("Alignment objects with actual ITS misalignment");
- md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
- AliCDBId id("ITS/Align/Data",0,AliCDBRunRange::Infinity());
- storage->Put(alignMaker.GetArray(),id,md);
- }
-
-
- return;
-}
-
+++ /dev/null
-#if !defined(__CINT__) || defined(__MAKECINT__)
-#include <TError.h>
-#include <TFile.h>
-#include <TGeoManager.h>
-#include <TMath.h>
-#include <TString.h>
-#include <TSystem.h>
-#include "AliCDBPath.h"
-#include "AliCDBEntry.h"
-#include "AliCDBManager.h"
-#include "AliCDBStorage.h"
-#include "AliGeomManager.h"
-#include "AliITSMisalignMaker.h"
-#endif
-
-
-TRandom3 rnd;
-rnd.SetSeed(98723456);
-
-void MakeITSResMisAlignment() {
-//========================================================================
-//
-// Steering macro for ITS residual (realistic) misalignment
-//
-// Main author: L. Gaudichet
-// Contact: andrea.dainese@lnl.infn.it
-//
-//========================================================================
-
-
- const char* macroname = "MakeITSResMisAlignment.C";
-
- // Activate CDB storage and load geometry from CDB
- AliCDBManager* cdb = AliCDBManager::Instance();
- if(!cdb->IsDefaultStorageSet()) cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
- cdb->SetRun(0);
-
- AliCDBStorage* storage = NULL;
-
- if(TString(gSystem->Getenv("TOCDB")) == TString("kTRUE")){
- TString Storage = gSystem->Getenv("STORAGE");
- if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
- Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
- return;
- }
- storage = cdb->GetStorage(Storage.Data());
- if(!storage){
- Error(macroname,"Unable to open storage %s\n",Storage.Data());
- return;
- }
- AliCDBPath path("GRP","Geometry","Data");
- AliCDBEntry *entry = storage->Get(path.GetPath(),cdb->GetRun());
- if(!entry) Fatal(macroname,"Could not get the specified CDB entry!");
- entry->SetOwner(0);
- TGeoManager* geom = (TGeoManager*) entry->GetObject();
- AliGeomManager::SetGeometry(geom);
- }else{
- AliGeomManager::LoadGeometry("geometry.root"); //load geom from default CDB storage
- }
-
- // SETTINGS:
- // - tranformations are defined by the "maximum transformation"
- // dx,dy,dz,dpsi,dtheta,dphi: then we take a Gaussian with sigma=dx/3
- // and we cut it at +- 3*sigma = dx
- // (the option "unif" allows to sample from a uniform distr.)
- // - units are cm and deg
- // - transformations are defined in the local frame of the volume
- // being misaligned
- //
- const Float_t kRadToDeg = 180./TMath::Pi();
-
-
- //=****************************************
- // misalignment of the whole ITS according to survey as reported by Werner Riegler (18/07/2008)
- // no smearing added (would clash with vertex constraint)
- //=****************************************
- Double_t its_dx = -0.12;
- Double_t its_dy = -0.07;
- Double_t its_dz = 0.29;
- Double_t its_dpsi = 0.;
- Double_t its_dtheta = 0.03;
- Double_t its_dphi = 0.04;
- const char* unifits="fixed";
-
- //=****************************************
- // misalignment at the level of SPD sectors : source - A.Pepato
- //=****************************************
- Float_t spdsector_dx = 0.0050/5.; // 50 micron (~tangetial, i.e. rphi)
- Float_t spdsector_dy = 0.0100/5.; // 100 micron (~radial)
- Float_t spdsector_dz = 0.0100/5.; // 100 micron
- Float_t spdsector_dpsi = 0.0100/30.*kRadToDeg/5.; // so as to have 100 micron difference at the two extremes
- Float_t spdsector_dtheta = 0.0100/30.*kRadToDeg/5.; // so as to have 100 micron difference at the two extremes
- Float_t spdsector_dphi = 0.0050/1.5*kRadToDeg/5.; // so as to have 50 micron difference at the two extremes
- Bool_t unifspdsector=kFALSE;
-
- //=****************************************
- // misalignment at the level of SPD half-barrels : source - A.Pepato
- //=****************************************
- Float_t spdhalfbarrel_dx = 0.000; // 200 micron
- Float_t spdhalfbarrel_dy = 0.000; // 200 micron
- Float_t spdhalfbarrel_dz = 0.000; // 200 micron
- Float_t spdhalfbarrel_dpsi = 0.000/30.*kRadToDeg; // so as to have 100 micron difference at the two extremes
- Float_t spdhalfbarrel_dtheta = 0.000/30.*kRadToDeg; // so as to have 100 micron difference at the two extremes
- Float_t spdhalfbarrel_dphi = 0.000/7.*kRadToDeg; // so as to have 100 micron difference at the two extremes
-
- //=****************************************
- // misalignment at the level of SPD barrel : source - A.Pepato
- //=****************************************
- Float_t spdbarrel_dx = 0.000; // 1 mm (very pessimistic)
- Float_t spdbarrel_dy = 0.000; // 1 mm (very pessimistic)
- Float_t spdbarrel_dz = 0.000; // 1 mm (very pessimistic)
- Float_t spdbarrel_dpsi = 0.000/30.*kRadToDeg; // so as to have 500 micron difference at the two extremes
- Float_t spdbarrel_dtheta = 0.000/30.*kRadToDeg; // so as to have 500 micron difference at the two extremes
- Float_t spdbarrel_dphi = 0.000/7.*kRadToDeg; // so as to have 500 micron difference at the two extremes
-
-
- //=****************************************
- // misalignment at the level of SDD and SSD layers: source
- //=****************************************
- Float_t sddlayer_dx = 0.0000;
- Float_t sddlayer_dy = 0.0000;
- Float_t sddlayer_dz = 0.0000;
- Float_t sddlayer_dpsi = 0.0000;
- Float_t sddlayer_dtheta = 0.0000;
- Float_t sddlayer_dphi = 0.0000;
-
- Float_t ssdlayer_dx = 0.0000;
- Float_t ssdlayer_dy = 0.0000;
- Float_t ssdlayer_dz = 0.0000;
- Float_t ssdlayer_dpsi = 0.0000;
- Float_t ssdlayer_dtheta = 0.0000;
- Float_t ssdlayer_dphi = 0.0000;
-
-
- //=****************************************
- // misalignment at the level of half-staves (SPD) : source - S.Moretto
- // ladders (SDD,SSD) : source -
- //=****************************************
- Float_t spdhalfstave_dx = 0.0100/4.; // 100 micron
- Float_t spdhalfstave_dy = 0.0020/4.; // 20 micron
- Float_t spdhalfstave_dz = 0.0020/4.; // 20 micron
- Float_t spdhalfstave_dpsi = 0.0020/7.*kRadToDeg/4.; // so as to have 20 micron difference at the two extremes
- Float_t spdhalfstave_dtheta = 0.0050/7.*kRadToDeg/4.; // so as to have 50 micron difference at the two extremes
- Float_t spdhalfstave_dphi = 0.0050/0.7*kRadToDeg/4.; // so as to have 50 micron difference at the two extremes
- Bool_t unifspdhalfstave=kFALSE;
-
- Float_t sddladder_dx = 0.0005; // 5 micron
- Float_t sddladder_dy = 0.0005; // 5 micron
- Float_t sddladder_dz = 0.0005; // 5 micron
- Float_t sddladder_dpsi = 0.00; // ?
- Float_t sddladder_dtheta = 0.00; // ?
- Float_t sddladder_dphi = 0.00; // ?
-
- Float_t ssdladder_dx = 0.0005; // 5 micron
- Float_t ssdladder_dy = 0.0005; // 5 micron
- Float_t ssdladder_dz = 0.0005; // 5 micron
- Float_t ssdladder_dpsi = 0.00; // ?
- Float_t ssdladder_dtheta = 0.00; // ?
- Float_t ssdladder_dphi = 0.00; // ?
-
-
- //=****************************************
- // misalignment at the level of ladders (SPD) : source - R.Santoro
- // modules (SDD) : source - L.Gaudichet
- // modules (SSD) : source -
- //=****************************************
- Float_t spdladder_dx = 0.0010/5.; // 10 micron
- Float_t spdladder_dy = 0.0050/5.; // 50 micron
- Float_t spdladder_dz = 0.0010/5.; // 10 micron
- Float_t spdladder_dpsi = 0.0001*kRadToDeg/5.; // 0.1 mrad
- Float_t spdladder_dtheta = 0.0001*kRadToDeg/5.; // 0.1 mrad
- Float_t spdladder_dphi = 0.0001*kRadToDeg/5.; // 0.1 mrad
-
- Float_t sddmodule_dx = 0.0045/5.; // 45 micron
- Float_t sddmodule_dy = 0.0045/5.; // 45 micron
- Float_t sddmodule_dz = 0.0105/5.; // 105 micron
- Float_t sddmodule_dpsi = 0.00; // ?
- Float_t sddmodule_dtheta = 0.00; // ?
- Float_t sddmodule_dphi = 0.00; // ?
-
- Float_t ssdmodule_dx = 0.0050/5.; // 50 micron
- Float_t ssdmodule_dy = 0.0050/5.; // 50 micron
- Float_t ssdmodule_dz = 0.0050/5.; // 50 micron
- Float_t ssdmodule_dpsi = 0.00; // ?
- Float_t ssdmodule_dtheta = 0.00; // ?
- Float_t ssdmodule_dphi = 0.00; // ?
- //
- // END SETTINGS
-
- AliITSMisalignMaker alignMaker;
-
- //=****************************************
- // overall ITS misalignment :
- //=****************************************
-
- alignMaker.AddAlignObj("ITS",its_dx,its_dy,its_dz,its_dpsi,its_dtheta,its_dphi,unifits);
-
-
- //=****************************************
- // misalignment at the level of SPD barrel, half-barrels, and at the level
- // of SPD sectors
- //=****************************************
-
- Double_t vx,vy,vz,vpsi,vtheta,vphi;
- Double_t vxbarrel,vybarrel,vzbarrel,vpsibarrel,vthetabarrel,vphibarrel;
-
- // barrel
- vxbarrel = AliMathBase::TruncatedGaus(0.,spdbarrel_dx/3,spdbarrel_dx);
- vxbarrel = AliMathBase::TruncatedGaus(0,spdbarrel_dx/3,spdbarrel_dx);
- vybarrel = AliMathBase::TruncatedGaus(0,spdbarrel_dy/3,spdbarrel_dy);
- vzbarrel = AliMathBase::TruncatedGaus(0,spdbarrel_dz/3,spdbarrel_dz);
- vpsibarrel = AliMathBase::TruncatedGaus(0,spdbarrel_dpsi/3,spdbarrel_dpsi);
- vthetabarrel = AliMathBase::TruncatedGaus(0,spdbarrel_dtheta/3,spdbarrel_dtheta);
- vphibarrel = AliMathBase::TruncatedGaus(0,spdbarrel_dphi/3,spdbarrel_dphi);
-
- // top half-barrel
- vx = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dx/3,spdhalfbarrel_dx);
- vy = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dy/3,spdhalfbarrel_dy);
- vz = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dz/3,spdhalfbarrel_dz);
- vpsi = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dpsi/3,spdhalfbarrel_dpsi);
- vtheta = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dtheta/3,spdhalfbarrel_dtheta);
- vphi = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dphi/3,spdhalfbarrel_dphi);
-
- vx += vxbarrel;
- vy += vybarrel;
- vz += vzbarrel;
- vpsi += vpsibarrel;
- vtheta += vthetabarrel;
- vphi += vphibarrel;
-
- alignMaker.AddSectorAlignObj(1,5,spdsector_dx,spdsector_dy,spdsector_dz,
- spdsector_dpsi,spdsector_dtheta,spdsector_dphi,
- vx,vy,vz,vpsi,vtheta,vphi,unifspdsector);
-
- // bottom half-barrel
- vx = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dx/3,spdhalfbarrel_dx);
- vy = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dy/3,spdhalfbarrel_dy);
- vz = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dz/3,spdhalfbarrel_dz);
- vpsi = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dpsi/3,spdhalfbarrel_dpsi);
- vtheta = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dtheta/3,spdhalfbarrel_dtheta);
- vphi = AliMathBase::TruncatedGaus(0,spdhalfbarrel_dphi/3,spdhalfbarrel_dphi);
-
- vx += vxbarrel;
- vy += vybarrel;
- vz += vzbarrel;
- vpsi += vpsibarrel;
- vtheta += vthetabarrel;
- vphi += vphibarrel;
-
- alignMaker.AddSectorAlignObj(6,10,spdsector_dx,spdsector_dy,spdsector_dz,
- spdsector_dpsi,spdsector_dtheta,spdsector_dphi,
- vx,vy,vz,vpsi,vtheta,vphi,unifspdsector);
-
-
- //=****************************************
- // misalignment at the level of half-staves (SPD)/ladders (SDD,SSD) :
- //=****************************************
-
- alignMaker.AddAlignObj(0,-1,spdhalfstave_dx,spdhalfstave_dy,spdhalfstave_dz,spdhalfstave_dpsi,spdhalfstave_dtheta,spdhalfstave_dphi,0,0,0,0,0,0,unifspdhalfstave); // all SPD1 half-staves
- alignMaker.AddAlignObj(1,-1,spdhalfstave_dx,spdhalfstave_dy,spdhalfstave_dz,spdhalfstave_dpsi,spdhalfstave_dtheta,spdhalfstave_dphi,0,0,0,0,0,0,unifspdhalfstave); // all SPD2 half-staves
-
- alignMaker.AddAlignObj(2,-1,sddladder_dx,sddladder_dy,sddladder_dz,sddladder_dpsi,sddladder_dtheta,sddladder_dphi,0,0,0,0,0,0,kFALSE); // all SDD1 ladders
- alignMaker.AddAlignObj(3,-1,sddladder_dx,sddladder_dy,sddladder_dz,sddladder_dpsi,sddladder_dtheta,sddladder_dphi,0,0,0,0,0,0,kFALSE); // all SDD2 ladders
-
- alignMaker.AddAlignObj(4,-1,ssdladder_dx,ssdladder_dy,ssdladder_dz,ssdladder_dpsi,ssdladder_dtheta,ssdladder_dphi,0,0,0,0,0,0,kFALSE); // all SSD1 ladders
- alignMaker.AddAlignObj(5,-1,ssdladder_dx,ssdladder_dy,ssdladder_dz,ssdladder_dpsi,ssdladder_dtheta,ssdladder_dphi,0,0,0,0,0,0,kFALSE); // all SSD2 ladders
-
- //=****************************************
- // misalignment at the level of ladders (SPD)/modules (SDD,SSD) :
- //=****************************************
-
- alignMaker.AddAlignObj(0,spdladder_dx,spdladder_dy,spdladder_dz,spdladder_dpsi,spdladder_dtheta,spdladder_dphi,kFALSE); // all SPD1 ladders
- alignMaker.AddAlignObj(1,spdladder_dx,spdladder_dy,spdladder_dz,spdladder_dpsi,spdladder_dtheta,spdladder_dphi,kFALSE); // all SPD2 ladders
-
- alignMaker.AddAlignObj(2,sddmodule_dx,sddmodule_dy,sddmodule_dz,sddmodule_dpsi,sddmodule_dtheta,sddmodule_dphi,kFALSE); // all SDD1 modules
- alignMaker.AddAlignObj(3,sddmodule_dx,sddmodule_dy,sddmodule_dz,sddmodule_dpsi,sddmodule_dtheta,sddmodule_dphi,kFALSE); // all SDD2 modules
-
- alignMaker.AddAlignObj(4,ssdmodule_dx,ssdmodule_dy,ssdmodule_dz,ssdmodule_dpsi,ssdmodule_dtheta,ssdmodule_dphi,kFALSE); // all SSD1 modules
- alignMaker.AddAlignObj(5,ssdmodule_dx,ssdmodule_dy,ssdmodule_dz,ssdmodule_dpsi,ssdmodule_dtheta,ssdmodule_dphi,kFALSE); // all SSD2 modules
-
-
- if( TString(gSystem->Getenv("TOCDB")) != TString("kTRUE") ){
- // save on file
- const char* filename = "ITSresidualMisalignment.root";
- TFile f(filename,"RECREATE");
- if(!f.IsOpen()){
- Error(macroname,"cannot open file for output\n");
- return;
- }
- Info(macroname,"Saving alignment objects to the file %s",filename);
- f.cd();
- f.WriteObject(alignMaker.GetArray(),"ITSAlignObjs","kSingleKey");
- f.Close();
- }else{
- // save in CDB storage
- AliCDBMetaData *md= new AliCDBMetaData();
- md->SetResponsible("Andrea Dainese");
- md->SetComment("Alignment objects with residual ITS misalignment");
- md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
- AliCDBId id("ITS/Align/Data",0,AliCDBRunRange::Infinity());
- storage->Put(alignMaker.GetArray(),id,md);
- }
-
-
- return;
-}
-
+++ /dev/null
-void MakeITSZeroMisAlignment(){
- // Create TClonesArray of zero misalignment objects for ITS
- //
- TClonesArray *array = new TClonesArray("AliAlignObjParams",4000);
- TClonesArray &alobj = *array;
- const char* macroname = "MakeITSZeroMisAlignment.C";
-
- // Activate CDB storage and load geometry from CDB
- AliCDBManager* cdb = AliCDBManager::Instance();
- if(!cdb->IsDefaultStorageSet()) cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
- cdb->SetRun(0);
-
- AliCDBStorage* storage = NULL;
-
- if(TString(gSystem->Getenv("TOCDB")) == TString("kTRUE")){
- TString Storage = gSystem->Getenv("STORAGE");
- if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
- Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
- return;
- }
- storage = cdb->GetStorage(Storage.Data());
- if(!storage){
- Error(macroname,"Unable to open storage %s\n",Storage.Data());
- return;
- }
- AliCDBPath path("GRP","Geometry","Data");
- AliCDBEntry *entry = storage->Get(path.GetPath(),cdb->GetRun());
- if(!entry) Fatal(macroname,"Could not get the specified CDB entry!");
- entry->SetOwner(0);
- TGeoManager* geom = (TGeoManager*) entry->GetObject();
- AliGeomManager::SetGeometry(geom);
- }else{
- AliGeomManager::LoadGeometry("geometry.root"); //load geom from default CDB storage
- }
-
- Int_t j = 0;
-
- //=****************************************
- // overall ITS misalignment according to survey as reported by Werner Riegler (18/07/2008)
- //=****************************************
- Float_t its_dx = -0.12;
- Float_t its_dy = -0.07;
- Float_t its_dz = 0.29;
- Float_t its_dpsi = 0.;
- Float_t its_dtheta = 0.03;
- Float_t its_dphi = 0.04;
-
- new(alobj[j++]) AliAlignObjParams("ITS", 0, its_dx, its_dy, its_dz, its_dpsi, its_dtheta, its_dphi, kTRUE);
-
- Double_t dx=0., dy=0., dz=0., dpsi=0., dtheta=0., dphi=0., globalZ=0.;
-
- for ( Int_t iLayer = AliGeomManager::kSPD1; iLayer <= AliGeomManager::kSSD2; iLayer++) {
-
- printf("%i modules in layer %i\n", AliGeomManager::LayerSize(iLayer), iLayer);
- for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer); iModule++) {
-
- UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
- const char *symname = AliGeomManager::SymName(volid);
-
- new(alobj[j++]) AliAlignObjParams(symname, volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
-
- }
- }
-
- if( TString(gSystem->Getenv("TOCDB")) != TString("kTRUE") ){
- // save on file
- const char* filename = "ITSzeroMisalignment.root";
- TFile f(filename,"RECREATE");
- if(!f){
- Error(macroname,"cannot open file for output\n");
- return;
- }
- Info(macroname,"Saving alignment objects to the file %s", filename);
- f.cd();
- f.WriteObject(array,"ITSAlignObjs","kSingleKey");
- f.Close();
- }else{
- // save in CDB storage
- Info(macroname,"Saving alignment objects in CDB storage %s", Storage.Data());
- AliCDBMetaData *md= new AliCDBMetaData();
- md->SetResponsible("Ludovic Gaudichet");
- md->SetComment("Alignment objects with zero ITS misalignment");
- md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
- AliCDBId id("ITS/Align/Data",0,AliCDBRunRange::Infinity());
- storage->Put(array,id, md);
- }
-
- array->Delete();
-
-}
-
-
AliITSMap.cxx \
AliITSMapA1.cxx \
AliITSMapA2.cxx \
- AliITSMisalignMaker.cxx \
+ AliITSMisAligner.cxx \
AliITSpList.cxx \
AliITSpListItem.cxx \
AliITSsegmentation.cxx \
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff