SiPixelRecHitConverter.cc

Go to the documentation of this file.

// Our own stuff
#include "RecoLocalTracker/SiPixelRecHits/interface/SiPixelRecHitConverter.h"
// Geometry
#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
#include "Geometry/CommonDetUnit/interface/PixelGeomDetUnit.h"

// Data Formats
#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/DetSet2RangeMap.h"

// STL
#include <vector>
#include <memory>
#include <string>
#include <iostream>

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

#include "RecoLocalTracker/Records/interface/TkPixelCPERecord.h"

using namespace std;

namespace cms {
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  SiPixelRecHitConverter::SiPixelRecHitConverter(edm::ParameterSet const& conf)
      : conf_(conf),
        src_(conf.getParameter<edm::InputTag>("src")),
        tPixelCluster(consumes<edmNew::DetSetVector<SiPixelCluster> >(src_)) {
    //--- Declare to the EDM what kind of collections we will be making.
    produces<SiPixelRecHitCollection>();
  }

  // Destructor
  SiPixelRecHitConverter::~SiPixelRecHitConverter() {}

  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  void SiPixelRecHitConverter::produce(edm::Event& e, const edm::EventSetup& es) {
    // Step A.1: get input data
    edm::Handle<edmNew::DetSetVector<SiPixelCluster> > input;
    e.getByToken(tPixelCluster, input);

    // Step A.2: get event setup
    edm::ESHandle<TrackerGeometry> geom;
    es.get<TrackerDigiGeometryRecord>().get(geom);

    // Step B: create empty output collection
    auto output = std::make_unique<SiPixelRecHitCollectionNew>();

    // Step B*: create CPE
    edm::ESHandle<PixelClusterParameterEstimator> hCPE;
    std::string cpeName_ = conf_.getParameter<std::string>("CPE");
    es.get<TkPixelCPERecord>().get(cpeName_, hCPE);
    cpe_ = dynamic_cast<const PixelCPEBase*>(&(*hCPE));

    // Step C: Iterate over DetIds and invoke the strip CPE algorithm
    // on each DetUnit

    run(input, *output, geom);

    output->shrink_to_fit();
    e.put(std::move(output));
  }

  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  void SiPixelRecHitConverter::run(edm::Handle<edmNew::DetSetVector<SiPixelCluster> > inputhandle,
                                   SiPixelRecHitCollectionNew& output,
                                   edm::ESHandle<TrackerGeometry>& geom) {
    if (!cpe_) {
      edm::LogError("SiPixelRecHitConverter") << " at least one CPE is not ready -- can't run!";
      // TO DO: throw an exception here?  The user may want to know...
      assert(0);
      return;  // clusterizer is invalid, bail out
    }

    int numberOfDetUnits = 0;
    int numberOfClusters = 0;

    const edmNew::DetSetVector<SiPixelCluster>& input = *inputhandle;

    edmNew::DetSetVector<SiPixelCluster>::const_iterator DSViter = input.begin();

    for (; DSViter != input.end(); DSViter++) {
      numberOfDetUnits++;
      unsigned int detid = DSViter->detId();
      DetId detIdObject(detid);
      const GeomDetUnit* genericDet = geom->idToDetUnit(detIdObject);
      const PixelGeomDetUnit* pixDet = dynamic_cast<const PixelGeomDetUnit*>(genericDet);
      assert(pixDet);
      SiPixelRecHitCollectionNew::FastFiller recHitsOnDetUnit(output, detid);

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

      for (; clustIt != clustEnd; clustIt++) {
        numberOfClusters++;
        std::tuple<LocalPoint, LocalError, SiPixelRecHitQuality::QualWordType> tuple =
            cpe_->getParameters(*clustIt, *genericDet);
        LocalPoint lp(std::get<0>(tuple));
        LocalError le(std::get<1>(tuple));
        SiPixelRecHitQuality::QualWordType rqw(std::get<2>(tuple));
        // Create a persistent edm::Ref to the cluster
        edm::Ref<edmNew::DetSetVector<SiPixelCluster>, SiPixelCluster> cluster =
            edmNew::makeRefTo(inputhandle, clustIt);
        // Make a RecHit and add it to the DetSet
        // old : recHitsOnDetUnit.push_back( new SiPixelRecHit( lp, le, detIdObject, &*clustIt) );
        SiPixelRecHit hit(lp, le, rqw, *genericDet, cluster);
        //
        // Now save it =================
        recHitsOnDetUnit.push_back(hit);
        // =============================

        // std::cout << "SiPixelRecHitConverterVI " << numberOfClusters << ' '<< lp << " " << le << std::endl;
      }  //  <-- End loop on Clusters

      //  LogDebug("SiPixelRecHitConverter")
      //std::cout << "SiPixelRecHitConverterVI "
      //    << " Found " << recHitsOnDetUnit.size() << " RecHits on " << detid //;
      //    << std::endl;

    }  //    <-- End loop on DetUnits

    //    LogDebug ("SiPixelRecHitConverter")
    //  std::cout << "SiPixelRecHitConverterVI "
    //  << cpeName_ << " converted " << numberOfClusters
    //  << " SiPixelClusters into SiPixelRecHits, in "
    //  << numberOfDetUnits << " DetUnits." //;
    //  << std::endl;
  }
}  // end of namespace cms