#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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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)

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

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::CompoundJetProducer ( const edm::ParameterSet & ps )

Definition at line 12 of file CompoundJetProducer.cc.

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

◆ ~CompoundJetProducer()

cms::CompoundJetProducer::~CompoundJetProducer ( )

inlineoverride

Definition at line 43 of file CompoundJetProducer.h.

43 {}

Member Function Documentation

◆ inputTowers()

void CompoundJetProducer::inputTowers ( )

overrideprotectedvirtual

compound fastjet::PseudoJets

Reimplemented from VirtualJetProducer.

Definition at line 17 of file CompoundJetProducer.cc.

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

References fjCompoundJets_, and VirtualJetProducer::inputTowers().

◆ output()

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 22 of file CompoundJetProducer.cc.

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

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

◆ writeCompoundJets()

template<class T >

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

protected

function template to write out the outputs

Definition at line 45 of file CompoundJetProducer.cc.

                                                                                          {
   // 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;
  
   // 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;
       reco::writeSpecific(jet, p4Subjet, point, subjetConstituents, iSetup);
       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));
 }

References fjCompoundJets_, iEvent, bTagCombinedSVVariables_cff::indices, VirtualJetProducer::inputs_, metsig::jet, jetfilter_cfi::jetCollection, VirtualJetProducer::jetCollInstanceName_, eostools::move(), point, reco::Jet::setJetArea(), and reco::writeSpecific().

Member Data Documentation

◆ fjCompoundJets_

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