MTDTrackingRecHitProducer.cc

Go to the documentation of this file.

#include "FWCore/Framework/interface/stream/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 "RecoLocalFastTime/FTLClusterizer/interface/MTDCPEBase.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"

//#define DEBUG_ENABLED
#ifdef DEBUG_ENABLED
#define DEBUG(x)                 \
  do {                           \
    std::cout << x << std::endl; \
  } while (0)
#else
#define DEBUG(x)
#endif

class MTDTrackingRecHitProducer : public edm::stream::EDProducer<> {
public:
  explicit MTDTrackingRecHitProducer(const edm::ParameterSet& ps);
  ~MTDTrackingRecHitProducer() override = default;
  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);

  void produce(edm::Event& evt, const edm::EventSetup& es) override;
  void run(edm::Handle<edmNew::DetSetVector<FTLCluster> > inputHandle, MTDTrackingDetSetVector& output);

private:
  const edm::EDGetTokenT<FTLClusterCollection> ftlbClusters_;  // collection of barrel digis
  const edm::EDGetTokenT<FTLClusterCollection> ftleClusters_;  // collection of endcap digis

  const MTDGeometry* geom_;
  const MTDClusterParameterEstimator* cpe_;
};

MTDTrackingRecHitProducer::MTDTrackingRecHitProducer(const edm::ParameterSet& ps)
    : ftlbClusters_(consumes<FTLClusterCollection>(ps.getParameter<edm::InputTag>("barrelClusters"))),
      ftleClusters_(consumes<FTLClusterCollection>(ps.getParameter<edm::InputTag>("endcapClusters"))) {
  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::Event& evt, const edm::EventSetup& es) {
  edm::ESHandle<MTDGeometry> geom;
  es.get<MTDDigiGeometryRecord>().get(geom);
  geom_ = geom.product();

  edm::ESHandle<MTDClusterParameterEstimator> cpe;
  es.get<MTDCPERecord>().get("MTDCPEBase", cpe);
  cpe_ = cpe.product();

  edm::Handle<FTLClusterCollection> inputBarrel;
  evt.getByToken(ftlbClusters_, inputBarrel);

  edm::Handle<FTLClusterCollection> inputEndcap;
  evt.getByToken(ftleClusters_, inputEndcap);

  auto outputhits = std::make_unique<MTDTrackingDetSetVector>();
  auto& theoutputhits = *outputhits;

  run(inputBarrel, theoutputhits);
  run(inputEndcap, theoutputhits);

  evt.put(std::move(outputhits));
}

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void MTDTrackingRecHitProducer::run(edm::Handle<FTLClusterCollection> inputHandle, MTDTrackingDetSetVector& output) {
  const edmNew::DetSetVector<FTLCluster>& input = *inputHandle;
  edmNew::DetSetVector<FTLCluster>::const_iterator DSViter = input.begin();

  DEBUG("inputCollection " << input.size());
  for (; DSViter != input.end(); DSViter++) {
    unsigned int detid = DSViter->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(output, detid);

    edmNew::DetSet<FTLCluster>::const_iterator clustIt = DSViter->begin(), clustEnd = DSViter->end();

    for (; clustIt != clustEnd; clustIt++) {
      DEBUG("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(inputHandle, clustIt);
      // Make a RecHit and add it to the DetSet
      MTDTrackingRecHit hit(lp, le, *genericDet, cluster);
      DEBUG("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
  DEBUG("outputCollection " << output.size());
}

#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(MTDTrackingRecHitProducer);