MTDTrackingRecHitProducer.cc

Go to the documentation of this file.

#include "FWCore/Framework/interface/global/EDProducer.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
 
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/FTLRecHit/interface/FTLClusterCollections.h"
 
#include "Geometry/Records/interface/MTDDigiGeometryRecord.h"
#include "Geometry/CommonTopologies/interface/Topology.h"
#include "Geometry/MTDGeometryBuilder/interface/MTDGeometry.h"
#include "DataFormats/TrackerRecHit2D/interface/MTDTrackingRecHit.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementError.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h"
 
#include "RecoLocalFastTime/Records/interface/MTDCPERecord.h"
#include "RecoLocalFastTime/FTLClusterizer/interface/MTDClusterParameterEstimator.h"
 
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
class MTDTrackingRecHitProducer : public edm::global::EDProducer<> {
public:
  explicit MTDTrackingRecHitProducer(const edm::ParameterSet& ps);
  ~MTDTrackingRecHitProducer() override = default;
  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
  void produce(edm::StreamID, edm::Event& evt, const edm::EventSetup& es) const override;
 
private:
  const edm::EDGetTokenT<FTLClusterCollection> ftlbClusters_;  // collection of barrel digis
  const edm::EDGetTokenT<FTLClusterCollection> ftleClusters_;  // collection of endcap digis
 
  const edm::ESGetToken<MTDGeometry, MTDDigiGeometryRecord> mtdgeoToken_;
  const edm::ESGetToken<MTDClusterParameterEstimator, MTDCPERecord> cpeToken_;
};
 
MTDTrackingRecHitProducer::MTDTrackingRecHitProducer(const edm::ParameterSet& ps)
    : ftlbClusters_(consumes<FTLClusterCollection>(ps.getParameter<edm::InputTag>("barrelClusters"))),
      ftleClusters_(consumes<FTLClusterCollection>(ps.getParameter<edm::InputTag>("endcapClusters"))),
      mtdgeoToken_(esConsumes<MTDGeometry, MTDDigiGeometryRecord>()),
      cpeToken_(esConsumes<MTDClusterParameterEstimator, MTDCPERecord>(edm::ESInputTag("", "MTDCPEBase"))) {
  produces<MTDTrackingDetSetVector>();
}
 
// Configuration descriptions
void MTDTrackingRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("barrelClusters", edm::InputTag("mtdClusters:FTLBarrel"));
  desc.add<edm::InputTag>("endcapClusters", edm::InputTag("mtdClusters:FTLEndcap"));
  descriptions.add("mtdTrackingRecHitProducer", desc);
}
 
void MTDTrackingRecHitProducer::produce(edm::StreamID, edm::Event& evt, const edm::EventSetup& es) const {
  auto const& geom = es.getData(mtdgeoToken_);
 
  auto const& cpe = es.getData(cpeToken_);
 
  edm::Handle<FTLClusterCollection> inputBarrel;
  evt.getByToken(ftlbClusters_, inputBarrel);
 
  edm::Handle<FTLClusterCollection> inputEndcap;
  evt.getByToken(ftleClusters_, inputEndcap);
 
  std::array<edm::Handle<FTLClusterCollection>, 2> inputHandle{{inputBarrel, inputEndcap}};
 
  auto outputhits = std::make_unique<MTDTrackingDetSetVector>();
  auto& theoutputhits = *outputhits;
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
 
  for (auto const& theInput : inputHandle) {
    const edmNew::DetSetVector<FTLCluster>& input = *theInput;
 
    LogDebug("MTDTrackingRecHitProducer") << "inputCollection " << input.size();
    for (const auto& DSVit : input) {
      unsigned int detid = DSVit.detId();
      DetId detIdObject(detid);
      const auto genericDet = geom.idToDetUnit(detIdObject);
      if (genericDet == nullptr) {
        throw cms::Exception("MTDTrackingRecHitProducer")
            << "GeographicalID: " << std::hex << detid << " is invalid!" << std::dec << std::endl;
      }
 
      MTDTrackingDetSetVector::FastFiller recHitsOnDet(theoutputhits, detid);
 
      for (const auto& clustIt : DSVit) {
        LogDebug("MTDTrackingRcHitProducer") << "Cluster: size " << clustIt.size() << " " << clustIt.x() << ","
                                             << clustIt.y() << " " << clustIt.energy() << " " << clustIt.time();
        MTDClusterParameterEstimator::ReturnType tuple = cpe.getParameters(clustIt, *genericDet);
        LocalPoint lp(std::get<0>(tuple));
        LocalError le(std::get<1>(tuple));
 
        // Create a persistent edm::Ref to the cluster
        edm::Ref<edmNew::DetSetVector<FTLCluster>, FTLCluster> cluster = edmNew::makeRefTo(theInput, &clustIt);
        // Make a RecHit and add it to the DetSet
        MTDTrackingRecHit hit(lp, le, *genericDet, cluster);
        LogDebug("MTDTrackingRcHitProducer")
            << "MTD_TRH: " << hit.localPosition().x() << "," << hit.localPosition().y() << " : "
            << hit.localPositionError().xx() << "," << hit.localPositionError().yy() << " : " << hit.time() << " : "
            << hit.timeError();
        // Now save it =================
        recHitsOnDet.push_back(hit);
      }  //  <-- End loop on Clusters
    }    //    <-- End loop on DetUnits
    LogDebug("MTDTrackingRcHitProducer") << "outputCollection " << theoutputhits.size();
  }
 
  evt.put(std::move(outputhits));
}
 
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(MTDTrackingRecHitProducer);