]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - ITS/AliITSAlignMille2.h
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Added Eventplane Dependence in dPhi Correlations code
[u/mrichter/AliRoot.git] / ITS / AliITSAlignMille2.h
... / ...
CommitLineData
1#ifndef ALIITSALIGNMILLE2_H
2#define ALIITSALIGNMILLE2_H
3
4/* Copyright(c) 2007-2009 , ALICE Experiment at CERN, All rights reserved. *
5 * See cxx source for full Copyright notice */
6
7/* $Id$ */
8//-----------------------------------------------------------------------------
9//
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//-----------------------------------------------------------------------------
19
20#include <TString.h>
21#include <TObject.h>
22#include <TGeoMatrix.h>
23#include <TArrayS.h>
24#include <TArrayD.h>
25#include "AliTrackPointArray.h"
26#include "AliITSAlignMille2Module.h"
27
28class TSystem;
29class TGeoManager;
30class TVirtualFitter;
31class AliMillePede2;
32class AliAlignObjParams;
33class AliTrackFitterRieman;
34class AliITSAlignMille2Constraint;
35class AliITSAlignMille2ConstrArray;
36class AliITSresponseSDD;
37class AliITSTPArrayFit;
38class AliITSsegmentationSDD;
39class AliITSDriftSpeedArraySDD;
40class AliITSCorrectSDDPoints;
41class AliCDBEntry;
42class AliESDVertex;
43
44class AliITSAlignMille2: public TObject
45{
46 public:
47 enum {kX,kY,kZ};
48 enum {kCosmics, kCollision, kNDataType};
49 enum {kNLocal=5,kMaxPoints=20,
50 kNParChGeom = AliITSAlignMille2Module::kMaxParGeom,
51 kNParCh = AliITSAlignMille2Module::kMaxParTot,
52 kMaxITSSensID=2197,kVtxSensID=kMaxITSSensID+1,kMaxITSSensVID=14300,kVtxSensVID=14371,
53 kMinITSSupeModuleID=14336,
54 kSDDoffsID=240,kNSDDmod=260};
55 //
56 enum {kCovIScaleBit=BIT(9),
57 kSameInitDeltasBit=BIT(14),
58 kSameInitSDDRespBit=BIT(15),
59 kSameInitSDDVDriftBit=BIT(16),
60 kSameDiamondBit=BIT(17),
61 kSameInitSDDCorrMapBit=BIT(18),
62 kSameInitGeomBit=BIT(19) };
63 //
64 enum {kDiamondIgnore,kDiamondCheckIfPrompt,kDiamondUse};
65 public:
66 //
67 AliITSAlignMille2(const Char_t *configFilename="AliITSAlignMille.conf",TList* userInfo=0);
68 virtual ~AliITSAlignMille2();
69 //
70 AliMillePede2* GetMillePede() const {return fMillepede;}
71 AliITSTPArrayFit* GetTPAFitter() const {return fTPAFitter;}
72 //
73 // configuration methods
74 //
75 Int_t IsVIDDefined(UShort_t voluid) const;
76 Int_t IsVIDContained(UShort_t voluid) const;
77 Int_t IsSymDefined(const Char_t* name) const;
78 Int_t IsSymContained(const Char_t* name) const;
79 Int_t GetRequestedModID(UShort_t voluid) const;
80 //
81 Int_t GetModuleIndex(const Char_t *symname);
82 Int_t GetModuleIndex(UShort_t voluid);
83 UShort_t GetModuleVolumeID(const Char_t *symname);
84 UShort_t GetModuleVolumeID(Int_t index);
85 AliITSAlignMille2Module* GetMilleModuleByVID(UShort_t voluid) const; // get pointer to the defined supermodule
86 AliITSAlignMille2Module* GetMilleModuleBySymName(const Char_t* symname) const; // get pointer to the defined supermodule
87 AliITSAlignMille2Module* GetMilleModuleIfContained(const Char_t* symname) const;
88 AliITSAlignMille2Module* GetMilleModule(Int_t id) const {return (AliITSAlignMille2Module*)fMilleModule[id];}
89 AliITSAlignMille2Module* GetCurrentModule() const {return fCurrentModule;}
90 AliITSAlignMille2Module* GetSuperModule(Int_t id) const {return (AliITSAlignMille2Module*)fSuperModule[id];}
91 AliITSAlignMille2Module* CreateVertexModule();
92 //
93 AliAlignObjParams* GetPrealignedObject(const Char_t* symname) const;
94 AliAlignObjParams* GetConstrRefObject(const Char_t* symname) const;
95 //
96 void ConvertParamsToGlobal() const;
97 void ConvertParamsToLocal() const;
98 //
99 const Char_t* GetGeometryPath() {return fGeometryPath.Data();}
100 const Char_t* GetPreAlignmentPath() {return fPreDeltaPath.Data();}
101 TClonesArray* GetPreAlignmentDeltas() const {return fPrealignment;}
102 AliITSresponseSDD* GetSDDPrecalResp() const {return fPreRespSDD;}
103 AliITSresponseSDD* GetSDDInitResp() const {return fIniRespSDD;}
104 TObjArray* GetSDDInitVDrift() const {return fIniVDriftSDD;}
105 void PrintCurrentModuleInfo() const {if (fCurrentModule) fCurrentModule->Print();}
106 void Print(Option_t*) const;
107 Bool_t IsConfigured() const {return fIsConfigured;}
108 Bool_t GetUseGlobalDelta() const {return fUseGlobalDelta;}
109 Bool_t IsConstraintWrtRef() const {return fConstrRef!=0;}
110 Bool_t FixedOrphans() const;
111 Bool_t IsLocalYError() const {return fUseLocalYErr;}
112 //
113 // geometry stuffs
114 Int_t GetNModules() const {return fNModules;}
115 Int_t GetCurrentModuleIndex() const {return fCurrentModule ? fCurrentModule->GetIndex():-1;}
116 TGeoHMatrix *GetCurrentModuleHMatrix() const {return fCurrentModule ? fCurrentModule->GetMatrix():0;}
117 Double_t *GetCurrentModuleTranslation() const {return fCurrentModule ? fCurrentModule->GetMatrix()->GetTranslation():0;}
118 Int_t GetCurrentModuleInternalIndex() const {return fCurrentModule ? Int_t(fCurrentModule->GetUniqueID()):-1;}
119 Int_t GetTotBadLocEqPoints() const {return fTotBadLocEqPoints;}
120 Int_t GetNConstraints() const {return fConstraints.GetLast()+1;}
121 Int_t InitModuleParams();
122 //
123 // fitting methods
124 AliTrackFitterRieman *GetRiemanFitter() const {return fRieman;}
125 AliTrackPointArray *PrepareTrack(const AliTrackPointArray *track);
126 AliTrackPointArray *GetCurrentTrack() const {return (AliTrackPointArray*)fTrack;}
127 AliTrackPoint *GetCurrentCluster() const {return (AliTrackPoint*)&fCluster;}
128 void ProcessSDDPointInfo(const AliTrackPoint* pnt,Int_t sID, Int_t pntID);
129 void SetCurrentTrack(const AliTrackPointArray *atp) {fTrack = (AliTrackPointArray*)atp;}
130 void SetCurrentCluster(const AliTrackPoint &atp);
131 void InitTrackParams(int meth=1);
132 Int_t ProcessTrack(const AliTrackPointArray *track, Double_t wgh=1.0);
133 Int_t FitTrack();
134 Int_t CheckCurrentTrack();
135 Bool_t GetFixCurvIfConstraned() const {return fFixCurvIfConstraned;}
136 void SetFixCurvIfConstraned(Bool_t v=kTRUE) {fFixCurvIfConstraned = v;}
137 //
138 // methods for point unbiasing (via scaling its inverted cov.matrix)
139 Bool_t IsCovIScaleTouched() const {return TestBit(kCovIScaleBit);}
140 void TouchCovIScale(Bool_t v=kTRUE) {SetBit(kCovIScaleBit,v);}
141 Float_t GetCovIScale(Int_t ip) const {return ip<kMaxPoints ? fCovIScale[ip]:-1.;}
142 Float_t* GetCovIScale() const {return (Float_t*)fCovIScale;}
143 void SetCovIScale(Int_t ip, Float_t v=-1.) {if (ip<kMaxPoints) fCovIScale[ip] = v; TouchCovIScale();}
144 void SetCovIScale(Float_t *v, Int_t np) {for (int i=TMath::Min(np,kMaxPoints);i--;) fCovIScale[i]=v[i]; TouchCovIScale();}
145 void ResetCovIScale() {for (int i=kMaxPoints;i--;) fCovIScale[i]=-1; TouchCovIScale(kFALSE);}
146 //
147 Int_t CalcIntersectionPoint(const Double_t *lpar, const Double_t *gpar);
148 Int_t CalcDerivatives(Int_t paridx, Bool_t islpar);
149 void JacobianPosGloLoc(int locid,double* jacobian);
150 Double_t* GetLocalIntersectionPoint() const {return (Double_t*)fPintLoc;}
151 Double_t* GetGlobalIntersectionPoint() const {return (Double_t*)fPintGlo;}
152 AliTrackPointArray *SortTrack(const AliTrackPointArray *atp);
153 void SetTemporaryExcludedModule(Int_t index) {fTempExcludedModule=index;}
154 Int_t GetTemporaryExcludedModule() const {return fTempExcludedModule;}
155 Double_t GetMeasGlo(Int_t dim) const {return fMeasGlo[dim];}
156 Double_t GetMeasLoc(Int_t dim) const {return fMeasLoc[dim];}
157 Int_t GetCurrentLayer() const;
158 void SetBField(Double_t b=0);
159 void SetTypeCosmics() {fDataType = kCosmics;}
160 void SetTypeCollision() {fDataType = kCollision;}
161 void SetDataType(Int_t tp=kCosmics) {fDataType = tp>=0&&tp< kNDataType ? tp:kCosmics;}
162 void SetUseLocalYErrors(Bool_t v=kTRUE) {fUseLocalYErr = v && fTPAFitter;}
163 void SetMinPointsPerSensor( Int_t n ) {fMinPntPerSens = n>0 ? n:0;}
164 Int_t GetMinPointsPerSensor() const {return fMinPntPerSens;}
165 void ConstrainHelixFitPT( Int_t q=0,Double_t pt=-1, Double_t err=-1);
166 void ConstrainHelixFitCurv(Int_t q=0,Double_t crv=-1,Double_t crverr=-1);
167 void RemoveHelixFitConstraint();
168 void SetVertexConstraint(const AliESDVertex* vtx);
169 Bool_t IsVertexSet() const {return fVertexSet;}
170 void RemoveVertexConstraint() {fVertexSet = kFALSE;}
171 void SetVertexSet(Bool_t v) {fVertexSet = v;}
172 Double_t GetHelixContraintCharge() const {return fConstrCharge;}
173 Double_t GetHelixContraintPT() const {return fConstrPT;}
174 Double_t GetHelixContraintPTErr() const {return fConstrPTErr;}
175 Int_t GetDataType() const {return fDataType;}
176 //
177 TGeoHMatrix* GetSensorOrigMatrixSID(Int_t sid) const;
178 TGeoHMatrix* GetSensorOrigMatrixVID(Int_t vid) const;
179 //
180 TGeoHMatrix* GetSensorCurrMatrixSID(Int_t sid) const;
181 TGeoHMatrix* GetSensorCurrMatrixVID(Int_t vid) const;
182 //
183 AliCDBEntry* GetCDBEntry(const char* path);
184 // Hierarchical contraints
185 void TieSDDVDriftsLR(AliITSAlignMille2Module* mod);
186 Bool_t PseudoParentsAllowed() const {return fAllowPseudoParents;}
187 void ConstrainModuleSubUnitsMean(Int_t idm, Double_t val=0, UInt_t pattern=0xff);
188 void ConstrainModuleSubUnitsMedian(Int_t idm, Double_t val=0, UInt_t pattern=0xff);
189 void ConstrainOrphansMean(Double_t val=0, UInt_t pattern=0xff);
190 void ConstrainOrphansMedian(Double_t val=0, UInt_t pattern=0xff);
191 void ConstrainLocal(const Char_t* name,Double_t *parcf,Int_t npar,Double_t val,Double_t err);
192 //
193 void ApplyGaussianConstraint(const AliITSAlignMille2ConstrArray* cstr);
194 void ApplyPreConstraints();
195 void ApplyPostConstraints();
196 //
197 void SetWeightPt(Double_t w=1) {fWeightPt = w;}
198 void SetSDDVDCorrMult(Bool_t v=kTRUE) {fIsSDDVDriftMult=v;}
199 Double_t GetWeightPt() const {return fWeightPt;}
200 Bool_t IsSDDVDCorrMult() const {return fIsSDDVDriftMult;}
201 Bool_t IsParModConstrained(const AliITSAlignMille2Module* mod,Int_t par, Bool_t &meanmed, Bool_t &gaussian) const;
202 Bool_t IsParModFamilyVaried(const AliITSAlignMille2Module* mod,Int_t par,Int_t depth=999) const;
203 Bool_t IsParFamilyFree(const AliITSAlignMille2Module* mod,Int_t par,Int_t depth=999) const;
204 //
205 // millepede methods
206 Int_t GlobalFit();
207 void FixParameter(Int_t param, Double_t value);
208 void PrintGlobalParameters();
209 //
210 TClonesArray* CreateDeltas();
211 AliITSresponseSDD* CreateSDDResponse();
212 // module specific
213 //
214 Double_t GetTDriftSDD() const;
215 Double_t GetVDriftSDD() const;
216 Double_t GetDriftSpeed(Int_t id) const {return fDriftSpeed[id];}
217 Double_t GetDriftSpeed0(Int_t id) const {return fDriftSpeed0[id];}
218 Double_t GetDriftTime0(Int_t id) const {return fDriftTime0[id];}
219
220 //
221 AliITSAlignMille2Constraint* GetConstraint(Int_t i) const {return (AliITSAlignMille2Constraint*)fConstraints.At(i);}
222 AliITSAlignMille2Constraint* GetConstraint(const char* name) const {return (AliITSAlignMille2Constraint*)fConstraints.FindObject(name);}
223 //
224 // debug stuffs
225 void FetchCluster(int ip) {fTrack->GetPoint(fCluster,ip);fCluster.SetUniqueID(ip);}
226 void SetLocalInitParams(const Double_t *par) {for (int i=kNLocal;i--;) fLocalInitParam[i]=par[i];}
227 Bool_t IsTypeCosmics() const {return fDataType==kCosmics;}
228 Bool_t IsTypeCollision() const {return fDataType==kCollision;}
229 Double_t *GetMeasLoc() const {return (Double_t*)fMeasLoc;}
230 Double_t *GetSigmaLoc() const {return (Double_t*)fSigmaLoc;}
231 Double_t GetBField() const {return fBField;}
232 Bool_t IsFieldON() const {return fBOn;}
233 Bool_t IsDiamondUsed() const {return fUseDiamond;}
234 Int_t GetCheckDiamondPoint() const {return fCheckDiamondPoint;}
235 void SetCheckDiamondPoint(Int_t m=kDiamondCheckIfPrompt) {fCheckDiamondPoint = m;}
236 Bool_t IsVertexUsed() const {return fUseVertex;}
237 Double_t *GetLocalInitParam() const {return (Double_t*)fLocalInitParam;}
238 Double_t *GetLocalInitParEr() const {return (Double_t*)fLocalInitParEr;}
239 Double_t GetLocalDif(int par, int coor) const {return fDerivativeLoc[par][coor];}
240 Double_t GetGlobalDif(int par, int coor) const {return fDerivativeGlo[par][coor];}
241 Int_t GetPreAlignmentQualityFactor(Int_t index) const;// if not prealign. return -1
242 void SetBug(Int_t bug) {fBug=bug;} // 1:SSD inversion sens.18-19
243 static AliITSAlignMille2* GetInstance() {return fgInstance;}
244
245 Int_t LoadPreSDDCalib();
246 // pepo270809
247 Int_t GetExtraClustersMode() const {return fExtraClustersMode;}
248 void SetExtraClustersMode(Int_t mode) {fExtraClustersMode=mode;}
249 // endpepo270809
250
251 // pepo
252 // flag for AliITSAlignMille compatibility
253 Int_t GetMilleVersion() const {return fMilleVersion;}
254 void SetMilleVersion(Int_t m1) {fMilleVersion=m1;}
255 // modified existing methods
256 void SetCurrentModule(Int_t id);
257 // old methods recovered
258 Int_t IsDefined(UShort_t voluid) const {return IsVIDDefined(voluid);}
259 Int_t IsContained(UShort_t voluid) const {return IsVIDContained(voluid);}
260 // moved from private to public
261 void SetRequiredPoint(Char_t* where, Int_t ndet, Int_t updw, Int_t nreqpts,Int_t runtype=-1);
262 Bool_t InitRiemanFit();
263 void SetMinNPtsPerTrack(Int_t pts=3) {fMinNPtsPerTrack=pts;}
264 //
265 Int_t GetRunID() const {return fRunID;}
266 void SetRunID(int run) {fRunID = run;}
267 //
268 AliITSCorrectSDDPoints * GetPreCorrMapSDD() const {return fPreCorrMapSDD;}
269 AliITSCorrectSDDPoints * GetIniCorrMapSDD() const {return fIniCorrMapSDD;}
270 static Bool_t IsZero(Double_t v,Double_t threshold = 1e-15) { return TMath::Abs(v)<threshold; }
271 static void SetWordBit(UInt_t word,Int_t bitID) { word |= (1<<bitID);}
272 static void ResetWordBit(UInt_t word,Int_t bitID) { word &= ~(1<<bitID);}
273 static Bool_t TestWordBit(UInt_t word,Int_t bitID) { return (Bool_t)(word&(1<<bitID));}
274 //
275 protected:
276 //
277 struct Mille2Data { // structure to store data for LocalEquations (X and Z, optionally Y)
278 enum {kMaxLev = 7};
279 Double_t fMeas[3]; // measured coordinates
280 Double_t fSigma[3]; // measured errors
281 Double_t fDerLoc[kNLocal][3]; // calculated local derivatives
282 Int_t fNModFilled, fNGlobFilled, fModuleID[kMaxLev]; // used module info
283 Int_t fParMilleID[AliITSAlignMille2Module::kMaxParTot*kMaxLev]; // param id's
284 Double_t fDerGlo[AliITSAlignMille2Module::kMaxParTot*kMaxLev][3]; // global derivatives
285 };
286 //
287 // configuration methods
288 void Init();
289 Int_t CacheMatricesOrig();
290 Int_t CacheMatricesCurr();
291 Int_t ProcessUserInfo(TList *userInfo=0);
292 Int_t GetPathFromUserInfo(const TList* cdbList,const char* calib,TString& path, Int_t useBit);
293 Int_t LoadConfig(const Char_t *cfile="AliITSAlignMille.conf");
294 TObjArray* GetConfigRecord(FILE* stream, TString& recTitle, TString& recOpt, Bool_t rew);
295 Int_t CheckConfigRecords(FILE* stream);
296 Int_t ReloadInitCalib(TList *userInfo);
297 Int_t ReloadInitCalib();
298 //
299 void BuildHierarchy();
300 Int_t LoadSuperModuleFile(const Char_t *cfile="ITSMilleSuperModules.root");
301 Int_t LoadGeometry(TString& path);
302 Int_t LoadSDDResponse(TString& path, AliITSresponseSDD *&resp);
303 Int_t LoadSDDVDrift(TString& path, TObjArray *&arr);
304 Int_t LoadSDDCorrMap(TString& path, AliITSCorrectSDDPoints *&map);
305 Int_t LoadDeltas(TString& path, TClonesArray *&arr);
306 Int_t LoadDiamond(TString& path);
307 void ResetLocalEquation();
308 Int_t ApplyToGeometry();
309 //
310 void ConstrainModuleSubUnits(Int_t idm, Double_t val=0, UInt_t pattern=0xff);
311 void ConstrainOrphans(Double_t val=0,UInt_t pattern=0xff);
312 void PostConstrainModuleSubUnits(Int_t type,Int_t idm, Double_t val, UInt_t pattern);
313 void PostConstrainOrphans(Int_t type,Double_t val, UInt_t pattern);
314 //
315 void SetGeometryPath(const Char_t* filename="geometry.root") { fGeometryPath = filename; }
316
317 void SetInitTrackParamsMeth(Int_t meth=1) {fIniTrackParamsMeth=meth;}
318 //
319 void AddConstraint(Double_t *factor, Double_t value, Double_t sigma=0);
320 void InitGlobalParameters(Double_t *par);
321 Bool_t SetLocalDerivative(Int_t index, Double_t value) {return IsZero(fLocalDerivatives[index]=value);}
322 Bool_t SetGlobalDerivative(Int_t index, Double_t value) {return IsZero(fGlobalDerivatives[index]=value);}
323 //
324 // millepede methods
325 //
326 Int_t AddLocalEquation(Mille2Data &m);
327 Int_t AddLocalEquationTPA(Mille2Data &m);
328 void SetLocalEquations(const Mille2Data *marr, Int_t neq);
329 void SetUseGlobalDelta(Bool_t v=kTRUE) {fUseGlobalDelta = v;}
330 void SetAllowPseudoParents(Bool_t v=kTRUE) {fAllowPseudoParents = v;}
331 Int_t SetConstraintWrtRef(const char* reffname);
332 //
333 void ConvertDeltas();
334 void ConvSortHierarchically(TObjArray& matArr);
335 Bool_t ConvIsJParentOfI(const TGeoHMatrix* matI,const TGeoHMatrix* matJ) const;
336 AliAlignObjParams* ConvFindDelta(const TClonesArray* arrDelta,const TString& algname) const;
337
338 AliITSAlignMille2(const AliITSAlignMille2& rhs);
339 AliITSAlignMille2& operator=(const AliITSAlignMille2& rhs);
340 //
341 protected:
342 //
343 enum {
344 kOCDBDefaultPath,
345 kOCDBSpecificPath,
346 kGeomFile,
347 kSuperModileFile,
348 kConstrRefFile,
349 kPreDeltaFile,
350 kPreCalSDDFile,
351 kPreVDriftSDDFile,
352 kPreCorrMapSDDFile,
353 kInitCorrMapSDDFile,
354 kInitCalSDDFile,
355 kInitVDriftSDDFile,
356 kInitDeltaFile,
357 kInitGeomFile,
358 kGlobalDeltas,
359 kConstrLocal,
360 kModVolID,
361 kModIndex,
362 kPseudoParents,
363 kTrackFitMethod,
364 kMinPntTrack,
365 kNStDev,
366 kResCutInit,
367 kResCutOther,
368 kLocalSigFactor,
369 kStartFactor,
370 kFinalFactor,
371 kBField,
372 kSparseMatrix,
373 kRequirePoint,
374 kConstrOrphans,
375 kConstrSubunits,
376 kApplyConstr,
377 kExtraClustersMode,
378 kTPAFitter,
379 kUseLocalYErr,
380 kMinPointsSens,
381 kSDDVDCorrMult,
382 kWeightPt,
383 kUseDiamond,
384 kCorrectDiamond,
385 kUseVertex,
386 kSameSDDT0,
387 //
388 kNKeyWords
389 }; // id's of the keywirds for config file records
390
391 // millepede stuffs
392 AliMillePede2 *fMillepede; // Detector independent alignment class
393 Double_t fStartFac; // Initial factor for chi2 cut
394 Double_t fFinalFac; // Final factor for chi2 cut
395 Double_t fResCutInitial; // Cut on residual for first iteration
396 Double_t fResCut; // Cut on residual for other iterations
397 Int_t fNGlobal; // Number of global parameters
398 Int_t fNLocal; // Number of local parameters
399 Int_t fNStdDev; // Number of standard deviations for chi2 cut
400 Bool_t fIsMilleInit; // Flag for initialization
401 Bool_t fAllowPseudoParents; // For simple constraints don't involve parents into the fit
402 //
403 // fitting stuffs
404 AliITSTPArrayFit *fTPAFitter; // TPArrayFitter
405 AliITSAlignMille2Module *fCurrentModule; // Current SuperModule index
406 AliTrackPointArray *fTrack; // pointer to current track
407 TObjArray fTrackBuff; // buffer for tracks of min length
408 AliTrackPoint fCluster; // current cluster
409 Int_t fCurrentSensID; // sensor index for current cluster
410 TArrayD fClusLoc; // local coordinates of the clusters
411 TArrayD fClusGlo; // global coordinates of the clusters
412 TArrayD fClusSigLoc; // local cov matrix of the clusters
413 Double_t *fGlobalDerivatives; // Array of global derivatives
414 Double_t fLocalDerivatives[kNLocal]; // Array of local deriv.
415 Double_t fLocalInitParam[kNLocal]; // Array with inital values for local parameters for current track
416 Double_t fLocalInitParEr[kNLocal][kNLocal];// Array with inital values for local parameters for current track
417 Double_t fModuleInitParam[kNParCh]; // Array with inital values for current module parameters (init geometry)
418 Double_t fPintLoc[3]; // track/module intersection point in local coordinates
419 Double_t fPintLoc0[3]; // track/module intersection point in local coordinates (before variation)
420 Double_t fPintGlo[3]; // track/module intersection point in global coordinates
421 Double_t *fMeasLoc; // current point local coordinates (the original ones)
422 Double_t *fMeasGlo; // current point glob. coord (AliTrackPoint)
423 Double_t *fSigmaLoc; // stdev current point
424 Double_t fSigmaFactor[3]; // multiplicative factor for cluster sigmaX,Y,Z
425 Double_t fConstrPT; // optional PT constraint for helix (abs value)
426 Double_t fConstrPTErr; // error on this constraint (0 - exact)
427 Int_t fConstrCharge; // optional constraint on charge of Helix track (0 - no constraint)
428 Int_t fRunID; // current runID
429 //
430 Double_t fDerivativeLoc[kNLocal][3]; // XYZ deriv. over local params
431 Double_t fDerivativeGlo[kNParCh][3]; // XYZ deriv. over global params
432 Int_t fMinNPtsPerTrack; // min number of points per track to accept it
433 Int_t fIniTrackParamsMeth; // method for track fit
434 Int_t fTotBadLocEqPoints; // total number of reject points because of bad EqLoc
435 AliTrackFitterRieman *fRieman; // riemann fitter for helices
436 //
437 TObjArray fConstraints; // list of constraints
438 TObjArray fCacheMatrixOrig; // cach for original geom matrices
439 TObjArray fCacheMatrixCurr; // cach for prealigned geom matrices
440 // >> new members
441 Bool_t fUseGlobalDelta; // intetpret deltas as global
442 Bool_t fRequirePoints[kNDataType]; // required points in specific layers
443 Int_t fNReqLayUp[kNDataType][6]; // number of points required in layer[n] with Y>0
444 Int_t fNReqLayDown[kNDataType][6]; // number of points required in layer[n] with Y<0
445 Int_t fNReqLay[kNDataType][6]; // number of points required in layer[n]
446 Int_t fNReqDetUp[kNDataType][3]; // number of points required in Detector[n] with Y>0
447 Int_t fNReqDetDown[kNDataType][3]; // number of points required in Detector[n] with Y<0
448 Int_t fNReqDet[kNDataType][3]; // number of points required in Detector[n]
449 Int_t fTempExcludedModule; /// single module temporary excluded from initial fit
450 UInt_t fUserProvided; // settings which user provided: not to update from the UserUnfo
451 // << new members
452 //
453 // OCDB stuff
454 TList *fIniUserInfo; // initial user info (validity is not guaranteed after initialization)
455 TString fIniGeomPath; // where to take the ideal geometry used to produce the points
456 TString fIniDeltaPath; // where to take the deltas used to produce the points
457 TString fIniSDDRespPath; // where to take the initial SDD response used to produce the points
458 TString fPreCalSDDRespPath; // precalibration SDD response file name
459 TString fIniSDDVDriftPath; // initial SDD vdrift file name
460 TString fPreSDDVDriftPath; // precalibration SDD vdrift file name
461 TString fIniSDDCorrMapPath; // initial SDD corr.map file name
462 TString fPreSDDCorrMapPath; // precalibration SDD corr.map file name
463 // geometry stuffs
464 Bool_t fConvertPreDeltas; // when the prealignment deltas come from UserInfo, convert them from UserInfo geometry to target one
465 TString fGeometryPath; // Geometry file name
466 TString fPreDeltaPath; // file with prealigned objects
467 TString fConstrRefPath; // file with prealigned objects wrt which constraints are defined
468 TString fDiamondPath; // file with diamond constraint
469 TGeoManager *fGeoManager; // pointer to Alice geomanager
470 Bool_t fIsConfigured; // flag for loaded config file
471 TArrayS fPreAlignQF; // prealignment flags (not used?)
472 //
473 AliITSresponseSDD* fIniRespSDD; // array of SDD t0/vdrift calib params used to create the track points
474 AliITSresponseSDD* fPreRespSDD; // array of SDD t0/vdrift calib params
475 TObjArray* fIniVDriftSDD; // array of AliITSDriftSpeedArraySDD objects used for original reco
476 TObjArray* fPreVDriftSDD; // array of AliITSDriftSpeedArraySDD objects to be used as a starting point instead of fIniVDriftSDD
477 AliITSCorrectSDDPoints* fIniCorrMapSDD; // SDD initial correction map
478 AliITSCorrectSDDPoints* fPreCorrMapSDD; // SDD precalibration correction map
479 AliITSsegmentationSDD* fSegmentationSDD; // extraction of SDD segmentation params
480 TClonesArray* fPrealignment; // array of prealignment global deltas
481 TClonesArray* fConstrRef; // array of refererence deltas with respect to which the constraint are defined (survey?)
482 TObjArray fMilleModule; /// array of super modules to be aligned
483 TObjArray fSuperModule; /// array of super modules defined in supermodule file
484 Int_t fNModules; // number of defined modules from config file
485 Int_t fNSuperModules; /// number of custom supermodules in SM file
486 Bool_t fUsePreAlignment; // start from prealigned setup
487 Bool_t fUseLocalYErr; // use local Yerror due to the sensor thickness
488 Bool_t fBOn; // magentic field ON
489 Double_t fBField; // value of magnetic field
490 Int_t fDataType; // is this cosmics or collision processing?
491 Int_t fMinPntPerSens; // min number of points per module to vary it
492 Int_t fBug; /// tag for temporary bug correction
493 // pepo
494 Int_t fMilleVersion; /// tag for backward compatibility
495 // endpepo
496 // pepo270809
497 Int_t fExtraClustersMode; /// 1=remove random / 2=remove internal / 10=use only tracks with xcl
498 // endpepo270809
499 //
500 Double_t fTrackWeight; //weight given by the user to current track
501 Double_t fWeightPt; //weight track equations by pT in this power
502 Bool_t fIsSDDVDriftMult; //use multiplicative correction for SDD vdrift
503 Double_t fDriftSpeed[50]; //temporary array for corrected drift speed of SDD alitrackpoints
504 Double_t fDriftSpeed0[50]; //temporary array for original drift speed of SDD alitrackpoints
505 Double_t fDriftTime0[50]; //temporary array for drift time 0's used for SDD alitrackpoints
506 Double_t fExtClusterPar[9]; //array to store the parameters of the externally imposed cluster
507 AliTrackPoint fDiamond; //optional constraint on the vertex
508 AliTrackPoint fDiamondI; //constraint on the vertex with inverted error matrix
509 Double_t fCorrDiamond[3]; //diamond correction
510 Bool_t fUseDiamond; //use diamond as a vertex constraint
511 Bool_t fUseVertex; //use vertex for constraint
512 Bool_t fVertexSet; //vertex is set for current track
513 Int_t fDiamondPointID; //ID of the diamond point in the track
514 Int_t fDiamondModID; //id of the fake diamond module
515 Int_t fCheckDiamondPoint; // kDiamondIgnore: ignore in this event, kDiamondCheckIfPrompt: verify if track is prompt, kDiamondUse: use w/o verification
516 Float_t fCovIScale[kMaxPoints]; //optional scaling for inv.cov matrix (debiasing). MANAGED BY THE USER EXTERNALLY
517 //
518 Bool_t fFixCurvIfConstraned; //when fit curv. was constrained, don't pass it as a free param to MP2
519 Bool_t fCurvFitWasConstrained; //flag that the last fit had constrained curvature
520 //
521 TObjArray fConvAlgMatOld; //array to keep matrices of alignables for deltas conversion
522 //
523 static AliITSAlignMille2* fgInstance; // global pointer on itself
524 static Int_t fgInstanceID; // global counter of the instances
525 static const Char_t * fgkRecKeys[]; // keywords for config file records
526 static const Char_t fgkXYZ[]; // XYZ labels
527 //
528 ClassDef(AliITSAlignMille2, 0)
529};
530
531
532//______________________________________________________________________________________
533inline void AliITSAlignMille2::SetCurrentCluster(const AliTrackPoint &atp)
534{
535 // set current cluster
536 fCluster = atp;
537 fCurrentSensID = AliITSAlignMille2Module::GetIndexFromVolumeID(fCluster.GetVolumeID());
538}
539
540//______________________________________________________________________________________
541inline TGeoHMatrix* AliITSAlignMille2::GetSensorOrigMatrixSID(Int_t sid) const
542{
543 // get cached original matrix by sensor ID
544 return sid<0 ? 0 : (TGeoHMatrix*) fCacheMatrixOrig[sid];
545}
546
547//______________________________________________________________________________________
548inline TGeoHMatrix* AliITSAlignMille2::GetSensorOrigMatrixVID(Int_t vid) const
549{
550 // get cached original matrix by sensor volume ID
551 return GetSensorOrigMatrixSID( AliITSAlignMille2Module::GetIndexFromVolumeID(vid) );
552}
553
554//______________________________________________________________________________________
555inline TGeoHMatrix* AliITSAlignMille2::GetSensorCurrMatrixSID(Int_t sid) const
556{
557 // get cached current matrix by sensor ID
558 return sid<0 ? 0 : (TGeoHMatrix*) fCacheMatrixCurr[sid];
559}
560
561//______________________________________________________________________________________
562inline TGeoHMatrix* AliITSAlignMille2::GetSensorCurrMatrixVID(Int_t vid) const
563{
564 // get cached current matrix by sensor volume ID
565 return GetSensorCurrMatrixSID( AliITSAlignMille2Module::GetIndexFromVolumeID(vid) );
566}
567
568#endif
569