Alignment framework (C.Cheshkov). More information is available in http://agenda...
[u/mrichter/AliRoot.git] / STEER / AliAlignObj.cxx
index 4065a88f3bd13e5d7e2a1d004edd6698f69dfdcd..9212ac6626c62a6af20632d489502cdec29f2ec6 100644 (file)
  **************************************************************************/
 
 //-----------------------------------------------------------------
-//   Implementation of the alignment object class through
-//   1) the abstract class AliAlignObj
-//   2) two derived concrete representation of alignment object class:
-//      - AliAlignObjAngles
-//      - AliAlignObjMatrix
+//   Implementation of the alignment object class through the abstract
+//  class AliAlignObj. From it two derived concrete representation of
+//  alignment object class (AliAlignObjAngles, AliAlignObjMatrix) are
+//  derived in separate files.
 //-----------------------------------------------------------------
+/*****************************************************************************
+ * AliAlignObjAngles: derived alignment class storing alignment information  *
+ *   for a single volume in form of three doubles for the translation        *
+ *   and three doubles for the rotation expressed with the euler angles      *
+ *   in the xyz-convention (http://mathworld.wolfram.com/EulerAngles.html),  *
+ *   also known as roll, pitch, yaw. PLEASE NOTE THE ANGLES SIGNS ARE        *
+ *   INVERSE WITH RESPECT TO THIS REFERENCE!!! In this way the representation*
+ *   is fully consistent with the TGeo Rotation methods.                     *
+ *****************************************************************************/
 
 #include "AliAlignObj.h"
 //#include "AliLog.h"
-
 ClassImp(AliAlignObj)
 
+Int_t AliAlignObj::fgLayerSize[kLastLayer - kFirstLayer] = {
+  80, 160,  // ITS SPD
+  84, 176,  // ITS SDD
+  748, 950, // ITS SSD
+  36, 36,   // TPC
+  90, 90, 90, 90, 90, 90,  // TRD
+  1,        // TOF ??
+  1, 1,     // PHOS ??
+  1,        // RICH ??
+  1         // MUON ??
+};
+
+const char* AliAlignObj::fgLayerName[kLastLayer - kFirstLayer] = {
+  "ITS inner pixels layer", "ITS outer pixels layer",
+  "ITS inner drifts layer", "ITS outer drifts layer",
+  "ITS inner strips layer", "ITS outer strips layer",
+  "TPC inner chambers layer", "TPC outer chambers layer",
+  "TRD chambers layer 1", "TRD chambers layer 2", "TRD chambers layer 3",
+  "TRD chambers layer 4", "TRD chambers layer 5", "TRD chambers layer 6",
+  "TOF layer",
+  "?","?",
+  "?",
+  "?"
+};
+
 //_____________________________________________________________________________
 AliAlignObj::AliAlignObj():
   fVolUID(0)
@@ -58,9 +91,33 @@ AliAlignObj::~AliAlignObj()
   // dummy destructor
 }
 
+//_____________________________________________________________________________
+void AliAlignObj::SetVolUID(ELayerID detId, Int_t modId)
+{
+  // From detector name and module number (according to detector numbering)
+  // build fVolUID, unique numerical identity of that volume inside ALICE
+  // fVolUID is 16 bits, first 5 reserved for detID (32 possible values),
+  // remaining 11 for module ID inside det (2048 possible values).
+  //
+  fVolUID = LayerToVolUID(detId,modId);
+}
+
+//_____________________________________________________________________________
+void AliAlignObj::GetVolUID(ELayerID &layerId, Int_t &modId) const
+{
+  // From detector name and module number (according to detector numbering)
+  // build fVolUID, unique numerical identity of that volume inside ALICE
+  // fVolUID is 16 bits, first 5 reserved for detID (32 possible values),
+  // remaining 11 for module ID inside det (2048 possible values).
+  //
+  layerId = VolUIDToLayer(fVolUID,modId);
+}
+
 //_____________________________________________________________________________
 void AliAlignObj::AnglesToMatrix(const Double_t *angles, Double_t *rot) const
 {
+  // Calculates the rotation matrix using the 
+  // Euler angles in "x y z" notation
   Double_t degrad = TMath::DegToRad();
   Double_t sinpsi = TMath::Sin(degrad*angles[0]);
   Double_t cospsi = TMath::Cos(degrad*angles[0]);
@@ -83,6 +140,8 @@ void AliAlignObj::AnglesToMatrix(const Double_t *angles, Double_t *rot) const
 //_____________________________________________________________________________
 Bool_t AliAlignObj::MatrixToAngles(const Double_t *rot, Double_t *angles) const
 {
+  // Calculates the Euler angles in "x y z" notation
+  // using the rotation matrix
   if(rot[0]<1e-7 || rot[8]<1e-7) return kFALSE;
   Double_t raddeg = TMath::RadToDeg();
   angles[0]=raddeg*TMath::ATan2(-rot[5],rot[8]);
@@ -104,237 +163,48 @@ void AliAlignObj::Print(Option_t *) const
   TGeoHMatrix m;
   GetMatrix(m);
   const Double_t *rot = m.GetRotationMatrix();
-  printf("Volume=%s ID=%u\n", GetVolPath(),GetVolUID());
+//   printf("Volume=%s ID=%u\n", GetVolPath(),GetVolUID());
+  ELayerID layerId;
+  Int_t modId;
+  GetVolUID(layerId,modId);
+  printf("Volume=%s LayerID=%d ModuleID=%d\n", GetVolPath(),layerId,modId);
   printf("%12.6f%12.6f%12.6f    Tx = %12.6f    Psi   = %12.6f\n", rot[0], rot[1], rot[2], tr[0], angles[0]);
   printf("%12.6f%12.6f%12.6f    Ty = %12.6f    Theta = %12.6f\n", rot[3], rot[4], rot[5], tr[1], angles[1]);
   printf("%12.6f%12.6f%12.6f    Tz = %12.6f    Phi   = %12.6f\n", rot[6], rot[7], rot[8], tr[2], angles[2]);
 
 }
 
-
-//=============================================================================
-
-ClassImp(AliAlignObjAngles)
-
-//_____________________________________________________________________________
-AliAlignObjAngles::AliAlignObjAngles() //: AliAlignObj()
-{
-  // default constructor
-  fTranslation[0]=fTranslation[1]=fTranslation[2]=0.;
-  fRotation[0]=fRotation[1]=fRotation[2]=0.;
-}
-
-//_____________________________________________________________________________
-AliAlignObjAngles::AliAlignObjAngles(const AliAlignObjAngles& theAlignObj) :
-  AliAlignObj(theAlignObj)
-{
-  // copy constructor
-  Double_t tr[3];
-  theAlignObj.GetTranslation(tr);
-  SetTranslation(tr[0],tr[1],tr[2]);
-  Double_t rot[3];
-  theAlignObj.GetAngles(rot);
-  SetRotation(rot[0],rot[1],rot[2]);
-}
-
-//_____________________________________________________________________________
-AliAlignObjAngles &AliAlignObjAngles::operator =(const AliAlignObjAngles& theAlignObj)
-{
-  // assignment operator
-  if(this==&theAlignObj) return *this;
-  ((AliAlignObj *)this)->operator=(theAlignObj);
-
-  Double_t tr[3];
-  theAlignObj.GetTranslation(tr);
-  SetTranslation(tr[0],tr[1],tr[2]);
-  Double_t rot[3];
-  theAlignObj.GetAngles(rot);
-  SetRotation(rot[0],rot[1],rot[2]);
-  return *this;
-}
-
-//_____________________________________________________________________________
-AliAlignObjAngles::~AliAlignObjAngles()
-{
-  // default destructor
-}
-
-//_____________________________________________________________________________
-void AliAlignObjAngles::SetTranslation(const TGeoMatrix& m)
-{
-  if(m.IsTranslation()){
-    const Double_t* tr = m.GetTranslation();
-    fTranslation[0]=tr[0];  fTranslation[1]=tr[1]; fTranslation[2]=tr[2];
-  }else{
-//     AliWarning("Argument matrix is not a translation! Setting zero-translation.");
-    fTranslation[0] = fTranslation[1] = fTranslation[2] = 0.;
-  }
-}
-
-//_____________________________________________________________________________
-Bool_t AliAlignObjAngles::SetRotation(const TGeoMatrix& m)
-{
-  if(m.IsRotation()){
-    const Double_t* rot = m.GetRotationMatrix();
-    return MatrixToAngles(rot,fRotation);
-  }else{
-//     AliWarning("Argument matrix is not a rotation! Setting yaw-pitch-roll to zero.");
-    fRotation[0] = fRotation[1] = fRotation[2] = 0.;
-    return kTRUE;
-  }
-}
-
-//_____________________________________________________________________________
-void AliAlignObjAngles::SetMatrix(const TGeoMatrix& m)
-{
-  SetTranslation(m);
-  SetRotation(m);
-}
-
-//_____________________________________________________________________________
-void AliAlignObjAngles::GetPars(Double_t tr[], Double_t angles[]) const
-{
-  GetTranslation(tr);
-  GetAngles(angles);
-}
-
-//_____________________________________________________________________________
-void AliAlignObjAngles::GetMatrix(TGeoHMatrix& m) const
-{
-  m.SetTranslation(&fTranslation[0]);
-  Double_t rot[9];
-  AnglesToMatrix(fRotation,rot);
-  m.SetRotation(rot);
-}
-
-//=============================================================================
-
-ClassImp(AliAlignObjMatrix)
-
 //_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix() : AliAlignObj()
+UShort_t AliAlignObj::LayerToVolUID(ELayerID layerId, Int_t modId)
 {
-  // Default constructor
-}
-
-AliAlignObjMatrix::AliAlignObjMatrix(const AliAlignObjMatrix& theAlignObj) :
-  AliAlignObj(theAlignObj)
-{
-  //copy constructor
+  // From detector (layer) name and module number (according to detector numbering)
+  // build fVolUID, unique numerical identity of that volume inside ALICE
+  // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
+  // remaining 11 for module ID inside det (2048 possible values).
   //
-  Double_t tr[3];
-  theAlignObj.GetTranslation(tr);
-  SetTranslation(tr[0],tr[1],tr[2]);
-  Double_t rot[3];
-  theAlignObj.GetAngles(rot);
-  SetRotation(rot[0],rot[1],rot[2]);
-}
-
-AliAlignObjMatrix &AliAlignObjMatrix::operator =(const AliAlignObjMatrix& theAlignObj)
-{  
-  // assignment operator
-  //
-  if(this==&theAlignObj) return *this;
-  ((AliAlignObj *)this)->operator=(theAlignObj);
-  Double_t tr[3];
-  theAlignObj.GetTranslation(tr);
-  SetTranslation(tr[0],tr[1],tr[2]);
-  Double_t rot[3];
-  theAlignObj.GetAngles(rot);
-  SetRotation(rot[0],rot[1],rot[2]);
-  return *this;
-}
-
-AliAlignObjMatrix::~AliAlignObjMatrix()
-{
-  // Destructor
-  //
-}
-
-//_____________________________________________________________________________
-void AliAlignObjMatrix::SetTranslation(Double_t x, Double_t y, Double_t z)
-{
-  Double_t tr[3];
-  tr[0]=x; tr[1]=y; tr[2]=z;
-  fMatrix.SetTranslation(tr);
-}
-
-//_____________________________________________________________________________
-void AliAlignObjMatrix::SetTranslation(const TGeoMatrix& m)
-{
-  const Double_t *tr = m.GetTranslation();
-  fMatrix.SetTranslation(tr);
+  return ((UShort_t(layerId) << 11) | UShort_t(modId));
 }
 
 //_____________________________________________________________________________
-void AliAlignObjMatrix::SetRotation(Double_t psi, Double_t theta, Double_t phi)
+AliAlignObj::ELayerID AliAlignObj::VolUIDToLayer(UShort_t voluid, Int_t &modId)
 {
-  Double_t angles[3] = {psi, theta, phi};
-  Double_t rot[9];
-  AnglesToMatrix(angles,rot);
-  fMatrix.SetRotation(rot);
-}
-
-//_____________________________________________________________________________
-Bool_t AliAlignObjMatrix::SetRotation(const TGeoMatrix& m)
-{
-  const Double_t* rot = m.GetRotationMatrix();
-  fMatrix.SetRotation(rot);
-  return kTRUE;
-}
-
-//_____________________________________________________________________________
-void AliAlignObjMatrix::SetMatrix(const TGeoMatrix& m)
-{
-  // Set rotation matrix and translation
-  // using TGeoMatrix
-  SetTranslation(m);
-  SetRotation(m);
-}
-
-//_____________________________________________________________________________
-void AliAlignObjMatrix::SetPars(Double_t x, Double_t y, Double_t z,
-                      Double_t psi, Double_t theta, Double_t phi)
-{
-  // Set rotation matrix and translation
-  // using 3 angles and 3 translations
-  SetTranslation(x,y,z);
-  SetRotation(psi,theta,phi);
-}
-
-//_____________________________________________________________________________
-void AliAlignObjMatrix::GetTranslation(Double_t *tr) const
-{
-  // Get Translation from TGeoMatrix
-  const Double_t* translation = fMatrix.GetTranslation();
-  tr[0] = translation[0];
-  tr[1] = translation[1];
-  tr[2] = translation[2];
-}
-
-//_____________________________________________________________________________
-Bool_t AliAlignObjMatrix::GetAngles(Double_t *angles) const
-{
-  // Get rotation angles from the TGeoHMatrix
-  const Double_t* rot = fMatrix.GetRotationMatrix();
-  return MatrixToAngles(rot,angles);
-}
+  // From detector (layer) name and module number (according to detector numbering)
+  // build fVolUID, unique numerical identity of that volume inside ALICE
+  // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
+  // remaining 11 for module ID inside det (2048 possible values).
+  //
+  modId = voluid & 0x7ff;
 
-//_____________________________________________________________________________
-void AliAlignObjMatrix::GetPars(Double_t tr[], Double_t angles[]) const
-{
-  GetTranslation(tr);
-  GetAngles(angles);
+  return VolUIDToLayer(voluid);
 }
 
 //_____________________________________________________________________________
-void AliAlignObjMatrix::GetMatrix(TGeoHMatrix& m) const
+AliAlignObj::ELayerID AliAlignObj::VolUIDToLayer(UShort_t voluid)
 {
-  // Get TGeoHMatrix
+  // From detector (layer) name and module number (according to detector numbering)
+  // build fVolUID, unique numerical identity of that volume inside ALICE
+  // fVolUID is 16 bits, first 5 reserved for layerID (32 possible values),
+  // remaining 11 for module ID inside det (2048 possible values).
   //
-  const Double_t *tr = fMatrix.GetTranslation();
-  m.SetTranslation(tr);
-  const Double_t *rot = fMatrix.GetRotationMatrix();
-  m.SetRotation(rot);
+  return ELayerID((voluid >> 11) & 0x1f);
 }
-