New version of AliAlignObj. The new things are the ITS mapping and some added functio...
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 26 Jan 2006 13:00:28 +0000 (13:00 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 26 Jan 2006 13:00:28 +0000 (13:00 +0000)
STEER/AliAlignObj.cxx
STEER/AliAlignObj.h
STEER/AliAlignObjAngles.cxx
STEER/AliAlignObjAngles.h
STEER/AliAlignObjMatrix.cxx
STEER/AliAlignObjMatrix.h

index 9212ac6626c62a6af20632d489502cdec29f2ec6..5c46d4134ed4e235c6c2a5cfe17fdd1cedc0e16d 100644 (file)
@@ -30,7 +30,8 @@
  *****************************************************************************/
 
 #include "AliAlignObj.h"
-//#include "AliLog.h"
+#include "AliTrackPointArray.h"
+#include "AliLog.h"
  
 ClassImp(AliAlignObj)
 
@@ -42,7 +43,7 @@ Int_t AliAlignObj::fgLayerSize[kLastLayer - kFirstLayer] = {
   90, 90, 90, 90, 90, 90,  // TRD
   1,        // TOF ??
   1, 1,     // PHOS ??
-  1,        // RICH ??
+  7,        // RICH ??
   1         // MUON ??
 };
 
@@ -55,15 +56,29 @@ const char* AliAlignObj::fgLayerName[kLastLayer - kFirstLayer] = {
   "TRD chambers layer 4", "TRD chambers layer 5", "TRD chambers layer 6",
   "TOF layer",
   "?","?",
-  "?",
+  "RICH layer",
   "?"
 };
 
+const char** AliAlignObj::fgVolPath[kLastLayer - kFirstLayer] = {
+  0x0,0x0,
+  0x0,0x0,
+  0x0,0x0,
+  0x0,0x0,
+  0x0,0x0,0x0,
+  0x0,0x0,0x0,
+  0x0,
+  0x0,0x0,
+  0x0,
+  0x0
+};
+
 //_____________________________________________________________________________
 AliAlignObj::AliAlignObj():
   fVolUID(0)
 {
-  // dummy constructor
+  // default constructor
+  InitVolPaths();
 }
 
 //_____________________________________________________________________________
@@ -150,6 +165,44 @@ Bool_t AliAlignObj::MatrixToAngles(const Double_t *rot, Double_t *angles) const
   return kTRUE;
 }
 
+//______________________________________________________________________________
+void AliAlignObj::Transform(AliTrackPoint &p) const
+{
+  // The method transforms the space-point coordinates using the
+  // transformation matrix provided by the AliAlignObj
+  // The covariance matrix is not affected since we assume
+  // that the transformations are sufficiently small
+
+  if (fVolUID != p.GetVolumeID())
+    AliWarning(Form("Alignment object ID is not equal to the space-point ID (%d != %d)",fVolUID,p.GetVolumeID())); 
+
+  TGeoHMatrix m;
+  GetMatrix(m);
+  Double_t *rot = m.GetRotationMatrix();
+  Double_t *tr  = m.GetTranslation();
+
+  Float_t xyzin[3],xyzout[3];
+  p.GetXYZ(xyzin);
+  for (Int_t i = 0; i < 3; i++)
+    xyzout[i] = tr[i]+
+                xyzin[0]*rot[3*i]+
+                xyzin[1]*rot[3*i+1]+
+                xyzin[2]*rot[3*i+2];
+  p.SetXYZ(xyzout);
+  
+}
+
+//______________________________________________________________________________
+void AliAlignObj::Transform(AliTrackPointArray &array) const
+{
+  AliTrackPoint p;
+  for (Int_t i = 0; i < array.GetNPoints(); i++) {
+    array.GetPoint(p,i);
+    Transform(p);
+    array.AddPoint(i,&p);
+  }
+}
+
 //_____________________________________________________________________________
 void AliAlignObj::Print(Option_t *) const
 {
@@ -208,3 +261,165 @@ AliAlignObj::ELayerID AliAlignObj::VolUIDToLayer(UShort_t voluid)
   //
   return ELayerID((voluid >> 11) & 0x1f);
 }
+
+//_____________________________________________________________________________
+void AliAlignObj::InitVolPaths()
+{
+  // Initialize the LUTs which contain
+  // the TGeo volume paths for each
+  // alignable volume. The LUTs are
+  // static, so they are created during
+  // the creation of the first intance
+  // of AliAlignObj
+
+  if (fgVolPath[0]) return;
+
+  for (Int_t iLayer = 0; iLayer < (kLastLayer - kFirstLayer); iLayer++)
+    fgVolPath[iLayer] = new const char *[fgLayerSize[iLayer]];
+
+  /*********************       SPD layer1  ***********************/
+  {
+    Int_t modnum = 0;
+    TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT12_1/I12B_"; //".../I12A_"
+    TString str1 = "/I10B_";    //"/I10A_";
+    TString str2 = "/I107_";    //"/I103_"
+    TString str3 = "/I101_1/ITS1_1";
+    TString volpath, volpath1, volpath2;
+
+    for(Int_t c1 = 1; c1<=10; c1++){
+      volpath = str0;
+      volpath += c1;
+      volpath += str1;
+      for(Int_t c2 =1; c2<=2; c2++){
+       volpath1 = volpath;
+       volpath1 += c2;
+       volpath1 += str2;
+       for(Int_t c3 =1; c3<=4; c3++){
+         volpath2 = volpath1;
+         volpath2 += c3;
+         volpath2 += str3;
+         fgVolPath[kSPD1-kFirstLayer][modnum] = volpath2.Data();
+         modnum++;
+       }
+      }
+    }
+  }
+  
+  /*********************       SPD layer2  ***********************/
+  {
+    Int_t modnum = 0;
+    TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT12_1/I12B_";  //".../I12A_"
+    TString str1 = "/I20B_";  //"/I20A"
+    TString str2 = "/I1D7_";  //"/I1D3"
+    TString str3 = "/I1D1_1/ITS2_1";
+    TString volpath, volpath1, volpath2;
+
+    for(Int_t c1 = 1; c1<=10; c1++){
+      volpath = str0;
+      volpath += c1;
+      volpath += str1;
+      for(Int_t c2 =1; c2<=4; c2++){
+       volpath1 = volpath;
+       volpath1 += c2;
+       volpath1 += str2;
+       for(Int_t c3 =1; c3<=4; c3++){
+         volpath2 = volpath1;
+         volpath2 += c3;
+         volpath2 += str3;
+         fgVolPath[kSPD2-kFirstLayer][modnum] = volpath2.Data();
+         modnum++;
+       }
+      }
+    }
+  }
+
+  /*********************       SDD layer1  ***********************/
+  {
+    Int_t modnum=0;
+    TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT34_1/I004_";
+    TString str1 = "/I302_";
+    TString str2 = "/ITS3_1";
+    TString volpath, volpath1;
+
+    for(Int_t c1 = 1; c1<=14; c1++){
+      volpath = str0;
+      volpath += c1;
+      volpath += str1;
+      for(Int_t c2 =1; c2<=6; c2++){
+       volpath1 = volpath;
+       volpath1 += c2;
+       volpath1 += str2;
+       fgVolPath[kSDD1-kFirstLayer][modnum] = volpath1.Data();
+       modnum++;
+      }
+    }
+  }
+
+  /*********************       SDD layer2  ***********************/
+  {
+    Int_t modnum=0;
+    TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT34_1/I005_";
+    TString str1 = "/I402_";
+    TString str2 = "/ITS4_1";
+    TString volpath, volpath1;
+
+    for(Int_t c1 = 1; c1<=22; c1++){
+      volpath = str0;
+      volpath += c1;
+      volpath += str1;
+      for(Int_t c2 = 1; c2<=8; c2++){
+       volpath1 = volpath;
+       volpath1 += c2;
+       volpath1 += str2;
+       fgVolPath[kSDD2-kFirstLayer][modnum] = volpath1.Data();
+       modnum++;
+      }
+    }
+  }
+
+  /*********************       SSD layer1  ***********************/
+  {
+    Int_t modnum=0;
+    TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT56_1/I565_";
+    TString str1 = "/I562_";
+    TString str2 = "/ITS5_1";
+    TString volpath, volpath1;
+
+    for(Int_t c1 = 1; c1<=34; c1++){
+      volpath = str0;
+      volpath += c1;
+      volpath += str1;
+      for(Int_t c2 = 1; c2<=22; c2++){
+       volpath1 = volpath;
+       volpath1 += c2;
+       volpath1 += str2;
+       fgVolPath[kSSD1-kFirstLayer][modnum] = volpath1.Data();
+       modnum++;
+      }
+    }
+  }
+
+  /*********************       SSD layer1  ***********************/
+  {
+    Int_t modnum=0;
+    TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT56_1/I569_";
+    TString str1 = "/I566_";
+    TString str2 = "/ITS6_1";
+    TString volpath, volpath1;
+
+    for(Int_t c1 = 1; c1<=38; c1++){
+      volpath = str0;
+      volpath += c1;
+      volpath += str1;
+      for(Int_t c2 = 1; c2<=25; c2++){
+       volpath1 = volpath;
+       volpath1 += c2;
+       volpath1 += str2;
+       fgVolPath[kSSD2-kFirstLayer][modnum] = volpath1.Data();
+       modnum++;
+      }
+    }
+  }
+
+}
index 4789269358616861fb54942e3a8c2644a2c2d6cc..9d1afca3bb2f55027027461edb32171bf36170f4 100644 (file)
@@ -11,6 +11,9 @@
 #include "TString.h"
 #include "TGeoMatrix.h"
 
+class AliTrackPoint;
+class AliTrackPointArray;
+
 class AliAlignObj : public TObject {
 
  public:
@@ -53,6 +56,11 @@ class AliAlignObj : public TObject {
   virtual void GetPars(Double_t transl[], Double_t rot[]) const=0;
   virtual void GetMatrix(TGeoHMatrix& m) const=0;
 
+  virtual AliAlignObj& Inverse() const=0;
+
+  void  Transform(AliTrackPoint &p) const;
+  void  Transform(AliTrackPointArray &array) const;
+
   void  Print(Option_t *) const;
 
   static Int_t       LayerSize(Int_t layer) { return fgLayerSize[layer]; }
@@ -61,19 +69,31 @@ class AliAlignObj : public TObject {
   static UShort_t LayerToVolUID(ELayerID layerId, Int_t modId);
   static ELayerID VolUIDToLayer(UShort_t voluid, Int_t &modId);
   static ELayerID VolUIDToLayer(UShort_t voluid);
+
+  static const char* GetVolPath(UShort_t voluid) {
+    Int_t modId;
+    ELayerID layerId = VolUIDToLayer(voluid,modId);
+    return GetVolPath(layerId,modId);
+  }
+  static const char* GetVolPath(ELayerID layerId, Int_t modId) { return fgVolPath[layerId-kFirstLayer][modId]; }
+
  protected:
 
   void AnglesToMatrix(const Double_t *angles, Double_t *rot) const;
   Bool_t MatrixToAngles(const Double_t *rot, Double_t *angles) const;
 
+  void InitVolPaths();
+
   //Volume identifiers
   TString  fVolPath; // Volume path inside TGeo geometry
   UShort_t fVolUID;  // Unique volume ID
 
   static Int_t       fgLayerSize[kLastLayer - kFirstLayer];
   static const char* fgLayerName[kLastLayer - kFirstLayer];
-  
-  ClassDef(AliAlignObj, 1)
+
+  static const char**fgVolPath[kLastLayer - kFirstLayer];
+
+  ClassDef(AliAlignObj, 2)
 };
 
 #endif
index d27d4428eb875d93e6da4ebdf8af4ed41f0623c7..0624a421853f4fe12e37c974e7e76d3b209fbb6e 100644 (file)
@@ -26,7 +26,7 @@
 ClassImp(AliAlignObjAngles)
 
 //_____________________________________________________________________________
-AliAlignObjAngles::AliAlignObjAngles() //: AliAlignObj()
+AliAlignObjAngles::AliAlignObjAngles() : AliAlignObj()
 {
   // default constructor
   //
@@ -35,7 +35,7 @@ AliAlignObjAngles::AliAlignObjAngles() //: AliAlignObj()
 }
 
 //_____________________________________________________________________________
-AliAlignObjAngles::AliAlignObjAngles(const char* volpath, UShort_t voluid, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi)
+AliAlignObjAngles::AliAlignObjAngles(const char* volpath, UShort_t voluid, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi) : AliAlignObj()
 {
   // standard constructor with 3 translation + 3 rotation parameters
   //
@@ -46,7 +46,7 @@ AliAlignObjAngles::AliAlignObjAngles(const char* volpath, UShort_t voluid, Doubl
 }
 
 //_____________________________________________________________________________
-AliAlignObjAngles::AliAlignObjAngles(const char* volpath, ELayerID detId, Int_t volId, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi)
+AliAlignObjAngles::AliAlignObjAngles(const char* volpath, ELayerID detId, Int_t volId, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi) : AliAlignObj()
 {
   // standard constructor with 3 translation + 3 rotation parameters
   //
@@ -57,7 +57,7 @@ AliAlignObjAngles::AliAlignObjAngles(const char* volpath, ELayerID detId, Int_t
 }
 
 //_____________________________________________________________________________
-AliAlignObjAngles::AliAlignObjAngles(const char* volpath, UShort_t voluid, TGeoMatrix& m)
+AliAlignObjAngles::AliAlignObjAngles(const char* volpath, UShort_t voluid, TGeoMatrix& m) : AliAlignObj()
 {
   // standard constructor with TGeoMatrix
   //
@@ -153,3 +153,17 @@ void AliAlignObjAngles::GetMatrix(TGeoHMatrix& m) const
   m.SetRotation(rot);
 }
 
+//_____________________________________________________________________________
+AliAlignObj& AliAlignObjAngles::Inverse() const
+{
+  // Return a temporary inverse of the alignment
+  // object. This means 'mis
+   static AliAlignObjAngles a;
+   a = *this;
+
+   TGeoHMatrix m;
+   GetMatrix(m);
+   a.SetMatrix(m.Inverse());
+
+   return a;
+}
index bec6326b63bf9ca1f43e9bb6d030c5546516e8a2..9fac8a892ded27210327d2e2d73e4887ed65be00 100644 (file)
@@ -45,6 +45,8 @@ class AliAlignObjAngles : public AliAlignObj{
     angles[2] = fRotation[2]; return kTRUE;}
   virtual void GetPars(Double_t tr[], Double_t angles[]) const;
   virtual void GetMatrix(TGeoHMatrix& m) const;
+
+  virtual AliAlignObj& Inverse() const;
   
  protected:
   Double_t fTranslation[3]; // Translation vector
index 0e4774559f76ea336435412e1df49a493f66cb31..9b8a553f2ab8544066f4c9166b6fd859fcdb2499 100644 (file)
@@ -33,7 +33,7 @@ AliAlignObjMatrix::AliAlignObjMatrix() : AliAlignObj()
 }
 
 //_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t voluid, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi)
+AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t voluid, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi) : AliAlignObj()
 {
   // standard constructor with 3 translation + 3 rotation parameters
   //
@@ -44,7 +44,7 @@ AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t voluid, Doubl
 }
 
 //_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, ELayerID detId, Int_t volId, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi)
+AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, ELayerID detId, Int_t volId, Double_t x, Double_t y, Double_t z, Double_t psi, Double_t theta, Double_t phi) : AliAlignObj()
 {
   // standard constructor with 3 translation + 3 rotation parameters
   //
@@ -55,7 +55,7 @@ AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, ELayerID detId, Int_t
 }
 
 //_____________________________________________________________________________
-AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t voluid, TGeoMatrix& m)
+AliAlignObjMatrix::AliAlignObjMatrix(const char* volpath, UShort_t voluid, TGeoMatrix& m) : AliAlignObj()
 {
   // standard constructor with TGeoMatrix
   //
@@ -189,3 +189,17 @@ void AliAlignObjMatrix::GetMatrix(TGeoHMatrix& m) const
   m.SetRotation(rot);
 }
 
+//_____________________________________________________________________________
+AliAlignObj& AliAlignObjMatrix::Inverse() const
+{
+  // Return a temporary inverse of the alignment
+  // object. This means 'mis
+   static AliAlignObjMatrix a;
+   a = *this;
+
+   TGeoHMatrix m;
+   GetMatrix(m);
+   a.SetMatrix(m.Inverse());
+
+   return a;
+}
index 1e5b620ced50e7ac44ee75e9631f64946072a67e..a0170c1dc6e3857446fb35b782d229db6add157c 100644 (file)
@@ -33,6 +33,8 @@ class AliAlignObjMatrix : public AliAlignObj {
   virtual Bool_t GetAngles(Double_t* angles)  const;
   virtual void GetPars(Double_t tr[], Double_t rot[]) const;
   virtual void GetMatrix(TGeoHMatrix& m) const;
+
+  virtual AliAlignObj& Inverse() const;
   
  protected:
   TGeoHMatrix fMatrix; // Transformation matrix