1 #ifndef ALIITSALIGNMILLE2_H
2 #define ALIITSALIGNMILLE2_H
4 /* Copyright(c) 2007-2009 , ALICE Experiment at CERN, All rights reserved. *
5 * See cxx source for full Copyright notice */
8 //-----------------------------------------------------------------------------
10 // Interface to AliMillePede2 alignment class for the ALICE ITS detector
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.
17 // author M. Lunardon (thanks to J. Castillo), ruben.shahoyan@cern.ch
18 //-----------------------------------------------------------------------------
22 #include <TGeoMatrix.h>
25 #include "AliTrackPointArray.h"
26 #include "AliITSAlignMille2Module.h"
32 class AliAlignObjParams;
33 class AliTrackFitterRieman;
34 class AliITSAlignMille2Constraint;
35 class AliITSAlignMille2ConstrArray;
36 class AliITSresponseSDD;
37 class AliITSTPArrayFit;
38 class AliITSsegmentationSDD;
39 class AliITSDriftSpeedArraySDD;
40 class AliITSCorrectSDDPoints;
44 class AliITSAlignMille2: public TObject
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};
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) };
64 enum {kDiamondIgnore,kDiamondCheckIfPrompt,kDiamondUse};
67 AliITSAlignMille2(const Char_t *configFilename="AliITSAlignMille.conf",TList* userInfo=0);
68 virtual ~AliITSAlignMille2();
70 AliMillePede2* GetMillePede() const {return fMillepede;}
71 AliITSTPArrayFit* GetTPAFitter() const {return fTPAFitter;}
73 // configuration methods
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;
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();
93 AliAlignObjParams* GetPrealignedObject(const Char_t* symname) const;
94 AliAlignObjParams* GetConstrRefObject(const Char_t* symname) const;
96 void ConvertParamsToGlobal() const;
97 void ConvertParamsToLocal() const;
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;}
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();
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);
134 Int_t CheckCurrentTrack();
135 Bool_t GetFixCurvIfConstraned() const {return fFixCurvIfConstraned;}
136 void SetFixCurvIfConstraned(Bool_t v=kTRUE) {fFixCurvIfConstraned = v;}
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);}
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;}
177 TGeoHMatrix* GetSensorOrigMatrixSID(Int_t sid) const;
178 TGeoHMatrix* GetSensorOrigMatrixVID(Int_t vid) const;
180 TGeoHMatrix* GetSensorCurrMatrixSID(Int_t sid) const;
181 TGeoHMatrix* GetSensorCurrMatrixVID(Int_t vid) const;
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);
193 void ApplyGaussianConstraint(const AliITSAlignMille2ConstrArray* cstr);
194 void ApplyPreConstraints();
195 void ApplyPostConstraints();
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;
207 void FixParameter(Int_t param, Double_t value);
208 void PrintGlobalParameters();
210 TClonesArray* CreateDeltas();
211 AliITSresponseSDD* CreateSDDResponse();
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];}
221 AliITSAlignMille2Constraint* GetConstraint(Int_t i) const {return (AliITSAlignMille2Constraint*)fConstraints.At(i);}
222 AliITSAlignMille2Constraint* GetConstraint(const char* name) const {return (AliITSAlignMille2Constraint*)fConstraints.FindObject(name);}
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;}
245 Int_t LoadPreSDDCalib();
247 Int_t GetExtraClustersMode() const {return fExtraClustersMode;}
248 void SetExtraClustersMode(Int_t mode) {fExtraClustersMode=mode;}
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;}
265 Int_t GetRunID() const {return fRunID;}
266 void SetRunID(int run) {fRunID = run;}
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));}
277 struct Mille2Data { // structure to store data for LocalEquations (X and Z, optionally Y)
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
287 // configuration methods
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();
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();
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);
315 void SetGeometryPath(const Char_t* filename="geometry.root") { fGeometryPath = filename; }
317 void SetInitTrackParamsMeth(Int_t meth=1) {fIniTrackParamsMeth=meth;}
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);}
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);
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;
338 AliITSAlignMille2(const AliITSAlignMille2& rhs);
339 AliITSAlignMille2& operator=(const AliITSAlignMille2& rhs);
389 }; // id's of the keywirds for config file records
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
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
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
437 TObjArray fConstraints; // list of constraints
438 TObjArray fCacheMatrixOrig; // cach for original geom matrices
439 TObjArray fCacheMatrixCurr; // cach for prealigned geom matrices
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
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
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?)
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
494 Int_t fMilleVersion; /// tag for backward compatibility
497 Int_t fExtraClustersMode; /// 1=remove random / 2=remove internal / 10=use only tracks with xcl
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
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
521 TObjArray fConvAlgMatOld; //array to keep matrices of alignables for deltas conversion
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
528 ClassDef(AliITSAlignMille2, 0)
532 //______________________________________________________________________________________
533 inline void AliITSAlignMille2::SetCurrentCluster(const AliTrackPoint &atp)
535 // set current cluster
537 fCurrentSensID = AliITSAlignMille2Module::GetIndexFromVolumeID(fCluster.GetVolumeID());
540 //______________________________________________________________________________________
541 inline TGeoHMatrix* AliITSAlignMille2::GetSensorOrigMatrixSID(Int_t sid) const
543 // get cached original matrix by sensor ID
544 return sid<0 ? 0 : (TGeoHMatrix*) fCacheMatrixOrig[sid];
547 //______________________________________________________________________________________
548 inline TGeoHMatrix* AliITSAlignMille2::GetSensorOrigMatrixVID(Int_t vid) const
550 // get cached original matrix by sensor volume ID
551 return GetSensorOrigMatrixSID( AliITSAlignMille2Module::GetIndexFromVolumeID(vid) );
554 //______________________________________________________________________________________
555 inline TGeoHMatrix* AliITSAlignMille2::GetSensorCurrMatrixSID(Int_t sid) const
557 // get cached current matrix by sensor ID
558 return sid<0 ? 0 : (TGeoHMatrix*) fCacheMatrixCurr[sid];
561 //______________________________________________________________________________________
562 inline TGeoHMatrix* AliITSAlignMille2::GetSensorCurrMatrixVID(Int_t vid) const
564 // get cached current matrix by sensor volume ID
565 return GetSensorCurrMatrixSID( AliITSAlignMille2Module::GetIndexFromVolumeID(vid) );