1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 //-----------------------------------------------------------------
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
22 // (AliAlignObjParams, AliAlignObjMatrix) are derived in separate files.
23 //-----------------------------------------------------------------
25 #include <TGeoManager.h>
26 #include <TGeoMatrix.h>
27 #include <TGeoPhysicalNode.h>
28 #include <TGeoOverlap.h>
31 #include "AliAlignObj.h"
32 #include "AliTrackPointArray.h"
37 //_____________________________________________________________________________
38 AliAlignObj::AliAlignObj():
42 // default constructor
43 for(Int_t i=0; i<6; i++) fDiag[i]=-999.;
44 for(Int_t i=0; i<15; i++) fODia[i]=-999.;
47 //_____________________________________________________________________________
48 AliAlignObj::AliAlignObj(const char* symname, UShort_t voluid) :
53 // standard constructor
55 for(Int_t i=0; i<6; i++) fDiag[i]=-999.;
56 for(Int_t i=0; i<15; i++) fODia[i]=-999.;
59 //_____________________________________________________________________________
60 AliAlignObj::AliAlignObj(const char* symname, UShort_t voluid, Double_t* cmat) :
65 // standard constructor
70 //_____________________________________________________________________________
71 AliAlignObj::AliAlignObj(const AliAlignObj& theAlignObj) :
73 fVolPath(theAlignObj.GetSymName()),
74 fVolUID(theAlignObj.GetVolUID())
77 for(Int_t i=0; i<6; i++) fDiag[i]=theAlignObj.fDiag[i];
78 for(Int_t i=0; i<15; i++) fODia[i]=theAlignObj.fODia[i];
81 //_____________________________________________________________________________
82 AliAlignObj &AliAlignObj::operator =(const AliAlignObj& theAlignObj)
84 // assignment operator
85 if(this==&theAlignObj) return *this;
86 fVolPath = theAlignObj.GetSymName();
87 fVolUID = theAlignObj.GetVolUID();
88 for(Int_t i=0; i<6; i++) fDiag[i]=theAlignObj.fDiag[i];
89 for(Int_t i=0; i<15; i++) fODia[i]=theAlignObj.fODia[i];
93 //_____________________________________________________________________________
94 AliAlignObj &AliAlignObj::operator*=(const AliAlignObj& theAlignObj)
96 // multiplication operator
97 // The operator can be used to 'combine'
98 // two alignment objects
102 theAlignObj.GetMatrix(m2);
103 m1.MultiplyLeft(&m2);
105 // temporary solution: the covariance matrix of the resulting combined object
106 // is set equal to the covariance matrix of the right operand
107 // (not to be used for combining alignment objects for different levels)
108 for(Int_t i=0; i<6; i++) fDiag[i] = theAlignObj.fDiag[i];
109 for(Int_t i=0; i<15; i++) fODia[i] = theAlignObj.fODia[i];
113 //_____________________________________________________________________________
114 AliAlignObj::~AliAlignObj()
119 //_____________________________________________________________________________
120 void AliAlignObj::SetVolUID(AliGeomManager::ELayerID detId, Int_t modId)
122 // From detector name and module number (according to detector numbering)
123 // build fVolUID, unique numerical identity of that volume inside ALICE
124 // fVolUID is 16 bits, first 5 reserved for detID (32 possible values),
125 // remaining 11 for module ID inside det (2048 possible values).
127 fVolUID = AliGeomManager::LayerToVolUID(detId,modId);
130 //_____________________________________________________________________________
131 void AliAlignObj::GetVolUID(AliGeomManager::ELayerID &layerId, Int_t &modId) const
133 // From the fVolUID, unique numerical identity of that volume inside ALICE,
134 // (voluid is 16 bits, first 5 reserved for layerID (32 possible values),
135 // remaining 11 for module ID inside det (2048 possible values)), sets
136 // the argument layerId to the identity of the layer to which that volume
137 // belongs and sets the argument modId to the identity of that volume
138 // internally to the layer.
140 layerId = AliGeomManager::VolUIDToLayer(fVolUID,modId);
143 //_____________________________________________________________________________
144 Bool_t AliAlignObj::GetPars(Double_t tr[], Double_t angles[]) const
147 return GetAngles(angles);
150 //_____________________________________________________________________________
151 Int_t AliAlignObj::GetLevel() const
153 // Return the geometry level of the alignable volume to which
154 // the alignment object is associated; this is the number of
155 // slashes in the corresponding volume path
158 AliWarning("gGeoManager doesn't exist or it is still open: unable to return meaningful level value.");
161 const char* symname = GetSymName();
163 TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname);
165 path = pne->GetTitle();
170 TString pathStr = path;
171 if(pathStr[0]!='/') pathStr.Prepend('/');
172 return pathStr.CountChar('/');
175 //_____________________________________________________________________________
176 Int_t AliAlignObj::Compare(const TObject *obj) const
178 // Compare the levels of two
180 // Used in the sorting during
181 // the application of alignment
182 // objects to the geometry
184 Int_t level = GetLevel();
185 Int_t level2 = ((AliAlignObj *)obj)->GetLevel();
189 return ((level > level2) ? 1 : -1);
192 //______________________________________________________________________________
193 void AliAlignObj::GetCovMatrix(Double_t *cmat) const
195 // Fills the cmat argument with the coefficients of the external cov matrix (21 elements)
196 // calculating them from the correlation matrix data member
199 for(Int_t i=0; i<6; ++i) {
200 // Off diagonal elements
201 for(Int_t j=0; j<i; ++j) {
202 cmat[i*(i+1)/2+j] = (fDiag[j] >= 0. && fDiag[i] >= 0.) ? fODia[(i-1)*i/2+j]*fDiag[j]*fDiag[i]: -999.;
206 cmat[i*(i+1)/2+i] = (fDiag[i] >= 0.) ? fDiag[i]*fDiag[i] : -999.;
212 //______________________________________________________________________________
213 void AliAlignObj::GetCovMatrix(TMatrixDSym& mcov) const
215 // Fills the matrix m passed as argument as the covariance matrix calculated
216 // from the coefficients of the reduced covariance matrix data members
219 for(Int_t i=0; i<6; ++i) {
220 // Off diagonal elements
221 for(Int_t j=0; j<i; ++j) {
222 mcov(j,i) = mcov(i,j) = (fDiag[j] >= 0. && fDiag[i] >= 0.) ? fODia[(i-1)*i/2+j]*fDiag[j]*fDiag[i]: -999.;
226 mcov(i,i) = (fDiag[i] >= 0.) ? fDiag[i]*fDiag[i] : -999.;
231 //______________________________________________________________________________
232 Bool_t AliAlignObj::GetLocalCovMatrix(TMatrixDSym& lCov) const
234 // Calculates the covariance matrix (6x6) associated to the six parameters
235 // defining the current alignment in the global coordinates system (and sets
236 // in the internal data members) from the covariance matrix (6x6) for the six
237 // parameters defining the alignment transformation in the local coordinates
238 // system, passed as an argument.
240 TMatrixD mJ(6,6);// the jacobian of the transformation from local to global parameters
241 if(!GetJacobian(mJ)) return kFALSE;
242 TMatrixD invJ = mJ.Invert(); // the inverse of the jacobian matrix
247 // Compute the global covariance matrix gcov = mJ lcov mJ-1
248 TMatrixD lCovM = invJ * gCov * mJ;
249 // To be done: somehow check that lCovM is close enough to be symmetric
250 for(Int_t i=0; i<6; i++)
252 lCov(i,i) = lCovM(i,i);
253 for(Int_t j=i+1; j<6; j++)
255 lCov(i,j)=lCovM(i,j);
256 lCov(j,i)=lCovM(i,j);
264 //______________________________________________________________________________
265 Bool_t AliAlignObj::GetLocalCovMatrix(Double_t *lCov) const
267 // Calculates the covariance matrix (6x6) associated to the six parameters
268 // defining the current alignment in the global coordinates system (and sets
269 // in the internal data members) from the covariance matrix (6x6) for the six
270 // parameters defining the alignment transformation in the local coordinates
271 // system, passed as an argument.
273 TMatrixDSym lCovMatrix(6);
274 GetLocalCovMatrix(lCovMatrix);
277 for(Int_t i=0; i<6; i++)
278 for(Int_t j=i; j<6; j++)
280 lCov[k++] = lCovMatrix(i,j);
286 //______________________________________________________________________________
287 Bool_t AliAlignObj::GetJacobian(TMatrixD& mJ) const
289 // Compute the jacobian J of the transformation of the six local to the six global delta parameters
291 // R00 R01 R02 | (R01Rk2 - R02Rk1)Tk (R02Rk0 - R00Rk2)Tk (R00Rk1 - R01Rk0)Tk
292 // R00 R01 R02 | (R11Rk2 - R12Rk1)Tk (R12Rk0 - R10Rk2)Tk (R10Rk1 - R11Rk0)Tk
293 // R00 R01 R02 | (R21Rk2 - R22Rk1)Tk (R22Rk0 - R20Rk2)Tk (R20Rk1 - R21Rk0)Tk
294 // - - - - - - - - - - - - - - - - - - - - - - -
295 // 0 0 0 | R11R22 - R12R21 R12R20 - R10R22 R10R21 - R11R20
296 // 0 0 0 | R21R02 - R22R01 R22R00 - R20R02 R20R01 - R21R00
297 // 0 0 0 | R01R12 - R02R11 R02R10 - R00R12 R00R11 - R01R10
299 if (!gGeoManager || !gGeoManager->IsClosed()) {
300 AliError("Can't compute the global covariance matrix from the local one without an open geometry!");
304 const char* symname = GetSymName();
305 TGeoPhysicalNode* node;
306 TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname);
308 if(!pne->GetPhysicalNode()){
309 node = gGeoManager->MakeAlignablePN(pne);
311 node = pne->GetPhysicalNode();
314 AliWarning(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as volume path!",symname));
315 node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(symname);
319 AliError(Form("Volume name or path %s not valid!",symname));
323 TGeoHMatrix gm; //global matrix
324 gm = *node->GetMatrix();
325 Double_t *tr = gm.GetTranslation();
326 Double_t *rot = gm.GetRotationMatrix();
328 TGeoHMatrix m; // global delta transformation matrix
330 // We should probably check that it's sufficinetly close to identity
331 // if it's not return because the "small angles" approximation cannot hold
333 // 3x3 upper left part (global shifts derived w.r.t. local shifts)
334 for(Int_t i=0; i<3; i++)
336 for(Int_t j=0; j<3; j++)
338 mJ(i,j) = rot[i+3*j];
342 // 3x3 lower left part (global angles derived w.r.t. local shifts)
343 for(Int_t i=0; i<3; i++)
345 for(Int_t j=0; j<3; j++)
351 // 3x3 upper right part (global shifts derived w.r.t. local angles)
352 for(Int_t i=0; i<3; i++)
354 for(Int_t j=0; j<3; j++)
359 for(Int_t k=0; k<3; k++)
361 mEl += (rot[3*i+b]*rot[3*k+d])*tr[k]-(rot[3*i+d]*rot[3*k+b])*tr[k];
367 // 3x3 lower right part (global angles derived w.r.t. local angles)
368 for(Int_t i=0; i<3; i++)
369 for(Int_t j=0; j<3; j++)
375 mJ(i+3,j+3) = rot[3*a+b]*rot[3*c+d]-rot[3*a+d]*rot[3*c+b];
382 //______________________________________________________________________________
383 Bool_t AliAlignObj::SetFromLocalCov(TMatrixDSym& lCov)
385 // Calculates the covariance matrix (6x6) associated to the six parameters
386 // defining the current alignment in the global coordinates system (and sets
387 // in the internal data members) from the covariance matrix (6x6) for the six
388 // parameters defining the alignment transformation in the local coordinates
389 // system, passed as an argument.
391 TMatrixD mJ(6,6);// the jacobian of the transformation from local to global parameters
392 if(!GetJacobian(mJ)) return kFALSE;
393 TMatrixD invJ = mJ.Invert(); // the inverse of the jacobian matrix
395 // Compute the global covariance matrix gcov = mJ lcov mJ-1
396 TMatrixD gCovM = mJ * lCov * invJ;
397 // To be done: somehow check that gCovM is close enough to be symmetric
399 for(Int_t i=0; i<6; i++)
401 gCov(i,i) = gCovM(i,i);
402 for(Int_t j=i+1; j<6; j++)
404 gCov(i,j)=gCovM(i,j);
405 gCov(j,i)=gCovM(i,j);
414 //______________________________________________________________________________
415 Bool_t AliAlignObj::SetFromLocalCov(Double_t *lCov)
417 // Calculates the covariance matrix (6x6) associated to the six parameters
418 // defining the current alignment in the global coordinates system, and sets
419 // in the internal data members, from the 21 coefficients, passed as argument,
420 // of the covariance matrix (6x6) for the six parameters defining the
421 // alignment transformation in the local coordinates system.
423 TMatrixDSym lCovMatrix(6);
426 for(Int_t i=0; i<6; i++)
427 for(Int_t j=i; j<6; j++)
429 lCovMatrix(i,j) = lCov[k++];
430 if(j!=i) lCovMatrix(j,i) = lCovMatrix(i,j);
433 return SetFromLocalCov(lCovMatrix);
438 //______________________________________________________________________________
439 void AliAlignObj::SetCorrMatrix(Double_t *cmat)
441 // Sets the correlation matrix data member from the coefficients of the external covariance
442 // matrix (21 elements passed as argument).
446 // Diagonal elements first
447 for(Int_t i=0; i<6; ++i) {
448 fDiag[i] = (cmat[i*(i+1)/2+i] >= 0.) ? TMath::Sqrt(cmat[i*(i+1)/2+i]) : -999.;
451 // ... then the ones off diagonal
452 for(Int_t i=0; i<6; ++i)
453 // Off diagonal elements
454 for(Int_t j=0; j<i; ++j) {
455 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).
456 if (fODia[(i-1)*i/2+j]>1.) fODia[(i-1)*i/2+j] = 1.; // check upper boundary
457 if (fODia[(i-1)*i/2+j]<-1.) fODia[(i-1)*i/2+j] = -1.; // check lower boundary
460 for(Int_t i=0; i< 6; ++i) fDiag[i]=-999.;
461 for(Int_t i=0; i< 6*(6-1)/2; ++i) fODia[i]=0.;
467 //______________________________________________________________________________
468 void AliAlignObj::SetCorrMatrix(TMatrixDSym& mcov)
470 // Sets the correlation matrix data member from the covariance matrix mcov passed
471 // passed as argument.
475 // Diagonal elements first
476 for(Int_t i=0; i<6; ++i) {
477 fDiag[i] = (mcov(i,i) >= 0.) ? TMath::Sqrt(mcov(i,i)) : -999.;
480 // ... then the ones off diagonal
481 for(Int_t i=0; i<6; ++i)
482 // Off diagonal elements
483 for(Int_t j=0; j<i; ++j) {
484 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).
485 if (fODia[(i-1)*i/2+j]>1.) fODia[(i-1)*i/2+j] = 1.; // check upper boundary
486 if (fODia[(i-1)*i/2+j]<-1.) fODia[(i-1)*i/2+j] = -1.; // check lower boundary
489 for(Int_t i=0; i< 6; ++i) fDiag[i]=-999.;
490 for(Int_t i=0; i< 6*(6-1)/2; ++i) fODia[i]=0.;
496 //_____________________________________________________________________________
497 void AliAlignObj::AnglesToMatrix(const Double_t *angles, Double_t *rot) const
499 // Calculates the rotation matrix using the
500 // Euler angles in "x y z" notation
502 Double_t degrad = TMath::DegToRad();
503 Double_t sinpsi = TMath::Sin(degrad*angles[0]);
504 Double_t cospsi = TMath::Cos(degrad*angles[0]);
505 Double_t sinthe = TMath::Sin(degrad*angles[1]);
506 Double_t costhe = TMath::Cos(degrad*angles[1]);
507 Double_t sinphi = TMath::Sin(degrad*angles[2]);
508 Double_t cosphi = TMath::Cos(degrad*angles[2]);
510 rot[0] = costhe*cosphi;
511 rot[1] = -costhe*sinphi;
513 rot[3] = sinpsi*sinthe*cosphi + cospsi*sinphi;
514 rot[4] = -sinpsi*sinthe*sinphi + cospsi*cosphi;
515 rot[5] = -costhe*sinpsi;
516 rot[6] = -cospsi*sinthe*cosphi + sinpsi*sinphi;
517 rot[7] = cospsi*sinthe*sinphi + sinpsi*cosphi;
518 rot[8] = costhe*cospsi;
521 //_____________________________________________________________________________
522 Bool_t AliAlignObj::MatrixToAngles(const Double_t *rot, Double_t *angles) const
524 // Calculates the Euler angles in "x y z" notation
525 // using the rotation matrix
526 // Returns false in case the rotation angles can not be
527 // extracted from the matrix
529 if(TMath::Abs(rot[0])<1e-7 || TMath::Abs(rot[8])<1e-7) {
530 AliError("Failed to extract roll-pitch-yall angles!");
533 Double_t raddeg = TMath::RadToDeg();
534 angles[0]=raddeg*TMath::ATan2(-rot[5],rot[8]);
535 angles[1]=raddeg*TMath::ASin(rot[2]);
536 angles[2]=raddeg*TMath::ATan2(-rot[1],rot[0]);
540 //______________________________________________________________________________
541 void AliAlignObj::Transform(AliTrackPoint &p, Bool_t copycov) const
543 // The method transforms the space-point coordinates using the
544 // transformation matrix provided by the AliAlignObj
545 // In case the copycov flag is set to kTRUE, the covariance matrix
546 // of the alignment object is copied into the space-point
548 if (fVolUID != p.GetVolumeID())
549 AliWarning(Form("Alignment object ID is not equal to the space-point ID (%d != %d)",fVolUID,p.GetVolumeID()));
553 Double_t *rot = m.GetRotationMatrix();
554 Double_t *tr = m.GetTranslation();
556 Float_t xyzin[3],xyzout[3];
558 for (Int_t i = 0; i < 3; i++)
566 TMatrixDSym covmat(6);
567 GetCovMatrix(covmat);
568 p.SetAlignCovMatrix(covmat);
573 //_____________________________________________________________________________
574 void AliAlignObj::Transform(AliTrackPointArray &array) const
576 // This method is used to transform all the track points
577 // from the input AliTrackPointArray
580 for (Int_t i = 0; i < array.GetNPoints(); i++) {
583 array.AddPoint(i,&p);
587 //_____________________________________________________________________________
588 void AliAlignObj::Print(Option_t *) const
590 // Print the contents of the
591 // alignment object in angles and
592 // matrix representations
600 const Double_t *rot = m.GetRotationMatrix();
602 printf("Volume=%s\n",GetSymName());
603 if (GetVolUID() != 0) {
604 AliGeomManager::ELayerID layerId;
606 GetVolUID(layerId,modId);
607 printf("VolumeID=%d LayerID=%d ( %s ) ModuleID=%d\n", GetVolUID(),layerId,AliGeomManager::LayerName(layerId),modId);
609 printf("%12.8f%12.8f%12.8f Tx = %12.8f Psi = %12.8f\n", rot[0], rot[1], rot[2], tr[0], angles[0]);
610 printf("%12.8f%12.8f%12.8f Ty = %12.8f Theta = %12.8f\n", rot[3], rot[4], rot[5], tr[1], angles[1]);
611 printf("%12.8f%12.8f%12.8f Tz = %12.8f Phi = %12.8f\n", rot[6], rot[7], rot[8], tr[2], angles[2]);
615 //_____________________________________________________________________________
616 void AliAlignObj::SetPars(Double_t x, Double_t y, Double_t z,
617 Double_t psi, Double_t theta, Double_t phi)
619 // Set the global delta transformation by passing 3 angles (expressed in
620 // degrees) and 3 shifts (in centimeters)
622 SetTranslation(x,y,z);
623 SetRotation(psi,theta,phi);
626 //_____________________________________________________________________________
627 Bool_t AliAlignObj::SetLocalPars(Double_t x, Double_t y, Double_t z,
628 Double_t psi, Double_t theta, Double_t phi)
630 // Set the global delta transformation by passing the parameters
631 // for the local delta transformation (3 shifts and 3 angles).
632 // In case that the TGeo was not initialized or not closed,
633 // returns false and the object parameters are not set.
636 Double_t tr[3] = {x, y, z};
637 m.SetTranslation(tr);
638 Double_t angles[3] = {psi, theta, phi};
640 AnglesToMatrix(angles,rot);
643 return SetLocalMatrix(m);
647 //_____________________________________________________________________________
648 Bool_t AliAlignObj::SetLocalTranslation(Double_t x, Double_t y, Double_t z)
650 // Set the global delta transformation by passing the three shifts giving
651 // the translation in the local reference system of the alignable
652 // volume (known by TGeo geometry).
653 // In case that the TGeo was not initialized or not closed,
654 // returns false and the object parameters are not set.
657 Double_t tr[3] = {x, y, z};
658 m.SetTranslation(tr);
660 return SetLocalMatrix(m);
664 //_____________________________________________________________________________
665 Bool_t AliAlignObj::SetLocalTranslation(const TGeoMatrix& m)
667 // Set the global delta transformation by passing the matrix of
668 // the local delta transformation and taking its translational part
669 // In case that the TGeo was not initialized or not closed,
670 // returns false and the object parameters are not set.
672 const Double_t* tr = m.GetTranslation();
674 mtr.SetTranslation(tr);
676 return SetLocalMatrix(mtr);
680 //_____________________________________________________________________________
681 Bool_t AliAlignObj::SetLocalRotation(Double_t psi, Double_t theta, Double_t phi)
683 // Set the global delta transformation by passing the three angles giving
684 // the rotation in the local reference system of the alignable
685 // volume (known by TGeo geometry).
686 // In case that the TGeo was not initialized or not closed,
687 // returns false and the object parameters are not set.
690 Double_t angles[3] = {psi, theta, phi};
692 AnglesToMatrix(angles,rot);
695 return SetLocalMatrix(m);
699 //_____________________________________________________________________________
700 Bool_t AliAlignObj::SetLocalRotation(const TGeoMatrix& m)
702 // Set the global delta transformation by passing the matrix of
703 // the local delta transformation and taking its rotational part
704 // In case that the TGeo was not initialized or not closed,
705 // returns false and the object parameters are not set.
708 const Double_t* rot = m.GetRotationMatrix();
709 rotm.SetRotation(rot);
711 return SetLocalMatrix(rotm);
715 //_____________________________________________________________________________
716 Bool_t AliAlignObj::SetLocalMatrix(const TGeoMatrix& m)
718 // Set the global delta transformation by passing the TGeo matrix
719 // for the local delta transformation.
720 // In case that the TGeo was not initialized or not closed,
721 // returns false and the object parameters are not set.
723 if (!gGeoManager || !gGeoManager->IsClosed()) {
724 AliError("Can't set the local alignment object parameters! gGeoManager doesn't exist or it is still open!");
728 const char* symname = GetSymName();
729 TGeoPhysicalNode* node;
730 TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname);
732 if(!pne->GetPhysicalNode()){
733 node = gGeoManager->MakeAlignablePN(pne);
735 node = pne->GetPhysicalNode();
738 AliWarning(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as volume path!",symname));
739 node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(symname);
743 AliError(Form("Volume name or path %s not valid!",symname));
746 if (node->IsAligned())
747 AliWarning(Form("Volume %s has been already misaligned!",symname));
750 const Double_t *tr = m.GetTranslation();
751 m1.SetTranslation(tr);
752 const Double_t* rot = m.GetRotationMatrix();
755 TGeoHMatrix align,gprime,gprimeinv;
756 gprime = *node->GetMatrix();
757 gprimeinv = gprime.Inverse();
758 m1.Multiply(&gprimeinv);
759 m1.MultiplyLeft(&gprime);
761 return SetMatrix(m1);
764 //_____________________________________________________________________________
765 Bool_t AliAlignObj::SetMatrix(const TGeoMatrix& m)
767 // Set the global delta transformation by passing the TGeoMatrix
771 return SetRotation(m);
774 //_____________________________________________________________________________
775 Bool_t AliAlignObj::GetLocalPars(Double_t transl[], Double_t angles[]) const
777 // Get the translations and angles (in degrees) expressing the
778 // local delta transformation.
779 // In case that the TGeo was not initialized or not closed,
780 // returns false and the object parameters are not set.
782 if(!GetLocalTranslation(transl)) return kFALSE;
783 return GetLocalAngles(angles);
786 //_____________________________________________________________________________
787 Bool_t AliAlignObj::GetLocalTranslation(Double_t* tr) const
789 // Get the 3 shifts giving the translational part of the local
790 // delta transformation.
791 // In case that the TGeo was not initialized or not closed,
792 // returns false and the object parameters are not set.
795 if(!GetLocalMatrix(ml)) return kFALSE;
796 const Double_t* transl;
797 transl = ml.GetTranslation();
804 //_____________________________________________________________________________
805 Bool_t AliAlignObj::GetLocalAngles(Double_t* angles) const
807 // Get the 3 angles giving the rotational part of the local
808 // delta transformation.
809 // In case that the TGeo was not initialized or not closed,
810 // returns false and the object parameters are not set.
813 if(!GetLocalMatrix(ml)) return kFALSE;
814 const Double_t *rot = ml.GetRotationMatrix();
815 return MatrixToAngles(rot,angles);
818 //_____________________________________________________________________________
819 Bool_t AliAlignObj::GetLocalMatrix(TGeoHMatrix& m) const
821 // Get the matrix for the local delta transformation.
822 // In case that the TGeo was not initialized or not closed,
823 // returns false and the object parameters are not set.
825 if (!gGeoManager || !gGeoManager->IsClosed()) {
826 AliError("Can't get the local alignment object parameters! gGeoManager doesn't exist or it is still open!");
830 const char* symname = GetSymName();
831 TGeoPhysicalNode* node;
832 TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname);
834 if(!pne->GetPhysicalNode()){
835 node = gGeoManager->MakeAlignablePN(pne);
837 node = pne->GetPhysicalNode();
840 AliWarning(Form("The symbolic volume name %s does not correspond to a physical entry. Using it as volume path!",symname));
841 node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(symname);
845 AliError(Form("Volume name or path %s not valid!",symname));
848 if (node->IsAligned())
849 AliWarning(Form("Volume %s has been already misaligned!",symname));
852 TGeoHMatrix gprime,gprimeinv;
853 gprime = *node->GetMatrix();
854 gprimeinv = gprime.Inverse();
856 m.MultiplyLeft(&gprimeinv);
861 //_____________________________________________________________________________
862 Bool_t AliAlignObj::ApplyToGeometry(Bool_t ovlpcheck)
864 // Apply the current alignment object to the TGeo geometry
865 // This method returns FALSE if the symname of the object was not
866 // valid neither to get a TGeoPEntry nor as a volume path
868 if (!gGeoManager || !gGeoManager->IsClosed()) {
869 AliError("Can't apply the alignment object! gGeoManager doesn't exist or it is still open!");
873 if (gGeoManager->IsLocked()){
874 AliError("Can't apply the alignment object! Geometry is locked!");
878 const char* symname = GetSymName();
880 TGeoPhysicalNode* node;
881 TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname);
883 path = pne->GetTitle();
884 node = gGeoManager->MakeAlignablePN(pne);
886 AliDebug(1,Form("The symbolic volume name %s does not correspond to a physical entry. Using it as a volume path!",symname));
888 if (!gGeoManager->CheckPath(path)) {
889 AliDebug(1,Form("Volume path %s not valid!",path));
892 if (gGeoManager->GetListOfPhysicalNodes()->FindObject(path)) {
893 AliError(Form("Volume %s has already been misaligned!",path));
896 node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(path);
900 AliError(Form("Volume path %s not valid!",path));
904 // Double_t threshold = 0.001;
906 TGeoHMatrix align,gprime;
907 gprime = *node->GetMatrix();
909 gprime.MultiplyLeft(&align);
910 TGeoHMatrix *ginv = new TGeoHMatrix;
911 TGeoHMatrix *g = node->GetMatrix(node->GetLevel()-1);
912 *ginv = g->Inverse();
914 AliGeomManager::ELayerID layerId; // unique identity for layer in the alobj
915 Int_t modId; // unique identity for volume inside layer in the alobj
916 GetVolUID(layerId, modId);
917 AliDebug(2,Form("Aligning volume %s of detector layer %d with local ID %d",symname,layerId,modId));
919 node->Align(ginv,0,kTRUE); //(trunk of root takes threshold as additional argument)
921 node->Align(ginv,0,kFALSE);
925 TObjArray* ovlpArray = gGeoManager->GetListOfOverlaps();
926 Int_t nOvlp = ovlpArray->GetEntriesFast();
929 AliInfo(Form("Misalignment of node %s generated the following overlaps/extrusions:",node->GetName()));
930 for(Int_t i=0; i<nOvlp; i++)
931 ((TGeoOverlap*)ovlpArray->UncheckedAt(i))->PrintInfo();