RPDisplacementGenerator.cc

Go to the documentation of this file.

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "Geometry/Records/interface/VeryForwardMisalignedGeometryRecord.h"
#include "Geometry/Records/interface/VeryForwardRealGeometryRecord.h"
#include "Geometry/VeryForwardGeometryBuilder/interface/CTPPSGeometry.h"
#include "CondFormats/PPSObjects/interface/CTPPSRPAlignmentCorrectionsData.h"
#include "DataFormats/CTPPSDetId/interface/TotemRPDetId.h"
#include "SimDataFormats/TrackingHit/interface/PSimHit.h"
#include "SimPPS/RPDigiProducer/plugins/RPDisplacementGenerator.h"

#include <Math/RotationZYX.h>
#include <Math/Rotation3D.h>

using namespace std;
using namespace edm;

RPDisplacementGenerator::RPDisplacementGenerator(const edm::ParameterSet &ps,
                                                 RPDetId _detId,
                                                 const edm::EventSetup &iSetup)
    : detId_(_detId) {
  isOn_ = ps.getParameter<bool>("RPDisplacementOn");

  // read the alignment correction
  ESHandle<CTPPSRPAlignmentCorrectionsData> alignments;
  if (auto rec = iSetup.tryToGet<VeryForwardMisalignedGeometryRecord>()) {
    iSetup.get<VeryForwardMisalignedGeometryRecord>().get(alignments);
  }

  unsigned int decId = rawToDecId(detId_);

  math::XYZVectorD S_m;
  RotationMatrix R_m;

  if (alignments.isValid()) {
    const CTPPSRPAlignmentCorrectionData &ac = alignments->getFullSensorCorrection(decId);
    S_m = ac.getTranslation();
    R_m = ac.getRotationMatrix();
  } else
    isOn_ = false;

  // transform shift and rotation to the local coordinate frame
  ESHandle<CTPPSGeometry> geom;
  iSetup.get<VeryForwardRealGeometryRecord>().get(geom);
  const DetGeomDesc *g = geom->sensor(detId_);
  const RotationMatrix &R_l = g->rotation();
  rotation_ = R_l.Inverse() * R_m.Inverse() * R_l;
  shift_ = R_l.Inverse() * R_m.Inverse() * S_m;

  LogDebug("RPDisplacementGenerator").log([&](auto &log) {
    log << " det id = " << decId << ", isOn = " << isOn_ << "\n";
    if (isOn_) {
      log << " shift = " << shift_ << "\n";
      log << " rotation = " << rotation_ << "\n";
    }
  });
}

Local3DPoint RPDisplacementGenerator::displacePoint(const Local3DPoint &p) {

  Translation v(p.x(), p.y(), p.z());
  v = rotation_ * v - shift_;

  return Local3DPoint(v.x(), v.y(), v.z());
}

PSimHit RPDisplacementGenerator::displace(const PSimHit &input) {
  if (!isOn_)
    return input;

  const Local3DPoint &ep = input.entryPoint(), &xp = input.exitPoint();
  const Local3DPoint &dep = displacePoint(ep), &dxp = displacePoint(xp);

  LogDebug("RPDisplacementGenerator::displace\n") << " entry point: " << ep << " -> " << dep << "\n"
                                                  << " exit point : " << xp << " -> " << dxp << "\n";

  return PSimHit(dep,
                 dxp,
                 input.pabs(),
                 input.tof(),
                 input.energyLoss(),
                 input.particleType(),
                 input.detUnitId(),
                 input.trackId(),
                 input.thetaAtEntry(),
                 input.phiAtEntry(),
                 input.processType());
}

uint32_t RPDisplacementGenerator::rawToDecId(uint32_t raw) {
  return ((raw >> CTPPSDetId::startArmBit) & CTPPSDetId::maskArm) * 1000 +
         ((raw >> CTPPSDetId::startStationBit) & CTPPSDetId::maskStation) * 100 +
         ((raw >> CTPPSDetId::startRPBit) & CTPPSDetId::maskRP) * 10 +
         ((raw >> TotemRPDetId::startPlaneBit) & TotemRPDetId::maskPlane);
}