CTPPSGeometryESModule.cc

Go to the documentation of this file.

/****************************************************************************
*
* Authors:
*  Jan Kaspar (jan.kaspar@gmail.com)
*  Dominik Mierzejewski <dmierzej@cern.ch>
*
****************************************************************************/
 
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ModuleFactory.h"
#include "FWCore/Framework/interface/ESProducer.h"
 
#include "DetectorDescription/Core/interface/DDCompactView.h"
#include "DetectorDescription/Core/interface/DDFilteredView.h"
#include "DetectorDescription/Core/interface/DDMaterial.h"
#include "DetectorDescription/Core/interface/DDSolid.h"
#include "DetectorDescription/Core/interface/DDSpecifics.h"
#include "DetectorDescription/Core/interface/DDRotationMatrix.h"
 
#include "CondFormats/PPSObjects/interface/CTPPSRPAlignmentCorrectionsData.h"
 
#include "DataFormats/CTPPSDetId/interface/TotemRPDetId.h"
#include "DataFormats/CTPPSDetId/interface/TotemTimingDetId.h"
#include "DataFormats/CTPPSDetId/interface/CTPPSPixelDetId.h"
#include "DataFormats/CTPPSDetId/interface/CTPPSDiamondDetId.h"
 
#include "CondFormats/AlignmentRecord/interface/RPRealAlignmentRecord.h"
//#include "CondFormats/AlignmentRecord/interface/CTPPSRPAlignmentCorrectionsDataRcd.h"
 
#include "CondFormats/AlignmentRecord/interface/RPMisalignedAlignmentRecord.h"
 
#include "Geometry/Records/interface/IdealGeometryRecord.h"
#include "Geometry/Records/interface/VeryForwardMisalignedGeometryRecord.h"
#include "Geometry/Records/interface/VeryForwardRealGeometryRecord.h"
 
#include "Geometry/VeryForwardGeometryBuilder/interface/DetGeomDesc.h"
#include "Geometry/VeryForwardGeometryBuilder/interface/CTPPSGeometry.h"
#include "Geometry/VeryForwardGeometryBuilder/interface/CTPPSDDDNames.h"
 
#include <regex>
 
class CTPPSGeometryESModule : public edm::ESProducer {
public:
  CTPPSGeometryESModule(const edm::ParameterSet&);
  ~CTPPSGeometryESModule() override {}
 
  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
private:
  std::unique_ptr<DetGeomDesc> produceIdealGD(const IdealGeometryRecord&);
 
  template <typename ALIGNMENT_REC>
  struct GDTokens {
    explicit GDTokens(edm::ESConsumesCollector&& iCC)
        : idealGDToken_{iCC.consumesFrom<DetGeomDesc, IdealGeometryRecord>(edm::ESInputTag())},
          alignmentToken_{iCC.consumesFrom<CTPPSRPAlignmentCorrectionsData, ALIGNMENT_REC>(edm::ESInputTag())} {}
    const edm::ESGetToken<DetGeomDesc, IdealGeometryRecord> idealGDToken_;
    const edm::ESGetToken<CTPPSRPAlignmentCorrectionsData, ALIGNMENT_REC> alignmentToken_;
  };
 
  std::unique_ptr<DetGeomDesc> produceRealGD(const VeryForwardRealGeometryRecord&);
  std::unique_ptr<CTPPSGeometry> produceRealTG(const VeryForwardRealGeometryRecord&);
 
  std::unique_ptr<DetGeomDesc> produceMisalignedGD(const VeryForwardMisalignedGeometryRecord&);
  std::unique_ptr<CTPPSGeometry> produceMisalignedTG(const VeryForwardMisalignedGeometryRecord&);
 
  template <typename REC>
  std::unique_ptr<DetGeomDesc> produceGD(IdealGeometryRecord const&,
                                         const std::optional<REC>&,
                                         GDTokens<REC> const&,
                                         const char* name);
 
  static void applyAlignments(const DetGeomDesc&, const CTPPSRPAlignmentCorrectionsData*, DetGeomDesc*&);
  static void buildDetGeomDesc(DDFilteredView* fv, DetGeomDesc* gd);
 
  const unsigned int verbosity_;
  const edm::ESGetToken<DDCompactView, IdealGeometryRecord> compactViewToken_;
 
  const GDTokens<RPRealAlignmentRecord> gdRealTokens_;
  const GDTokens<RPMisalignedAlignmentRecord> gdMisTokens_;
 
  const edm::ESGetToken<DetGeomDesc, VeryForwardRealGeometryRecord> dgdRealToken_;
  const edm::ESGetToken<DetGeomDesc, VeryForwardMisalignedGeometryRecord> dgdMisToken_;
};
 
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
 
CTPPSGeometryESModule::CTPPSGeometryESModule(const edm::ParameterSet& iConfig)
    : verbosity_(iConfig.getUntrackedParameter<unsigned int>("verbosity")),
      compactViewToken_{setWhatProduced(this, &CTPPSGeometryESModule::produceIdealGD)
                            .consumes<DDCompactView>(edm::ESInputTag(
                                "" /*optional module label */, iConfig.getParameter<std::string>("compactViewTag")))},
      gdRealTokens_{setWhatProduced(this, &CTPPSGeometryESModule::produceRealGD)},
      gdMisTokens_{setWhatProduced(this, &CTPPSGeometryESModule::produceMisalignedGD)},
      dgdRealToken_{
          setWhatProduced(this, &CTPPSGeometryESModule::produceRealTG).consumes<DetGeomDesc>(edm::ESInputTag())},
      dgdMisToken_{
          setWhatProduced(this, &CTPPSGeometryESModule::produceMisalignedTG).consumes<DetGeomDesc>(edm::ESInputTag())} {
}
 
void CTPPSGeometryESModule::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  desc.addUntracked<unsigned int>("verbosity", 1);
  desc.add<std::string>("compactViewTag", std::string());
  descriptions.add("DoodadESSource", desc);
}
 
//----------------------------------------------------------------------------------------------------
 
void CTPPSGeometryESModule::applyAlignments(const DetGeomDesc& idealGD,
                                            const CTPPSRPAlignmentCorrectionsData* alignments,
                                            DetGeomDesc*& newGD) {
  newGD = new DetGeomDesc(idealGD);
  std::deque<const DetGeomDesc*> buffer;
  std::deque<DetGeomDesc*> bufferNew;
  buffer.emplace_back(&idealGD);
  bufferNew.emplace_back(newGD);
 
  while (!buffer.empty()) {
    const DetGeomDesc* sD = buffer.front();
    DetGeomDesc* pD = bufferNew.front();
    buffer.pop_front();
    bufferNew.pop_front();
 
    const std::string name = pD->name();
 
    // Is it sensor? If yes, apply full sensor alignments
    if (name == DDD_TOTEM_RP_SENSOR_NAME || name == DDD_CTPPS_DIAMONDS_SEGMENT_NAME ||
        name == DDD_CTPPS_UFSD_SEGMENT_NAME || name == DDD_CTPPS_PIXELS_SENSOR_NAME ||
        std::regex_match(name, std::regex(DDD_TOTEM_TIMING_SENSOR_TMPL))) {
      unsigned int plId = pD->geographicalID();
 
      if (alignments) {
        const auto& ac = alignments->getFullSensorCorrection(plId);
        pD->applyAlignment(ac);
      }
    }
 
    // Is it RP box? If yes, apply RP alignments
    if (name == DDD_TOTEM_RP_RP_NAME || name == DDD_CTPPS_DIAMONDS_RP_NAME || name == DDD_CTPPS_PIXELS_RP_NAME ||
        name == DDD_TOTEM_TIMING_RP_NAME) {
      unsigned int rpId = pD->geographicalID();
 
      if (alignments) {
        const auto& ac = alignments->getRPCorrection(rpId);
        pD->applyAlignment(ac);
      }
    }
 
    // create and add children
    for (unsigned int i = 0; i < sD->components().size(); i++) {
      const DetGeomDesc* sDC = sD->components()[i];
      buffer.emplace_back(sDC);
 
      // create new node with the same information as in sDC and add it as a child of pD
      DetGeomDesc* cD = new DetGeomDesc(*sDC);
      pD->addComponent(cD);
 
      bufferNew.emplace_back(cD);
    }
  }
}
 
//----------------------------------------------------------------------------------------------------
 
void CTPPSGeometryESModule::buildDetGeomDesc(DDFilteredView* fv, DetGeomDesc* gd) {
  // try to dive into next level
  if (!fv->firstChild())
    return;
 
  // loop over siblings in the level
  do {
    // create new DetGeomDesc node and add it to the parent's (gd) list
    DetGeomDesc* newGD = new DetGeomDesc(fv);
 
    const std::string name = fv->logicalPart().name().name();
 
    // strip sensors
    if (name == DDD_TOTEM_RP_SENSOR_NAME) {
      const std::vector<int>& copy_num = fv->copyNumbers();
      // check size of copy numubers array
      if (copy_num.size() < 3)
        throw cms::Exception("DDDTotemRPContruction")
            << "size of copyNumbers for strip sensor is " << copy_num.size() << ". It must be >= 3.";
 
      // extract information
      const unsigned int decRPId = copy_num[copy_num.size() - 3];
      const unsigned int arm = decRPId / 100;
      const unsigned int station = (decRPId % 100) / 10;
      const unsigned int rp = decRPId % 10;
      const unsigned int detector = copy_num[copy_num.size() - 1];
      newGD->setGeographicalID(TotemRPDetId(arm, station, rp, detector));
    }
 
    // strip and pixels RPs
    else if (name == DDD_TOTEM_RP_RP_NAME || name == DDD_CTPPS_PIXELS_RP_NAME) {
      unsigned int decRPId = fv->copyno();
 
      // check if it is a pixel RP
      if (decRPId >= 10000) {
        decRPId = decRPId % 10000;
        const unsigned int armIdx = (decRPId / 100) % 10;
        const unsigned int stIdx = (decRPId / 10) % 10;
        const unsigned int rpIdx = decRPId % 10;
        newGD->setGeographicalID(CTPPSPixelDetId(armIdx, stIdx, rpIdx));
      } else {
        const unsigned int armIdx = (decRPId / 100) % 10;
        const unsigned int stIdx = (decRPId / 10) % 10;
        const unsigned int rpIdx = decRPId % 10;
        newGD->setGeographicalID(TotemRPDetId(armIdx, stIdx, rpIdx));
      }
    }
 
    else if (std::regex_match(name, std::regex(DDD_TOTEM_TIMING_SENSOR_TMPL))) {
      const std::vector<int>& copy_num = fv->copyNumbers();
      // check size of copy numbers array
      if (copy_num.size() < 4)
        throw cms::Exception("DDDTotemRPContruction")
            << "size of copyNumbers for TOTEM timing sensor is " << copy_num.size() << ". It must be >= 4.";
 
      const unsigned int decRPId = copy_num[copy_num.size() - 4];
      const unsigned int arm = decRPId / 100, station = (decRPId % 100) / 10, rp = decRPId % 10;
      const unsigned int plane = copy_num[copy_num.size() - 2], channel = copy_num[copy_num.size() - 1];
      newGD->setGeographicalID(TotemTimingDetId(arm, station, rp, plane, channel));
    }
 
    else if (name == DDD_TOTEM_TIMING_RP_NAME) {
      const unsigned int arm = fv->copyno() / 100, station = (fv->copyno() % 100) / 10, rp = fv->copyno() % 10;
      newGD->setGeographicalID(TotemTimingDetId(arm, station, rp));
    }
 
    // pixel sensors
    else if (name == DDD_CTPPS_PIXELS_SENSOR_NAME) {
      const std::vector<int>& copy_num = fv->copyNumbers();
      // check size of copy numubers array
      if (copy_num.size() < 4)
        throw cms::Exception("DDDTotemRPContruction")
            << "size of copyNumbers for pixel sensor is " << copy_num.size() << ". It must be >= 4.";
 
      // extract information
      const unsigned int decRPId = copy_num[copy_num.size() - 4] % 10000;
      const unsigned int arm = decRPId / 100;
      const unsigned int station = (decRPId % 100) / 10;
      const unsigned int rp = decRPId % 10;
      const unsigned int detector = copy_num[copy_num.size() - 2] - 1;
      newGD->setGeographicalID(CTPPSPixelDetId(arm, station, rp, detector));
    }
 
    // diamond/UFSD sensors
    else if (name == DDD_CTPPS_DIAMONDS_SEGMENT_NAME || name == DDD_CTPPS_UFSD_SEGMENT_NAME) {
      const std::vector<int>& copy_num = fv->copyNumbers();
 
      const unsigned int id = copy_num[copy_num.size() - 1];
      const unsigned int arm = copy_num[1] - 1;
      const unsigned int station = 1;
      const unsigned int rp = 6;
      const unsigned int plane = (id / 100);
      const unsigned int channel = id % 100;
 
      newGD->setGeographicalID(CTPPSDiamondDetId(arm, station, rp, plane, channel));
    }
 
    // diamond/UFSD RPs
    else if (name == DDD_CTPPS_DIAMONDS_RP_NAME) {
      const std::vector<int>& copy_num = fv->copyNumbers();
 
      // check size of copy numubers array
      if (copy_num.size() < 2)
        throw cms::Exception("DDDTotemRPContruction")
            << "size of copyNumbers for diamond RP is " << copy_num.size() << ". It must be >= 2.";
 
      const unsigned int arm = copy_num[1] - 1;
      const unsigned int station = 1;
      const unsigned int rp = 6;
 
      newGD->setGeographicalID(CTPPSDiamondDetId(arm, station, rp));
    }
 
    // add component
    gd->addComponent(newGD);
 
    // recursion
    buildDetGeomDesc(fv, newGD);
  } while (fv->nextSibling());
 
  // go a level up
  fv->parent();
}
 
//----------------------------------------------------------------------------------------------------
 
std::unique_ptr<DetGeomDesc> CTPPSGeometryESModule::produceIdealGD(const IdealGeometryRecord& iRecord) {
  // get the DDCompactView from EventSetup
  auto const& cpv = iRecord.get(compactViewToken_);
 
  // create DDFilteredView and apply the filter
  DDPassAllFilter filter;
  DDFilteredView fv(cpv, filter);
 
  // conversion to DetGeomDesc structure
  auto root = std::make_unique<DetGeomDesc>(&fv);
  buildDetGeomDesc(&fv, root.get());
 
  // construct the tree of DetGeomDesc
  return root;
}
 
//----------------------------------------------------------------------------------------------------
 
template <typename REC>
std::unique_ptr<DetGeomDesc> CTPPSGeometryESModule::produceGD(IdealGeometryRecord const& iIdealRec,
                                                              std::optional<REC> const& iAlignRec,
                                                              GDTokens<REC> const& iTokens,
                                                              const char* name) {
  // get the input GeometricalDet
  auto const& idealGD = iIdealRec.get(iTokens.idealGDToken_);
 
  // load alignments
  edm::ESHandle<CTPPSRPAlignmentCorrectionsData> alignments;
  if (iAlignRec) {
    alignments = iAlignRec->getHandle(iTokens.alignmentToken_);
  }
 
  if (alignments.isValid()) {
    if (verbosity_)
      edm::LogVerbatim(name) << ">> " << name << " > Real geometry: " << alignments->getRPMap().size() << " RP and "
                             << alignments->getSensorMap().size() << " sensor alignments applied.";
  } else {
    if (verbosity_)
      edm::LogVerbatim(name) << ">> " << name << " > Real geometry: No alignments applied.";
  }
 
  DetGeomDesc* newGD = nullptr;
  applyAlignments(idealGD, alignments.product(), newGD);
  return std::unique_ptr<DetGeomDesc>(newGD);
}
 
std::unique_ptr<DetGeomDesc> CTPPSGeometryESModule::produceRealGD(const VeryForwardRealGeometryRecord& iRecord) {
  return produceGD(iRecord.getRecord<IdealGeometryRecord>(),
                   iRecord.tryToGetRecord<RPRealAlignmentRecord>(),
                   gdRealTokens_,
                   "CTPPSGeometryESModule::produceRealGD");
}
 
//----------------------------------------------------------------------------------------------------
 
std::unique_ptr<DetGeomDesc> CTPPSGeometryESModule::produceMisalignedGD(
    const VeryForwardMisalignedGeometryRecord& iRecord) {
  return produceGD(iRecord.getRecord<IdealGeometryRecord>(),
                   iRecord.tryToGetRecord<RPMisalignedAlignmentRecord>(),
                   gdMisTokens_,
                   "CTPPSGeometryESModule::produceMisalignedGD");
}
 
//----------------------------------------------------------------------------------------------------
 
std::unique_ptr<CTPPSGeometry> CTPPSGeometryESModule::produceRealTG(const VeryForwardRealGeometryRecord& iRecord) {
  auto const& gD = iRecord.get(dgdRealToken_);
 
  return std::make_unique<CTPPSGeometry>(&gD);
}
 
//----------------------------------------------------------------------------------------------------
 
std::unique_ptr<CTPPSGeometry> CTPPSGeometryESModule::produceMisalignedTG(
    const VeryForwardMisalignedGeometryRecord& iRecord) {
  auto const& gD = iRecord.get(dgdMisToken_);
 
  return std::make_unique<CTPPSGeometry>(&gD);
}
 
DEFINE_FWK_EVENTSETUP_MODULE(CTPPSGeometryESModule);