ITS/AliITSAlignMille2Module.h

   1 #ifndef ALIITSALIGNMILLE2MODULE_H\r
   2 #define ALIITSALIGNMILLE2MODULE_H \r
   3 /* Copyright(c) 2007-2009 , ALICE Experiment at CERN, All rights reserved. * \r
   4  * See cxx source for full Copyright notice                               */  \r
   5  \r
   6 /// \ingroup rec \r
   7 /// \class AliITSAlignMille2Module\r
   8 /// \brief Class for alignment of ITS \r
   9 // \r
  10 // Authors: Marcello Lunardon \r
  11 //\r
  12 // RS Converted static arrays fSensVolVolumeID and fSensVolIndex\r
  13 // to TArrays in user transparent way.\r
  14 //\r
  15 /* $Id$  */ \r
  16 //#include <TString.h> \r
  17 //#include <TObject.h> \r
  18 #include <TNamed.h> \r
  19 #include <TArrayI.h> \r
  20 #include <TArrayS.h> \r
  21 #include <TObjArray.h> \r
  22 class AliITSAlignMille2;\r
  23 \r
  24 class AliAlignObjParams; \r
  25 class TGeoHMatrix; \r
  26 \r
  27 class AliITSAlignMille2Module : public TNamed \r
  28 { \r
  29 public: \r
  30   enum {kSPD,kSDD,kSSD};\r
  31   enum {kMaxParGeom=6,kMaxParTot=9,kSensDefBit=BIT(14),kGlobalGeomBit=BIT(15),kNotInConfBit=BIT(16),kVdSDDSameLRBit=BIT(17)};\r
  32   enum {kDOFTX,kDOFTY,kDOFTZ,kDOFPS,kDOFTH,kDOFPH,kDOFT0,kDOFDVL,kDOFDVR};\r
  33   //\r
  34   AliITSAlignMille2Module(); \r
  35   AliITSAlignMille2Module(UShort_t volid);\r
  36   AliITSAlignMille2Module(Int_t index, UShort_t volid, const char* symname, const TGeoHMatrix *m, Int_t nsv=0, const UShort_t *volidsv=NULL);\r
  37   AliITSAlignMille2Module(const AliITSAlignMille2Module& rhs); // copy constructor\r
  38   AliITSAlignMille2Module& operator=(const AliITSAlignMille2Module& rhs);  \r
  39   //\r
  40   virtual ~AliITSAlignMille2Module(); \r
  41   //\r
  42   // geometry methods  \r
  43   Int_t        GetIndex()                             const {return fIndex;} \r
  44   UShort_t     GetVolumeID()                          const {return fVolumeID;}  \r
  45   Int_t        GetNSensitiveVolumes()                 const {return fNSensVol;} \r
  46   Int_t        GetSensVolIndex(Int_t at)              const {return fSensVolIndex[at];}\r
  47   Short_t      GetSensVolVolumeID(Int_t at)           const {return fSensVolVolumeID[at];}\r
  48   TGeoHMatrix *GetMatrix()                            const {return fMatrix;}\r
  49   void         GetLocalMatrix(TGeoHMatrix& mat)       const;\r
  50   UShort_t    *GetSensitiveVolumeVolumeID()           const {return (UShort_t*)fSensVolVolumeID.GetArray();}\r
  51   Float_t      GetSigmaFactor(Int_t i)                const {return fSigmaFactor[i];}\r
  52   Float_t      GetSigmaXFactor()                      const {return fSigmaFactor[0];}\r
  53   Float_t      GetSigmaYFactor()                      const {return fSigmaFactor[1];}\r
  54   Float_t      GetSigmaZFactor()                      const {return fSigmaFactor[2];}\r
  55   Int_t        GetNProcessedPoints()                  const {return fNProcPoints;}\r
  56   Bool_t       IsFreeDOF(Int_t dof)                   const {return dof<fNParTot && fParCstr[dof]>0;}\r
  57   Bool_t       AreSensorsProvided()                   const {return TestBit(kSensDefBit);}\r
  58   Bool_t       GeomParamsGlobal()                     const {return TestBit(kGlobalGeomBit);}\r
  59   Bool_t       IsNotInConf()                          const {return TestBit(kNotInConfBit);}\r
  60   Bool_t       IsVDriftLRSame()                       const {return TestBit(kVdSDDSameLRBit);}\r
  61   //\r
  62   Bool_t       IsIn(UShort_t volid)                   const;\r
  63   Bool_t       IsAlignable()                          const;\r
  64   Bool_t       BelongsTo(AliITSAlignMille2Module* parent) const;\r
  65   AliITSAlignMille2Module* GetParent()                const {return fParent;}\r
  66   AliITSAlignMille2Module* GetChild(Int_t i)          const {return (AliITSAlignMille2Module*)fChildren[i];}\r
  67   Int_t        GetNChildren()                         const {return fChildren.GetLast()+1;}\r
  68   //\r
  69   void         Print(Option_t* opt="")                const; \r
  70   //\r
  71   void         EvaluateDOF();\r
  72   UShort_t     GetNParTot()                           const {return fNParTot;}\r
  73   UShort_t     GetNParFree()                          const {return fNParFree;}\r
  74   Float_t     *GetParVals()                           const {return fParVals;}\r
  75   Double_t     GetParVal(int par)                     const {return par<fNParTot ? fParVals[par] : 0;}\r
  76   Double_t     GetParErr(int par)                     const {return par<fNParTot ? fParErrs[par] : 0;}\r
  77   Double_t     GetParConstraint(int par)              const {return par<fNParTot ? fParCstr[par] : 0;}\r
  78   Int_t        GetParOffset(Int_t par)                const {return par<fNParTot ? fParOffs[par] : -1;}\r
  79   Int_t        GetDetType()                           const {return fDetType;}\r
  80   Bool_t       IsParConstrained(Int_t par)            const {return fParCstr[par]>0 && fParCstr[par]<fgkDummyConstraint;}\r
  81   Bool_t       IsSPD()                                const {return fDetType == kSPD;}\r
  82   Bool_t       IsSDD()                                const {return fDetType == kSDD;}\r
  83   Bool_t       IsSSD()                                const {return fDetType == kSSD;}\r
  84   Bool_t       IsSensor()                             const {return IsSensor(fVolumeID);}\r
  85   void         SetDetType(Int_t tp)                         {fDetType = tp;}\r
  86   void         SetParOffset(Int_t par,Int_t offs)           {fParOffs[par] = offs;}\r
  87   //\r
  88   void         SetParVals(Double_t *vl,Int_t npar);          \r
  89   void         SetParVal(Int_t par,Double_t v=0)            {fParVals[par] = v;}\r
  90   void         SetParErr(Int_t par,Double_t e=0)            {fParErrs[par] = e;}\r
  91   void         SetParConstraint(Int_t par,Double_t s=1e6)   {fParCstr[par] = s>0. ? s:0.0;}\r
  92   void         SetSigmaFactor(Int_t i,Float_t v)            {fSigmaFactor[i]=TMath::Max(0.001F,v);}\r
  93   void         SetSigmaXFactor(Float_t v)                   {SetSigmaFactor(0,v);}\r
  94   void         SetSigmaYFactor(Float_t v)                   {SetSigmaFactor(1,v);}\r
  95   void         SetSigmaZFactor(Float_t v)                   {SetSigmaFactor(2,v);}\r
  96   void         IncNProcessedPoints(Int_t step=1)            {fNProcPoints += step;}\r
  97   void         SetNProcessedPoints(Int_t v)                 {fNProcPoints = v;}\r
  98   void         SetParent(AliITSAlignMille2Module* par)      {fParent = par;}\r
  99   void         AddChild(AliITSAlignMille2Module* cld)       {fChildren.Add(cld);}\r
 100   void         SetFreeDOF(Int_t dof,Double_t cstr);\r
 101   void         SetSensorsProvided(Bool_t v=kTRUE)           {SetBit(kSensDefBit,v);}\r
 102   void         SetGeomParamsGlobal(Bool_t v=kTRUE)          {SetBit(kGlobalGeomBit,v);}\r
 103   void         SetNotInConf(Bool_t v=kTRUE)                 {SetBit(kNotInConfBit,v);}\r
 104   void         SetVDriftLRSame(Bool_t v=kTRUE)              {SetBit(kVdSDDSameLRBit,v);}\r
 105   Int_t        Set(Int_t index,UShort_t volid, const char* symname, const TGeoHMatrix *m,Int_t nsv=0, const UShort_t *volidsv=0);\r
 106   //\r
 107   void         AddSensitiveVolume(UShort_t volid);\r
 108   void         DelSensitiveVolume(Int_t at);\r
 109   void         DelSensitiveVolumes()                        {fNSensVol = 0;}\r
 110   //\r
 111   void         GetGeomParamsGlo(Double_t *pars);\r
 112   void         GetGeomParamsLoc(Double_t *pars);\r
 113   //\r
 114   TGeoHMatrix *GetSensitiveVolumeMatrix(UShort_t voluid);\r
 115   TGeoHMatrix *GetSensitiveVolumeOrigGlobalMatrix(UShort_t voluid);\r
 116   TGeoHMatrix *GetSensitiveVolumeModifiedMatrix(UShort_t voluid, const Double_t *delta,Bool_t local=kTRUE); \r
 117   AliAlignObjParams *GetSensitiveVolumeMisalignment(UShort_t voluid, const AliAlignObjParams *a); \r
 118   AliAlignObjParams *GetSensitiveVolumeMisalignment(UShort_t voluid, const Double_t *deltalocal); \r
 119   //\r
 120   void         GetGlobalParams(Double_t *t, Double_t *r) const;\r
 121   void         GetGlobalParams(const Double_t *loct, const Double_t *locr,Double_t *t, Double_t *r);\r
 122   void         GetLocalParams(const Double_t *loct, const Double_t *locr,Double_t *t, Double_t *r);\r
 123   //\r
 124   void         GetSensVolGlobalParams(UShort_t volid,Double_t *t, Double_t *r);\r
 125   void         GetSensVolLocalParams(UShort_t volid,Double_t *t, Double_t *r);\r
 126   void         GetSensVolGlobalParams(UShort_t volid,const Double_t* loct,const Double_t* locr,Double_t *t, Double_t *r);\r
 127   void         GetSensVolLocalParams(UShort_t volid,const Double_t* loct,const Double_t* locr,Double_t *t, Double_t *r);\r
 128   //\r
 129   void         CalcDerivLocGlo(Double_t *deriv);\r
 130   void         CalcDerivGloLoc(Int_t idx,Double_t *deriv);\r
 131   void         CalcDerivGloLoc(Int_t sensVol,Int_t paridx,Double_t* derivative);\r
 132   void         CalcDerivCurLoc(Int_t sensVol,Int_t paridx,Double_t* derivative);\r
 133   void         CalcDerivDPosDPar(Int_t sensVol,const Double_t *pl,Double_t *deriv);\r
 134   //\r
 135   // forse non serve...\r
 136   AliAlignObjParams *GetSensitiveVolumeGlobalMisalignment(UShort_t voluid, const Double_t *deltalocal); \r
 137   // mo' proviamo questo\r
 138   AliAlignObjParams *GetSensitiveVolumeTotalMisalignment(UShort_t voluid, const Double_t *deltalocal); \r
 139   //\r
 140   static Int_t    GetIndexFromVolumeID(UShort_t volid);\r
 141   static UShort_t GetVolumeIDFromSymname(const Char_t *symname);\r
 142   static UShort_t GetVolumeIDFromIndex(Int_t index);\r
 143   static Bool_t   IsSensor(UShort_t vid);\r
 144   static Int_t    SensVolMatrix(UShort_t volid, TGeoHMatrix *m); \r
 145   static Int_t    SensVolOrigGlobalMatrix(UShort_t volid, TGeoHMatrix *m); \r
 146 \r
 147   //\r
 148 protected:\r
 149   //\r
 150   void         AssignDetType();\r
 151   //\r
 152 protected:\r
 153   //\r
 154   Int_t          fNSensVol;                       // number of sensor it refers to\r
 155   Int_t          fIndex;                          // aliroot index\r
 156   Int_t          fDetType;                        // Detector type\r
 157   UShort_t       fVolumeID;                       // aliroot volune ID\r
 158   UShort_t       fNParTot;                        // total number of parameters\r
 159   UShort_t       fNParFree;                       // number of free parameters\r
 160   TArrayS        fParOffs;                        // offsets of free params in the fit results\r
 161   Int_t          fNProcPoints;                    // number of processed points\r
 162   Float_t        fSigmaFactor[3];                 // multiplicative factor for referred sensor X,Y,Z error\r
 163   Float_t       *fParVals;                        // values of the fitted params\r
 164   Float_t       *fParErrs;                        // errors of the fitted params\r
 165   Float_t       *fParCstr;                        // Gaussian type constraint on parameter, 0 means fixed param\r
 166   //\r
 167   TArrayI        fSensVolIndex;                   // aliroot indices for sensors\r
 168   TArrayS        fSensVolVolumeID;                // aliroot indices for sensors volumes\r
 169   TGeoHMatrix   *fMatrix;                         // ideal TGeoHMatrix of the supermodule\r
 170   TGeoHMatrix   *fSensVolMatrix;                  // sensor's ideal matrices\r
 171   TGeoHMatrix   *fSensVolModifMatrix;             // sensor's modified matrices\r
 172   //\r
 173   AliITSAlignMille2Module* fParent;               // optional parent pointer\r
 174   TObjArray      fChildren;                       // array of optional children\r
 175   //\r
 176   static const Float_t fgkDummyConstraint;        // dummy (lose) contraint on parameter\r
 177   //\r
 178   ClassDef(AliITSAlignMille2Module, 0)\r
 179 }; \r
 180 \r
 181 #endif \r