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