Alignment framework (C.Cheshkov). More information is available in http://agenda...
[u/mrichter/AliRoot.git] / STEER / AliAlignObj.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 //   Implementation of the alignment object class through the abstract
18 //  class AliAlignObj. From it two derived concrete representation of
19 //  alignment object class (AliAlignObjAngles, AliAlignObjMatrix) are
20 //  derived in separate files.
21 //-----------------------------------------------------------------
22 /*****************************************************************************
23  * AliAlignObjAngles: derived alignment class storing alignment information  *
24  *   for a single volume in form of three doubles for the translation        *
25  *   and three doubles for the rotation expressed with the euler angles      *
26  *   in the xyz-convention (http://mathworld.wolfram.com/EulerAngles.html),  *
27  *   also known as roll, pitch, yaw. PLEASE NOTE THE ANGLES SIGNS ARE        *
28  *   INVERSE WITH RESPECT TO THIS REFERENCE!!! In this way the representation*
29  *   is fully consistent with the TGeo Rotation methods.                     *
30  *****************************************************************************/
31
32 #include "AliAlignObj.h"
33 //#include "AliLog.h"
34  
35 ClassImp(AliAlignObj)
36
37 Int_t AliAlignObj::fgLayerSize[kLastLayer - kFirstLayer] = {
38   80, 160,  // ITS SPD
39   84, 176,  // ITS SDD
40   748, 950, // ITS SSD
41   36, 36,   // TPC
42   90, 90, 90, 90, 90, 90,  // TRD
43   1,        // TOF ??
44   1, 1,     // PHOS ??
45   1,        // RICH ??
46   1         // MUON ??
47 };
48
49 const char* AliAlignObj::fgLayerName[kLastLayer - kFirstLayer] = {
50   "ITS inner pixels layer", "ITS outer pixels layer",
51   "ITS inner drifts layer", "ITS outer drifts layer",
52   "ITS inner strips layer", "ITS outer strips layer",
53   "TPC inner chambers layer", "TPC outer chambers layer",
54   "TRD chambers layer 1", "TRD chambers layer 2", "TRD chambers layer 3",
55   "TRD chambers layer 4", "TRD chambers layer 5", "TRD chambers layer 6",
56   "TOF layer",
57   "?","?",
58   "?",
59   "?"
60 };
61
62 //_____________________________________________________________________________
63 AliAlignObj::AliAlignObj():
64   fVolUID(0)
65 {
66   // dummy constructor
67 }
68
69 //_____________________________________________________________________________
70 AliAlignObj::AliAlignObj(const AliAlignObj& theAlignObj) :
71   TObject(theAlignObj)
72 {
73   //copy constructor
74   fVolPath = theAlignObj.GetVolPath();
75   fVolUID = theAlignObj.GetVolUID();
76 }
77
78 //_____________________________________________________________________________
79 AliAlignObj &AliAlignObj::operator =(const AliAlignObj& theAlignObj)
80 {
81   // assignment operator
82   if(this==&theAlignObj) return *this;
83   fVolPath = theAlignObj.GetVolPath();
84   fVolUID = theAlignObj.GetVolUID();
85   return *this;
86 }
87
88 //_____________________________________________________________________________
89 AliAlignObj::~AliAlignObj()
90 {
91   // dummy destructor
92 }
93
94 //_____________________________________________________________________________
95 void AliAlignObj::SetVolUID(ELayerID detId, Int_t modId)
96 {
97   // From detector name and module number (according to detector numbering)
98   // build fVolUID, unique numerical identity of that volume inside ALICE
99   // fVolUID is 16 bits, first 5 reserved for detID (32 possible values),
100   // remaining 11 for module ID inside det (2048 possible values).
101   //
102   fVolUID = LayerToVolUID(detId,modId);
103 }
104
105 //_____________________________________________________________________________
106 void AliAlignObj::GetVolUID(ELayerID &layerId, Int_t &modId) const
107 {
108   // From detector name and module number (according to detector numbering)
109   // build fVolUID, unique numerical identity of that volume inside ALICE
110   // fVolUID is 16 bits, first 5 reserved for detID (32 possible values),
111   // remaining 11 for module ID inside det (2048 possible values).
112   //
113   layerId = VolUIDToLayer(fVolUID,modId);
114 }
115
116 //_____________________________________________________________________________
117 void AliAlignObj::AnglesToMatrix(const Double_t *angles, Double_t *rot) const
118 {
119   // Calculates the rotation matrix using the 
120   // Euler angles in "x y z" notation
121   Double_t degrad = TMath::DegToRad();
122   Double_t sinpsi = TMath::Sin(degrad*angles[0]);
123   Double_t cospsi = TMath::Cos(degrad*angles[0]);
124   Double_t sinthe = TMath::Sin(degrad*angles[1]);
125   Double_t costhe = TMath::Cos(degrad*angles[1]);
126   Double_t sinphi = TMath::Sin(degrad*angles[2]);
127   Double_t cosphi = TMath::Cos(degrad*angles[2]);
128
129   rot[0] =  costhe*cosphi;
130   rot[1] = -costhe*sinphi;
131   rot[2] =  sinthe;
132   rot[3] =  sinpsi*sinthe*cosphi + cospsi*sinphi;
133   rot[4] = -sinpsi*sinthe*sinphi + cospsi*cosphi;
134   rot[5] = -costhe*sinpsi;
135   rot[6] = -cospsi*sinthe*cosphi + sinpsi*sinphi;
136   rot[7] =  cospsi*sinthe*sinphi + sinpsi*cosphi;
137   rot[8] =  costhe*cospsi;
138 }
139
140 //_____________________________________________________________________________
141 Bool_t AliAlignObj::MatrixToAngles(const Double_t *rot, Double_t *angles) const
142 {
143   // Calculates the Euler angles in "x y z" notation
144   // using the rotation matrix
145   if(rot[0]<1e-7 || rot[8]<1e-7) return kFALSE;
146   Double_t raddeg = TMath::RadToDeg();
147   angles[0]=raddeg*TMath::ATan2(-rot[5],rot[8]);
148   angles[1]=raddeg*TMath::ASin(rot[2]);
149   angles[2]=raddeg*TMath::ATan2(-rot[1],rot[0]);
150   return kTRUE;
151 }
152
153 //_____________________________________________________________________________
154 void AliAlignObj::Print(Option_t *) const
155 {
156   // Print the contents of the
157   // alignment object in angles and
158   // matrix representations
159   Double_t tr[3];
160   GetTranslation(tr);
161   Double_t angles[3];
162   GetAngles(angles);
163   TGeoHMatrix m;
164   GetMatrix(m);
165   const Double_t *rot = m.GetRotationMatrix();
166 //   printf("Volume=%s ID=%u\n", GetVolPath(),GetVolUID());
167   ELayerID layerId;
168   Int_t modId;
169   GetVolUID(layerId,modId);
170   printf("Volume=%s LayerID=%d ModuleID=%d\n", GetVolPath(),layerId,modId);
171   printf("%12.6f%12.6f%12.6f    Tx = %12.6f    Psi   = %12.6f\n", rot[0], rot[1], rot[2], tr[0], angles[0]);
172   printf("%12.6f%12.6f%12.6f    Ty = %12.6f    Theta = %12.6f\n", rot[3], rot[4], rot[5], tr[1], angles[1]);
173   printf("%12.6f%12.6f%12.6f    Tz = %12.6f    Phi   = %12.6f\n", rot[6], rot[7], rot[8], tr[2], angles[2]);
174
175 }
176
177 //_____________________________________________________________________________
178 UShort_t AliAlignObj::LayerToVolUID(ELayerID layerId, Int_t modId)
179 {
180   // From detector (layer) name and module number (according to detector numbering)
181   // build fVolUID, unique numerical identity of that volume inside ALICE
182   // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
183   // remaining 11 for module ID inside det (2048 possible values).
184   //
185   return ((UShort_t(layerId) << 11) | UShort_t(modId));
186 }
187
188 //_____________________________________________________________________________
189 AliAlignObj::ELayerID AliAlignObj::VolUIDToLayer(UShort_t voluid, Int_t &modId)
190 {
191   // From detector (layer) name and module number (according to detector numbering)
192   // build fVolUID, unique numerical identity of that volume inside ALICE
193   // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
194   // remaining 11 for module ID inside det (2048 possible values).
195   //
196   modId = voluid & 0x7ff;
197
198   return VolUIDToLayer(voluid);
199 }
200
201 //_____________________________________________________________________________
202 AliAlignObj::ELayerID AliAlignObj::VolUIDToLayer(UShort_t voluid)
203 {
204   // From detector (layer) name and module number (according to detector numbering)
205   // build fVolUID, unique numerical identity of that volume inside ALICE
206   // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
207   // remaining 11 for module ID inside det (2048 possible values).
208   //
209   return ELayerID((voluid >> 11) & 0x1f);
210 }