117b430b36286727947f563189ff2aa93727265d
[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 /* $Id$ */
17
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 //-----------------------------------------------------------------
24
25 #include <TClass.h>
26 #include <TGeoManager.h>
27 #include <TGeoPhysicalNode.h>
28 #include <TMath.h>
29 #include "TObjString.h"
30
31 #include "AliAlignObj.h"
32 #include "AliTrackPointArray.h"
33 #include "AliLog.h"
34 #include "AliAlignObjParams.h"
35  
36 ClassImp(AliAlignObj)
37
38 //_____________________________________________________________________________
39 AliAlignObj::AliAlignObj():
40   fVolPath(),
41   fVolUID(0)
42 {
43   // default constructor
44   for(Int_t i=0; i<6; i++) fDiag[i]=-999.;
45   for(Int_t i=0; i<21; i++) fODia[i]=-999.;
46 }
47
48 //_____________________________________________________________________________
49 AliAlignObj::AliAlignObj(const char* symname, UShort_t voluid) :
50   TObject(),
51   fVolPath(symname),
52   fVolUID(voluid)
53 {
54   // standard constructor
55   //
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);
69 }
70
71 //_____________________________________________________________________________
72 AliAlignObj::AliAlignObj(const AliAlignObj& theAlignObj) :
73   TObject(theAlignObj),
74   fVolPath(theAlignObj.GetSymName()),
75   fVolUID(theAlignObj.GetVolUID())
76 {
77   //copy constructor
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];
80 }
81
82 //_____________________________________________________________________________
83 AliAlignObj &AliAlignObj::operator =(const AliAlignObj& theAlignObj)
84 {
85   // assignment operator
86   if(this==&theAlignObj) return *this;
87   fVolPath = theAlignObj.GetSymName();
88   fVolUID = theAlignObj.GetVolUID();
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];
91   return *this;
92 }
93
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);
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]));
108   return *this;
109 }
110
111 //_____________________________________________________________________________
112 AliAlignObj::~AliAlignObj()
113 {
114   // dummy destructor
115 }
116
117 //_____________________________________________________________________________
118 void AliAlignObj::SetVolUID(AliGeomManager::ELayerID detId, Int_t modId)
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   //
125   fVolUID = AliGeomManager::LayerToVolUID(detId,modId);
126 }
127
128 //_____________________________________________________________________________
129 void AliAlignObj::GetVolUID(AliGeomManager::ELayerID &layerId, Int_t &modId) const
130 {
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.
137   //
138   layerId = AliGeomManager::VolUIDToLayer(fVolUID,modId);
139 }
140
141 //_____________________________________________________________________________
142 Bool_t AliAlignObj::GetPars(Double_t tr[], Double_t angles[]) const
143 {
144   GetTranslation(tr);
145   return GetAngles(angles);
146 }
147
148 //_____________________________________________________________________________
149 Int_t AliAlignObj::GetLevel() const
150 {
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('/');
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
181   //
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
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   }
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
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
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
287 //_____________________________________________________________________________
288 void AliAlignObj::AnglesToMatrix(const Double_t *angles, Double_t *rot) const
289 {
290   // Calculates the rotation matrix using the 
291   // Euler angles in "x y z" notation
292   //
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 {
315   // Calculates the Euler angles in "x y z" notation
316   // using the rotation matrix
317   // Returns false in case the rotation angles can not be
318   // extracted from the matrix
319   //
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   }
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
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
338   //
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
358 //_____________________________________________________________________________
359 void AliAlignObj::Transform(AliTrackPointArray &array) const
360 {
361   // This method is used to transform all the track points
362   // from the input AliTrackPointArray
363   // 
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
372 //_____________________________________________________________________________
373 void AliAlignObj::Print(Option_t *) const
374 {
375   // Print the contents of the
376   // alignment object in angles and
377   // matrix representations
378   //
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();
386
387   printf("Volume=%s\n",GetSymName());
388   if (GetVolUID() != 0) {
389     AliGeomManager::ELayerID layerId;
390     Int_t modId;
391     GetVolUID(layerId,modId);
392     printf("VolumeID=%d LayerID=%d ( %s ) ModuleID=%d\n", GetVolUID(),layerId,AliGeomManager::LayerName(layerId),modId);
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
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 {
404   // Set the global delta transformation by passing 3 angles (expressed in
405   // degrees) and 3 shifts (in centimeters)
406   // 
407   SetTranslation(x,y,z);
408   SetRotation(psi,theta,phi);
409 }
410
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 {
415   // Set the global delta transformation by passing the parameters
416   // for the local delta transformation (3 shifts and 3 angles).
417   // In case that the TGeo was not initialized or not closed,
418   // returns false and the object parameters are not set.
419   //
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
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
500 //_____________________________________________________________________________
501 Bool_t AliAlignObj::SetLocalMatrix(const TGeoMatrix& m)
502 {
503   // Set the global delta transformation by passing the TGeo matrix
504   // for the local delta transformation.
505   // In case that the TGeo was not initialized or not closed,
506   // returns false and the object parameters are not set.
507   //
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
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
523   if (!node) {
524     AliError(Form("Volume name or path %s not valid!",symname));
525     return kFALSE;
526   }
527   if (node->IsAligned())
528     AliWarning(Form("Volume %s has been already misaligned!",symname));
529
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);
535
536   TGeoHMatrix align,gprime,gprimeinv;
537   gprime = *node->GetMatrix();
538   gprimeinv = gprime.Inverse();
539   m1.Multiply(&gprimeinv);
540   m1.MultiplyLeft(&gprime);
541
542   return SetMatrix(m1);
543 }
544
545 //_____________________________________________________________________________
546 Bool_t AliAlignObj::SetMatrix(const TGeoMatrix& m)
547 {
548   // Set the global delta transformation by passing the TGeoMatrix
549   // for it
550   //
551   SetTranslation(m);
552   return SetRotation(m);
553 }
554
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
638 //_____________________________________________________________________________
639 Bool_t AliAlignObj::ApplyToGeometry()
640 {
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   //
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   
650   const char* symname = GetSymName();
651   const char* path;
652   TGeoPhysicalNode* node;
653   TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname);
654   if(pne){
655     path = pne->GetTitle();
656     node = gGeoManager->MakeAlignablePN(pne);
657   }else{
658     AliDebug(1,Form("The symbolic volume name %s does not correspond to a physical entry. Using it as a volume path!",symname));
659     path=symname;
660     if (!gGeoManager->CheckPath(path)) {
661       AliDebug(1,Form("Volume path %s not valid!",path));
662       return kFALSE;
663     }
664     if (gGeoManager->GetListOfPhysicalNodes()->FindObject(path)) {
665       AliError(Form("Volume %s has already been misaligned!",path));
666       return kFALSE;
667     }
668     node = (TGeoPhysicalNode*) gGeoManager->MakePhysicalNode(path);
669   }
670
671   if (!node) {
672     AliError(Form("Volume path %s not valid!",path));
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;
684   AliGeomManager::ELayerID layerId; // unique identity for layer in the alobj
685   Int_t modId; // unique identity for volume inside layer in the alobj
686   GetVolUID(layerId, modId);
687   AliDebug(2,Form("Aligning volume %s of detector layer %d with local ID %d",symname,layerId,modId));
688   node->Align(ginv);
689
690   return kTRUE;
691 }
692