HGCalClusterProducer Class Reference

Inheritance diagram for HGCalClusterProducer:

Public Member Functions
	HGCalClusterProducer (const edm::ParameterSet &)
void	produce (edm::Event &, const edm::EventSetup &) override
	~HGCalClusterProducer () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () const final

Private Attributes
std::unique_ptr< HGCalImagingAlgo >	algo
reco::CaloCluster::AlgoId	algoId
std::string	detector
bool	doSharing
edm::EDGetTokenT< HGCRecHitCollection >	hits_bh_token
edm::EDGetTokenT< HGCRecHitCollection >	hits_ee_token
edm::EDGetTokenT< HGCRecHitCollection >	hits_fh_token
std::unique_ptr< HGCal3DClustering >	multicluster_algo
HGCalImagingAlgo::VerbosityLevel	verbosity

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 32 of file HGCalClusterProducer.cc.

Constructor & Destructor Documentation

HGCalClusterProducer::HGCalClusterProducer

(

const edm::ParameterSet &

ps

)

Definition at line 57 of file HGCalClusterProducer.cc.

References algo, algoId, hgcalLayerClusters_cfi::dEdXweights, hgcalLayerClusters_cfi::dependSensor, detector, doSharing, hgcalLayerClusters_cfi::ecut, hgcalLayerClusters_cfi::fcPerEle, hgcalLayerClusters_cfi::fcPerMip, edm::ParameterSet::getParameter(), reco::CaloCluster::hgcal_em, reco::CaloCluster::hgcal_had, reco::CaloCluster::hgcal_mixed, hits_bh_token, hits_ee_token, hits_fh_token, kappa, hgcalLayerClusters_cfi::minClusters, multicluster_algo, hgcalLayerClusters_cfi::noiseMip, hgcalLayerClusters_cfi::nonAgedNoises, particleFlowClusterECALUncorrected_cfi::showerSigma, hgcalLayerClusters_cfi::thicknessCorrection, and verbosity.

                                                                    :
  algoId(reco::CaloCluster::undefined),
  doSharing(ps.getParameter<bool>("doSharing")),
  detector(ps.getParameter<std::string >("detector")), // one of EE, FH, BH or "all"
  verbosity((HGCalImagingAlgo::VerbosityLevel)ps.getUntrackedParameter<unsigned int>("verbosity",3)){
  double ecut = ps.getParameter<double>("ecut");
  std::vector<double> vecDeltas = ps.getParameter<std::vector<double> >("deltac");
  double kappa = ps.getParameter<double>("kappa");
  std::vector<double> multicluster_radii = ps.getParameter<std::vector<double> >("multiclusterRadii");
  double minClusters = ps.getParameter<unsigned>("minClusters");
  std::vector<double> dEdXweights = ps.getParameter<std::vector<double> >("dEdXweights");
  std::vector<double> thicknessCorrection = ps.getParameter<std::vector<double> >("thicknessCorrection");
  std::vector<double> fcPerMip = ps.getParameter<std::vector<double> >("fcPerMip");
  double fcPerEle = ps.getParameter<double>("fcPerEle");
  std::vector<double> nonAgedNoises = ps.getParameter<std::vector<double> >("nonAgedNoises");
  double noiseMip = ps.getParameter<double>("noiseMip");
  bool dependSensor = ps.getParameter<bool>("dependSensor");


  if(detector=="all") {
    hits_ee_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCEEInput"));
    hits_fh_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCFHInput"));
    hits_bh_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCBHInput"));
    algoId = reco::CaloCluster::hgcal_mixed;
  }else if(detector=="EE") {
    hits_ee_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCEEInput"));
    algoId = reco::CaloCluster::hgcal_em;
  }else if(detector=="FH") {
    hits_fh_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCFHInput"));
    algoId = reco::CaloCluster::hgcal_had;
  } else {
    hits_bh_token = consumes<HGCRecHitCollection>(ps.getParameter<edm::InputTag>("HGCBHInput"));
    algoId = reco::CaloCluster::hgcal_had;
  }


  if(doSharing){
    double showerSigma =  ps.getParameter<double>("showerSigma");
    algo = std::make_unique<HGCalImagingAlgo>(vecDeltas, kappa, ecut, showerSigma, algoId, dependSensor, dEdXweights, thicknessCorrection, fcPerMip, fcPerEle, nonAgedNoises, noiseMip, verbosity);
  }else{
    algo = std::make_unique<HGCalImagingAlgo>(vecDeltas, kappa, ecut, algoId, dependSensor, dEdXweights, thicknessCorrection, fcPerMip, fcPerEle, nonAgedNoises, noiseMip, verbosity);
  }

  auto sumes = consumesCollector();

  multicluster_algo = std::make_unique<HGCal3DClustering>(ps, sumes, multicluster_radii, minClusters);

  produces<std::vector<reco::BasicCluster> >();
  produces<std::vector<reco::BasicCluster> >("sharing");

  produces<std::vector<reco::HGCalMultiCluster> >();
  produces<std::vector<reco::HGCalMultiCluster> >("sharing");
}

HGCalClusterProducer::~HGCalClusterProducer ( )

inlineoverride

Definition at line 35 of file HGCalClusterProducer.cc.

References produce().

{ }

Member Function Documentation

void HGCalClusterProducer::produce ( edm::Event &  evt, const edm::EventSetup &  es  )

override

Definition at line 111 of file HGCalClusterProducer.cc.

References algo, algoId, fastPrimaryVertexProducer_cfi::clusters, doSharing, edm::Event::getByToken(), reco::CaloCluster::hgcal_em, reco::CaloCluster::hgcal_had, reco::CaloCluster::hgcal_mixed, hits_bh_token, hits_ee_token, hits_fh_token, mps_fire::i, edm::HandleBase::isValid(), eostools::move(), multicluster_algo, cscdqm::h::names, cmsPerfSuiteHarvest::now, edm::PtrVector< T >::push_back(), edm::Event::put(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by ~HGCalClusterProducer().

                                                {

  edm::Handle<HGCRecHitCollection> ee_hits;
  edm::Handle<HGCRecHitCollection> fh_hits;
  edm::Handle<HGCRecHitCollection> bh_hits;


  std::unique_ptr<std::vector<reco::BasicCluster> > clusters( new std::vector<reco::BasicCluster> ),
    clusters_sharing( new std::vector<reco::BasicCluster> );

  algo->reset();

  algo->getEventSetup(es);

  multicluster_algo->getEvent(evt);
  multicluster_algo->getEventSetup(es);

  switch(algoId){
  case reco::CaloCluster::hgcal_em:
    evt.getByToken(hits_ee_token,ee_hits);
    algo->populate(*ee_hits);
    break;
  case  reco::CaloCluster::hgcal_had:
    evt.getByToken(hits_fh_token,fh_hits);
    evt.getByToken(hits_bh_token,bh_hits);
    if( fh_hits.isValid() ) {
      algo->populate(*fh_hits);
    } else if ( bh_hits.isValid() ) {
      algo->populate(*bh_hits);
    }
    break;
  case reco::CaloCluster::hgcal_mixed:
    evt.getByToken(hits_ee_token,ee_hits);
    algo->populate(*ee_hits);
    evt.getByToken(hits_fh_token,fh_hits);
    algo->populate(*fh_hits);
    evt.getByToken(hits_bh_token,bh_hits);
    algo->populate(*bh_hits);
    break;
  default:
    break;
  }
  algo->makeClusters();
  *clusters = algo->getClusters(false);
  if(doSharing)
    *clusters_sharing = algo->getClusters(true);

  std::vector<std::string> names;
  names.push_back(std::string("gen"));
  names.push_back(std::string("calo_face"));

  auto clusterHandle = evt.put(std::move(clusters));
  auto clusterHandleSharing = evt.put(std::move(clusters_sharing),"sharing");

  edm::PtrVector<reco::BasicCluster> clusterPtrs, clusterPtrsSharing;
  for( unsigned i = 0; i < clusterHandle->size(); ++i ) {
    edm::Ptr<reco::BasicCluster> ptr(clusterHandle,i);
    clusterPtrs.push_back(ptr);
  }

  if(doSharing){
    for( unsigned i = 0; i < clusterHandleSharing->size(); ++i ) {
      edm::Ptr<reco::BasicCluster> ptr(clusterHandleSharing,i);
      clusterPtrsSharing.push_back(ptr);
    }
  }

  std::unique_ptr<std::vector<reco::HGCalMultiCluster> >
    multiclusters( new std::vector<reco::HGCalMultiCluster> ),
    multiclusters_sharing( new std::vector<reco::HGCalMultiCluster> );

  std::chrono::high_resolution_clock::time_point then = std::chrono::high_resolution_clock::now();
  *multiclusters = multicluster_algo->makeClusters(clusterPtrs);
  if(doSharing)
    *multiclusters_sharing = multicluster_algo->makeClusters(clusterPtrsSharing);
  evt.put(std::move(multiclusters));
  if(doSharing)
    evt.put(std::move(multiclusters_sharing),"sharing");
  std::chrono::high_resolution_clock::time_point now = std::chrono::high_resolution_clock::now();
  std::chrono::duration<float> time_span = std::chrono::duration_cast<std::chrono::milliseconds>(now - then);
  // delta += float (now.tv_usec - then.tv_usec)/1000.;
  edm::LogInfo ("HGCalClusterProducer") << "Time taken by multiclustering " << time_span.count() << " ms";
}

Member Data Documentation

std::unique_ptr<HGCalImagingAlgo> HGCalClusterProducer::algo

private

Definition at line 47 of file HGCalClusterProducer.cc.

Referenced by HGCalClusterProducer(), and produce().

reco::CaloCluster::AlgoId HGCalClusterProducer::algoId

private

Definition at line 45 of file HGCalClusterProducer.cc.

Referenced by HGCalClusterProducer(), and produce().

std::string HGCalClusterProducer::detector

private

Definition at line 50 of file HGCalClusterProducer.cc.

Referenced by HGCalClusterProducer().

bool HGCalClusterProducer::doSharing

private

Definition at line 49 of file HGCalClusterProducer.cc.

Referenced by HGCalClusterProducer(), and produce().

edm::EDGetTokenT<HGCRecHitCollection> HGCalClusterProducer::hits_bh_token

private

Definition at line 43 of file HGCalClusterProducer.cc.

Referenced by HGCalClusterProducer(), and produce().

edm::EDGetTokenT<HGCRecHitCollection> HGCalClusterProducer::hits_ee_token

private

Definition at line 41 of file HGCalClusterProducer.cc.

Referenced by HGCalClusterProducer(), and produce().

edm::EDGetTokenT<HGCRecHitCollection> HGCalClusterProducer::hits_fh_token

private

Definition at line 42 of file HGCalClusterProducer.cc.

Referenced by HGCalClusterProducer(), and produce().

std::unique_ptr<HGCal3DClustering> HGCalClusterProducer::multicluster_algo

private

Definition at line 48 of file HGCalClusterProducer.cc.

Referenced by HGCalClusterProducer(), and produce().

HGCalImagingAlgo::VerbosityLevel HGCalClusterProducer::verbosity

private

Definition at line 52 of file HGCalClusterProducer.cc.

Referenced by HGCalClusterProducer().