]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ITS/AliITSAlignMille2.h
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
New fitter for millipede2 + updates to AliITSAlignMille2 (Ruben)
[u/mrichter/AliRoot.git] / ITS / AliITSAlignMille2.h
CommitLineData
7b85e477 1#ifndef ALIITSALIGNMILLE2_H
2#define ALIITSALIGNMILLE2_H
6526a72c 3
7b85e477 4/* Copyright(c) 2007-2009 , ALICE Experiment at CERN, All rights reserved. *
5 * See cxx source for full Copyright notice */
6
057304f3 7/* $Id$ */
6526a72c 8//-----------------------------------------------------------------------------
7b85e477 9//
6526a72c 10// Interface to AliMillePede2 alignment class for the ALICE ITS detector
11//
12// ITS specific alignment class which interface to AliMillepede.
13// For each track ProcessTrack calculates the local and global derivatives
14// at each hit and fill the corresponding local equations. Provide methods for
15// fixing or constraining detection elements for best results.
16//
17// author M. Lunardon (thanks to J. Castillo), ruben.shahoyan@cern.ch
18//-----------------------------------------------------------------------------
7b85e477 19
20#include <TString.h>
21#include <TObject.h>
6526a72c 22#include <TGeoMatrix.h>
6be22b3f 23#include <TArrayS.h>
24#include <TArrayD.h>
7b85e477 25#include "AliTrackPointArray.h"
26#include "AliITSAlignMille2Module.h"
27
45993b23 28class TSystem;
29class TGeoManager;
30class TVirtualFitter;
7b85e477 31class AliMillePede2;
32class AliAlignObjParams;
7b85e477 33class AliTrackFitterRieman;
45993b23 34class AliITSAlignMille2Constraint;
35class AliITSAlignMille2ConstrArray;
36class AliITSresponseSDD;
6be22b3f 37class AliITSTPArrayFit;
7b85e477 38
39class AliITSAlignMille2: public TObject
40{
41 public:
6be22b3f 42 enum {kX,kY,kZ};
43 enum {kNLocal=5,kMaxPoints=100,
44 kNParChGeom = AliITSAlignMille2Module::kMaxParGeom,
45 kNParCh = AliITSAlignMille2Module::kMaxParTot,
46 kMaxITSSensID=2197,kMaxITSSensVID=14300,kMinITSSupeModuleID=14336,
47 kSDDoffsID=240,kNSDDmod=260};
7b85e477 48 //
49 public:
50 //
6be22b3f 51 AliITSAlignMille2(const Char_t *configFilename="AliITSAlignMille.conf",TList* userInfo=0);
7b85e477 52 virtual ~AliITSAlignMille2();
53 //
6526a72c 54 AliMillePede2* GetMillePede() const {return fMillepede;}
6be22b3f 55 AliITSTPArrayFit* GetTPAFitter() const {return fTPAFitter;}
6526a72c 56 //
57 // configuration methods
58 //
59 Int_t IsVIDDefined(UShort_t voluid) const;
60 Int_t IsVIDContained(UShort_t voluid) const;
61 Int_t IsSymDefined(const Char_t* name) const;
62 Int_t IsSymContained(const Char_t* name) const;
63 //
7b85e477 64 Int_t GetModuleIndex(const Char_t *symname);
65 Int_t GetModuleIndex(UShort_t voluid);
66 UShort_t GetModuleVolumeID(const Char_t *symname);
67 UShort_t GetModuleVolumeID(Int_t index);
6526a72c 68 AliITSAlignMille2Module* GetMilleModuleByVID(UShort_t voluid) const; // get pointer to the defined supermodule
69 AliITSAlignMille2Module* GetMilleModuleBySymName(const Char_t* symname) const; // get pointer to the defined supermodule
70 AliITSAlignMille2Module* GetMilleModuleIfContained(const Char_t* symname) const;
71 AliITSAlignMille2Module* GetMilleModule(Int_t id) const {return (AliITSAlignMille2Module*)fMilleModule[id];}
72 AliITSAlignMille2Module* GetCurrentModule() const {return fCurrentModule;}
73 AliITSAlignMille2Module* GetSuperModule(Int_t id) const {return (AliITSAlignMille2Module*)fSuperModule[id];}
74 //
75 AliAlignObjParams* GetPrealignedObject(const Char_t* symname) const;
76 AliAlignObjParams* GetConstrRefObject(const Char_t* symname) const;
77 //
78 void ConvertParamsToGlobal();
79 void ConvertParamsToLocal();
7b85e477 80 //
6be22b3f 81 const Char_t* GetGeometryPath() {return fGeometryPath.Data();}
82 const Char_t* GetPreAlignmentPath() {return fPreDeltaPath.Data();}
7b85e477 83 TClonesArray* GetPreAlignmentDeltas() const {return fPrealignment;}
6526a72c 84 AliITSresponseSDD* GetSDDPrecalibration() const {return fCorrectSDD;}
85 AliITSresponseSDD* GetSDDInit() const {return fInitialRecSDD;}
7b85e477 86 void PrintCurrentModuleInfo() const {if (fCurrentModule) fCurrentModule->Print();}
87 void Print(Option_t*) const;
88 Bool_t IsConfigured() const {return fIsConfigured;}
7b85e477 89 Bool_t GetUseGlobalDelta() const {return fUseGlobalDelta;}
6526a72c 90 Bool_t IsConstraintWrtRef() const {return fConstrRef!=0;}
91 Bool_t FixedOrphans() const;
6be22b3f 92 Bool_t IsLocalYError() const {return fUseLocalYErr;}
6526a72c 93 //
94 // geometry stuffs
95 Int_t GetNModules() const {return fNModules;}
96 Int_t GetCurrentModuleIndex() const {return fCurrentModule ? fCurrentModule->GetIndex():-1;}
97 TGeoHMatrix *GetCurrentModuleHMatrix() const {return fCurrentModule ? fCurrentModule->GetMatrix():0;}
98 Double_t *GetCurrentModuleTranslation() const {return fCurrentModule ? fCurrentModule->GetMatrix()->GetTranslation():0;}
99 Int_t GetCurrentModuleInternalIndex() const {return fCurrentModule ? Int_t(fCurrentModule->GetUniqueID()):-1;}
100 Int_t GetTotBadLocEqPoints() const {return fTotBadLocEqPoints;}
101 Int_t GetNConstraints() const {return fConstraints.GetLast()+1;}
102 Int_t InitModuleParams();
7b85e477 103 //
104 // fitting methods
45993b23 105 AliTrackFitterRieman *GetRiemanFitter() const {return fRieman;}
7b85e477 106 AliTrackPointArray *PrepareTrack(const AliTrackPointArray *track);
45993b23 107 AliTrackPointArray *GetCurrentTrack() const {return (AliTrackPointArray*)fTrack;}
108 AliTrackPoint *GetCurrentCluster() const {return (AliTrackPoint*)&fCluster;}
109 void SetCurrentTrack(const AliTrackPointArray *atp) {fTrack = (AliTrackPointArray*)atp;}
6be22b3f 110 void SetCurrentCluster(const AliTrackPoint &atp);
7b85e477 111 void InitTrackParams(int meth=1);
6526a72c 112 Int_t ProcessTrack(const AliTrackPointArray *track);
7b85e477 113 Int_t CheckCurrentTrack();
6526a72c 114 //
7b85e477 115 Int_t CalcIntersectionPoint(Double_t *lpar, Double_t *gpar);
116 Int_t CalcDerivatives(Int_t paridx, Bool_t islpar);
117 Double_t* GetLocalIntersectionPoint() const {return (Double_t*)fPintLoc;}
118 Double_t* GetGlobalIntersectionPoint() const {return (Double_t*)fPintGlo;}
119 AliTrackPointArray *SortTrack(const AliTrackPointArray *atp);
120 void SetTemporaryExcludedModule(Int_t index) {fTempExcludedModule=index;}
121 Int_t GetTemporaryExcludedModule() const {return fTempExcludedModule;}
6526a72c 122 Double_t GetMeasGlo(Int_t dim) const {return fMeasGlo[dim];}
123 Double_t GetMeasLoc(Int_t dim) const {return fMeasLoc[dim];}
124 Int_t GetCurrentLayer() const;
6be22b3f 125 void SetBField(Double_t b=0);
126 void SetUseLocalYErrors(Bool_t v=kTRUE) {fUseLocalYErr = v && fTPAFitter;}
127 void SetMinPointsPerSensor( Int_t n ) {fMinPntPerSens = n>0 ? n:0;}
128 Int_t GetMinPointsPerSensor() const {return fMinPntPerSens;}
129 void ConstrainHelixFitPT( Int_t q=0,Double_t pt=-1, Double_t err=-1);
130 void ConstrainHelixFitCurv(Int_t q=0,Double_t crv=-1,Double_t crverr=-1);
131 Double_t GetHelixContraintCharge() const {return fConstrCharge;}
132 Double_t GetHelixContraintPT() const {return fConstrPT;}
133 Double_t GetHelixContraintPTErr() const {return fConstrPTErr;}
134 //
135 TGeoHMatrix* GetSensorOrigMatrixSID(Int_t sid) const;
136 TGeoHMatrix* GetSensorOrigMatrixVID(Int_t vid) const;
137 //
138 TGeoHMatrix* GetSensorCurrMatrixSID(Int_t sid) const;
139 TGeoHMatrix* GetSensorCurrMatrixVID(Int_t vid) const;
140
7b85e477 141 // Hierarchical contraints
6526a72c 142 Bool_t PseudoParentsAllowed() const {return fAllowPseudoParents;}
143 void ConstrainModuleSubUnitsMean(Int_t idm, Double_t val=0, UInt_t pattern=0xff);
144 void ConstrainModuleSubUnitsMedian(Int_t idm, Double_t val=0, UInt_t pattern=0xff);
145 void ConstrainOrphansMean(Double_t val=0, UInt_t pattern=0xff);
146 void ConstrainOrphansMedian(Double_t val=0, UInt_t pattern=0xff);
147 void ConstrainLocal(const Char_t* name,Double_t *parcf,Int_t npar,Double_t val,Double_t err);
7b85e477 148 //
45993b23 149 void ApplyGaussianConstraint(const AliITSAlignMille2ConstrArray* cstr);
6526a72c 150 void ApplyPreConstraints();
151 void ApplyPostConstraints();
7b85e477 152 //
45993b23 153 Bool_t IsParModConstrained(const AliITSAlignMille2Module* mod,Int_t par, Bool_t &meanmed, Bool_t &gaussian) const;
154 Bool_t IsParModFamilyVaried(const AliITSAlignMille2Module* mod,Int_t par,Int_t depth=999) const;
155 Bool_t IsParFamilyFree(const AliITSAlignMille2Module* mod,Int_t par,Int_t depth=999) const;
7b85e477 156 //
157 // millepede methods
6526a72c 158 Int_t GlobalFit();
7b85e477 159 void FixParameter(Int_t param, Double_t value);
7b85e477 160 void PrintGlobalParameters();
7b85e477 161 //
6be22b3f 162 TClonesArray* CreateDeltas();
163 AliITSresponseSDD* CreateSDDResponse();
6526a72c 164 // module specific
7b85e477 165 //
6526a72c 166 Double_t GetTDriftSDD() const;
167 Double_t GetVDriftSDD() const;
168 //
169 AliITSAlignMille2Constraint* GetConstraint(Int_t i) const {return (AliITSAlignMille2Constraint*)fConstraints.At(i);}
170 AliITSAlignMille2Constraint* GetConstraint(const char* name) const {return (AliITSAlignMille2Constraint*)fConstraints.FindObject(name);}
7b85e477 171 //
172 // debug stuffs
6be22b3f 173 void FetchCluster(int ip) {fTrack->GetPoint(fCluster,ip);fCluster.SetUniqueID(ip);}
45993b23 174 void SetLocalInitParams(const Double_t *par) {for (int i=kNLocal;i--;) fLocalInitParam[i]=par[i];}
7b85e477 175 Double_t *GetMeasLoc() const {return (Double_t*)fMeasLoc;}
176 Double_t *GetSigmaLoc() const {return (Double_t*)fSigmaLoc;}
177 Double_t GetBField() const {return fBField;}
178 Double_t *GetLocalInitParam() const {return (Double_t*)fLocalInitParam;}
179 Double_t *GetLocalInitParEr() const {return (Double_t*)fLocalInitParEr;}
6526a72c 180 Double_t GetLocalDif(int par, int coor) const {return fDerivativeLoc[par][coor];}
181 Double_t GetGlobalDif(int par, int coor) const {return fDerivativeGlo[par][coor];}
7b85e477 182 Int_t GetPreAlignmentQualityFactor(Int_t index) const;// if not prealign. return -1
183 void SetBug(Int_t bug) {fBug=bug;} // 1:SSD inversion sens.18-19
6526a72c 184 static AliITSAlignMille2* GetInstance() {return fgInstance;}
185
6be22b3f 186 // pepo270809
187 Int_t GetExtraClustersMode() const {return fExtraClustersMode;}
188 void SetExtraClustersMode(Int_t mode) {fExtraClustersMode=mode;}
189 // endpepo270809
190
6526a72c 191 // pepo
192 // flag for AliITSAlignMille compatibility
193 Int_t GetMilleVersion() const {return fMilleVersion;}
194 void SetMilleVersion(Int_t m1) {fMilleVersion=m1;}
195 // modified existing methods
196 void SetCurrentModule(Int_t id);
197 // old methods recovered
198 Int_t IsDefined(UShort_t voluid) const {return IsVIDDefined(voluid);}
199 Int_t IsContained(UShort_t voluid) const {return IsVIDContained(voluid);}
200 // moved from private to public
201 void SetRequiredPoint(Char_t* where, Int_t ndet, Int_t updw, Int_t nreqpts);
202 Bool_t InitRiemanFit();
203 void SetMinNPtsPerTrack(Int_t pts=3) {fMinNPtsPerTrack=pts;}
7b85e477 204 //
6be22b3f 205 static Bool_t IsZero(Double_t v,Double_t threshold = 1e-16) { return TMath::Abs(v)<threshold; }
206 static void SetWordBit(UInt_t word,Int_t bitID) { word |= (1<<bitID);}
207 static void ResetWordBit(UInt_t word,Int_t bitID) { word &= ~(1<<bitID);}
208 static Bool_t TestWordBit(UInt_t word,Int_t bitID) { return (Bool_t)(word&(1<<bitID));}
209 //
4bd2db93 210 protected:
7b85e477 211 //
4bd2db93 212 struct Mille2Data { // structure to store data for 2 LocalEquations (X and Z)
213 enum {kMaxLev = 7};
6be22b3f 214 Double_t fMeas[3]; // measured coordinates
215 Double_t fSigma[3]; // measured errors
216 Double_t fDerLoc[kNLocal][3]; // calculated local derivatives
4bd2db93 217 Int_t fNModFilled, fNGlobFilled, fModuleID[kMaxLev]; // used module info
218 Int_t fParMilleID[AliITSAlignMille2Module::kMaxParTot*kMaxLev]; // param id's
6be22b3f 219 Double_t fDerGlo[AliITSAlignMille2Module::kMaxParTot*kMaxLev][3]; // global derivatives
4bd2db93 220 };
6be22b3f 221 //
7b85e477 222 // configuration methods
6526a72c 223 void Init();
6be22b3f 224 Int_t CacheMatrices();
225 Int_t ProcessUserInfo(TList *userInfo=0);
7b85e477 226 Int_t LoadConfig(const Char_t *cfile="AliITSAlignMille.conf");
6526a72c 227 TObjArray* GetConfigRecord(FILE* stream, TString& recTitle, TString& recOpt, Bool_t rew);
18986853 228 Int_t CheckConfigRecords(FILE* stream);
6526a72c 229 //
230 void BuildHierarchy();
7b85e477 231 Int_t LoadSuperModuleFile(const Char_t *cfile="ITSMilleSuperModules.root");
6be22b3f 232 Int_t LoadSDDResponse(TString& path, AliITSresponseSDD *&resp);
233 Int_t LoadDeltas(TString& path, TClonesArray *&arr);
7b85e477 234 void ResetLocalEquation();
6526a72c 235 Int_t InitGeometry();
7b85e477 236 Int_t ApplyToGeometry();
237 //
6526a72c 238 void ConstrainModuleSubUnits(Int_t idm, Double_t val=0, UInt_t pattern=0xff);
239 void ConstrainOrphans(Double_t val=0,UInt_t pattern=0xff);
240 void PostConstrainModuleSubUnits(Int_t type,Int_t idm, Double_t val, UInt_t pattern);
241 void PostConstrainOrphans(Int_t type,Double_t val, UInt_t pattern);
242 //
6be22b3f 243 void SetGeometryPath(const Char_t* filename="geometry.root") { fGeometryPath = filename; }
6526a72c 244
245 void SetInitTrackParamsMeth(Int_t meth=1) {fInitTrackParamsMeth=meth;}
246 //
247 void AddConstraint(Double_t *factor, Double_t value, Double_t sigma=0);
6be22b3f 248 void InitGlobalParameters(Double_t *par);
249 Bool_t SetLocalDerivative(Int_t index, Double_t value) {return IsZero(fLocalDerivatives[index]=value);}
250 Bool_t SetGlobalDerivative(Int_t index, Double_t value) {return IsZero(fGlobalDerivatives[index]=value);}
6526a72c 251 //
7b85e477 252 // millepede methods
6526a72c 253 //
4bd2db93 254 Int_t AddLocalEquation(Mille2Data &m);
6be22b3f 255 Int_t AddLocalEquationTPA(Mille2Data &m);
4bd2db93 256 void SetLocalEquations(const Mille2Data *marr, Int_t neq);
6526a72c 257 void SetUseGlobalDelta(Bool_t v=kTRUE) {fUseGlobalDelta = v;}
258 void SetAllowPseudoParents(Bool_t v=kTRUE) {fAllowPseudoParents = v;}
259 Int_t SetConstraintWrtRef(const char* reffname);
7b85e477 260 //
261 AliITSAlignMille2(const AliITSAlignMille2& rhs);
262 AliITSAlignMille2& operator=(const AliITSAlignMille2& rhs);
263 //
264 protected:
265 //
18986853 266 enum {
6be22b3f 267 kOCDBPath,
18986853 268 kGeomFile,
269 kSuperModileFile,
270 kConstrRefFile,
6be22b3f 271 kPreDeltaFile,
18986853 272 kPreCalSDDFile,
273 kInitCalSDDFile,
6be22b3f 274 kInitDeltaFile,
18986853 275 kGlobalDeltas,
276 kConstrLocal,
277 kModVolID,
278 kModIndex,
279 kPseudoParents,
280 kTrackFitMethod,
281 kMinPntTrack,
282 kNStDev,
283 kResCutInit,
284 kResCutOther,
285 kLocalSigFactor,
286 kStartFactor,
287 kBField,
288 kSparseMatrix,
289 kRequirePoint,
290 kConstrOrphans,
291 kConstrSubunits,
292 kApplyConstr,
6be22b3f 293 kExtraClustersMode,
294 kTPAFitter,
295 kUseLocalYErr,
296 kMinPointsSens,
18986853 297 //
298 kNKeyWords
299 }; // id's of the keywirds for config file records
300
7b85e477 301 // millepede stuffs
302 AliMillePede2 *fMillepede; // Detector independent alignment class
303 Double_t fStartFac; // Initial value for chi2 cut
304 Double_t fResCutInitial; // Cut on residual for first iteration
305 Double_t fResCut; // Cut on residual for other iterations
306 Int_t fNGlobal; // Number of global parameters
307 Int_t fNLocal; // Number of local parameters
308 Int_t fNStdDev; // Number of standard deviations for chi2 cut
309 Bool_t fIsMilleInit; // Flag for initialization
6526a72c 310 Bool_t fAllowPseudoParents; // For simple constraints don't involve parents into the fit
7b85e477 311 //
312 // fitting stuffs
6be22b3f 313 AliITSTPArrayFit *fTPAFitter; // TPArrayFitter
7b85e477 314 AliITSAlignMille2Module *fCurrentModule; // Current SuperModule index
315 AliTrackPointArray *fTrack; // pointer to current track
6526a72c 316 TObjArray fTrackBuff; // buffer for tracks of min length
7b85e477 317 AliTrackPoint fCluster; // current cluster
6be22b3f 318 Int_t fCurrentSensID; // sensor index for current cluster
319 TArrayD fClusLoc; // local coordinates of the clusters
320 TArrayD fClusGlo; // global coordinates of the clusters
321 TArrayD fClusSigLoc; // local cov matrix of the clusters
7b85e477 322 Double_t *fGlobalDerivatives; // Array of global derivatives
323 Double_t fLocalDerivatives[kNLocal]; // Array of local deriv.
324 Double_t fLocalInitParam[kNLocal]; // Array with inital values for local parameters for current track
325 Double_t fLocalInitParEr[kNLocal][kNLocal];// Array with inital values for local parameters for current track
326 Double_t fModuleInitParam[kNParCh]; // Array with inital values for current module parameters (init geometry)
45993b23 327 Double_t fPintLoc[3]; // track/module intersection point in local coordinates
328 Double_t fPintLoc0[3]; // track/module intersection point in local coordinates (before variation)
329 Double_t fPintGlo[3]; // track/module intersection point in global coordinates
6be22b3f 330 Double_t *fMeasLoc; // current point local coordinates (the original ones)
331 Double_t *fMeasGlo; // current point glob. coord (AliTrackPoint)
332 Double_t *fSigmaLoc; // stdev current point
7b85e477 333 Double_t fSigmaFactor[3]; // multiplicative factor for cluster sigmaX,Y,Z
6be22b3f 334 Double_t fConstrPT; // optional PT constraint for helix (abs value)
335 Double_t fConstrPTErr; // error on this constraint (0 - exact)
336 Int_t fConstrCharge; // optional constraint on charge of Helix track (0 - no constraint)
7b85e477 337 //
6526a72c 338 Double_t fDerivativeLoc[kNLocal][3]; // XYZ deriv. over local params
339 Double_t fDerivativeGlo[kNParCh][3]; // XYZ deriv. over global params
7b85e477 340 Int_t fMinNPtsPerTrack; // min number of points per track to accept it
341 Int_t fInitTrackParamsMeth; // method for track fit
342 Int_t fTotBadLocEqPoints; // total number of reject points because of bad EqLoc
343 AliTrackFitterRieman *fRieman; // riemann fitter for helices
344 //
6526a72c 345 TObjArray fConstraints; // list of constraints
6be22b3f 346 TObjArray fCacheMatrixOrig; // cach for original geom matrices
347 TObjArray fCacheMatrixCurr; // cach for prealigned geom matrices
7b85e477 348 // >> new members
349 Bool_t fUseGlobalDelta; // intetpret deltas as global
350 Bool_t fRequirePoints; // required points in specific layers
351 Int_t fNReqLayUp[6]; /// number of points required in layer[n] with Y>0
352 Int_t fNReqLayDown[6]; /// number of points required in layer[n] with Y<0
353 Int_t fNReqLay[6]; /// number of points required in layer[n]
354 Int_t fNReqDetUp[3]; /// number of points required in Detector[n] with Y>0
355 Int_t fNReqDetDown[3]; /// number of points required in Detector[n] with Y<0
356 Int_t fNReqDet[3]; /// number of points required in Detector[n]
357 Int_t fTempExcludedModule; /// single module temporary excluded from initial fit
358 // << new members
359 //
6be22b3f 360 // OCDB stuff
361 TString fDefCDBpath; // default OCDB path
362 TString fInitDeltaPath; // where to take the deltas used to produce the points
363 TString fInitSDDRespPath; // where to take the initial SDD response used to produce the points
364 TString fPreCalSDDRespPath; // precalibration SDD response file name
7b85e477 365 // geometry stuffs
6be22b3f 366 TString fGeometryPath; // Geometry file name
367 TString fPreDeltaPath; // file with prealigned objects
368 TString fConstrRefPath; // file with prealigned objects wrt which constraints are defined
45993b23 369 TGeoManager *fGeoManager; // pointer to Alice geomanager
370 Bool_t fIsConfigured; // flag for loaded config file
371 TArrayS fPreAlignQF; // prealignment flags (not used?)
7b85e477 372 //
6be22b3f 373 AliITSresponseSDD* fCorrectSDD; // array of SDD t0/vdrift calib params
374 AliITSresponseSDD* fInitialRecSDD; // array of SDD t0/vdrift calib params used to create the track points
7b85e477 375 TClonesArray* fPrealignment; // array of prealignment global deltas
6526a72c 376 TClonesArray* fConstrRef; // array of refererence deltas with respect to which the constraint are defined (survey?)
7b85e477 377 TObjArray fMilleModule; /// array of super modules to be aligned
378 TObjArray fSuperModule; /// array of super modules defined in supermodule file
379 Int_t fNModules; // number of defined modules from config file
380 Int_t fNSuperModules; /// number of custom supermodules in SM file
381 Bool_t fUsePreAlignment; // start from prealigned setup
6be22b3f 382 Bool_t fUseLocalYErr; // use local Yerror due to the sensor thickness
7b85e477 383 Bool_t fBOn; // magentic field ON
384 Double_t fBField; // value of magnetic field
6be22b3f 385 Int_t fMinPntPerSens; // min number of points per module to vary it
7b85e477 386 Int_t fBug; /// tag for temporary bug correction
6526a72c 387 // pepo
388 Int_t fMilleVersion; /// tag for backward compatibility
389 // endpepo
6be22b3f 390 // pepo270809
391 Int_t fExtraClustersMode; /// 1=remove random / 2=remove internal / 10=use only tracks with xcl
392 // endpepo270809
6526a72c 393 //
394 Double_t fDriftSpeed[50]; //temporary array for drift times of SDD alitrackpoints
395 Double_t fDriftTime0[50]; //temporary array for drift time 0's used for SDD alitrackpoints
6be22b3f 396 Double_t fExtClusterPar[9]; //array to store the parameters of the externally imposed cluster
7b85e477 397 //
398 static AliITSAlignMille2* fgInstance; // global pointer on itself
399 static Int_t fgInstanceID; // global counter of the instances
6be22b3f 400 static const Char_t * fgkRecKeys[]; // keywords for config file records
401 static const Char_t fgkXYZ[]; // XYZ labels
6526a72c 402 //
7b85e477 403 ClassDef(AliITSAlignMille2, 0)
7b85e477 404};
405
6be22b3f 406
407//______________________________________________________________________________________
408inline void AliITSAlignMille2::SetCurrentCluster(const AliTrackPoint &atp)
409{
410 // set current cluster
411 fCluster = atp;
412 fCurrentSensID = AliITSAlignMille2Module::GetIndexFromVolumeID(fCluster.GetVolumeID());
413}
414
415//______________________________________________________________________________________
416inline TGeoHMatrix* AliITSAlignMille2::GetSensorOrigMatrixSID(Int_t sid) const
417{
418 // get cached original matrix by sensor ID
419 return sid<0 ? 0 : (TGeoHMatrix*) fCacheMatrixOrig[sid];
420}
421
422//______________________________________________________________________________________
423inline TGeoHMatrix* AliITSAlignMille2::GetSensorOrigMatrixVID(Int_t vid) const
424{
425 // get cached original matrix by sensor volume ID
426 return GetSensorOrigMatrixSID( AliITSAlignMille2Module::GetIndexFromVolumeID(vid) );
427}
428
429//______________________________________________________________________________________
430inline TGeoHMatrix* AliITSAlignMille2::GetSensorCurrMatrixSID(Int_t sid) const
431{
432 // get cached current matrix by sensor ID
433 return sid<0 ? 0 : (TGeoHMatrix*) fCacheMatrixCurr[sid];
434}
435
436//______________________________________________________________________________________
437inline TGeoHMatrix* AliITSAlignMille2::GetSensorCurrMatrixVID(Int_t vid) const
438{
439 // get cached current matrix by sensor volume ID
440 return GetSensorCurrMatrixSID( AliITSAlignMille2Module::GetIndexFromVolumeID(vid) );
441}
442
7b85e477 443#endif
18986853 444