#include <CompoundJetProducer.h>

Inheritance diagram for cms::CompoundJetProducer:

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

virtual	~CompoundJetProducer ()

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

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

	VirtualJetProducer (const edm::ParameterSet &iConfig)

virtual	~VirtualJetProducer ()

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)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

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

	EDConsumerBase ()

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

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

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

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)

Protected Attributes
std::vector< CompoundPseudoJet >	fjCompoundJets_

Protected Attributes inherited from VirtualJetProducer
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_

RangeDefPtr	fjRangeDef_

edm::EDGetTokenT < reco::VertexCollection >	input_vertex_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	rParam_

edm::InputTag	src_

edm::InputTag	srcPVs_

boost::shared_ptr < PileUpSubtractor >	subtractor_

bool	useDeterministicSeed_

bool	useExplicitGhosts_

int	verbosity_

reco::Particle::Point	vertex_

double	voronoiRfact_

bool	writeCompound_

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

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

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

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

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

typedef boost::shared_ptr < fastjet::RangeDefinition >	RangeDefPtr

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)

Detailed Description

Definition at line 41 of file CompoundJetProducer.h.

Constructor & Destructor Documentation

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

virtual cms::CompoundJetProducer::~CompoundJetProducer ( )

inlinevirtual

Definition at line 47 of file CompoundJetProducer.h.

47 {}

Member Function Documentation

void CompoundJetProducer::inputTowers ( )

protectedvirtual

compound fastjet::PseudoJets

Reimplemented from VirtualJetProducer.

Definition at line 21 of file CompoundJetProducer.cc.

References fjCompoundJets_, and VirtualJetProducer::inputTowers().

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

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

protectedvirtual

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

Reimplemented from VirtualJetProducer.

Definition at line 27 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 52 of file CompoundJetProducer.cc.

References fjCompoundJets_, VirtualJetProducer::inputs_, metsig::jet, VirtualJetProducer::jetCollInstanceName_, point, edm::Event::put(), reco::Jet::setJetArea(), and reco::writeSpecific().

 {
 
   // get a list of output jets
   std::auto_ptr<reco::BasicJetCollection>  jetCollection( new reco::BasicJetCollection() );
   // get a list of output subjets
   std::auto_ptr<std::vector<T> >  subjetCollection( new 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( 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( jetCollection);
 
 }

Member Data Documentation

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

protected

Definition at line 50 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