Inheritance diagram for HGCalClusterTestProducer:

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

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

	~HGCalClusterTestProducer ()

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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< HGCalDepthPreClusterer >	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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 29 of file HGCalClusterTestProducer.cc.

Constructor & Destructor Documentation

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

Definition at line 55 of file HGCalClusterTestProducer.cc.

References algo, algoId, edm::EDConsumerBase::consumesCollector(), detector, doSharing, hgcalLayerClusters_cfi::ecut, 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, particleFlowClusterECALUncorrected_cfi::showerSigma, and verbosity.

                                                                             :
   algoId(reco::CaloCluster::undefined),
   doSharing(ps.getParameter<bool>("doSharing")),
   detector(ps.getParameter<std::string >("detector")),              //one of EE, EF or "both"
   verbosity((HGCalImagingAlgo::VerbosityLevel)ps.getUntrackedParameter<unsigned int>("verbosity",3)){
   double ecut = ps.getParameter<double>("ecut");
   double delta_c = ps.getParameter<double>("deltac");
   double kappa = ps.getParameter<double>("kappa");
   double multicluster_radius = ps.getParameter<double>("multiclusterRadius");
   double minClusters = ps.getParameter<unsigned>("minClusters");
   
   
   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>(delta_c, kappa, ecut, showerSigma, algoId, verbosity);
   }else{
     algo = std::make_unique<HGCalImagingAlgo>(delta_c, kappa, ecut, algoId, verbosity);
   }
 
   auto sumes = consumesCollector();
 
   multicluster_algo = std::make_unique<HGCalDepthPreClusterer>(ps, sumes, multicluster_radius, minClusters);
 
   // hydraTokens[0] = consumes<std::vector<reco::PFCluster> >( edm::InputTag("FakeClusterGen") );
   // hydraTokens[1] = consumes<std::vector<reco::PFCluster> >( edm::InputTag("FakeClusterCaloFace") );
 
   //std::cout << "Constructing HGCalClusterTestProducer" << std::endl;
 
   produces<std::vector<reco::BasicCluster> >();
   produces<std::vector<reco::BasicCluster> >("sharing");
   
   produces<std::vector<reco::HGCalMultiCluster> >();
   produces<std::vector<reco::HGCalMultiCluster> >("sharing");
 }

HGCalClusterTestProducer::~HGCalClusterTestProducer ( )

inline

Definition at line 32 of file HGCalClusterTestProducer.cc.

References produce().

32 { }

Member Function Documentation

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

virtual

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

Referenced by ~HGCalClusterTestProducer().

                                                 {
   
   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->makeClusters(*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->makeClusters(*fh_hits);
     } else if ( bh_hits.isValid() ) {
       algo->makeClusters(*bh_hits);
     }
     break;
   case reco::CaloCluster::hgcal_mixed:
     evt.getByToken(hits_ee_token,ee_hits);
     algo->makeClusters(*ee_hits);
     evt.getByToken(hits_fh_token,fh_hits);
     algo->makeClusters(*fh_hits);
     evt.getByToken(hits_bh_token,bh_hits);
     algo->makeClusters(*bh_hits);
     break;
   default:
     break;
   }
   *clusters = algo->getClusters(false);
   if(doSharing)
     *clusters_sharing = algo->getClusters(true);
 
   //std::cout << "Density based cluster size: " << clusters->size() << std::endl;
   //if(doSharing)
   //std::cout << "Sharing clusters size     : " << clusters_sharing->size() << std::endl;
   
   //  edm::Handle<std::vector<reco::PFCluster> > hydra[2];
   std::vector<std::string> names;
   names.push_back(std::string("gen"));
   names.push_back(std::string("calo_face"));
   // for( unsigned i = 0 ; i < 2; ++i ) {
   //   evt.getByToken(hydraTokens[i],hydra[i]);
   //   std::cout << "hydra " << names[i] << " size : " << hydra[i]->size() << std::endl;
   // }
 
   
 
   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);
   }
   
   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> );
 
   *multiclusters = std::move(multicluster_algo->makePreClusters(clusterPtrs));
   *multiclusters_sharing = std::move(multicluster_algo->makePreClusters(clusterPtrsSharing));
   
   evt.put(std::move(multiclusters));
   evt.put(std::move(multiclusters_sharing),"sharing");
 
 }