AlignableSensorITS.cxx

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#include "ITSBase/GeometryTGeo.h"
#include "Align/AlignableSensorITS.h"
#include "Align/utils.h"
#include "Framework/Logger.h"
#include "Align/AlignmentPoint.h"
#include "Align/AlignableDetector.h"
 
ClassImp(o2::align::AlignableSensorITS);
 
using namespace o2::align::utils;
using namespace TMath;
 
namespace o2
{
namespace align
{
 
//_________________________________________________________
AlignableSensorITS::AlignableSensorITS(const char* name, int vid, int iid, Controller* ctr)
  : AlignableSensor(name, vid, iid, ctr)
{
  // def c-tor
}
 
//____________________________________________
void AlignableSensorITS::prepareMatrixT2L()
{
  // extract geometry T2L matrix
  TGeoHMatrix t2l;
  const auto& l2g = getMatrixL2GIdeal();
  double locA[3] = {-100., 0., 0.}, locB[3] = {100., 0., 0.}, gloA[3], gloB[3];
  l2g.LocalToMaster(locA, gloA);
  l2g.LocalToMaster(locB, gloB);
  double dx = gloB[0] - gloA[0], dy = gloB[1] - gloA[1];
  double t = (gloB[0] * dx + gloB[1] * dy) / (dx * dx + dy * dy);
  double xp = gloB[0] - dx * t, yp = gloB[1] - dy * t;
  mX = std::sqrt(xp * xp + yp * yp);
  float alp = std::atan2(yp, xp);
  o2::math_utils::bringTo02Pi(alp);
  mAlp = alp;
  /* // this would proved x, alpha accounting for the corrections, we need ideal ones ?
     float x, alp;
     auto geom = o2::its::GeometryTGeo::Instance();
     geom->getSensorXAlphaRefPlane(getVolID(), x, alp);
     mAlp = alp;
     mX = x;
  */
  t2l.RotateZ(mAlp * RadToDeg()); // rotate in direction of normal to the sensor plane
  const TGeoHMatrix l2gi = l2g.Inverse();
  t2l.MultiplyLeft(&l2gi);
  setMatrixT2L(t2l);
}
 
void AlignableSensorITS::prepareMatrixL2G(bool reco)
{
  // Note that for ITS2 it is NOT the same as GeometryManager::getMatrix() (i.e. that of the alignable volule)
  // since we need the matrix of epitaxial layer and not the whole chip
  auto geom = o2::its::GeometryTGeo::Instance();
  const auto* m = geom->extractMatrixSensor(getVolID());
  if (!m) {
    LOGP(fatal, "Failed on :GeometryTGeo::extractMatrixSensor({})", getVolID());
  }
  reco ? setMatrixL2GReco(*m) : setMatrixL2G(*m);
}
 
void AlignableSensorITS::prepareMatrixL2GIdeal()
{
  // Note that for ITS2 it is NOT the same as GeometryManager::getOriginalMatrix (i.e. that of the alignable volule)
  // since we need the matrix of epitaxial layer and not the whole chip
  auto geom = o2::its::GeometryTGeo::Instance();
  TGeoHMatrix mtmp;
  if (!base::GeometryManager::getOriginalMatrix(getSymName(), mtmp)) { // this is chip ideal matrix, not that of the epitaxial layer
    LOG(fatal) << "Failed to find ideal L2G matrix for " << getSymName();
  }
  // we have to apply to it the difference between the aligner epitaxial layer matrix and that of the chip
  const auto* malgSens = geom->extractMatrixSensor(getVolID());
  if (!malgSens) {
    LOGP(fatal, "Failed on :GeometryTGeo::extractMatrixSensor({})", getVolID());
  }
  const auto* malgChip = geom->getMatrix(getVolID());
  // correct chip original matrix by the difference between aligneg chip and sensor matrices
  // Sens_ideal = Chip_ideal * Chip_aligned^-1 * Sens_aligned
  auto chAlignInv = malgChip->Inverse();
  chAlignInv.Multiply(*malgSens);
  mtmp.Multiply(chAlignInv);
  setMatrixL2GIdeal(mtmp);
}
 
} // namespace align
} // namespace o2