Fix TRD matrices definition and pad shift accounting

Author: shahor02

Detectors/Align/include/Align/AlignableSensorTRD.h

@@ -35,7 +35,12 @@ class AlignableSensorTRD final : public AlignableSensor
   int getSector() const { return mSector; }
   void setSector(int sc) { mSector = (uint8_t)sc; }
   void dPosTraDParCalib(const AlignmentPoint* pnt, double* deriv, int calibID, const AlignableVolume* parent = nullptr) const final;
+
+  void prepareMatrixL2G(bool reco = false) final;
+  void prepareMatrixL2GIdeal() final;
   void prepareMatrixT2L() final;
+  void prepareMatrixClAlg() final;
+  void prepareMatrixClAlgReco() final;
 
  protected:
   uint8_t mSector = 0; // sector ID

Detectors/Align/src/AlignableDetectorTRD.cxx

@@ -192,7 +192,7 @@ int AlignableDetectorTRD::processPoints(GIndex gid, int npntCut, bool inv)
     }
     int trkltId = trk.getTrackletIndex(il);
     const auto& trackletRaw = trackletsRaw[trkltId];
-    const auto trackletCalibLoc = transformer->transformTracklet(trackletRaw, true); // calibrated tracket in local frame !!!
+    const auto trackletCalibLoc = transformer->transformTracklet(trackletRaw, false); // calibrated tracket in local frame !!!
     int trkltDet = trackletRaw.getDetector();
     auto* sensor = (AlignableSensorTRD*)getSensor(trkltDet);
     if (sensor->isDummy()) {
@@ -201,23 +201,10 @@ int AlignableDetectorTRD::processPoints(GIndex gid, int npntCut, bool inv)
       continue;
     }
     double locXYZ[3] = {trackletCalibLoc.getX(), trackletCalibLoc.getY(), trackletCalibLoc.getZ()}, locXYZC[3], traXYZ[3];
-    /*
     const auto& matAlg = sensor->getMatrixClAlg(); // local alignment matrix
     matAlg.LocalToMaster(locXYZ, locXYZC);         // aligned point in the local frame
     const auto& mat = sensor->getMatrixT2L();      // RS FIXME check if correct
     mat.MasterToLocal(locXYZC, traXYZ);
-    */
-    traXYZ[0] = trackletCalibLoc.getX();
-    traXYZ[1] = trackletCalibLoc.getY();
-    traXYZ[2] = trackletCalibLoc.getZ();
-
-    /*
-    // This is a hack until TRD T2L matrix problem will be solved
-    const auto trackletCalib = recoData->getTRDCalibratedTracklets()[trkltId];
-    traXYZ[0] = trackletCalib.getX();
-    traXYZ[1] = trackletCalib.getY();
-    traXYZ[2] = trackletCalib.getZ();
-    */
     int trkltSec = sensor->getSector();       // trkltDet / (o2::trd::constants::NLAYER * o2::trd::constants::NSTACK);
     float alpSens = sensor->getAlpTracking(); // o2::math_utils::sector2Angle(trkltSec);
     if (trkltSec != o2::math_utils::angle2Sector(trkParam.getAlpha()) ||

Detectors/Align/src/AlignableSensorTRD.cxx

@@ -19,6 +19,7 @@
 #include "Align/utils.h"
 #include "Framework/Logger.h"
 #include "Align/AlignmentPoint.h"
+#include "DetectorsBase/GeometryManager.h"
 
 namespace o2
 {
@@ -33,22 +34,71 @@ AlignableSensorTRD::AlignableSensorTRD(const char* name, int vid, int iid, int i
   // def c-tor
 }
 
+//____________________________________________
+void AlignableSensorTRD::prepareMatrixClAlg()
+{
+  // prepare alignment matrix in the pseudo-LOCAL frame of TRD (account that the chamber has extra X,Y rotations
+  TGeoHMatrix ma = getMatrixL2GIdeal().Inverse();
+  ma *= getMatrixL2G();
+  setMatrixClAlg(ma);
+  //
+}
+
+//____________________________________________
+void AlignableSensorTRD::prepareMatrixClAlgReco()
+{
+  // prepare alignment matrix in the pseudo-LOCAL frame of TRD (account that the chamber has extra X,Y rotations
+  TGeoHMatrix ma = getMatrixL2GIdeal().Inverse();
+  ma *= getMatrixL2G();
+  setMatrixClAlgReco(ma);
+  //
+}
+
+//____________________________________________
+void AlignableSensorTRD::prepareMatrixL2GIdeal()
+{
+  TGeoHMatrix Rxy;
+  Rxy.RotateX(-90);
+  Rxy.RotateY(-90);
+  TGeoHMatrix mtmp;
+  if (!base::GeometryManager::getOriginalMatrix(getSymName(), mtmp)) {
+    LOG(fatal) << "Failed to find ideal L2G matrix for " << getSymName();
+  }
+  mtmp *= Rxy;
+  setMatrixL2GIdeal(mtmp);
+}
+
+//____________________________________________
+void AlignableSensorTRD::prepareMatrixL2G(bool reco)
+{
+  TGeoHMatrix Rxy;
+  Rxy.RotateX(-90);
+  Rxy.RotateY(-90);
+  const char* path = getSymName();
+  const TGeoHMatrix* l2g = nullptr;
+  if (!gGeoManager->GetAlignableEntry(path) || !(l2g = base::GeometryManager::getMatrix(path))) {
+    LOGP(fatal, "Failed to find L2G matrix for {}alignable {} -> {}", gGeoManager->GetAlignableEntry(path) ? "" : "non-", path, (void*)l2g);
+  }
+  TGeoHMatrix mtmp = *l2g;
+  mtmp *= Rxy;
+  reco ? setMatrixL2GReco(mtmp) : setMatrixL2G(mtmp);
+}
+
 //____________________________________________
 void AlignableSensorTRD::prepareMatrixT2L()
 {
   // extract from geometry T2L matrix
   double alp = math_utils::detail::sector2Angle<float>(mSector);
   mAlp = alp;
-  double loc[3] = {0, 0, 0}, glo[3];
-  getMatrixL2GIdeal().LocalToMaster(loc, glo);
-  mX = Sqrt(glo[0] * glo[0] + glo[1] * glo[1]);
-  TGeoHMatrix t2l;
-  //  t2l.SetDx(mX); // to remove when T2L will be clarified
-  t2l.RotateZ(alp * RadToDeg());
-  const TGeoHMatrix l2gi = getMatrixL2GIdeal().Inverse();
-  t2l.MultiplyLeft(&l2gi);
-
+  TGeoHMatrix Rs;
+  Rs.RotateZ(-alp * TMath::RadToDeg());
+  TGeoHMatrix m0 = getMatrixL2GIdeal();
+  m0.MultiplyLeft(Rs);
+  TGeoHMatrix t2l = m0.Inverse();
   setMatrixT2L(t2l);
+  double loc[3] = {0, 0, 0}, glo[3];
+  t2l.MasterToLocal(loc, glo);
+  mX = glo[0];
   //
 }