SiPixelClusterProducer.cc

Go to the documentation of this file.

// Our own stuff
#include "SiPixelClusterProducer.h"
#include "PixelThresholdClusterizer.h"

// Geometry
#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h"

// Data Formats
#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/SiPixelDigi/interface/PixelDigi.h"
#include "DataFormats/DetId/interface/DetId.h"

// Database payloads
#include "CalibTracker/SiPixelESProducers/interface/SiPixelGainCalibrationService.h"
#include "CalibTracker/SiPixelESProducers/interface/SiPixelGainCalibrationOfflineService.h"
#include "CalibTracker/SiPixelESProducers/interface/SiPixelGainCalibrationForHLTService.h"

// Framework
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"

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

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


  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  SiPixelClusterProducer::SiPixelClusterProducer(edm::ParameterSet const& conf) 
    : 
    tPutPixelClusters(produces<SiPixelClusterCollectionNew>()),
    clusterMode_( conf.getParameter<std::string>("ClusterMode") ),
    maxTotalClusters_( conf.getParameter<int32_t>( "maxNumberOfClusters" ) )
  {
    if ( clusterMode_ == "PixelThresholdReclusterizer" )
      tPixelClusters = consumes<SiPixelClusterCollectionNew>( conf.getParameter<edm::InputTag>("src") );
    else
      tPixelDigi = consumes<edm::DetSetVector<PixelDigi>>( conf.getParameter<edm::InputTag>("src") );

    const auto& payloadType = conf.getParameter<std::string>( "payloadType" );
    if (payloadType == "HLT")
        theSiPixelGainCalibration_ = std::make_unique<SiPixelGainCalibrationForHLTService>(conf);
    else if (payloadType == "Offline")
        theSiPixelGainCalibration_ = std::make_unique<SiPixelGainCalibrationOfflineService>(conf);
    else if (payloadType == "Full")
        theSiPixelGainCalibration_ = std::make_unique<SiPixelGainCalibrationService>(conf);

    //--- Make the algorithm(s) according to what the user specified
    //--- in the ParameterSet.
    setupClusterizer(conf);

  }

  // Destructor
SiPixelClusterProducer::~SiPixelClusterProducer() = default;

void SiPixelClusterProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  edm::ParameterSetDescription desc;

  desc.add<edm::InputTag>("src", edm::InputTag("siPixelDigis"));
  desc.add<std::string>("ClusterMode", "PixelThresholdClusterizer");
  desc.add<int>("maxNumberOfClusters", -1)->setComment("-1 means no limit");
  desc.add<std::string>("payloadType", "Offline")->setComment("Options: HLT - column granularity, Offline - gain:col/ped:pix");

  PixelThresholdClusterizer::fillPSetDescription(desc);
  SiPixelGainCalibrationServiceBase::fillPSetDescription(desc); // no-op, but in principle the structures are there...

  descriptions.add("SiPixelClusterizerDefault", desc);
}

  
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  void SiPixelClusterProducer::produce(edm::Event& e, const edm::EventSetup& es)
  {

    //Setup gain calibration service
    theSiPixelGainCalibration_->setESObjects( es );

    // Step A.1: get input data
    edm::Handle< SiPixelClusterCollectionNew >   inputClusters;
    edm::Handle< edm::DetSetVector<PixelDigi> >  inputDigi;
    if ( clusterMode_ == "PixelThresholdReclusterizer" )
      e.getByToken(tPixelClusters, inputClusters);
    else
      e.getByToken(tPixelDigi, inputDigi);

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

    edm::ESHandle<TrackerTopology> trackerTopologyHandle;
    es.get<TrackerTopologyRcd>().get(trackerTopologyHandle);
    tTopo_ = trackerTopologyHandle.product();

    // Step B: create the final output collection
    auto output = std::make_unique< SiPixelClusterCollectionNew>();
    //FIXME: put a reserve() here

    // Step C: Iterate over DetIds and invoke the pixel clusterizer algorithm
    // on each DetUnit
    if ( clusterMode_ == "PixelThresholdReclusterizer" )
      run(*inputClusters, geom, *output );
    else
      run(*inputDigi, geom, *output );

    // Step D: write output to file
    output->shrink_to_fit();
    e.put(tPutPixelClusters, std::move(output));

  }

  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  void SiPixelClusterProducer::setupClusterizer(const edm::ParameterSet& conf)  {

    if ( clusterMode_ == "PixelThresholdReclusterizer" || clusterMode_ == "PixelThresholdClusterizer" ) {
      clusterizer_ = std::make_unique<PixelThresholdClusterizer>(conf);
      clusterizer_->setSiPixelGainCalibrationService(theSiPixelGainCalibration_.get());
    } 
    else {
      throw cms::Exception("Configuration") << "[SiPixelClusterProducer]:"
        <<" choice " << clusterMode_ << " is invalid.\n"
        << "Possible choices:\n" 
        << "    PixelThresholdClusterizer";
    }
  }


  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  template<typename T>
  void SiPixelClusterProducer::run(const T                              & input, 
                                   const edm::ESHandle<TrackerGeometry> & geom,
                                   edmNew::DetSetVector<SiPixelCluster> & output) {
    int numberOfDetUnits = 0;
    int numberOfClusters = 0;
 
    // Iterate on detector units
    typename T::const_iterator DSViter = input.begin();
    for( ; DSViter != input.end(); DSViter++) {
      ++numberOfDetUnits;

      //  LogDebug takes very long time, get rid off.
      //LogDebug("SiStripClusterizer") << "[SiPixelClusterProducer::run] DetID" << DSViter->id;

      std::vector<short> badChannels; 
      DetId detIdObject(DSViter->detId());
      
      // Comment: At the moment the clusterizer depends on geometry
      // to access information as the pixel topology (number of columns
      // and rows in a detector module). 
      // In the future the geometry service will be replaced with
      // a ES service.
      const GeomDetUnit      * geoUnit = geom->idToDetUnit( detIdObject );
      const PixelGeomDetUnit * pixDet  = dynamic_cast<const PixelGeomDetUnit*>(geoUnit);
      if (! pixDet) {
    // Fatal error!  TO DO: throw an exception!
    assert(0);
      }
      {
      // Produce clusters for this DetUnit and store them in 
      // a DetSet
      edmNew::DetSetVector<SiPixelCluster>::FastFiller spc(output, DSViter->detId());
      clusterizer_->clusterizeDetUnit(*DSViter, pixDet, tTopo_, badChannels, spc);
      if ( spc.empty() ) {
        spc.abort();
      } else {
    numberOfClusters += spc.size();
      }
      } // spc is not deleted and detsetvector updated
      if ((maxTotalClusters_ >= 0) && (numberOfClusters > maxTotalClusters_)) {
        edm::LogError("TooManyClusters") <<  "Limit on the number of clusters exceeded. An empty cluster collection will be produced instead.\n";
        edmNew::DetSetVector<SiPixelCluster> empty;
        empty.swap(output);
        break;
      }
    } // end of DetUnit loop
    
    //LogDebug ("SiPixelClusterProducer") << " Executing " 
    //      << clusterMode_ << " resulted in " << numberOfClusters
    //      << " SiPixelClusters in " << numberOfDetUnits << " DetUnits."; 
  }




#include "FWCore/PluginManager/interface/ModuleDef.h"
#include "FWCore/Framework/interface/MakerMacros.h"

DEFINE_FWK_MODULE(SiPixelClusterProducer);