Fixes for Coverity warnings (M. van Leeuwen)
[u/mrichter/AliRoot.git] / 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);\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 AliAlignObjParams fgTempAlignObj;        // temp.alignment object used as a buffer               \r
177   static const Float_t fgkDummyConstraint;        // dummy (lose) contraint on parameter\r
178   //\r
179   ClassDef(AliITSAlignMille2Module, 0)\r
180 }; \r
181 \r
182 #endif \r