--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/* $Id$ */
+
+//========================================================================
+//
+// This class is a helper, producing ITS aligmnent objects.
+// It provides also some useful functions
+// See the parameters of the misalignment at the end of this script.
+//
+// Main author: L. Gaudichet
+// Contact: andrea.dainese@lnl.infn.it
+//
+//========================================================================
+
+#include <TRandom3.h>
+#include <TClonesArray.h>
+#include <TMath.h>
+
+
+#include "AliLog.h"
+#include "AliAlignObjParams.h"
+#include "AliITSMisalignMaker.h"
+
+
+ClassImp(AliITSMisalignMaker)
+
+const Int_t AliITSMisalignMaker::fgkNLadders[AliITSMisalignMaker::kNLayers] = {20,40,14,22,34,38};
+const Int_t AliITSMisalignMaker::fgkNDetectors[AliITSMisalignMaker::kNLayers] = {4,4,6,8,22,25};
+
+
+//________________________________________________________________________
+AliITSMisalignMaker::AliITSMisalignMaker():
+ fRnd(),
+ fInd(0),
+ fAlobj(TClonesArray("AliAlignObjParams",4000)),
+ fStrSPD("ITS/SPD"),
+ fStrSDD("ITS/SDD"),
+ fStrSSD("ITS/SSD"),
+ fStrStave("/Stave"),
+ fStrHalfStave("/HalfStave"),
+ fStrLadder("/Ladder"),
+ fStrSector("/Sector"),
+ fStrSensor("/Sensor")
+{
+ fRnd.SetSeed(23472341);
+}
+//________________________________________________________________________
+Int_t AliITSMisalignMaker::AddAlignObj(char* name,Double_t dx,Double_t dy,Double_t dz,
+ Double_t dpsi,Double_t dtheta,Double_t dphi,Bool_t unif) {
+
+ 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);
+ }
+
+ new(fAlobj[fInd]) AliAlignObjParams(name,0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
+
+ AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
+ its_alobj->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
+
+ Int_t nLadd = fgkNLadders[lay];
+ Int_t nMod = fgkNDetectors[lay];
+
+ for (Int_t iLadd=0; iLadd<nLadd; iLadd++) {
+ for (Int_t iMod=0; iMod<nMod; iMod++) {
+
+ 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);
+ }
+
+ TString name = GetSymbName(lay,iLadd,iMod);
+ new(fAlobj[fInd]) AliAlignObjParams(name.Data(),0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
+ AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
+ its_alobj->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,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;
+
+ Int_t laddMin = ladd;
+ Int_t laddMax = laddMin+1;
+ if (ladd<0) {
+ laddMin = 0;
+ laddMax = fgkNLadders[lay];
+ }
+
+ for (Int_t iLadd=laddMin; iLadd<laddMax; iLadd++) {
+
+ Int_t nHS = 1;
+ if (lay<2) nHS = 2;
+ for (Int_t iHalfStave=0; iHalfStave<nHS; iHalfStave++) {
+
+ if(!unif) {
+ vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
+ vy = GaussCut(0,dy/3.,dy);
+ vz = GaussCut(0,dz/3.,dz);
+ vpsi = GaussCut(0,dpsi/3., dpsi );
+ vtheta = GaussCut(0,dtheta/3.,dtheta);
+ vphi = GaussCut(0,dphi/3., dphi);
+ } else {
+ vx = fRnd.Uniform(-dx,dx);
+ vy = fRnd.Uniform(-dy,dy);
+ vz = fRnd.Uniform(-dz,dz);
+ vpsi = fRnd.Uniform(-dpsi,dpsi);
+ vtheta = fRnd.Uniform(-dtheta,dtheta);
+ vphi = fRnd.Uniform(-dphi,dphi);
+ }
+
+ TString name = GetHalfStaveLadderSymbName(lay,iLadd,iHalfStave);
+ new(fAlobj[fInd]) AliAlignObjParams(name.Data(),0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
+ AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
+ its_alobj->ApplyToGeometry();
+ fInd++;
+ }
+ }
+
+ return kTRUE;
+}
+
+
+//________________________________________________________________________
+Int_t AliITSMisalignMaker::AddSectorAlignObj(Int_t sectMin,Int_t sectMax,
+ Double_t dx,Double_t dy,Double_t dz,
+ Double_t dpsi,Double_t dtheta,Double_t dphi,
+ Double_t xShift,Double_t yShift,Double_t zShift,
+ Double_t psiShift,Double_t thetaShift,Double_t phiShift,Bool_t unif) {
+
+ // misalignment at the level of SPD sectors and half-barrels
+
+ if ((sectMin<1) || (sectMax>10)) return kFALSE;
+ Double_t vx,vy,vz,vpsi,vtheta,vphi;
+ Double_t tr[3],rot[3];
+
+ for (Int_t iSect = sectMin-1; iSect<sectMax; iSect++) {
+
+ // first, apply sector level misalignment
+ if(!unif) {
+ vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
+ vy = GaussCut(0,dy/3.,dy);
+ vz = GaussCut(0,dz/3.,dz);
+ vpsi = GaussCut(0,dpsi/3., dpsi );
+ vtheta = GaussCut(0,dtheta/3.,dtheta);
+ vphi = GaussCut(0,dphi/3., dphi);
+ } else {
+ vx = fRnd.Uniform(-dx,dx);
+ vy = fRnd.Uniform(-dy,dy);
+ vz = fRnd.Uniform(-dz,dz);
+ vpsi = fRnd.Uniform(-dpsi,dpsi);
+ vtheta = fRnd.Uniform(-dtheta,dtheta);
+ vphi = fRnd.Uniform(-dphi,dphi);
+ }
+
+ TString name = GetSymbName(0);
+ name += fStrSector;
+ name += iSect;
+
+
+ AliAlignObjParams aaop(name.Data(),0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE); // set them as local
+ aaop.GetPars(tr,rot); // global
+
+ // then, apply half-barrel level misalignment
+ tr[0] += xShift;
+ tr[1] += yShift;
+ tr[2] += zShift;
+ rot[0] += psiShift;
+ rot[1] += thetaShift;
+ rot[2] += phiShift;
+
+ new(fAlobj[fInd]) AliAlignObjParams(name.Data(),0,tr[0],tr[1],tr[2],rot[0],rot[1],rot[2],kTRUE); // set them as global
+
+ AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
+ its_alobj->ApplyToGeometry();
+ fInd++;
+ }
+ return kTRUE;
+}
+
+//________________________________________________________________________
+Double_t AliITSMisalignMaker::GaussCut(Double_t mean,Double_t sigma,Double_t absMax) {
+
+ Double_t val = fRnd.Gaus(mean,sigma);
+ while (TMath::Abs(val)>absMax)
+ val = fRnd.Gaus(mean,sigma);
+ return val;
+}
+
+//________________________________________________________________________
+TString 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;
+}
+
+//________________________________________________________________________
+TString 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;
+}
+
+//________________________________________________________________________
+TString 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;
+}
+
+//________________________________________________________________________
+TString AliITSMisalignMaker::GetSymbName(Int_t layer,Int_t ladd,Int_t mod) const {
+
+ // Get logical names at the level of SPD ladders / SDD and SSD modules
+
+ Int_t halfStave = mod/2;
+ TString name = GetHalfStaveLadderSymbName(layer,ladd,halfStave);
+
+ if (layer<2) { // SPD
+ name += fStrLadder;
+ name += mod;
+ }
+ else if (layer>=2 && layer<=5) { // SDD and SSD
+ name += fStrSensor;
+ name += mod;
+ }
+ else {
+ AliFatal("Wrong layer index");
+ }
+ return name;
+}
--- /dev/null
+#ifndef ALIITSMISALIGNMAKER_H
+#define ALIITSMISALIGNMAKER_H
+/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+//------------------------------------------------------------------------
+//
+// This class is a helper, producing ITS aligmnent objects.
+// It provides also some useful functions
+// See the parameters of the misalignment at the end of this script.
+//
+// Main author: L. Gaudichet
+// Contact: andrea.dainese@lnl.infn.it
+//
+//------------------------------------------------------------------------
+
+#include <TRandom3.h>
+#include <TString.h>
+#include <TClonesArray.h>
+
+
+//-------------------------------------------------------------------------
+class AliITSMisalignMaker : public TObject {
+
+public:
+ AliITSMisalignMaker();
+
+ ~AliITSMisalignMaker() {};
+
+ TClonesArray* GetArray() {return &fAlobj;}
+
+ void SetSeed(Int_t seed) {fRnd.SetSeed(seed); return;}
+
+ Int_t AddAlignObj(char* name,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,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,
+ 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);
+
+ TString GetSymbName(Int_t layer) const;
+ TString GetSymbName(Int_t layer,Int_t ladd) const;
+ TString GetHalfStaveLadderSymbName(Int_t layer,Int_t ladd,Int_t halfStave) const;
+ TString GetSymbName(Int_t layer,Int_t ladd,Int_t mod) const;
+ Double_t GaussCut(Double_t mean,Double_t sigma,Double_t cutn);
+
+ 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];}
+
+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
+
--- /dev/null
+#if !defined(__CINT__) || defined(__MAKECINT__)
+#include <TCanvas.h>
+#include <TClonesArray.h>
+#include <TFile.h>
+#include <TGeoManager.h>
+#include <TH1F.h>
+#include <TString.h>
+#include <Riostream.h>
+#include "AliAlignObj.h"
+#endif
+void DrawITSAlignObj(const char* filename="ITSrealisticMisalignment.root",
+ Bool_t local=kTRUE) {
+ //
+ // Draw distribution of alignment constants
+ // (original version: A.Jacholkowski; modified by: A.Dainese)
+ //
+
+/* $Id$ */
+
+ TGeoManager::Import("geometry.root");
+
+ TFile* f = TFile::Open(filename);
+ if(!f) {cerr<<"cannot open input file\n"; return;}
+
+ TCanvas *cSPDsector = new TCanvas("cSPDsector","SPD sectors alignobjs",0,0,800,600);
+ cSPDsector->Divide(3,2);
+ TH1F* hxSPDsector = new TH1F("hxSPDsector","x in SPD sectors",100,-0.1,0.1);
+ hxSPDsector->SetXTitle("[cm]");
+ TH1F* hySPDsector = new TH1F("hySPDsector","y in SPD sectors",100,-0.1,0.1);
+ hySPDsector->SetXTitle("[cm]");
+ TH1F* hzSPDsector = new TH1F("hzSPDsector","z in SPD sectors",100,-0.1,0.1);
+ hzSPDsector->SetXTitle("[cm]");
+ TH1F* hrxSPDsector = new TH1F("hrxSPDsector","rx in SPD sectors",100,-0.5,0.5);
+ hrxSPDsector->SetXTitle("[deg]");
+ TH1F* hrySPDsector = new TH1F("hrySPDsector","ry in SPD sectors",100,-0.5,0.5);
+ hrySPDsector->SetXTitle("[deg]");
+ TH1F* hrzSPDsector = new TH1F("hrzSPDsector","rz in SPD sectors",100,-0.5,0.5);
+ hrzSPDsector->SetXTitle("[deg]");
+
+ TCanvas *cSPDhalfstave = new TCanvas("cSPDhalfstave","SPD halfstaves alignobjs",0,0,800,600);
+ cSPDhalfstave->Divide(3,2);
+ TH1F* hxSPDhalfstave = new TH1F("hxSPDhalfstave","x in SPD halfstaves",100,-0.01,0.01);
+ hxSPDhalfstave->SetXTitle("[cm]");
+ TH1F* hySPDhalfstave = new TH1F("hySPDhalfstave","y in SPD halfstaves",100,-0.01,0.01);
+ hySPDhalfstave->SetXTitle("[cm]");
+ TH1F* hzSPDhalfstave = new TH1F("hzSPDhalfstave","z in SPD halfstaves",100,-0.01,0.01);
+ hzSPDhalfstave->SetXTitle("[cm]");
+ TH1F* hrxSPDhalfstave = new TH1F("hrxSPDhalfstave","rx in SPD halfstaves",100,-0.1,0.1);
+ hrxSPDhalfstave->SetXTitle("[deg]");
+ TH1F* hrySPDhalfstave = new TH1F("hrySPDhalfstave","ry in SPD halfstaves",100,-0.1,0.1);
+ hrySPDhalfstave->SetXTitle("[deg]");
+ TH1F* hrzSPDhalfstave = new TH1F("hrzSPDhalfstave","rz in SPD halfstaves",100,-0.5,0.5);
+ hrzSPDhalfstave->SetXTitle("[deg]");
+
+ TCanvas *cSPDladder = new TCanvas("cSPDladder","SPD ladders alignobjs",0,0,800,600);
+ cSPDladder->Divide(3,2);
+ TH1F* hxSPDladder = new TH1F("hxSPDladder","x in SPD ladders",100,-0.01,0.01);
+ hxSPDladder->SetXTitle("[cm]");
+ TH1F* hySPDladder = new TH1F("hySPDladder","y in SPD ladders",100,-0.01,0.01);
+ hySPDladder->SetXTitle("[cm]");
+ TH1F* hzSPDladder = new TH1F("hzSPDladder","z in SPD ladders",100,-0.01,0.01);
+ hzSPDladder->SetXTitle("[cm]");
+ TH1F* hrxSPDladder = new TH1F("hrxSPDladder","rx in SPD ladders",100,-0.01,0.01);
+ hrxSPDladder->SetXTitle("[deg]");
+ TH1F* hrySPDladder = new TH1F("hrySPDladder","ry in SPD ladders",100,-0.01,0.01);
+ hrySPDladder->SetXTitle("[deg]");
+ TH1F* hrzSPDladder = new TH1F("hrzSPDladder","rz in SPD ladders",100,-0.01,0.01);
+ hrzSPDladder->SetXTitle("[deg]");
+
+ TCanvas *cSDDladder = new TCanvas("cSDDladder","SDD ladders alignobjs",0,0,800,600);
+ cSDDladder->Divide(3,2);
+ TH1F* hxSDDladder = new TH1F("hxSDDladder","x in SDD ladders",100,-0.01,0.01);
+ hxSDDladder->SetXTitle("[cm]");
+ TH1F* hySDDladder = new TH1F("hySDDladder","y in SDD ladders",100,-0.01,0.01);
+ hySDDladder->SetXTitle("[cm]");
+ TH1F* hzSDDladder = new TH1F("hzSDDladder","z in SDD ladders",100,-0.01,0.01);
+ hzSDDladder->SetXTitle("[cm]");
+ TH1F* hrxSDDladder = new TH1F("hrxSDDladder","rx in SDD ladders",100,-0.01,0.01);
+ hrxSDDladder->SetXTitle("[deg]");
+ TH1F* hrySDDladder = new TH1F("hrySDDladder","ry in SDD ladders",100,-0.01,0.01);
+ hrySDDladder->SetXTitle("[deg]");
+ TH1F* hrzSDDladder = new TH1F("hrzSDDladder","rz in SDD ladders",100,-0.01,0.01);
+ hrzSDDladder->SetXTitle("[deg]");
+
+ TCanvas *cSDDsensor = new TCanvas("cSDDsensor","SDD sensors alignobjs",0,0,800,600);
+ cSDDsensor->Divide(3,2);
+ TH1F* hxSDDsensor = new TH1F("hxSDDsensor","x in SDD sensors",100,-0.01,0.01);
+ hxSDDsensor->SetXTitle("[cm]");
+ TH1F* hySDDsensor = new TH1F("hySDDsensor","y in SDD sensors",100,-0.01,0.01);
+ hySDDsensor->SetXTitle("[cm]");
+ TH1F* hzSDDsensor = new TH1F("hzSDDsensor","z in SDD sensors",100,-0.01,0.01);
+ hzSDDsensor->SetXTitle("[cm]");
+ TH1F* hrxSDDsensor = new TH1F("hrxSDDsensor","rx in SDD sensors",100,-0.01,0.01);
+ hrxSDDsensor->SetXTitle("[deg]");
+ TH1F* hrySDDsensor = new TH1F("hrySDDsensor","ry in SDD sensors",100,-0.01,0.01);
+ hrySDDsensor->SetXTitle("[deg]");
+ TH1F* hrzSDDsensor = new TH1F("hrzSDDsensor","rz in SDD sensors",100,-0.01,0.01);
+ hrzSDDsensor->SetXTitle("[deg]");
+
+
+ TCanvas *cSSDladder = new TCanvas("cSSDladder","SSD ladders alignobjs",0,0,800,600);
+ cSSDladder->Divide(3,2);
+ TH1F* hxSSDladder = new TH1F("hxSSDladder","x in SSD ladders",100,-0.01,0.01);
+ hxSSDladder->SetXTitle("[cm]");
+ TH1F* hySSDladder = new TH1F("hySSDladder","y in SSD ladders",100,-0.01,0.01);
+ hySSDladder->SetXTitle("[cm]");
+ TH1F* hzSSDladder = new TH1F("hzSSDladder","z in SSD ladders",100,-0.01,0.01);
+ hzSSDladder->SetXTitle("[cm]");
+ TH1F* hrxSSDladder = new TH1F("hrxSSDladder","rx in SSD ladders",100,-0.01,0.01);
+ hrxSSDladder->SetXTitle("[deg]");
+ TH1F* hrySSDladder = new TH1F("hrySSDladder","ry in SSD ladders",100,-0.01,0.01);
+ hrySSDladder->SetXTitle("[deg]");
+ TH1F* hrzSSDladder = new TH1F("hrzSSDladder","rz in SSD ladders",100,-0.01,0.01);
+ hrzSSDladder->SetXTitle("[deg]");
+
+ TCanvas *cSSDsensor = new TCanvas("cSSDsensor","SSD sensors alignobjs",0,0,800,600);
+ cSSDsensor->Divide(3,2);
+ TH1F* hxSSDsensor = new TH1F("hxSSDsensor","x in SSD sensors",100,-0.01,0.01);
+ hxSSDsensor->SetXTitle("[cm]");
+ TH1F* hySSDsensor = new TH1F("hySSDsensor","y in SSD sensors",100,-0.01,0.01);
+ hySSDsensor->SetXTitle("[cm]");
+ TH1F* hzSSDsensor = new TH1F("hzSSDsensor","z in SSD sensors",100,-0.01,0.01);
+ hzSSDsensor->SetXTitle("[cm]");
+ TH1F* hrxSSDsensor = new TH1F("hrxSSDsensor","rx in SSD sensors",100,-0.01,0.01);
+ hrxSSDsensor->SetXTitle("[deg]");
+ TH1F* hrySSDsensor = new TH1F("hrySSDsensor","ry in SSD sensors",100,-0.01,0.01);
+ hrySSDsensor->SetXTitle("[deg]");
+ TH1F* hrzSSDsensor = new TH1F("hrzSSDsensor","rz in SSD sensors",100,-0.01,0.01);
+ hrzSSDsensor->SetXTitle("[deg]");
+
+
+
+ TClonesArray* ar = (TClonesArray*)f->Get("ITSAlignObjs");
+ Int_t entries = ar->GetEntriesFast();
+ cout<<"number of alignment objects: "<<entries<<endl;
+
+ AliAlignObj* a;
+ Option_t *opt = NULL;
+ Double_t tr[3];
+ Double_t rot[3];
+
+ for(Int_t i=0; i<entries; i++){
+ a=(AliAlignObj*)ar->UncheckedAt(i);
+ if(local) {
+ a->GetLocalPars(tr,rot);
+ } else {
+ a->GetPars(tr,rot);
+ }
+ TString symName = a->GetSymName();
+ printf(" %s\n",symName.Data());
+ if(!symName.Contains("SPD") && !symName.Contains("SDD") && !symName.Contains("SSD")) {
+ a->Print(opt);
+ }
+ if(symName.Contains("SPD") && symName.Contains("Sector") && !symName.Contains("HalfStave")) {
+ hxSPDsector->Fill(tr[0]);
+ hySPDsector->Fill(tr[1]);
+ hzSPDsector->Fill(tr[2]);
+ hrxSPDsector->Fill(rot[0]);
+ hrySPDsector->Fill(rot[1]);
+ hrzSPDsector->Fill(rot[2]); printf("%f\n",rot[2]);
+ }
+ if(symName.Contains("SPD") && symName.Contains("Sector") && symName.Contains("HalfStave") && !symName.Contains("Ladder")) {
+ hxSPDhalfstave->Fill(tr[0]);
+ hySPDhalfstave->Fill(tr[1]);
+ hzSPDhalfstave->Fill(tr[2]);
+ hrxSPDhalfstave->Fill(rot[0]);
+ hrySPDhalfstave->Fill(rot[1]);
+ hrzSPDhalfstave->Fill(rot[2]);
+ }
+ if(symName.Contains("SPD") && symName.Contains("Sector") && symName.Contains("HalfStave") && symName.Contains("Ladder")) {
+ hxSPDladder->Fill(tr[0]);
+ hySPDladder->Fill(tr[1]);
+ hzSPDladder->Fill(tr[2]);
+ hrxSPDladder->Fill(rot[0]);
+ hrySPDladder->Fill(rot[1]);
+ hrzSPDladder->Fill(rot[2]);
+ }
+ if(symName.Contains("SDD") && symName.Contains("Ladder") && !symName.Contains("Sensor")) {
+ hxSDDladder->Fill(tr[0]);
+ hySDDladder->Fill(tr[1]);
+ hzSDDladder->Fill(tr[2]);
+ hrxSDDladder->Fill(rot[0]);
+ hrySDDladder->Fill(rot[1]);
+ hrzSDDladder->Fill(rot[2]);
+ }
+ if(symName.Contains("SDD") && symName.Contains("Ladder") && symName.Contains("Sensor")) {
+ hxSDDsensor->Fill(tr[0]);
+ hySDDsensor->Fill(tr[1]);
+ hzSDDsensor->Fill(tr[2]);
+ hrxSDDsensor->Fill(rot[0]);
+ hrySDDsensor->Fill(rot[1]);
+ hrzSDDsensor->Fill(rot[2]);
+ }
+ if(symName.Contains("SSD") && symName.Contains("Ladder") && !symName.Contains("Sensor")) {
+ hxSSDladder->Fill(tr[0]);
+ hySSDladder->Fill(tr[1]);
+ hzSSDladder->Fill(tr[2]);
+ hrxSSDladder->Fill(rot[0]);
+ hrySSDladder->Fill(rot[1]);
+ hrzSSDladder->Fill(rot[2]);
+ }
+ if(symName.Contains("SSD") && symName.Contains("Ladder") && symName.Contains("Sensor")) {
+ hxSSDsensor->Fill(tr[0]);
+ hySSDsensor->Fill(tr[1]);
+ hzSSDsensor->Fill(tr[2]);
+ hrxSSDsensor->Fill(rot[0]);
+ hrySSDsensor->Fill(rot[1]);
+ hrzSSDsensor->Fill(rot[2]);
+ }
+
+
+ }
+
+
+ cSPDsector->cd(1);
+ hxSPDsector->Draw();
+ cSPDsector->cd(2);
+ hySPDsector->Draw();
+ cSPDsector->cd(3);
+ hzSPDsector->Draw();
+ cSPDsector->cd(4);
+ hrxSPDsector->Draw();
+ cSPDsector->cd(5);
+ hrySPDsector->Draw();
+ cSPDsector->cd(6);
+ hrzSPDsector->Draw();
+
+ cSPDhalfstave->cd(1);
+ hxSPDhalfstave->Draw();
+ cSPDhalfstave->cd(2);
+ hySPDhalfstave->Draw();
+ cSPDhalfstave->cd(3);
+ hzSPDhalfstave->Draw();
+ cSPDhalfstave->cd(4);
+ hrxSPDhalfstave->Draw();
+ cSPDhalfstave->cd(5);
+ hrySPDhalfstave->Draw();
+ cSPDhalfstave->cd(6);
+ hrzSPDhalfstave->Draw();
+
+ cSPDladder->cd(1);
+ hxSPDladder->Draw();
+ cSPDladder->cd(2);
+ hySPDladder->Draw();
+ cSPDladder->cd(3);
+ hzSPDladder->Draw();
+ cSPDladder->cd(4);
+ hrxSPDladder->Draw();
+ cSPDladder->cd(5);
+ hrySPDladder->Draw();
+ cSPDladder->cd(6);
+ hrzSPDladder->Draw();
+
+
+ cSDDladder->cd(1);
+ hxSDDladder->Draw();
+ cSDDladder->cd(2);
+ hySDDladder->Draw();
+ cSDDladder->cd(3);
+ hzSDDladder->Draw();
+ cSDDladder->cd(4);
+ hrxSDDladder->Draw();
+ cSDDladder->cd(5);
+ hrySDDladder->Draw();
+ cSDDladder->cd(6);
+ hrzSDDladder->Draw();
+
+ cSDDsensor->cd(1);
+ hxSDDsensor->Draw();
+ cSDDsensor->cd(2);
+ hySDDsensor->Draw();
+ cSDDsensor->cd(3);
+ hzSDDsensor->Draw();
+ cSDDsensor->cd(4);
+ hrxSDDsensor->Draw();
+ cSDDsensor->cd(5);
+ hrySDDsensor->Draw();
+ cSDDsensor->cd(6);
+ hrzSDDsensor->Draw();
+
+ cSSDladder->cd(1);
+ hxSSDladder->Draw();
+ cSSDladder->cd(2);
+ hySSDladder->Draw();
+ cSSDladder->cd(3);
+ hzSSDladder->Draw();
+ cSSDladder->cd(4);
+ hrxSSDladder->Draw();
+ cSSDladder->cd(5);
+ hrySSDladder->Draw();
+ cSSDladder->cd(6);
+ hrzSSDladder->Draw();
+
+ cSSDsensor->cd(1);
+ hxSSDsensor->Draw();
+ cSSDsensor->cd(2);
+ hySSDsensor->Draw();
+ cSSDsensor->cd(3);
+ hzSSDsensor->Draw();
+ cSSDsensor->cd(4);
+ hrxSSDsensor->Draw();
+ cSSDsensor->cd(5);
+ hrySSDsensor->Draw();
+ cSSDsensor->cd(6);
+ hrzSSDsensor->Draw();
+
+ return;
+}
#pragma link C++ class AliITSMap+;
#pragma link C++ class AliITSMapA1+;
#pragma link C++ class AliITSMapA2+;
+#pragma link C++ class AliITSMisalignMaker+;
#pragma link C++ class AliITSsegmentation+;
#pragma link C++ class AliITSsegmentationSPD+;
#pragma link C++ class AliITSsegmentationSDD+;
--- /dev/null
+#if !defined(__CINT__) || defined(__MAKECINT__)
+#include <TError.h>
+#include <TFile.h>
+#include <TGeoManager.h>
+#include <TMath.h>
+#include <TString.h>
+#include <TSystem.h>
+#include "AliCDBPath.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
+#include "AliGeomManager.h"
+#include "AliITSMisalignMaker.h"
+#endif
+void MakeITSRealisticMisAlignment() {
+//========================================================================
+//
+// Steering macro for ITS realistic misalignment
+//
+// Main author: L. Gaudichet
+// Contact: andrea.dainese@lnl.infn.it
+//
+//========================================================================
+
+/* $Id$ */
+
+ const char* macroname = "MakeITSRealisticMisAlignment.C";
+
+ // Activate CDB storage and load geometry from CDB
+ AliCDBManager* cdb = AliCDBManager::Instance();
+ if(!cdb->IsDefaultStorageSet()) cdb->SetDefaultStorage("local://$ALICE_ROOT");
+ cdb->SetRun(0);
+
+ AliCDBStorage* storage = NULL;
+
+
+ if(gSystem->Getenv("TOCDB")){
+ 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();
+
+
+ //=****************************************
+ // overall ITS misalignment : source -
+ //=****************************************
+ Float_t its_dx = 0.0000; // ?
+ Float_t its_dy = 0.0000; // ?
+ Float_t its_dz = 0.0000; // ?
+ Float_t its_dpsi = 0.0000; // ?
+ Float_t its_dtheta = 0.0000; // ?
+ Float_t its_dphi = 0.0000; // ?
+
+ //=****************************************
+ // 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
+ //=****************************************
+ /*
+ 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.0020; // 20 micron
+ Float_t spdhalfstave_dy = 0.0100; // 100 micron
+ Float_t spdhalfstave_dz = 0.0020; // 20 micron
+ Float_t spdhalfstave_dpsi = 0.0050/7.*kRadToDeg; // so as to have 50 micron difference at the two extremes
+ Float_t spdhalfstave_dtheta = 0.0020/7.*kRadToDeg; // so as to have 20 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.0050; // 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,kFALSE);
+
+
+ //=****************************************
+ // 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 = alignMaker.GaussCut(0, spdbarrel_dx/3, spdbarrel_dx);
+ vybarrel = alignMaker.GaussCut(0, spdbarrel_dy/3, spdbarrel_dy);
+ vzbarrel = alignMaker.GaussCut(0, spdbarrel_dz/3, spdbarrel_dz);
+ vpsibarrel = alignMaker.GaussCut(0, spdbarrel_dpsi/3, spdbarrel_dpsi);
+ vthetabarrel = alignMaker.GaussCut(0, spdbarrel_dtheta/3, spdbarrel_dtheta);
+ vphibarrel = alignMaker.GaussCut(0, spdbarrel_dphi/3, spdbarrel_dphi);
+
+ // top half-barrel
+ vx = alignMaker.GaussCut(0, spdhalfbarrel_dx/3, spdhalfbarrel_dx);
+ vy = alignMaker.GaussCut(0, spdhalfbarrel_dy/3, spdhalfbarrel_dy);
+ vz = alignMaker.GaussCut(0, spdhalfbarrel_dz/3, spdhalfbarrel_dz);
+ vpsi = alignMaker.GaussCut(0, spdhalfbarrel_dpsi/3, spdhalfbarrel_dpsi);
+ vtheta = alignMaker.GaussCut(0, spdhalfbarrel_dtheta/3, spdhalfbarrel_dtheta);
+ vphi = alignMaker.GaussCut(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 = alignMaker.GaussCut(0, spdhalfbarrel_dx/3, spdhalfbarrel_dx);
+ vy = alignMaker.GaussCut(0, spdhalfbarrel_dy/3, spdhalfbarrel_dy);
+ vz = alignMaker.GaussCut(0, spdhalfbarrel_dz/3, spdhalfbarrel_dz);
+ vpsi = alignMaker.GaussCut(0, spdhalfbarrel_dpsi/3, spdhalfbarrel_dpsi);
+ vtheta = alignMaker.GaussCut(0, spdhalfbarrel_dtheta/3, spdhalfbarrel_dtheta);
+ vphi = alignMaker.GaussCut(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 SDD and SSD layers
+ //=****************************************
+ /* alignMaker.AddAlignObj("ITS/SDD2", sddlayer_dx,sddlayer_dy,sddlayer_dz, sddlayer_dpsi,sddlayer_dtheta,sddlayer_dphi);
+ alignMaker.AddAlignObj("ITS/SDD3", sddlayer_dx,sddlayer_dy,sddlayer_dz, sddlayer_dpsi,sddlayer_dtheta,sddlayer_dphi);
+ alignMaker.AddAlignObj("ITS/SSD4", ssdlayer_dx,ssdlayer_dy,ssdlayer_dz, ssdlayer_dpsi,ssdlayer_dtheta,ssdlayer_dphi);
+ alignMaker.AddAlignObj("ITS/SSD5", ssdlayer_dx,ssdlayer_dy,ssdlayer_dz, ssdlayer_dpsi,ssdlayer_dtheta,ssdlayer_dphi); */
+ // still waiting for some changes in aliroot
+
+
+
+ //=****************************************
+ // 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,unifspdhalfstave); // all SPD1 half-staves
+ alignMaker.AddAlignObj(1, -1, spdhalfstave_dx,spdhalfstave_dy,spdhalfstave_dz, spdhalfstave_dpsi,spdhalfstave_dtheta,spdhalfstave_dphi,unifspdhalfstave); // all SPD2 half-staves
+
+ alignMaker.AddAlignObj(2, -1, sddladder_dx,sddladder_dy,sddladder_dz, sddladder_dpsi,sddladder_dtheta,sddladder_dphi,kFALSE); // all SDD1 ladders
+ alignMaker.AddAlignObj(3, -1, sddladder_dx,sddladder_dy,sddladder_dz, sddladder_dpsi,sddladder_dtheta,sddladder_dphi,kFALSE); // all SDD2 ladders
+
+ alignMaker.AddAlignObj(4, -1, ssdladder_dx,ssdladder_dy,ssdladder_dz, ssdladder_dpsi,ssdladder_dtheta,ssdladder_dphi,kFALSE); // all SSD1 ladders
+ alignMaker.AddAlignObj(5, -1, ssdladder_dx,ssdladder_dy,ssdladder_dz, ssdladder_dpsi,ssdladder_dtheta,ssdladder_dphi,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( !gSystem->Getenv("TOCDB") ){
+ // save on file
+ const char* filename = "ITSrealisticMisalignment.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;
+}
AliITSMap.cxx \
AliITSMapA1.cxx \
AliITSMapA2.cxx \
+ AliITSMisalignMaker.cxx \
AliITSpList.cxx \
AliITSpListItem.cxx \
AliITSsegmentation.cxx \
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff