]>
Commit | Line | Data |
---|---|---|
c18195b9 | 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 | ||
090026bf | 16 | /* $Id$ */ |
17 | ||
c18195b9 | 18 | //----------------------------------------------------------------- |
7e154d52 | 19 | // Implementation of the alignment object class, holding the alignment |
20 | // constants for a single volume, through the abstract class AliAlignObj. | |
21 | // From it two derived concrete representation of alignment object class | |
90dbf5fb | 22 | // (AliAlignObjParams, AliAlignObjMatrix) are derived in separate files. |
c18195b9 | 23 | //----------------------------------------------------------------- |
a1e17193 | 24 | |
25 | #include <TClass.h> | |
995ad051 | 26 | #include <TGeoManager.h> |
27 | #include <TGeoPhysicalNode.h> | |
090026bf | 28 | #include <TMath.h> |
276cb1b1 | 29 | #include "TObjString.h" |
995ad051 | 30 | |
c18195b9 | 31 | #include "AliAlignObj.h" |
03b18860 | 32 | #include "AliTrackPointArray.h" |
33 | #include "AliLog.h" | |
90dbf5fb | 34 | #include "AliAlignObjParams.h" |
98937d93 | 35 | |
c18195b9 | 36 | ClassImp(AliAlignObj) |
37 | ||
38 | //_____________________________________________________________________________ | |
39 | AliAlignObj::AliAlignObj(): | |
fe12e09c | 40 | fVolPath(), |
c18195b9 | 41 | fVolUID(0) |
42 | { | |
03b18860 | 43 | // default constructor |
90dbf5fb | 44 | for(Int_t i=0; i<6; i++) fDiag[i]=-999.; |
45 | for(Int_t i=0; i<21; i++) fODia[i]=-999.; | |
c18195b9 | 46 | } |
47 | ||
48 | //_____________________________________________________________________________ | |
b760c02e | 49 | AliAlignObj::AliAlignObj(const char* symname, UShort_t voluid) : |
fe12e09c | 50 | TObject(), |
b760c02e | 51 | fVolPath(symname), |
fe12e09c | 52 | fVolUID(voluid) |
d9cc42ed | 53 | { |
54 | // standard constructor | |
55 | // | |
90dbf5fb | 56 | for(Int_t i=0; i<6; i++) fDiag[i]=-999.; |
57 | for(Int_t i=0; i<21; i++) fODia[i]=-999.; | |
58 | } | |
59 | ||
60 | //_____________________________________________________________________________ | |
61 | AliAlignObj::AliAlignObj(const char* symname, UShort_t voluid, Double_t* cmat) : | |
62 | TObject(), | |
63 | fVolPath(symname), | |
64 | fVolUID(voluid) | |
65 | { | |
66 | // standard constructor | |
67 | // | |
68 | SetCorrMatrix(cmat); | |
d9cc42ed | 69 | } |
70 | ||
d9cc42ed | 71 | //_____________________________________________________________________________ |
c18195b9 | 72 | AliAlignObj::AliAlignObj(const AliAlignObj& theAlignObj) : |
fe12e09c | 73 | TObject(theAlignObj), |
b760c02e | 74 | fVolPath(theAlignObj.GetSymName()), |
fe12e09c | 75 | fVolUID(theAlignObj.GetVolUID()) |
c18195b9 | 76 | { |
77 | //copy constructor | |
90dbf5fb | 78 | for(Int_t i=0; i<6; i++) fDiag[i]=theAlignObj.fDiag[i]; |
79 | for(Int_t i=0; i<21; i++) fODia[i]=theAlignObj.fODia[i]; | |
c18195b9 | 80 | } |
81 | ||
82 | //_____________________________________________________________________________ | |
83 | AliAlignObj &AliAlignObj::operator =(const AliAlignObj& theAlignObj) | |
84 | { | |
85 | // assignment operator | |
86 | if(this==&theAlignObj) return *this; | |
b760c02e | 87 | fVolPath = theAlignObj.GetSymName(); |
c18195b9 | 88 | fVolUID = theAlignObj.GetVolUID(); |
90dbf5fb | 89 | for(Int_t i=0; i<6; i++) fDiag[i]=theAlignObj.fDiag[i]; |
90 | for(Int_t i=0; i<21; i++) fODia[i]=theAlignObj.fODia[i]; | |
c18195b9 | 91 | return *this; |
92 | } | |
93 | ||
38b3a170 | 94 | //_____________________________________________________________________________ |
95 | AliAlignObj &AliAlignObj::operator*=(const AliAlignObj& theAlignObj) | |
96 | { | |
97 | // multiplication operator | |
98 | // The operator can be used to 'combine' | |
99 | // two alignment objects | |
100 | TGeoHMatrix m1; | |
101 | GetMatrix(m1); | |
102 | TGeoHMatrix m2; | |
103 | theAlignObj.GetMatrix(m2); | |
104 | m1.MultiplyLeft(&m2); | |
105 | SetMatrix(m1); | |
90dbf5fb | 106 | // temporary solution: consider parameters indipendent |
107 | for(Int_t i=0; i<6; i++) fDiag[i] = TMath::Sqrt((fDiag[i]*fDiag[i])+(theAlignObj.fDiag[i]*theAlignObj.fDiag[i])); | |
38b3a170 | 108 | return *this; |
109 | } | |
110 | ||
c18195b9 | 111 | //_____________________________________________________________________________ |
112 | AliAlignObj::~AliAlignObj() | |
113 | { | |
114 | // dummy destructor | |
115 | } | |
116 | ||
befe2c08 | 117 | //_____________________________________________________________________________ |
25be1e5c | 118 | void AliAlignObj::SetVolUID(AliGeomManager::ELayerID detId, Int_t modId) |
befe2c08 | 119 | { |
120 | // From detector name and module number (according to detector numbering) | |
121 | // build fVolUID, unique numerical identity of that volume inside ALICE | |
122 | // fVolUID is 16 bits, first 5 reserved for detID (32 possible values), | |
123 | // remaining 11 for module ID inside det (2048 possible values). | |
124 | // | |
25be1e5c | 125 | fVolUID = AliGeomManager::LayerToVolUID(detId,modId); |
befe2c08 | 126 | } |
127 | ||
128 | //_____________________________________________________________________________ | |
25be1e5c | 129 | void AliAlignObj::GetVolUID(AliGeomManager::ELayerID &layerId, Int_t &modId) const |
befe2c08 | 130 | { |
7e154d52 | 131 | // From the fVolUID, unique numerical identity of that volume inside ALICE, |
132 | // (voluid is 16 bits, first 5 reserved for layerID (32 possible values), | |
133 | // remaining 11 for module ID inside det (2048 possible values)), sets | |
134 | // the argument layerId to the identity of the layer to which that volume | |
135 | // belongs and sets the argument modId to the identity of that volume | |
136 | // internally to the layer. | |
befe2c08 | 137 | // |
25be1e5c | 138 | layerId = AliGeomManager::VolUIDToLayer(fVolUID,modId); |
befe2c08 | 139 | } |
140 | ||
b760c02e | 141 | //_____________________________________________________________________________ |
142 | Bool_t AliAlignObj::GetPars(Double_t tr[], Double_t angles[]) const | |
143 | { | |
144 | GetTranslation(tr); | |
145 | return GetAngles(angles); | |
146 | } | |
147 | ||
4b94e753 | 148 | //_____________________________________________________________________________ |
149 | Int_t AliAlignObj::GetLevel() const | |
150 | { | |
85fbf070 | 151 | // Return the geometry level of the alignable volume to which |
152 | // the alignment object is associated; this is the number of | |
153 | // slashes in the corresponding volume path | |
154 | // | |
155 | if(!gGeoManager){ | |
156 | AliWarning("gGeoManager doesn't exist or it is still opened: unable to return meaningful level value."); | |
157 | return (-1); | |
158 | } | |
159 | const char* symname = GetSymName(); | |
160 | const char* path; | |
161 | TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname); | |
162 | if(pne){ | |
163 | path = pne->GetTitle(); | |
164 | }else{ | |
165 | path = symname; | |
166 | } | |
167 | ||
168 | TString path_str = path; | |
169 | if(path_str[0]!='/') path_str.Prepend('/'); | |
170 | return path_str.CountChar('/'); | |
4b94e753 | 171 | } |
172 | ||
173 | //_____________________________________________________________________________ | |
174 | Int_t AliAlignObj::Compare(const TObject *obj) const | |
175 | { | |
176 | // Compare the levels of two | |
177 | // alignment objects | |
178 | // Used in the sorting during | |
179 | // the application of alignment | |
180 | // objects to the geometry | |
7e154d52 | 181 | // |
4b94e753 | 182 | Int_t level = GetLevel(); |
183 | Int_t level2 = ((AliAlignObj *)obj)->GetLevel(); | |
184 | if (level == level2) | |
185 | return 0; | |
186 | else | |
187 | return ((level > level2) ? 1 : -1); | |
188 | } | |
189 | ||
90dbf5fb | 190 | //______________________________________________________________________________ |
191 | void AliAlignObj::GetCovMatrix(Double_t *cmat) const | |
192 | { | |
193 | // Fills the cmat argument with the coefficients of the external cov matrix (21 elements) | |
194 | // calculating them from the correlation matrix data member | |
195 | // | |
196 | ||
197 | for(Int_t i=0; i<6; ++i) { | |
198 | // Off diagonal elements | |
199 | for(Int_t j=0; j<i; ++j) { | |
200 | cmat[i*(i+1)/2+j] = (fDiag[j] >= 0. && fDiag[i] >= 0.) ? fODia[(i-1)*i/2+j]*fDiag[j]*fDiag[i]: -999.; | |
201 | } | |
202 | ||
203 | // Diagonal elements | |
204 | cmat[i*(i+1)/2+i] = (fDiag[i] >= 0.) ? fDiag[i]*fDiag[i] : -999.; | |
205 | } | |
e9304cb8 | 206 | |
207 | return; | |
208 | } | |
209 | ||
210 | //______________________________________________________________________________ | |
211 | void AliAlignObj::GetCovMatrix(TMatrixDSym& mcov) const | |
212 | { | |
213 | // Fills the matrix m passed as argument as the covariance matrix calculated | |
214 | // from the coefficients of the reduced covariance matrix data members | |
215 | // | |
216 | ||
217 | for(Int_t i=0; i<6; ++i) { | |
218 | // Off diagonal elements | |
219 | for(Int_t j=0; j<i; ++j) { | |
220 | mcov(j,i) = mcov(i,j) = (fDiag[j] >= 0. && fDiag[i] >= 0.) ? fODia[(i-1)*i/2+j]*fDiag[j]*fDiag[i]: -999.; | |
221 | } | |
222 | ||
223 | // Diagonal elements | |
224 | mcov(i,i) = (fDiag[i] >= 0.) ? fDiag[i]*fDiag[i] : -999.; | |
225 | } | |
226 | ||
90dbf5fb | 227 | } |
228 | ||
229 | //______________________________________________________________________________ | |
230 | void AliAlignObj::SetCorrMatrix(Double_t *cmat) | |
231 | { | |
232 | // Sets the correlation matrix data member from the coefficients of the external covariance | |
233 | // matrix (21 elements passed as argument). | |
234 | // | |
235 | if(cmat) { | |
236 | ||
237 | // Diagonal elements first | |
238 | for(Int_t i=0; i<6; ++i) { | |
239 | fDiag[i] = (cmat[i*(i+1)/2+i] >= 0.) ? TMath::Sqrt(cmat[i*(i+1)/2+i]) : -999.; | |
240 | } | |
241 | ||
242 | // ... then the ones off diagonal | |
243 | for(Int_t i=0; i<6; ++i) | |
244 | // Off diagonal elements | |
245 | for(Int_t j=0; j<i; ++j) { | |
246 | fODia[(i-1)*i/2+j] = (fDiag[i] > 0. && fDiag[j] > 0.) ? cmat[i*(i+1)/2+j]/(fDiag[j]*fDiag[i]) : 0.; // check for division by zero (due to diagonal element of 0) and for fDiag != -999. (due to negative input diagonal element). | |
247 | if (fODia[(i-1)*i/2+j]>1.) fODia[(i-1)*i/2+j] = 1.; // check upper boundary | |
248 | if (fODia[(i-1)*i/2+j]<-1.) fODia[(i-1)*i/2+j] = -1.; // check lower boundary | |
249 | } | |
250 | } else { | |
251 | for(Int_t i=0; i< 6; ++i) fDiag[i]=-999.; | |
252 | for(Int_t i=0; i< 6*(6-1)/2; ++i) fODia[i]=0.; | |
253 | } | |
254 | ||
255 | return; | |
256 | } | |
257 | ||
e9304cb8 | 258 | //______________________________________________________________________________ |
259 | void AliAlignObj::SetCorrMatrix(TMatrixDSym& mcov) | |
260 | { | |
261 | // Sets the correlation matrix data member from the covariance matrix mcov passed | |
262 | // passed as argument. | |
263 | // | |
264 | if(mcov.IsValid()) { | |
265 | ||
266 | // Diagonal elements first | |
267 | for(Int_t i=0; i<6; ++i) { | |
268 | fDiag[i] = (mcov(i,i) >= 0.) ? TMath::Sqrt(mcov(i,i)) : -999.; | |
269 | } | |
270 | ||
271 | // ... then the ones off diagonal | |
272 | for(Int_t i=0; i<6; ++i) | |
273 | // Off diagonal elements | |
274 | for(Int_t j=0; j<i; ++j) { | |
275 | fODia[(i-1)*i/2+j] = (fDiag[i] > 0. && fDiag[j] > 0.) ? mcov(i,j)/(fDiag[j]*fDiag[i]) : 0.; // check for division by zero (due to diagonal element of 0) and for fDiag != -999. (due to negative input diagonal element). | |
276 | if (fODia[(i-1)*i/2+j]>1.) fODia[(i-1)*i/2+j] = 1.; // check upper boundary | |
277 | if (fODia[(i-1)*i/2+j]<-1.) fODia[(i-1)*i/2+j] = -1.; // check lower boundary | |
278 | } | |
279 | } else { | |
280 | for(Int_t i=0; i< 6; ++i) fDiag[i]=-999.; | |
281 | for(Int_t i=0; i< 6*(6-1)/2; ++i) fODia[i]=0.; | |
282 | } | |
283 | ||
284 | return; | |
285 | } | |
286 | ||
c18195b9 | 287 | //_____________________________________________________________________________ |
288 | void AliAlignObj::AnglesToMatrix(const Double_t *angles, Double_t *rot) const | |
289 | { | |
fdf65bb5 | 290 | // Calculates the rotation matrix using the |
291 | // Euler angles in "x y z" notation | |
7e154d52 | 292 | // |
c18195b9 | 293 | Double_t degrad = TMath::DegToRad(); |
294 | Double_t sinpsi = TMath::Sin(degrad*angles[0]); | |
295 | Double_t cospsi = TMath::Cos(degrad*angles[0]); | |
296 | Double_t sinthe = TMath::Sin(degrad*angles[1]); | |
297 | Double_t costhe = TMath::Cos(degrad*angles[1]); | |
298 | Double_t sinphi = TMath::Sin(degrad*angles[2]); | |
299 | Double_t cosphi = TMath::Cos(degrad*angles[2]); | |
300 | ||
301 | rot[0] = costhe*cosphi; | |
302 | rot[1] = -costhe*sinphi; | |
303 | rot[2] = sinthe; | |
304 | rot[3] = sinpsi*sinthe*cosphi + cospsi*sinphi; | |
305 | rot[4] = -sinpsi*sinthe*sinphi + cospsi*cosphi; | |
306 | rot[5] = -costhe*sinpsi; | |
307 | rot[6] = -cospsi*sinthe*cosphi + sinpsi*sinphi; | |
308 | rot[7] = cospsi*sinthe*sinphi + sinpsi*cosphi; | |
309 | rot[8] = costhe*cospsi; | |
310 | } | |
311 | ||
312 | //_____________________________________________________________________________ | |
313 | Bool_t AliAlignObj::MatrixToAngles(const Double_t *rot, Double_t *angles) const | |
314 | { | |
fdf65bb5 | 315 | // Calculates the Euler angles in "x y z" notation |
316 | // using the rotation matrix | |
b760c02e | 317 | // Returns false in case the rotation angles can not be |
318 | // extracted from the matrix | |
7e154d52 | 319 | // |
b760c02e | 320 | if(TMath::Abs(rot[0])<1e-7 || TMath::Abs(rot[8])<1e-7) { |
321 | AliError("Failed to extract roll-pitch-yall angles!"); | |
322 | return kFALSE; | |
323 | } | |
c18195b9 | 324 | Double_t raddeg = TMath::RadToDeg(); |
325 | angles[0]=raddeg*TMath::ATan2(-rot[5],rot[8]); | |
326 | angles[1]=raddeg*TMath::ASin(rot[2]); | |
327 | angles[2]=raddeg*TMath::ATan2(-rot[1],rot[0]); | |
328 | return kTRUE; | |
329 | } | |
330 | ||
03b18860 | 331 | //______________________________________________________________________________ |
332 | void AliAlignObj::Transform(AliTrackPoint &p) const | |
333 | { | |
334 | // The method transforms the space-point coordinates using the | |
335 | // transformation matrix provided by the AliAlignObj | |
336 | // The covariance matrix is not affected since we assume | |
337 | // that the transformations are sufficiently small | |
7e154d52 | 338 | // |
03b18860 | 339 | if (fVolUID != p.GetVolumeID()) |
340 | AliWarning(Form("Alignment object ID is not equal to the space-point ID (%d != %d)",fVolUID,p.GetVolumeID())); | |
341 | ||
342 | TGeoHMatrix m; | |
343 | GetMatrix(m); | |
344 | Double_t *rot = m.GetRotationMatrix(); | |
345 | Double_t *tr = m.GetTranslation(); | |
346 | ||
347 | Float_t xyzin[3],xyzout[3]; | |
348 | p.GetXYZ(xyzin); | |
349 | for (Int_t i = 0; i < 3; i++) | |
350 | xyzout[i] = tr[i]+ | |
351 | xyzin[0]*rot[3*i]+ | |
352 | xyzin[1]*rot[3*i+1]+ | |
353 | xyzin[2]*rot[3*i+2]; | |
354 | p.SetXYZ(xyzout); | |
355 | ||
356 | } | |
357 | ||
79e21da6 | 358 | //_____________________________________________________________________________ |
03b18860 | 359 | void AliAlignObj::Transform(AliTrackPointArray &array) const |
360 | { | |
e1e6896f | 361 | // This method is used to transform all the track points |
362 | // from the input AliTrackPointArray | |
7e154d52 | 363 | // |
03b18860 | 364 | AliTrackPoint p; |
365 | for (Int_t i = 0; i < array.GetNPoints(); i++) { | |
366 | array.GetPoint(p,i); | |
367 | Transform(p); | |
368 | array.AddPoint(i,&p); | |
369 | } | |
370 | } | |
371 | ||
c18195b9 | 372 | //_____________________________________________________________________________ |
373 | void AliAlignObj::Print(Option_t *) const | |
374 | { | |
375 | // Print the contents of the | |
376 | // alignment object in angles and | |
377 | // matrix representations | |
7e154d52 | 378 | // |
c18195b9 | 379 | Double_t tr[3]; |
380 | GetTranslation(tr); | |
381 | Double_t angles[3]; | |
382 | GetAngles(angles); | |
383 | TGeoHMatrix m; | |
384 | GetMatrix(m); | |
385 | const Double_t *rot = m.GetRotationMatrix(); | |
c18195b9 | 386 | |
b760c02e | 387 | printf("Volume=%s\n",GetSymName()); |
c041444f | 388 | if (GetVolUID() != 0) { |
25be1e5c | 389 | AliGeomManager::ELayerID layerId; |
c041444f | 390 | Int_t modId; |
391 | GetVolUID(layerId,modId); | |
25be1e5c | 392 | printf("VolumeID=%d LayerID=%d ( %s ) ModuleID=%d\n", GetVolUID(),layerId,AliGeomManager::LayerName(layerId),modId); |
c041444f | 393 | } |
394 | printf("%12.8f%12.8f%12.8f Tx = %12.8f Psi = %12.8f\n", rot[0], rot[1], rot[2], tr[0], angles[0]); | |
395 | printf("%12.8f%12.8f%12.8f Ty = %12.8f Theta = %12.8f\n", rot[3], rot[4], rot[5], tr[1], angles[1]); | |
396 | printf("%12.8f%12.8f%12.8f Tz = %12.8f Phi = %12.8f\n", rot[6], rot[7], rot[8], tr[2], angles[2]); | |
397 | ||
398 | } | |
399 | ||
b760c02e | 400 | //_____________________________________________________________________________ |
401 | void AliAlignObj::SetPars(Double_t x, Double_t y, Double_t z, | |
402 | Double_t psi, Double_t theta, Double_t phi) | |
403 | { | |
32898fe7 | 404 | // Set the global delta transformation by passing 3 angles (expressed in |
405 | // degrees) and 3 shifts (in centimeters) | |
7e154d52 | 406 | // |
b760c02e | 407 | SetTranslation(x,y,z); |
408 | SetRotation(psi,theta,phi); | |
409 | } | |
410 | ||
1bfe7ffc | 411 | //_____________________________________________________________________________ |
412 | Bool_t AliAlignObj::SetLocalPars(Double_t x, Double_t y, Double_t z, | |
413 | Double_t psi, Double_t theta, Double_t phi) | |
414 | { | |
32898fe7 | 415 | // Set the global delta transformation by passing the parameters |
416 | // for the local delta transformation (3 shifts and 3 angles). | |
7e154d52 | 417 | // In case that the TGeo was not initialized or not closed, |
418 | // returns false and the object parameters are not set. | |
419 | // | |
b760c02e | 420 | TGeoHMatrix m; |
421 | Double_t tr[3] = {x, y, z}; | |
422 | m.SetTranslation(tr); | |
423 | Double_t angles[3] = {psi, theta, phi}; | |
424 | Double_t rot[9]; | |
425 | AnglesToMatrix(angles,rot); | |
426 | m.SetRotation(rot); | |
427 | ||
428 | return SetLocalMatrix(m); | |
429 | ||
430 | } | |
431 | ||
32898fe7 | 432 | //_____________________________________________________________________________ |
433 | Bool_t AliAlignObj::SetLocalTranslation(Double_t x, Double_t y, Double_t z) | |
434 | { | |
435 | // Set the global delta transformation by passing the three shifts giving | |
436 | // the translation in the local reference system of the alignable | |
437 | // volume (known by TGeo geometry). | |
438 | // In case that the TGeo was not initialized or not closed, | |
439 | // returns false and the object parameters are not set. | |
440 | // | |
441 | TGeoHMatrix m; | |
442 | Double_t tr[3] = {x, y, z}; | |
443 | m.SetTranslation(tr); | |
444 | ||
445 | return SetLocalMatrix(m); | |
446 | ||
447 | } | |
448 | ||
449 | //_____________________________________________________________________________ | |
450 | Bool_t AliAlignObj::SetLocalTranslation(const TGeoMatrix& m) | |
451 | { | |
452 | // Set the global delta transformation by passing the matrix of | |
453 | // the local delta transformation and taking its translational part | |
454 | // In case that the TGeo was not initialized or not closed, | |
455 | // returns false and the object parameters are not set. | |
456 | // | |
457 | const Double_t* tr = m.GetTranslation(); | |
458 | TGeoHMatrix mtr; | |
459 | mtr.SetTranslation(tr); | |
460 | ||
461 | return SetLocalMatrix(mtr); | |
462 | ||
463 | } | |
464 | ||
465 | //_____________________________________________________________________________ | |
466 | Bool_t AliAlignObj::SetLocalRotation(Double_t psi, Double_t theta, Double_t phi) | |
467 | { | |
468 | // Set the global delta transformation by passing the three angles giving | |
469 | // the rotation in the local reference system of the alignable | |
470 | // volume (known by TGeo geometry). | |
471 | // In case that the TGeo was not initialized or not closed, | |
472 | // returns false and the object parameters are not set. | |
473 | // | |
474 | TGeoHMatrix m; | |
475 | Double_t angles[3] = {psi, theta, phi}; | |
476 | Double_t rot[9]; | |
477 | AnglesToMatrix(angles,rot); | |
478 | m.SetRotation(rot); | |
479 | ||
480 | return SetLocalMatrix(m); | |
481 | ||
482 | } | |
483 | ||
484 | //_____________________________________________________________________________ | |
485 | Bool_t AliAlignObj::SetLocalRotation(const TGeoMatrix& m) | |
486 | { | |
487 | // Set the global delta transformation by passing the matrix of | |
488 | // the local delta transformation and taking its rotational part | |
489 | // In case that the TGeo was not initialized or not closed, | |
490 | // returns false and the object parameters are not set. | |
491 | // | |
492 | TGeoHMatrix rotm; | |
493 | const Double_t* rot = m.GetRotationMatrix(); | |
494 | rotm.SetRotation(rot); | |
495 | ||
496 | return SetLocalMatrix(rotm); | |
497 | ||
498 | } | |
499 | ||
b760c02e | 500 | //_____________________________________________________________________________ |
501 | Bool_t AliAlignObj::SetLocalMatrix(const TGeoMatrix& m) | |
502 | { | |
32898fe7 | 503 | // Set the global delta transformation by passing the TGeo matrix |
504 | // for the local delta transformation. | |
7e154d52 | 505 | // In case that the TGeo was not initialized or not closed, |
506 | // returns false and the object parameters are not set. | |
507 | // | |
1bfe7ffc | 508 | if (!gGeoManager || !gGeoManager->IsClosed()) { |
509 | AliError("Can't set the alignment object parameters! gGeoManager doesn't exist or it is still opened!"); | |
510 | return kFALSE; | |
511 | } | |
512 | ||
b760c02e | 513 | const char* symname = GetSymName(); |
514 | TGeoPhysicalNode* node; | |
515 | TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname); | |
516 | if(pne){ | |
517 | node = gGeoManager->MakeAlignablePN(pne); | |
518 | }else{ | |
519 | AliWarning(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as volume path!",symname)); | |
520 | node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(symname); | |
521 | } | |
522 | ||
1bfe7ffc | 523 | if (!node) { |
b760c02e | 524 | AliError(Form("Volume name or path %s not valid!",symname)); |
1bfe7ffc | 525 | return kFALSE; |
526 | } | |
527 | if (node->IsAligned()) | |
b760c02e | 528 | AliWarning(Form("Volume %s has been already misaligned!",symname)); |
1bfe7ffc | 529 | |
b760c02e | 530 | TGeoHMatrix m1; |
531 | const Double_t *tr = m.GetTranslation(); | |
532 | m1.SetTranslation(tr); | |
533 | const Double_t* rot = m.GetRotationMatrix(); | |
534 | m1.SetRotation(rot); | |
1bfe7ffc | 535 | |
536 | TGeoHMatrix align,gprime,gprimeinv; | |
537 | gprime = *node->GetMatrix(); | |
538 | gprimeinv = gprime.Inverse(); | |
b760c02e | 539 | m1.Multiply(&gprimeinv); |
540 | m1.MultiplyLeft(&gprime); | |
1bfe7ffc | 541 | |
b760c02e | 542 | return SetMatrix(m1); |
543 | } | |
1bfe7ffc | 544 | |
b760c02e | 545 | //_____________________________________________________________________________ |
546 | Bool_t AliAlignObj::SetMatrix(const TGeoMatrix& m) | |
547 | { | |
32898fe7 | 548 | // Set the global delta transformation by passing the TGeoMatrix |
549 | // for it | |
7e154d52 | 550 | // |
b760c02e | 551 | SetTranslation(m); |
552 | return SetRotation(m); | |
1bfe7ffc | 553 | } |
554 | ||
32898fe7 | 555 | //_____________________________________________________________________________ |
556 | Bool_t AliAlignObj::GetLocalPars(Double_t transl[], Double_t angles[]) const | |
557 | { | |
558 | // Get the translations and angles (in degrees) expressing the | |
559 | // local delta transformation. | |
560 | // In case that the TGeo was not initialized or not closed, | |
561 | // returns false and the object parameters are not set. | |
562 | // | |
563 | if(!GetLocalTranslation(transl)) return kFALSE; | |
564 | return GetLocalAngles(angles); | |
565 | } | |
566 | ||
567 | //_____________________________________________________________________________ | |
568 | Bool_t AliAlignObj::GetLocalTranslation(Double_t* tr) const | |
569 | { | |
570 | // Get the 3 shifts giving the translational part of the local | |
571 | // delta transformation. | |
572 | // In case that the TGeo was not initialized or not closed, | |
573 | // returns false and the object parameters are not set. | |
574 | // | |
575 | TGeoHMatrix ml; | |
576 | if(!GetLocalMatrix(ml)) return kFALSE; | |
577 | const Double_t* transl; | |
578 | transl = ml.GetTranslation(); | |
579 | tr[0]=transl[0]; | |
580 | tr[1]=transl[1]; | |
581 | tr[2]=transl[2]; | |
582 | return kTRUE; | |
583 | } | |
584 | ||
585 | //_____________________________________________________________________________ | |
586 | Bool_t AliAlignObj::GetLocalAngles(Double_t* angles) const | |
587 | { | |
588 | // Get the 3 angles giving the rotational part of the local | |
589 | // delta transformation. | |
590 | // In case that the TGeo was not initialized or not closed, | |
591 | // returns false and the object parameters are not set. | |
592 | // | |
593 | TGeoHMatrix ml; | |
594 | if(!GetLocalMatrix(ml)) return kFALSE; | |
595 | const Double_t *rot = ml.GetRotationMatrix(); | |
596 | return MatrixToAngles(rot,angles); | |
597 | } | |
598 | ||
599 | //_____________________________________________________________________________ | |
600 | Bool_t AliAlignObj::GetLocalMatrix(TGeoHMatrix& m) const | |
601 | { | |
602 | // Get the matrix for the local delta transformation. | |
603 | // In case that the TGeo was not initialized or not closed, | |
604 | // returns false and the object parameters are not set. | |
605 | // | |
606 | if (!gGeoManager || !gGeoManager->IsClosed()) { | |
607 | AliError("Can't set the alignment object parameters! gGeoManager doesn't exist or it is still opened!"); | |
608 | return kFALSE; | |
609 | } | |
610 | ||
611 | const char* symname = GetSymName(); | |
612 | TGeoPhysicalNode* node; | |
613 | TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname); | |
614 | if(pne){ | |
615 | node = gGeoManager->MakeAlignablePN(pne); | |
616 | }else{ | |
617 | AliWarning(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as volume path!",symname)); | |
618 | node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(symname); | |
619 | } | |
620 | ||
621 | if (!node) { | |
622 | AliError(Form("Volume name or path %s not valid!",symname)); | |
623 | return kFALSE; | |
624 | } | |
625 | if (node->IsAligned()) | |
626 | AliWarning(Form("Volume %s has been already misaligned!",symname)); | |
627 | ||
628 | GetMatrix(m); | |
629 | TGeoHMatrix gprime,gprimeinv; | |
630 | gprime = *node->GetMatrix(); | |
631 | gprimeinv = gprime.Inverse(); | |
632 | m.Multiply(&gprime); | |
633 | m.MultiplyLeft(&gprimeinv); | |
634 | ||
635 | return kTRUE; | |
636 | } | |
637 | ||
995ad051 | 638 | //_____________________________________________________________________________ |
639 | Bool_t AliAlignObj::ApplyToGeometry() | |
640 | { | |
7e154d52 | 641 | // Apply the current alignment object to the TGeo geometry |
642 | // This method returns FALSE if the symname of the object was not | |
643 | // valid neither to get a TGeoPEntry nor as a volume path | |
644 | // | |
995ad051 | 645 | if (!gGeoManager || !gGeoManager->IsClosed()) { |
646 | AliError("Can't apply the alignment object! gGeoManager doesn't exist or it is still opened!"); | |
647 | return kFALSE; | |
648 | } | |
649 | ||
b760c02e | 650 | const char* symname = GetSymName(); |
651 | const char* path; | |
652 | TGeoPhysicalNode* node; | |
653 | TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname); | |
654 | if(pne){ | |
b760c02e | 655 | path = pne->GetTitle(); |
7e154d52 | 656 | node = gGeoManager->MakeAlignablePN(pne); |
b760c02e | 657 | }else{ |
5bd470e1 | 658 | AliDebug(1,Form("The symbolic volume name %s does not correspond to a physical entry. Using it as a volume path!",symname)); |
b760c02e | 659 | path=symname; |
7e154d52 | 660 | if (!gGeoManager->CheckPath(path)) { |
5bd470e1 | 661 | AliDebug(1,Form("Volume path %s not valid!",path)); |
b760c02e | 662 | return kFALSE; |
663 | } | |
7e154d52 | 664 | if (gGeoManager->GetListOfPhysicalNodes()->FindObject(path)) { |
665 | AliError(Form("Volume %s has already been misaligned!",path)); | |
b760c02e | 666 | return kFALSE; |
667 | } | |
668 | node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(path); | |
995ad051 | 669 | } |
48cac49d | 670 | |
48cac49d | 671 | if (!node) { |
b760c02e | 672 | AliError(Form("Volume path %s not valid!",path)); |
995ad051 | 673 | return kFALSE; |
674 | } | |
675 | ||
676 | TGeoHMatrix align,gprime; | |
677 | gprime = *node->GetMatrix(); | |
678 | GetMatrix(align); | |
679 | gprime.MultiplyLeft(&align); | |
680 | TGeoHMatrix *ginv = new TGeoHMatrix; | |
681 | TGeoHMatrix *g = node->GetMatrix(node->GetLevel()-1); | |
682 | *ginv = g->Inverse(); | |
683 | *ginv *= gprime; | |
25be1e5c | 684 | AliGeomManager::ELayerID layerId; // unique identity for layer in the alobj |
b760c02e | 685 | Int_t modId; // unique identity for volume inside layer in the alobj |
995ad051 | 686 | GetVolUID(layerId, modId); |
b760c02e | 687 | AliDebug(2,Form("Aligning volume %s of detector layer %d with local ID %d",symname,layerId,modId)); |
995ad051 | 688 | node->Align(ginv); |
689 | ||
690 | return kTRUE; | |
691 | } | |
692 |