Fixes for coverity.
[u/mrichter/AliRoot.git] / STEER / STEER / AliCluster.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 //-------------------------------------------------------------------------
17 //                         Class AliCluster
18 // This is the future base for managing the clusters in barrel detectors.
19 // It is fully interfaced with the ROOT geometrical modeller TGeo.
20 // Each cluster contains XYZ coordinates in the local tracking c.s. and
21 // the unique ID of the sensitive detector element which continas the
22 // cluster. The coordinates in global c.s. are computed using the interface
23 // to TGeo and will be not overwritten by the derived sub-detector cluster
24 // classes.
25 //
26 // cvetan.cheshkov@cern.ch & jouri.belikov@cern.ch    5/3/2007
27 //-------------------------------------------------------------------------
28
29 #include <TGeoManager.h>
30 #include <TGeoMatrix.h>
31 #include <TGeoPhysicalNode.h>
32 #include <TMath.h>
33
34 #include "AliCluster.h"
35 #include "AliLog.h"
36 #include "AliAlignObj.h"
37
38 ClassImp(AliCluster)
39
40 //______________________________________________________________________________
41 AliCluster::AliCluster():
42   TObject(),
43   fX(0),
44   fY(0),
45   fZ(0),
46   fSigmaY2(0),
47   fSigmaZ2(0),
48   fSigmaYZ(0),
49   fVolumeId(0),
50   fIsMisaligned(kFALSE)
51 {
52   // Default constructor
53   fTracks[0]=fTracks[1]=fTracks[2]=-3141593; 
54 }
55
56 //______________________________________________________________________________
57 AliCluster::AliCluster(UShort_t volId,
58                                const Float_t *hit,
59                                Float_t x,
60                                Float_t sigyz,
61                                const Int_t *lab):
62   TObject(),
63   fX(x),
64   fY(hit[0]),
65   fZ(hit[1]),
66   fSigmaY2(hit[2]),
67   fSigmaZ2(hit[3]),
68   fSigmaYZ(sigyz),
69   fVolumeId(volId),
70   fIsMisaligned(kFALSE)
71 {
72   // Constructor
73   if (lab) {
74     fTracks[0] = lab[0];
75     fTracks[1] = lab[1];
76     fTracks[2] = lab[2];
77   }
78   else
79     fTracks[0]=fTracks[1]=fTracks[2]=-3141593; 
80 }
81
82 //______________________________________________________________________________
83 AliCluster::AliCluster(UShort_t volId,
84                                Float_t x, Float_t y, Float_t z,
85                                Float_t sy2, Float_t sz2, Float_t syz,
86                                const Int_t *lab):
87   TObject(),
88   fX(x),
89   fY(y),
90   fZ(z),
91   fSigmaY2(sy2),
92   fSigmaZ2(sz2),
93   fSigmaYZ(syz),
94   fVolumeId(volId),
95   fIsMisaligned(kFALSE)
96 {
97   // Constructor
98   if (lab) {
99     fTracks[0] = lab[0];
100     fTracks[1] = lab[1];
101     fTracks[2] = lab[2];
102   }
103   else
104     fTracks[0]=fTracks[1]=fTracks[2]=-3141593; 
105 }
106
107 //______________________________________________________________________________
108 AliCluster::AliCluster(const AliCluster& cluster):
109   TObject(cluster),
110   fX(cluster.fX),
111   fY(cluster.fY),
112   fZ(cluster.fZ),
113   fSigmaY2(cluster.fSigmaY2),
114   fSigmaZ2(cluster.fSigmaZ2),
115   fSigmaYZ(cluster.fSigmaYZ),
116   fVolumeId(cluster.fVolumeId),
117   fIsMisaligned(cluster.fIsMisaligned)
118 {
119   // Copy constructor
120   fTracks[0] = cluster.fTracks[0];
121   fTracks[1] = cluster.fTracks[1];
122   fTracks[2] = cluster.fTracks[2];
123 }
124
125 //______________________________________________________________________________
126 AliCluster & AliCluster::operator=(const AliCluster& cluster)
127 {
128   // Assignment operator
129
130   if(&cluster == this) return *this;
131
132   fX = cluster.fX;
133   fY = cluster.fY;
134   fZ = cluster.fZ;
135   fSigmaY2 = cluster.fSigmaY2;
136   fSigmaZ2 = cluster.fSigmaZ2;
137   fSigmaYZ = cluster.fSigmaYZ;
138   fVolumeId = cluster.fVolumeId;
139   fIsMisaligned = cluster.fIsMisaligned;
140
141   fTracks[0] = cluster.fTracks[0];
142   fTracks[1] = cluster.fTracks[1];
143   fTracks[2] = cluster.fTracks[2];
144
145   return *this;
146 }
147
148 //______________________________________________________________________________
149 void AliCluster::Print(Option_t* /*option*/) const
150 {
151   // Print cluster information.
152   
153   printf("AliCluster pos=(%.4f, %.4f, %.4f), s_y2=%f, s_z2=%f, s_yz=%f, vol=%hu\n",
154          fX, fY, fZ, fSigmaY2, fSigmaZ2, fSigmaYZ, fVolumeId);
155   Float_t g[3];
156   if (GetGlobalXYZ(g))
157     printf("    global_pos=(%.4f, %.4f, %.4f)\n", g[0], g[1], g[2]);
158
159 }
160
161 //______________________________________________________________________________
162 Bool_t AliCluster::GetGlobalXYZ(Float_t xyz[3]) const
163 {
164   // Get the global coordinates of the cluster
165   // All the needed information is taken only
166   // from TGeo.
167
168   xyz[0] = xyz[1] = xyz[2] = 0;
169
170   if (!gGeoManager || !gGeoManager->IsClosed()) {
171     AliError("Can't get the global coordinates! gGeoManager doesn't exist or it is still opened!");
172     return kFALSE;
173   }
174
175   const TGeoHMatrix *mt = GetTracking2LocalMatrix();
176   if (!mt) return kFALSE;
177   Double_t txyz[3] = {fX, fY, fZ};
178   Double_t lxyz[3] = {0, 0, 0};
179   mt->LocalToMaster(txyz,lxyz);
180
181   TGeoHMatrix *ml = GetMatrix();
182   if (!ml) return kFALSE;
183   Double_t gxyz[3] = {0, 0, 0};
184   ml->LocalToMaster(lxyz,gxyz);
185   xyz[0] = gxyz[0]; xyz[1] = gxyz[1]; xyz[2] = gxyz[2];
186   return kTRUE;
187 }
188
189 //______________________________________________________________________________
190 Bool_t AliCluster::GetGlobalCov(Float_t cov[6]) const
191 {
192   // Get the global covariance matrix of the cluster coordinates
193   // All the needed information is taken only
194   // from TGeo.
195   for (Int_t i = 0; i < 6; i++) cov[i] = 0;
196
197   if (!gGeoManager || !gGeoManager->IsClosed()) {
198     AliError("Can't get the global coordinates! gGeoManager doesn't exist or it is still opened!");
199     return kFALSE;
200   }
201
202   const TGeoHMatrix *mt = GetTracking2LocalMatrix();
203   if (!mt) return kFALSE;
204
205   TGeoHMatrix *ml = GetMatrix();
206   if (!ml) return kFALSE;
207
208   TGeoHMatrix m;
209   Double_t tcov[9] = { 0, 0, 0, 0, fSigmaY2, fSigmaYZ, 0, fSigmaYZ, fSigmaZ2 };
210   m.SetRotation(tcov);
211   m.Multiply(&mt->Inverse());
212   m.Multiply(&ml->Inverse());
213   m.MultiplyLeft(mt);
214   m.MultiplyLeft(ml);
215   Double_t *ncov = m.GetRotationMatrix();
216   cov[0] = ncov[0]; cov[1] = ncov[1]; cov[2] = ncov[2];
217   cov[3] = ncov[4]; cov[4] = ncov[5];
218   cov[5] = ncov[8];
219
220   return kTRUE;
221 }
222
223 //______________________________________________________________________________
224 Bool_t AliCluster::GetXRefPlane(Float_t &xref) const
225 {
226   // Get the distance between the origin and the ref.plane.
227   // All the needed information is taken only
228   // from TGeo.
229   xref = 0;
230
231   const TGeoHMatrix *mt = GetTracking2LocalMatrix();
232   if (!mt) return kFALSE;
233
234   TGeoHMatrix *ml = GetMatrix();
235   if (!ml) return kFALSE;
236
237   TGeoHMatrix m = *mt;
238   m.MultiplyLeft(ml);
239
240   xref = -(m.Inverse()).GetTranslation()[0];
241   return kTRUE;
242 }
243
244 //______________________________________________________________________________
245 Bool_t AliCluster::GetXAlphaRefPlane(Float_t &x, Float_t &alpha) const
246 {
247   // Get the distance between the origin and the ref. plane together with
248   // the rotation anlge of the ref. plane.
249   // All the needed information is taken only
250   // from TGeo.
251   const TGeoHMatrix *mt = GetTracking2LocalMatrix();
252   if (!mt) return kFALSE;
253
254   const TGeoHMatrix *ml = GetMatrix();
255   if (!ml) return kFALSE;
256
257   TGeoHMatrix m(*ml);
258   m.Multiply(mt);
259   const Double_t txyz[3]={0.}; Double_t xyz[3]={0.};
260   m.LocalToMaster(txyz,xyz);
261     
262   x=TMath::Sqrt(xyz[0]*xyz[0] + xyz[1]*xyz[1]);
263     
264   Double_t a=TMath::ATan2(xyz[1],xyz[0]);
265   if (a<0) a+=TMath::TwoPi();
266   else if (a>=TMath::TwoPi()) a-=TMath::TwoPi();
267   alpha=a;
268
269   return kTRUE;
270 }
271
272 //______________________________________________________________________________
273 Bool_t AliCluster::Misalign()
274 {
275   // ...
276   // All the needed information is taken only
277   // from TGeo.
278   if (!gGeoManager || !gGeoManager->IsClosed()) {
279     AliError("Can't get the PN entry! gGeoManager doesn't exist or it is still opened!");
280     return kFALSE;
281   }
282
283   if (fIsMisaligned) {
284     AliError("The cluster was already misaligned!");
285     return kFALSE;
286   }
287
288   const TGeoHMatrix *mt = GetTracking2LocalMatrix();
289   if (!mt) return kFALSE;
290
291   TGeoHMatrix *ml = GetMatrix();
292   if (!ml) return kFALSE;
293
294   TGeoHMatrix *mlorig = GetMatrix(kTRUE);
295   if (!mlorig) return kFALSE;
296
297   TGeoHMatrix delta = *mt;
298   delta.MultiplyLeft(ml);
299   delta.MultiplyLeft(&(mlorig->Inverse()));
300   delta.MultiplyLeft(&(mt->Inverse()));
301
302   Double_t xyzorig[3] = {fX, fY, fZ};
303   Double_t xyz[3] = {0, 0, 0};
304   delta.LocalToMaster(xyzorig,xyz);
305   fX = xyz[0]; fY = xyz[1]; fZ = xyz[2];
306   fIsMisaligned = kTRUE;
307   return kTRUE;
308 }
309
310 //______________________________________________________________________________
311 TGeoHMatrix* AliCluster::GetMatrix(Bool_t original) const
312 {
313   // Get the matrix which transforms from the
314   // local TGeo alignable volume c.s. to the global one.
315   // In case the cluster was already misaligned, get the
316   // ideal matrix from TGeo. The option 'original'
317   // can be used to force the calculation of the ideal
318   // matrix.
319   if (!fIsMisaligned && (original == kFALSE)) {
320     return AliGeomManager::GetMatrix(fVolumeId);
321   }
322   else {
323     return AliGeomManager::GetOrigGlobalMatrix(fVolumeId);
324   }
325 }
326
327 //______________________________________________________________________________
328 const TGeoHMatrix* AliCluster::GetTracking2LocalMatrix() const
329 {
330   // Get the matrix which is stored with the PN entries in TGeo.
331   // The matrix makes the transformation from the tracking c.s. to
332   // the local one.
333   return AliGeomManager::GetTracking2LocalMatrix(fVolumeId);
334 }
335