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 "AliTrackPointArray.h"
  24 #include "AliITSAlignMille2Module.h"
  25
  26 class TArrayI;
  27 class TSystem;
  28 class TGeoManager;
  29 class TVirtualFitter;
  30 class AliMillePede2;
  31 class AliAlignObjParams;
  32 class AliTrackFitterRieman;
  33 class AliITSAlignMille2Constraint;
  34 class AliITSAlignMille2ConstrArray;
  35 class AliITSresponseSDD;
  36
  37 class AliITSAlignMille2: public TObject
  38 {
  39  public:
  40  enum {kNLocal=5,kMaxPoints=100,
  41        kNParChGeom = AliITSAlignMille2Module::kMaxParGeom,
  42        kNParCh     = AliITSAlignMille2Module::kMaxParTot,
  43        kMaxITSSensID=2197,kMaxITSSensVID=14300,kMinITSSupeModuleID=14336,kSDDoffsID=240};
  44   //
  45  public:
  46   //
  47   AliITSAlignMille2(const Char_t *configFilename="AliITSAlignMille.conf");
  48   virtual ~AliITSAlignMille2();
  49   //
  50   AliMillePede2* GetMillePede()                                   const {return fMillepede;}
  51   //
  52   // configuration methods
  53   //
  54   Int_t     IsVIDDefined(UShort_t voluid)                         const;
  55   Int_t     IsVIDContained(UShort_t voluid)                       const;
  56   Int_t     IsSymDefined(const Char_t* name)                      const;
  57   Int_t     IsSymContained(const Char_t* name)                    const;
  58   //
  59   Int_t     GetModuleIndex(const Char_t *symname);
  60   Int_t     GetModuleIndex(UShort_t voluid);
  61   UShort_t  GetModuleVolumeID(const Char_t *symname);
  62   UShort_t  GetModuleVolumeID(Int_t index);
  63   AliITSAlignMille2Module*  GetMilleModuleByVID(UShort_t voluid) const; // get pointer to the defined supermodule
  64   AliITSAlignMille2Module*  GetMilleModuleBySymName(const Char_t* symname) const; // get pointer to the defined supermodule
  65   AliITSAlignMille2Module*  GetMilleModuleIfContained(const Char_t* symname) const;
  66   AliITSAlignMille2Module*  GetMilleModule(Int_t id)             const {return (AliITSAlignMille2Module*)fMilleModule[id];}
  67   AliITSAlignMille2Module*  GetCurrentModule()                   const {return fCurrentModule;}
  68   AliITSAlignMille2Module*  GetSuperModule(Int_t id)             const {return (AliITSAlignMille2Module*)fSuperModule[id];}
  69   //
  70   AliAlignObjParams*        GetPrealignedObject(const Char_t* symname) const;
  71   AliAlignObjParams*        GetConstrRefObject(const Char_t* symname) const;
  72   //
  73   void          ConvertParamsToGlobal();
  74   void          ConvertParamsToLocal();
  75   //
  76   const Char_t* GetGeometryFileName()                                   {return fGeometryFileName.Data();}
  77   const Char_t* GetPreAlignmentFileName()                               {return fPreAlignmentFileName.Data();}
  78   TClonesArray* GetPreAlignmentDeltas()                           const {return fPrealignment;}
  79   AliITSresponseSDD* GetSDDPrecalibration()                       const {return fCorrectSDD;}
  80   AliITSresponseSDD* GetSDDInit()                                 const {return fInitialRecSDD;}
  81   void      PrintCurrentModuleInfo()                              const {if (fCurrentModule) fCurrentModule->Print();}
  82   void      Print(Option_t*)                                      const;
  83   Bool_t    IsConfigured()                                        const {return fIsConfigured;}
  84   Bool_t    GetUseGlobalDelta()                                   const {return fUseGlobalDelta;}
  85   Bool_t    IsConstraintWrtRef()                                  const {return fConstrRef!=0;}
  86   Bool_t    FixedOrphans()                                        const;
  87   //
  88   // geometry stuffs
  89   Int_t     GetNModules()                   const {return fNModules;}
  90   Int_t     GetCurrentModuleIndex()         const {return fCurrentModule ? fCurrentModule->GetIndex():-1;}
  91   TGeoHMatrix *GetCurrentModuleHMatrix()    const {return fCurrentModule ? fCurrentModule->GetMatrix():0;}
  92   Double_t *GetCurrentModuleTranslation()   const {return fCurrentModule ? fCurrentModule->GetMatrix()->GetTranslation():0;}
  93   Int_t     GetCurrentModuleInternalIndex() const {return fCurrentModule ? Int_t(fCurrentModule->GetUniqueID()):-1;}
  94   Int_t     GetTotBadLocEqPoints()          const {return fTotBadLocEqPoints;}
  95   Int_t     GetNConstraints()               const {return fConstraints.GetLast()+1;}
  96   Int_t     InitModuleParams();
  97   //
  98   // fitting methods
  99   AliTrackFitterRieman *GetRiemanFitter()   const                       {return fRieman;}
 100   AliTrackPointArray   *PrepareTrack(const AliTrackPointArray *track);
 101   AliTrackPointArray *GetCurrentTrack()     const                       {return (AliTrackPointArray*)fTrack;}
 102   AliTrackPoint      *GetCurrentCluster()   const                       {return (AliTrackPoint*)&fCluster;}
 103   void      SetCurrentTrack(const AliTrackPointArray *atp)              {fTrack = (AliTrackPointArray*)atp;}
 104   void      SetCurrentCluster(const AliTrackPoint &atp)                 {fCluster = atp;}
 105   void      InitTrackParams(int meth=1);
 106   Int_t     ProcessTrack(const AliTrackPointArray *track);
 107   Int_t     CheckCurrentTrack();
 108   //
 109   Int_t     CalcIntersectionPoint(Double_t *lpar, Double_t *gpar);
 110   Int_t     CalcDerivatives(Int_t paridx, Bool_t islpar);
 111   Double_t* GetLocalIntersectionPoint()                           const {return (Double_t*)fPintLoc;}
 112   Double_t* GetGlobalIntersectionPoint()                          const {return (Double_t*)fPintGlo;}
 113   AliTrackPointArray *SortTrack(const AliTrackPointArray *atp);
 114   void      SetTemporaryExcludedModule(Int_t index)                     {fTempExcludedModule=index;}
 115   Int_t     GetTemporaryExcludedModule()                          const {return fTempExcludedModule;}
 116   Double_t  GetMeasGlo(Int_t dim)                                 const {return fMeasGlo[dim];}
 117   Double_t  GetMeasLoc(Int_t dim)                                 const {return fMeasLoc[dim];}
 118   Int_t     GetCurrentLayer()                                     const;
 119   //
 120   // Hierarchical contraints
 121   Bool_t    PseudoParentsAllowed()                                const {return fAllowPseudoParents;}
 122   void      ConstrainModuleSubUnitsMean(Int_t idm, Double_t val=0, UInt_t pattern=0xff);
 123   void      ConstrainModuleSubUnitsMedian(Int_t idm, Double_t val=0, UInt_t pattern=0xff);
 124   void      ConstrainOrphansMean(Double_t val=0, UInt_t pattern=0xff);
 125   void      ConstrainOrphansMedian(Double_t val=0, UInt_t pattern=0xff);
 126   void      ConstrainLocal(const Char_t* name,Double_t *parcf,Int_t npar,Double_t val,Double_t err);
 127   //
 128   void      ApplyGaussianConstraint(const AliITSAlignMille2ConstrArray* cstr);
 129   void      ApplyPreConstraints();
 130   void      ApplyPostConstraints();
 131   //
 132   Bool_t    IsParModConstrained(const AliITSAlignMille2Module* mod,Int_t par, Bool_t &meanmed, Bool_t &gaussian) const;
 133   Bool_t    IsParModFamilyVaried(const AliITSAlignMille2Module* mod,Int_t par,Int_t depth=999)             const;
 134   Bool_t    IsParFamilyFree(const AliITSAlignMille2Module* mod,Int_t par,Int_t depth=999)                  const;
 135   //
 136   // millepede methods
 137   Int_t     GlobalFit();
 138   void      FixParameter(Int_t param, Double_t value);
 139   void      PrintGlobalParameters();
 140   //
 141   // module specific
 142   //
 143   Double_t  GetTDriftSDD()                  const;
 144   Double_t  GetVDriftSDD()                  const;
 145   //
 146   AliITSAlignMille2Constraint* GetConstraint(Int_t i)            const {return (AliITSAlignMille2Constraint*)fConstraints.At(i);}
 147   AliITSAlignMille2Constraint* GetConstraint(const char* name)   const {return (AliITSAlignMille2Constraint*)fConstraints.FindObject(name);}
 148   //
 149   // debug stuffs
 150   void       FetchCluster(const AliTrackPointArray *trc,int ip)        {trc->GetPoint(fCluster,ip);}
 151   void       SetLocalInitParams(const Double_t *par)                   {for (int i=kNLocal;i--;) fLocalInitParam[i]=par[i];}
 152   Double_t  *GetMeasLoc()                                        const {return (Double_t*)fMeasLoc;}
 153   Double_t  *GetSigmaLoc()                                       const {return (Double_t*)fSigmaLoc;}
 154   Double_t   GetBField()                                         const {return fBField;}
 155   Double_t  *GetLocalInitParam()                                 const {return (Double_t*)fLocalInitParam;}
 156   Double_t  *GetLocalInitParEr()                                 const {return (Double_t*)fLocalInitParEr;}
 157   Double_t   GetLocalDif(int par, int coor)                      const {return fDerivativeLoc[par][coor];}
 158   Double_t   GetGlobalDif(int par, int coor)                     const {return fDerivativeGlo[par][coor];}
 159   Int_t      GetPreAlignmentQualityFactor(Int_t index)           const;// if not prealign. return -1
 160   void       SetBug(Int_t bug) {fBug=bug;}                             // 1:SSD inversion sens.18-19
 161   static     AliITSAlignMille2* GetInstance()                          {return fgInstance;}
 162
 163   // pepo
 164   // flag for AliITSAlignMille compatibility
 165   Int_t      GetMilleVersion() const {return fMilleVersion;}
 166   void       SetMilleVersion(Int_t m1) {fMilleVersion=m1;}
 167   // modified existing methods
 168   void      SetCurrentModule(Int_t id);
 169   // old methods recovered
 170   Int_t     IsDefined(UShort_t voluid) const {return IsVIDDefined(voluid);}
 171   Int_t     IsContained(UShort_t voluid) const {return IsVIDContained(voluid);}
 172   // moved from private to public
 173   void      SetRequiredPoint(Char_t* where, Int_t ndet, Int_t updw, Int_t nreqpts);
 174   Bool_t    InitRiemanFit();
 175   void      SetMinNPtsPerTrack(Int_t pts=3)  {fMinNPtsPerTrack=pts;}
 176   //
 177  protected:
 178   //
 179   struct Mille2Data { // structure to store data for 2 LocalEquations (X and Z)
 180     enum {kMaxLev = 7};
 181     Double_t fMeasX, fMeasZ, fSigmaX, fSigmaZ;        // measured coordinates/errors
 182     Double_t fDerLocX[kNLocal], fDerLocZ[kNLocal];    // calculated local derivatives
 183     Int_t    fNModFilled, fNGlobFilled, fModuleID[kMaxLev]; // used module info
 184     Int_t    fParMilleID[AliITSAlignMille2Module::kMaxParTot*kMaxLev]; // param id's
 185     Double_t fDerGloX[AliITSAlignMille2Module::kMaxParTot*kMaxLev]; // global derivatives in X
 186     Double_t fDerGloZ[AliITSAlignMille2Module::kMaxParTot*kMaxLev]; // and Z
 187   };
 188
 189   // configuration methods
 190   void      Init();
 191   Int_t     LoadConfig(const Char_t *cfile="AliITSAlignMille.conf");
 192   TObjArray* GetConfigRecord(FILE* stream, TString& recTitle, TString& recOpt, Bool_t rew);
 193   //
 194   void      BuildHierarchy();
 195   Int_t     LoadSuperModuleFile(const Char_t *cfile="ITSMilleSuperModules.root");
 196   void      ResetLocalEquation();
 197   Int_t     InitGeometry();
 198   Int_t     ApplyToGeometry();
 199   //
 200   void      ConstrainModuleSubUnits(Int_t idm, Double_t val=0, UInt_t pattern=0xff);
 201   void      ConstrainOrphans(Double_t val=0,UInt_t pattern=0xff);
 202   void      PostConstrainModuleSubUnits(Int_t type,Int_t idm, Double_t val, UInt_t pattern);
 203   void      PostConstrainOrphans(Int_t type,Double_t val, UInt_t pattern);
 204   //
 205   void      SetGeometryFileName(const Char_t* filename="geometry.root") { fGeometryFileName = filename; }
 206
 207   void      SetInitTrackParamsMeth(Int_t meth=1)                        {fInitTrackParamsMeth=meth;}
 208   //
 209   void      AddConstraint(Double_t *factor, Double_t value, Double_t sigma=0);
 210   void      InitGlobalParameters(Double_t *par);
 211   void      SetLocalDerivative(Int_t index, Double_t value)             {fLocalDerivatives[index] = value;}
 212   void      SetGlobalDerivative(Int_t index, Double_t value)            {fGlobalDerivatives[index] = value;}
 213   //
 214   // millepede methods
 215   //
 216   Int_t     AddLocalEquation(Mille2Data &m);
 217   void      SetLocalEquations(const Mille2Data *marr, Int_t neq);
 218   void      SetUseGlobalDelta(Bool_t v=kTRUE)                           {fUseGlobalDelta = v;}
 219   void      SetAllowPseudoParents(Bool_t v=kTRUE)                       {fAllowPseudoParents = v;}
 220   Int_t     SetConstraintWrtRef(const char* reffname);
 221   //
 222   AliITSAlignMille2(const AliITSAlignMille2& rhs);
 223   AliITSAlignMille2& operator=(const AliITSAlignMille2& rhs);
 224   //
 225  protected:
 226   //
 227   // millepede stuffs
 228   AliMillePede2 *fMillepede;                    // Detector independent alignment class
 229   Double_t      fStartFac;                      // Initial value for chi2 cut
 230   Double_t      fResCutInitial;                 // Cut on residual for first iteration
 231   Double_t      fResCut;                        // Cut on residual for other iterations
 232   Int_t         fNGlobal;                       // Number of global parameters
 233   Int_t         fNLocal;                        // Number of local parameters
 234   Int_t         fNStdDev;                       // Number of standard deviations for chi2 cut
 235   Bool_t        fIsMilleInit;                   // Flag for initialization
 236   Bool_t        fAllowPseudoParents;            // For simple constraints don't involve parents into the fit
 237   //
 238   // fitting stuffs
 239   AliITSAlignMille2Module *fCurrentModule;      // Current SuperModule index
 240   AliTrackPointArray *fTrack;                   // pointer to current track
 241   TObjArray     fTrackBuff;                     // buffer for tracks of min length
 242   AliTrackPoint fCluster;                       // current cluster
 243   Double_t     *fGlobalDerivatives;             // Array of global derivatives
 244   Double_t      fLocalDerivatives[kNLocal];     // Array of local deriv.
 245   Double_t      fLocalInitParam[kNLocal];       // Array with inital values for local parameters for current track
 246   Double_t      fLocalInitParEr[kNLocal][kNLocal];// Array with inital values for local parameters for current track
 247   Double_t      fModuleInitParam[kNParCh];      // Array with inital values for current module parameters (init geometry)
 248   Double_t      fPintLoc[3];                    // track/module intersection point in local coordinates
 249   Double_t      fPintLoc0[3];                   // track/module intersection point in local coordinates (before variation)
 250   Double_t      fPintGlo[3];                    // track/module intersection point in global coordinates
 251   Double_t      fMeasLoc[3];                    // current point local coordinates (the original ones)
 252   Double_t      fMeasGlo[3];                    // current point glob. coord (AliTrackPoint)
 253   Double_t      fSigmaLoc[3];                   // stdev current point
 254   Double_t      fSigmaFactor[3];                // multiplicative factor for cluster sigmaX,Y,Z
 255   //
 256   Double_t      fDerivativeLoc[kNLocal][3];    // XYZ deriv. over local params
 257   Double_t      fDerivativeGlo[kNParCh][3];     // XYZ deriv. over global params
 258   Int_t         fMinNPtsPerTrack;               // min number of points per track to accept it
 259   Int_t         fInitTrackParamsMeth;           // method for track fit
 260   Int_t         fTotBadLocEqPoints;             // total number of reject points because of bad EqLoc
 261   AliTrackFitterRieman *fRieman;                // riemann fitter for helices
 262   //
 263   TObjArray     fConstraints;                   // list of constraints
 264   // >> new members
 265   Bool_t        fUseGlobalDelta;  // intetpret deltas as global
 266   Bool_t        fRequirePoints;   // required points in specific layers
 267   Int_t         fNReqLayUp[6];    /// number of points required in layer[n] with Y>0
 268   Int_t         fNReqLayDown[6];  /// number of points required in layer[n] with Y<0
 269   Int_t         fNReqLay[6];      /// number of points required in layer[n]
 270   Int_t         fNReqDetUp[3];    /// number of points required in Detector[n] with Y>0
 271   Int_t         fNReqDetDown[3];  /// number of points required in Detector[n] with Y<0
 272   Int_t         fNReqDet[3];      /// number of points required in Detector[n]
 273   Int_t         fTempExcludedModule; /// single module temporary excluded from initial fit
 274   // << new members
 275   //
 276   // geometry stuffs
 277   TString       fGeometryFileName;              // Geometry file name
 278   TString       fPreAlignmentFileName;          // file with prealigned objects
 279   TString       fConstrRefFileName;             // file with prealigned objects wrt which constraints are defined
 280   TGeoManager  *fGeoManager;                    // pointer to Alice geomanager
 281   Bool_t        fIsConfigured;                  // flag for loaded config file
 282   TArrayS       fPreAlignQF;                    // prealignment flags (not used?)
 283   //
 284   AliITSresponseSDD* fCorrectSDD;   // array of SDD t0/vdrift calib params
 285   AliITSresponseSDD* fInitialRecSDD;   // array of SDD t0/vdrift calib params used to create the track points
 286   TClonesArray* fPrealignment; // array of prealignment global deltas
 287   TClonesArray* fConstrRef;    // array of refererence deltas with respect to which the constraint are defined (survey?)
 288   TObjArray     fMilleModule; /// array of super modules to be aligned
 289   TObjArray     fSuperModule; /// array of super modules defined in supermodule file
 290   Int_t         fNModules;                      // number of defined modules from config file
 291   Int_t         fNSuperModules; /// number of custom supermodules in SM file
 292   Bool_t        fUsePreAlignment;               // start from prealigned setup
 293   Bool_t        fBOn;                           // magentic field ON
 294   Double_t      fBField;                        // value of magnetic field
 295   Int_t         fBug;                           /// tag for temporary bug correction
 296   // pepo
 297   Int_t         fMilleVersion; /// tag for backward compatibility
 298   // endpepo
 299   //
 300   Double_t      fDriftSpeed[50];                   //temporary array for drift times of SDD alitrackpoints
 301   Double_t      fDriftTime0[50];                   //temporary array for drift time 0's used for SDD alitrackpoints
 302   //
 303   static AliITSAlignMille2* fgInstance;         // global pointer on itself
 304   static Int_t              fgInstanceID;       // global counter of the instances
 305   //
 306   ClassDef(AliITSAlignMille2, 0)
 307 };
 308
 309 #endif