technial fix to suppress the warning
[u/mrichter/AliRoot.git] / ITS / AliITSAlignMille2.h
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
28 class TSystem;
29 class TGeoManager;
30 class TVirtualFitter;
31 class AliMillePede2;
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;
41 class AliCDBEntry;
42 class AliESDVertex;
43
44 class 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 //______________________________________________________________________________________
533 inline void AliITSAlignMille2::SetCurrentCluster(const AliTrackPoint &atp) 
534 {
535   // set current cluster
536   fCluster = atp; 
537   fCurrentSensID = AliITSAlignMille2Module::GetIndexFromVolumeID(fCluster.GetVolumeID());
538 }
539
540 //______________________________________________________________________________________
541 inline 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 //______________________________________________________________________________________
548 inline 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 //______________________________________________________________________________________
555 inline 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 //______________________________________________________________________________________
562 inline 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