Inheritance diagram for HGCalLayerClusterProducer:

Public Member Functions
	HGCalLayerClusterProducer (const edm::ParameterSet &)

void	produce (edm::Event &, const edm::EventSetup &) override

	~HGCalLayerClusterProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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

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 30 of file HGCalLayerClusterProducer.cc.

Constructor & Destructor Documentation

HGCalLayerClusterProducer::HGCalLayerClusterProducer ( const edm::ParameterSet & ps )

Definition at line 55 of file HGCalLayerClusterProducer.cc.

References algo, algoId, hgcalLayerClusters_cff::dEdXweights, detector, doSharing, hgcalLayerClusters_cff::fcPerEle, hgcalLayerClusters_cff::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_cff::noiseMip, hgcalDigitizer_cfi::nonAgedNoises, particleFlowClusterECALUncorrected_cfi::showerSigma, hgcalLayerClusters_cff::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> 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<edm::ParameterSet>("noises").getParameter<std::vector<double> >("values");
   double noiseMip = ps.getParameter<edm::ParameterSet>("noiseMip").getParameter<double>("value");
   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);
   }
 
 
   produces<std::vector<reco::BasicCluster> >();
   produces<std::vector<reco::BasicCluster> >("sharing");
 
 }

HGCalLayerClusterProducer::~HGCalLayerClusterProducer ( )

inlineoverride

Definition at line 33 of file HGCalLayerClusterProducer.cc.

References fillDescriptions(), and produce().

33 { }

Member Function Documentation

void HGCalLayerClusterProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 103 of file HGCalLayerClusterProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by ~HGCalLayerClusterProducer().

                                                                                            {
   // hgcalLayerClusters
   edm::ParameterSetDescription desc;
   desc.add<std::string>("detector", "all");
   desc.add<bool>("doSharing", false);
   desc.add<std::vector<double>>("deltac", {
     2.0,
     2.0,
     5.0,
   });
   desc.add<bool>("dependSensor", true);
   desc.add<double>("ecut", 3.0);
   desc.add<double>("kappa", 9.0);
   desc.addUntracked<unsigned int>("verbosity", 3);
   desc.add<edm::InputTag>("HGCEEInput", edm::InputTag("HGCalRecHit","HGCEERecHits"));
   desc.add<edm::InputTag>("HGCFHInput", edm::InputTag("HGCalRecHit","HGCHEFRecHits"));
   desc.add<edm::InputTag>("HGCBHInput", edm::InputTag("HGCalRecHit","HGCHEBRecHits"));
   desc.add<std::vector<double>>("dEdXweights",{});
   desc.add<std::vector<double>>("thicknessCorrection",{});
   desc.add<std::vector<double>>("fcPerMip",{});
   desc.add<double>("fcPerEle",0.0);
   edm::ParameterSetDescription descNestedNoises;
   descNestedNoises.add<std::vector<double> >("values", {});
   desc.add<edm::ParameterSetDescription>("noises", descNestedNoises);
   edm::ParameterSetDescription descNestedNoiseMIP;
   descNestedNoiseMIP.add<double>("value", 0 );
   desc.add<edm::ParameterSetDescription>("noiseMip", descNestedNoiseMIP);
   descriptions.add("hgcalLayerClusters", desc);
 
 }

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

override

Definition at line 135 of file HGCalLayerClusterProducer.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(), edm::PtrVector< T >::push_back(), and edm::Event::put().

Referenced by ~HGCalLayerClusterProducer().

                                                 {
 
   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);
 
   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);
 
   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);
     }
   }
 }