From edccc22d0dd77d5ec90dcf3f788d4c11bcd73700 Mon Sep 17 00:00:00 2001 From: masera Date: Tue, 7 Apr 2009 16:26:53 +0000 Subject: [PATCH] New AliITSMisAligner class. It replaces MakeITS...MisAlignment.C macros and class AliITSMisalignMaker (R. Grosso) --- ITS/AliITSMisAligner.cxx | 1074 +++++++++++++++++++++++++++++++++ ITS/AliITSMisAligner.h | 229 +++++++ ITS/AliITSMisalignMaker.cxx | 526 ---------------- ITS/AliITSMisalignMaker.h | 95 --- ITS/CMake_libITSbase.txt | 2 +- ITS/ITSbaseLinkDef.h | 2 +- ITS/MakeITSFullMisAlignment.C | 404 ------------- ITS/MakeITSResMisAlignment.C | 307 ---------- ITS/MakeITSZeroMisAlignment.C | 92 --- ITS/libITSbase.pkg | 2 +- 10 files changed, 1306 insertions(+), 1427 deletions(-) create mode 100644 ITS/AliITSMisAligner.cxx create mode 100644 ITS/AliITSMisAligner.h delete mode 100644 ITS/AliITSMisalignMaker.cxx delete mode 100644 ITS/AliITSMisalignMaker.h delete mode 100644 ITS/MakeITSFullMisAlignment.C delete mode 100644 ITS/MakeITSResMisAlignment.C delete mode 100644 ITS/MakeITSZeroMisAlignment.C diff --git a/ITS/AliITSMisAligner.cxx b/ITS/AliITSMisAligner.cxx new file mode 100644 index 00000000000..0f7ab7a73f9 --- /dev/null +++ b/ITS/AliITSMisAligner.cxx @@ -0,0 +1,1074 @@ +/************************************************************************** + * 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 +#include +#include +#include +#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 (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; iiGetEntriesFast(); ii++) + { + AliAlignObjParams* aop = dynamic_cast (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; iiGetEntriesFast(); ii++) + { + AliAlignObjParams* aop = dynamic_cast (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; iLadd1) { + 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; iSectUncheckedAt(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; +} +*/ diff --git a/ITS/AliITSMisAligner.h b/ITS/AliITSMisAligner.h new file mode 100644 index 00000000000..098d3e70cf7 --- /dev/null +++ b/ITS/AliITSMisAligner.h @@ -0,0 +1,229 @@ +#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 +#include "AliMisAligner.h" +#include + +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 diff --git a/ITS/AliITSMisalignMaker.cxx b/ITS/AliITSMisalignMaker.cxx deleted file mode 100644 index 370af324489..00000000000 --- a/ITS/AliITSMisalignMaker.cxx +++ /dev/null @@ -1,526 +0,0 @@ -/************************************************************************** - * 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 -#include -#include - - -#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; iLadd1) { - 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; iSectApplyToGeometry(); - 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; -} -*/ - diff --git a/ITS/AliITSMisalignMaker.h b/ITS/AliITSMisalignMaker.h deleted file mode 100644 index 4aaf3225e58..00000000000 --- a/ITS/AliITSMisalignMaker.h +++ /dev/null @@ -1,95 +0,0 @@ -#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 -#include -#include - - -//------------------------------------------------------------------------- -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 diff --git a/ITS/CMake_libITSbase.txt b/ITS/CMake_libITSbase.txt index fefa3a840e6..9853d12b4cd 100644 --- a/ITS/CMake_libITSbase.txt +++ b/ITS/CMake_libITSbase.txt @@ -18,7 +18,7 @@ set(SRCS AliITSMap.cxx AliITSMapA1.cxx AliITSMapA2.cxx - AliITSMisalignMaker.cxx + AliITSMisAligner.cxx AliITSpList.cxx AliITSpListItem.cxx AliITSsegmentation.cxx diff --git a/ITS/ITSbaseLinkDef.h b/ITS/ITSbaseLinkDef.h index ce5430fa959..4ed30c2b995 100644 --- a/ITS/ITSbaseLinkDef.h +++ b/ITS/ITSbaseLinkDef.h @@ -40,7 +40,7 @@ #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+; diff --git a/ITS/MakeITSFullMisAlignment.C b/ITS/MakeITSFullMisAlignment.C deleted file mode 100644 index 65b7eeb747d..00000000000 --- a/ITS/MakeITSFullMisAlignment.C +++ /dev/null @@ -1,404 +0,0 @@ -#if !defined(__CINT__) || defined(__MAKECINT__) -#include -#include -#include -#include -#include -#include -#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; -} - diff --git a/ITS/MakeITSResMisAlignment.C b/ITS/MakeITSResMisAlignment.C deleted file mode 100644 index 69752558e47..00000000000 --- a/ITS/MakeITSResMisAlignment.C +++ /dev/null @@ -1,307 +0,0 @@ -#if !defined(__CINT__) || defined(__MAKECINT__) -#include -#include -#include -#include -#include -#include -#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; -} - diff --git a/ITS/MakeITSZeroMisAlignment.C b/ITS/MakeITSZeroMisAlignment.C deleted file mode 100644 index d61b64eef76..00000000000 --- a/ITS/MakeITSZeroMisAlignment.C +++ /dev/null @@ -1,92 +0,0 @@ -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(); - -} - - diff --git a/ITS/libITSbase.pkg b/ITS/libITSbase.pkg index 508063986ad..67b69ab38b5 100644 --- a/ITS/libITSbase.pkg +++ b/ITS/libITSbase.pkg @@ -17,7 +17,7 @@ SRCS = AliITSgeom.cxx \ AliITSMap.cxx \ AliITSMapA1.cxx \ AliITSMapA2.cxx \ - AliITSMisalignMaker.cxx \ + AliITSMisAligner.cxx \ AliITSpList.cxx \ AliITSpListItem.cxx \ AliITSsegmentation.cxx \ -- 2.43.0