#include <CompoundJetProducer.h>

Inheritance diagram for cms::CompoundJetProducer:

Public Member Functions
	CompoundJetProducer (const edm::ParameterSet &ps)

	~CompoundJetProducer () override

Public Member Functions inherited from VirtualJetProducer
std::string	jetType () const

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

	VirtualJetProducer (const edm::ParameterSet &iConfig)

	~VirtualJetProducer () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Protected Member Functions
void	inputTowers () override
	compound fastjet::PseudoJets More...

void	output (edm::Event &iEvent, edm::EventSetup const &iSetup) override

template<typename T >
void	writeCompoundJets (edm::Event &iEvent, edm::EventSetup const &iSetup)
	function template to write out the outputs More...

Protected Member Functions inherited from VirtualJetProducer
virtual void	addHTTTopJetTagInfoCollection (edm::Event &iEvent, const edm::EventSetup &iSetup, edm::OrphanHandle< reco::BasicJetCollection > &oh)

virtual void	copyConstituents (const std::vector< fastjet::PseudoJet > &fjConstituents, reco::Jet *jet)

virtual std::vector < reco::CandidatePtr >	getConstituents (const std::vector< fastjet::PseudoJet > &fjConstituents)

CaloGeometry const &	getGeometry (edm::EventSetup const &) const

HcalTopology const &	getTopology (edm::EventSetup const &) const

virtual bool	isAnomalousTower (reco::CandidatePtr input)

bool	makeBasicJet (const JetType::Type &fTag)

bool	makeCaloJet (const JetType::Type &fTag)

bool	makeGenJet (const JetType::Type &fTag)

bool	makePFClusterJet (const JetType::Type &fTag)

bool	makePFJet (const JetType::Type &fTag)

virtual void	makeProduces (std::string s, std::string tag="")

bool	makeTrackJet (const JetType::Type &fTag)

void	offsetCorrectJets (std::vector< fastjet::PseudoJet > &orphanInput)

virtual void	runAlgorithm (edm::Event &iEvent, const edm::EventSetup &iSetup)=0

template<typename T >
void	writeCompoundJets (edm::Event &iEvent, edm::EventSetup const &iSetup)
	function template to write out the outputs More...

template<typename T >
void	writeJets (edm::Event &iEvent, edm::EventSetup const &iSetup)

template<typename T >
void	writeJetsWithConstituents (edm::Event &iEvent, edm::EventSetup const &iSetup)
	function template to write out the outputs More...

Protected Attributes
std::vector< CompoundPseudoJet >	fjCompoundJets_

Protected Attributes inherited from VirtualJetProducer
int	activeAreaRepeats_

bool	applyWeight_

bool	doAreaDiskApprox_

bool	doAreaFastjet_

bool	doFastJetNonUniform_

bool	doPUOffsetCorr_

bool	doPVCorrection_

bool	doRhoFastjet_

ActiveAreaSpecPtr	fjActiveArea_

AreaDefinitionPtr	fjAreaDefinition_

ClusterSequencePtr	fjClusterSeq_

std::vector< fastjet::PseudoJet >	fjInputs_

JetDefPtr	fjJetDefinition_

std::vector< fastjet::PseudoJet >	fjJets_

PluginPtr	fjPlugin_

SelectorPtr	fjSelector_

bool	fromHTTTopJetProducer_ = false

double	ghostArea_

double	ghostEtaMax_

edm::EDGetTokenT < reco::VertexCollection >	input_vertex_token_

edm::EDGetTokenT < edm::ValueMap< float > >	input_weights_token_

double	inputEMin_

double	inputEtMin_

std::vector< edm::Ptr < reco::Candidate > >	inputs_

std::string	jetAlgorithm_

std::string	jetCollInstanceName_

double	jetPtMin_

std::string	jetType_

JetType::Type	jetTypeE

unsigned int	maxInputs_

unsigned int	minSeed_

std::string	moduleLabel_

unsigned int	nExclude_

std::vector< double >	puCenters_

std::string	puSubtractorName_

double	puWidth_

bool	restrictInputs_

double	rhoEtaMax_

double	rParam_

edm::InputTag	src_

edm::InputTag	srcPVs_

std::shared_ptr< PileUpSubtractor >	subtractor_

bool	useDeterministicSeed_

bool	useExplicitGhosts_

int	verbosity_

reco::Particle::Point	vertex_

double	voronoiRfact_

edm::ValueMap< float >	weights_

bool	writeCompound_

bool	writeJetsWithConst_

Additional Inherited Members
Public Types inherited from VirtualJetProducer
typedef std::shared_ptr < fastjet::GhostedAreaSpec >	ActiveAreaSpecPtr

typedef std::shared_ptr < fastjet::AreaDefinition >	AreaDefinitionPtr

typedef std::shared_ptr < fastjet::ClusterSequence >	ClusterSequencePtr

typedef std::shared_ptr < fastjet::JetDefinition >	JetDefPtr

typedef std::shared_ptr < fastjet::JetDefinition::Plugin >	PluginPtr

typedef std::shared_ptr < fastjet::Selector >	SelectorPtr

Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

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

static void	fillDescriptionsFromVirtualJetProducer (edm::ParameterSetDescription &desc)

Detailed Description

Definition at line 39 of file CompoundJetProducer.h.

Constructor & Destructor Documentation

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

Definition at line 14 of file CompoundJetProducer.cc.

                                                                     : VirtualJetProducer(conf) {
   produces<reco::BasicJetCollection>();
   // the subjet collections are set through the config file in the "jetCollInstanceName" field.
 }

cms::CompoundJetProducer::~CompoundJetProducer ( )

inlineoverride

Definition at line 43 of file CompoundJetProducer.h.

43 {}

Member Function Documentation

void CompoundJetProducer::inputTowers ( )

overrideprotectedvirtual

compound fastjet::PseudoJets

Reimplemented from VirtualJetProducer.

Definition at line 19 of file CompoundJetProducer.cc.

References fjCompoundJets_, and VirtualJetProducer::inputTowers().

                                       {
   fjCompoundJets_.clear();
   VirtualJetProducer::inputTowers();
 }

void CompoundJetProducer::output	(	edm::Event &	iEvent,
		edm::EventSetup const &	iSetup
	)

overrideprotectedvirtual

Overridden output method. For the compound jet producer, this will call the "writeCompoundJets" function template.

Reimplemented from VirtualJetProducer.

Definition at line 24 of file CompoundJetProducer.cc.

References VirtualJetProducer::JetType::BasicJet, VirtualJetProducer::JetType::CaloJet, Exception, VirtualJetProducer::JetType::GenJet, iEvent, VirtualJetProducer::jetTypeE, and VirtualJetProducer::JetType::PFJet.

                                                                               {
   // Write jets and constitutents. Will use fjJets_.
   switch (jetTypeE) {
     case JetType::CaloJet:
       writeCompoundJets<reco::CaloJet>(iEvent, iSetup);
       break;
     case JetType::PFJet:
       writeCompoundJets<reco::PFJet>(iEvent, iSetup);
       break;
     case JetType::GenJet:
       writeCompoundJets<reco::GenJet>(iEvent, iSetup);
       break;
     case JetType::BasicJet:
       writeCompoundJets<reco::BasicJet>(iEvent, iSetup);
       break;
     default:
       throw cms::Exception("InvalidInput") << "invalid jet type in CompoundJetProducer\n";
       break;
   };
 }

template<class T >

void CompoundJetProducer::writeCompoundJets	(	edm::Event &	iEvent,
		edm::EventSetup const &	iSetup
	)

protected

function template to write out the outputs

Definition at line 47 of file CompoundJetProducer.cc.

References fjCompoundJets_, VirtualJetProducer::getGeometry(), VirtualJetProducer::getTopology(), dqmdumpme::indices, VirtualJetProducer::inputs_, metsig::jet, VirtualJetProducer::jetCollInstanceName_, eostools::move(), point, edm::Event::put(), reco::Jet::setJetArea(), and reco::writeSpecific().

                                                                                          {
   // get a list of output jets
   auto jetCollection = std::make_unique<reco::BasicJetCollection>();
   // get a list of output subjets
   auto subjetCollection = std::make_unique<std::vector<T>>();
 
   // This will store the handle for the subjets after we write them
   edm::OrphanHandle<std::vector<T>> subjetHandleAfterPut;
   // this is the mapping of subjet to hard jet
   std::vector<std::vector<int>> indices;
   // this is the list of hardjet 4-momenta
   std::vector<math::XYZTLorentzVector> p4_hardJets;
   // this is the hardjet areas
   std::vector<double> area_hardJets;
 
   [[maybe_unused]] const CaloGeometry* pGeometry = nullptr;
   [[maybe_unused]] const HcalTopology* pTopology = nullptr;
   if constexpr (std::is_same_v<T, reco::CaloJet>) {
     pGeometry = &getGeometry(iSetup);
     pTopology = &getTopology(iSetup);
   }
 
   // Loop over the hard jets
   std::vector<CompoundPseudoJet>::const_iterator it = fjCompoundJets_.begin(), iEnd = fjCompoundJets_.end(),
                                                  iBegin = fjCompoundJets_.begin();
   indices.resize(fjCompoundJets_.size());
   for (; it != iEnd; ++it) {
     int jetIndex = it - iBegin;
     fastjet::PseudoJet localJet = it->hardJet();
     // Get the 4-vector for the hard jet
     p4_hardJets.push_back(math::XYZTLorentzVector(localJet.px(), localJet.py(), localJet.pz(), localJet.e()));
     area_hardJets.push_back(it->hardJetArea());
 
     // create the subjet list
     std::vector<CompoundPseudoSubJet>::const_iterator itSubJetBegin = it->subjets().begin(), itSubJet = itSubJetBegin,
                                                       itSubJetEnd = it->subjets().end();
     for (; itSubJet != itSubJetEnd; ++itSubJet) {
       fastjet::PseudoJet subjet = itSubJet->subjet();
       math::XYZTLorentzVector p4Subjet(subjet.px(), subjet.py(), subjet.pz(), subjet.e());
       reco::Particle::Point point(0, 0, 0);
 
       // This will hold ptr's to the subjets
       std::vector<reco::CandidatePtr> subjetConstituents;
 
       // Get the transient subjet constituents from fastjet
       std::vector<int> const& subjetFastjetConstituentIndices = itSubJet->constituents();
       std::vector<int>::const_iterator fastSubIt = subjetFastjetConstituentIndices.begin(),
                                        transConstEnd = subjetFastjetConstituentIndices.end();
       for (; fastSubIt != transConstEnd; ++fastSubIt) {
         // Add a ptr to this constituent
         if (*fastSubIt < static_cast<int>(inputs_.size()))
           subjetConstituents.push_back(inputs_[*fastSubIt]);
       }
 
       // This holds the subjet-to-hardjet mapping
       indices[jetIndex].push_back(subjetCollection->size());
 
       // Add the concrete subjet type to the subjet list to write to event record
       T jet;
       if constexpr (std::is_same_v<T, reco::CaloJet>) {
         reco::writeSpecific(jet, p4Subjet, point, subjetConstituents, *pGeometry, *pTopology);
       } else {
         reco::writeSpecific(jet, p4Subjet, point, subjetConstituents);
       }
       jet.setJetArea(itSubJet->subjetArea());
       subjetCollection->push_back(jet);
     }
   }
   // put subjets into event record
   subjetHandleAfterPut = iEvent.put(std::move(subjetCollection), jetCollInstanceName_);
 
   // Now create the hard jets with ptr's to the subjets as constituents
   std::vector<math::XYZTLorentzVector>::const_iterator ip4 = p4_hardJets.begin(), ip4Begin = p4_hardJets.begin(),
                                                        ip4End = p4_hardJets.end();
 
   for (; ip4 != ip4End; ++ip4) {
     int p4_index = ip4 - ip4Begin;
     std::vector<int>& ind = indices[p4_index];
     std::vector<reco::CandidatePtr> i_hardJetConstituents;
     // Add the subjets to the hard jet
     for (std::vector<int>::const_iterator isub = ind.begin(); isub != ind.end(); ++isub) {
       reco::CandidatePtr candPtr(subjetHandleAfterPut, *isub, false);
       i_hardJetConstituents.push_back(candPtr);
     }
     reco::Particle::Point point(0, 0, 0);
     reco::BasicJet toput(*ip4, point, i_hardJetConstituents);
     toput.setJetArea(area_hardJets[ip4 - ip4Begin]);
     jetCollection->push_back(toput);
   }
 
   // put hard jets into event record
   iEvent.put(std::move(jetCollection));
 }

Member Data Documentation

std::vector<CompoundPseudoJet> cms::CompoundJetProducer::fjCompoundJets_

protected

Definition at line 46 of file CompoundJetProducer.h.

Referenced by inputTowers(), cms::SubJetProducer::runAlgorithm(), and writeCompoundJets().

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation