DTGeometryESProducer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    DetectorDescription/DTGeometryESProducer
// Class:      DTGeometryESProducer
// 
//
// Original Author:  Ianna Osborne
//         Created:  Wed, 16 Jan 2019 10:19:37 GMT
//
//
#include "CondFormats/GeometryObjects/interface/RecoIdealGeometry.h"
#include "CondFormats/Alignment/interface/DetectorGlobalPosition.h"
#include "CondFormats/Alignment/interface/AlignmentErrorsExtended.h"
#include "CondFormats/AlignmentRecord/interface/GlobalPositionRcd.h"
#include "CondFormats/AlignmentRecord/interface/DTAlignmentRcd.h"
#include "CondFormats/AlignmentRecord/interface/DTAlignmentErrorRcd.h"
#include "CondFormats/AlignmentRecord/interface/DTAlignmentErrorExtendedRcd.h"
#include "Geometry/CommonTopologies/interface/GeometryAligner.h"
#include "Geometry/Records/interface/DTRecoGeometryRcd.h"
#include "DataFormats/GeometrySurface/interface/Plane.h"
#include "DataFormats/GeometrySurface/interface/Bounds.h"
#include "DataFormats/GeometrySurface/interface/RectangularPlaneBounds.h"

#include "FWCore/Framework/interface/ESTransientHandle.h"
#include "FWCore/Framework/interface/ModuleFactory.h"
#include "FWCore/Framework/interface/ESProducer.h"
#include "FWCore/Framework/interface/ESProductHost.h"
#include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/ESGetToken.h"
#include "FWCore/Utilities/interface/ReusableObjectHolder.h"
#include "Geometry/MuonNumbering/interface/DD4hep_MuonNumbering.h"
#include "Geometry/Records/interface/MuonNumberingRecord.h"
#include "Geometry/Records/interface/MuonGeometryRecord.h"
#include "Geometry/Records/interface/DDSpecParRegistryRcd.h"
#include "Geometry/Records/interface/GeometryFileRcd.h"
#include "DetectorDescription/DDCMS/interface/DDSpecParRegistry.h"
#include "DetectorDescription/DDCMS/interface/DDDetector.h"
#include "DetectorDescription/DDCMS/interface/DDFilteredView.h"
#include "DetectorDescription/DDCMS/interface/BenchmarkGrd.h"
#include "Geometry/DTGeometry/interface/DTGeometry.h"
#include "DTGeometryBuilder.h"

#include <memory>
#include <iostream>
#include <iterator>
#include <string>

using namespace edm;
using namespace std;
using namespace cms;

class DTGeometryESProducer : public ESProducer {
public:
  DTGeometryESProducer(const ParameterSet&);
  ~DTGeometryESProducer() override;

  using ReturnType = shared_ptr<DTGeometry>;
  using Detector = dd4hep::Detector;
  
  ReturnType produce(const MuonGeometryRecord& record);

private:

  using HostType = ESProductHost<DTGeometry,
                 MuonNumberingRecord,
                 DTRecoGeometryRcd>;

  void setupGeometry(MuonNumberingRecord const&, shared_ptr<HostType>&);
  void setupDBGeometry(DTRecoGeometryRcd const&, shared_ptr<HostType>&);

  ReusableObjectHolder<HostType> m_holder;

  edm::ESGetToken<Alignments, GlobalPositionRcd> m_globalPositionToken;
  edm::ESGetToken<Alignments, DTAlignmentRcd> m_alignmentsToken;
  edm::ESGetToken<AlignmentErrorsExtended, DTAlignmentErrorExtendedRcd> m_alignmentErrorsToken;
  edm::ESGetToken<MuonNumbering, MuonNumberingRecord> m_mdcToken;
  edm::ESGetToken<DDDetector, GeometryFileRcd> m_cpvToken;
  edm::ESGetToken<DDSpecParRegistry, DDSpecParRegistryRcd> m_registryToken;
  const ESInputTag m_tag;
  const string m_alignmentsLabel;
  const string m_myLabel;
  const string m_attribute;
  const string m_value;
  bool m_applyAlignment;
  bool m_fromDDD;
};

DTGeometryESProducer::DTGeometryESProducer(const ParameterSet & iConfig)
  : m_tag(iConfig.getParameter<ESInputTag>("DDDetector")),
    m_alignmentsLabel(iConfig.getParameter<string>("alignmentsLabel")),
    m_myLabel(iConfig.getParameter<string>("appendToDataLabel")),
    m_attribute(iConfig.getParameter<string>("attribute")),
    m_value(iConfig.getParameter<string>("value")),
    m_fromDDD(iConfig.getParameter<bool>("fromDDD"))
{
  m_applyAlignment = iConfig.getParameter<bool>("applyAlignment");

  auto cc = setWhatProduced(this);

  if(m_applyAlignment) {
    m_globalPositionToken = cc.consumesFrom<Alignments, GlobalPositionRcd>(edm::ESInputTag{"", m_alignmentsLabel});
    m_alignmentsToken = cc.consumesFrom<Alignments, DTAlignmentRcd>(edm::ESInputTag{"", m_alignmentsLabel});
    m_alignmentErrorsToken = cc.consumesFrom<AlignmentErrorsExtended, DTAlignmentErrorExtendedRcd>(edm::ESInputTag{"", m_alignmentsLabel});
  }

  if(m_fromDDD) {
    m_mdcToken = cc.consumesFrom<MuonNumbering, MuonNumberingRecord>(edm::ESInputTag{});
    m_cpvToken = cc.consumesFrom<DDDetector, GeometryFileRcd>(m_tag);
    m_registryToken = cc.consumesFrom<DDSpecParRegistry, DDSpecParRegistryRcd>(m_tag);
  }

  edm::LogInfo("Geometry") << "@SUB=DTGeometryESProducer"
    << "Label '" << m_myLabel << "' "
    << (m_applyAlignment ? "looking for" : "IGNORING")
    << " alignment labels '" << m_alignmentsLabel << "'.";
}

DTGeometryESProducer::~DTGeometryESProducer(){}

std::shared_ptr<DTGeometry> 
DTGeometryESProducer::produce(const MuonGeometryRecord & record) {
  
  auto host = m_holder.makeOrGet([]() {
    return new HostType;
  });

  {
    BenchmarkGrd counter("DTGeometryESProducer");

    if(m_fromDDD) {
      host->ifRecordChanges<MuonNumberingRecord>(record,
                          [this, &host](auto const& rec) {
                        setupGeometry(rec, host);
                          });
    } else {
      host->ifRecordChanges<DTRecoGeometryRcd>(record,
                           [this, &host](auto const& rec) {
                         setupDBGeometry(rec, host);
                           });
    }
  }
  //
  // Called whenever the alignments or alignment errors change
  //  
  if(m_applyAlignment) {
    // m_applyAlignment is scheduled for removal. 
    // Ideal geometry obtained by using 'fake alignment' (with m_applyAlignment = true)
    edm::ESHandle<Alignments> globalPosition;
    record.getRecord<GlobalPositionRcd>().get(m_alignmentsLabel, globalPosition);
    edm::ESHandle<Alignments> alignments;
    record.getRecord<DTAlignmentRcd>().get(m_alignmentsLabel, alignments);
    edm::ESHandle<AlignmentErrorsExtended> alignmentErrors;
    record.getRecord<DTAlignmentErrorExtendedRcd>().get(m_alignmentsLabel, alignmentErrors);
    // Only apply alignment if values exist
    if (alignments->empty() && alignmentErrors->empty() && globalPosition->empty()) {
      edm::LogInfo("Config") << "@SUB=DTGeometryRecord::produce"
        << "Alignment(Error)s and global position (label '"
        << m_alignmentsLabel << "') empty: Geometry producer (label "
        << "'" << m_myLabel << "') assumes fake and does not apply.";
    } else {
      GeometryAligner aligner;
      aligner.applyAlignments<DTGeometry>( &(*host),
                                           &(*alignments), &(*alignmentErrors),
                                           align::DetectorGlobalPosition(*globalPosition, DetId(DetId::Muon)));
    }
  }

  return host; // automatically converts to std::shared_ptr<DTGeometry>
}

void
DTGeometryESProducer::setupGeometry(const MuonNumberingRecord& record,
                    shared_ptr<HostType>& host) {
  host->clear();
  
  const auto& mdc = record.get(m_mdcToken);
  
  edm::ESTransientHandle<DDDetector> cpv = record.getTransientHandle(m_cpvToken);
  
  ESTransientHandle<DDSpecParRegistry> registry = record.getTransientHandle(m_registryToken);
  
  DDSpecParRefs myReg;
  {
    BenchmarkGrd b1("DTGeometryESProducer Filter Registry");
    registry->filter(myReg, m_attribute, m_value);
  }
  
  DTGeometryBuilder builder;
  builder.build(*host, cpv.product(), mdc, myReg);
}

void
DTGeometryESProducer::setupDBGeometry( const DTRecoGeometryRcd& record,
                       std::shared_ptr<HostType>& host ) {
  // host->clear();
  
  // edm::ESHandle<RecoIdealGeometry> rig;
  // record.get(rig);
  
  // DTGeometryBuilderFromCondDB builder;
  // builder.build(host, *rig);
}

DEFINE_FWK_EVENTSETUP_MODULE(DTGeometryESProducer);