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