#include <VirtualJetProducer.h>

Inheritance diagram for VirtualJetProducer:

Classes
struct	JetType

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

Public Member Functions
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

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

static void	fillDescriptionsFromVirtualJetProducer (edm::ParameterSetDescription &desc)

Protected Member Functions
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 void	inputTowers ()

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	output (edm::Event &iEvent, edm::EventSetup const &iSetup)

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

Private Attributes
std::unique_ptr< AnomalousTower >	anomalousTowerDef_

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geometry_token_

edm::EDGetTokenT< std::vector< edm::FwdPtr< reco::PFCandidate > > >	input_candidatefwdptr_token_

edm::EDGetTokenT< reco::CandidateView >	input_candidateview_token_

edm::EDGetTokenT< std::vector< edm::FwdPtr< reco::GenParticle > > >	input_gencandidatefwdptr_token_

edm::EDGetTokenT< std::vector< edm::FwdPtr< pat::PackedCandidate > > >	input_packedcandidatefwdptr_token_

edm::EDGetTokenT< std::vector< edm::FwdPtr< pat::PackedGenParticle > > >	input_packedgencandidatefwdptr_token_

edm::ESGetToken< HcalTopology, HcalRecNumberingRecord >	topology_token_

Detailed Description

Definition at line 38 of file VirtualJetProducer.h.

Member Typedef Documentation

◆ ActiveAreaSpecPtr

typedef std::shared_ptr<fastjet::GhostedAreaSpec> VirtualJetProducer::ActiveAreaSpecPtr

Definition at line 79 of file VirtualJetProducer.h.

◆ AreaDefinitionPtr

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

Definition at line 80 of file VirtualJetProducer.h.

◆ ClusterSequencePtr

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

Definition at line 76 of file VirtualJetProducer.h.

◆ JetDefPtr

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

Definition at line 78 of file VirtualJetProducer.h.

◆ PluginPtr

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

Definition at line 77 of file VirtualJetProducer.h.

◆ SelectorPtr

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

Definition at line 81 of file VirtualJetProducer.h.

Constructor & Destructor Documentation

◆ VirtualJetProducer()

VirtualJetProducer::VirtualJetProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 116 of file VirtualJetProducer.cc.

References btagElecInJet_cfi::CaloJet, deDxTools::esConsumes(), Exception, get, edm::ParameterSet::getParameter(), and HLT_2023v12_cff::srcWeights.

                                                                      {
   moduleLabel_ = iConfig.getParameter<string>("@module_label");
   src_ = iConfig.getParameter<edm::InputTag>("src");
   srcPVs_ = iConfig.getParameter<edm::InputTag>("srcPVs");
   jetType_ = iConfig.getParameter<string>("jetType");
   jetAlgorithm_ = iConfig.getParameter<string>("jetAlgorithm");
   rParam_ = iConfig.getParameter<double>("rParam");
   inputEtMin_ = iConfig.getParameter<double>("inputEtMin");
   inputEMin_ = iConfig.getParameter<double>("inputEMin");
   jetPtMin_ = iConfig.getParameter<double>("jetPtMin");
   doPVCorrection_ = iConfig.getParameter<bool>("doPVCorrection");
   doAreaFastjet_ = iConfig.getParameter<bool>("doAreaFastjet");
   doRhoFastjet_ = iConfig.getParameter<bool>("doRhoFastjet");
   jetCollInstanceName_ = iConfig.getParameter<string>("jetCollInstanceName");
   doPUOffsetCorr_ = iConfig.getParameter<bool>("doPUOffsetCorr");
   puSubtractorName_ = iConfig.getParameter<string>("subtractorName");
   useExplicitGhosts_ =
       iConfig.getParameter<bool>("useExplicitGhosts");  // use explicit ghosts in the fastjet clustering sequence?
   doAreaDiskApprox_ = iConfig.getParameter<bool>("doAreaDiskApprox");
   voronoiRfact_ = iConfig.getParameter<double>(
       "voronoiRfact");  // Voronoi-based area calculation allows for an empirical scale factor
   rhoEtaMax_ = iConfig.getParameter<double>(
       "Rho_EtaMax");  // do fasjet area / rho calcluation? => accept corresponding parameters
   ghostEtaMax_ = iConfig.getParameter<double>("Ghost_EtaMax");
   activeAreaRepeats_ = iConfig.getParameter<int>("Active_Area_Repeats");
   ghostArea_ = iConfig.getParameter<double>("GhostArea");
   restrictInputs_ = iConfig.getParameter<bool>("restrictInputs");  // restrict inputs to first "maxInputs" towers?
   maxInputs_ = iConfig.getParameter<unsigned int>("maxInputs");
   writeCompound_ = iConfig.getParameter<bool>(
       "writeCompound");  // Check to see if we are writing compound jets for substructure and jet grooming
   writeJetsWithConst_ = iConfig.getParameter<bool>("writeJetsWithConst");  //write subtracted jet constituents
   doFastJetNonUniform_ = iConfig.getParameter<bool>("doFastJetNonUniform");
   puCenters_ = iConfig.getParameter<vector<double>>("puCenters");
   puWidth_ = iConfig.getParameter<double>("puWidth");
   nExclude_ = iConfig.getParameter<unsigned int>("nExclude");
   useDeterministicSeed_ = iConfig.getParameter<bool>("useDeterministicSeed");
   minSeed_ = iConfig.getParameter<unsigned int>("minSeed");
   verbosity_ = iConfig.getParameter<int>("verbosity");
   applyWeight_ = iConfig.getParameter<bool>("applyWeight");
   if (applyWeight_) {
     edm::InputTag srcWeights = iConfig.getParameter<edm::InputTag>("srcWeights");
     if (srcWeights.label() == src_.label())
       LogWarning("VirtualJetProducer")
           << "Particle and weights collection have the same label. You may be applying the same weights twice.\n";
     if (!srcWeights.label().empty())
       input_weights_token_ = consumes<edm::ValueMap<float>>(srcWeights);
   }
 
   anomalousTowerDef_ = std::make_unique<AnomalousTower>(iConfig);
 
   input_vertex_token_ = consumes<reco::VertexCollection>(srcPVs_);
   input_candidateview_token_ = consumes<reco::CandidateView>(src_);
   input_candidatefwdptr_token_ =
       consumes<vector<edm::FwdPtr<reco::PFCandidate>>>(iConfig.getParameter<edm::InputTag>("src"));
   input_packedcandidatefwdptr_token_ =
       consumes<vector<edm::FwdPtr<pat::PackedCandidate>>>(iConfig.getParameter<edm::InputTag>("src"));
   input_gencandidatefwdptr_token_ =
       consumes<vector<edm::FwdPtr<reco::GenParticle>>>(iConfig.getParameter<edm::InputTag>("src"));
   input_packedgencandidatefwdptr_token_ =
       consumes<vector<edm::FwdPtr<pat::PackedGenParticle>>>(iConfig.getParameter<edm::InputTag>("src"));
 
   //
   // additional parameters to think about:
   // - overlap threshold (set to 0.75 for the time being)
   // - p parameter for generalized kT (set to -2 for the time being)
   // - fastjet PU subtraction parameters (not yet considered)
   //
   if (jetAlgorithm_ == "Kt")
     fjJetDefinition_ = std::make_shared<fastjet::JetDefinition>(fastjet::kt_algorithm, rParam_);
 
   else if (jetAlgorithm_ == "CambridgeAachen")
     fjJetDefinition_ = std::make_shared<fastjet::JetDefinition>(fastjet::cambridge_algorithm, rParam_);
 
   else if (jetAlgorithm_ == "AntiKt")
     fjJetDefinition_ = std::make_shared<fastjet::JetDefinition>(fastjet::antikt_algorithm, rParam_);
 
   else if (jetAlgorithm_ == "GeneralizedKt")
     fjJetDefinition_ = std::make_shared<fastjet::JetDefinition>(fastjet::genkt_algorithm, rParam_, -2);
 
   else if (jetAlgorithm_ == "SISCone") {
     fjPlugin_ = PluginPtr(new fastjet::SISConePlugin(rParam_, 0.75, 0, 0.0, false, fastjet::SISConePlugin::SM_pttilde));
     fjJetDefinition_ = std::make_shared<fastjet::JetDefinition>(&*fjPlugin_);
 
   } else if (jetAlgorithm_ == "IterativeCone") {
     fjPlugin_ = PluginPtr(new fastjet::CMSIterativeConePlugin(rParam_, 1.0));
     fjJetDefinition_ = std::make_shared<fastjet::JetDefinition>(&*fjPlugin_);
 
   } else if (jetAlgorithm_ == "CDFMidPoint") {
     fjPlugin_ = PluginPtr(new fastjet::CDFMidPointPlugin(rParam_, 0.75));
     fjJetDefinition_ = std::make_shared<fastjet::JetDefinition>(&*fjPlugin_);
 
   } else if (jetAlgorithm_ == "ATLASCone") {
     fjPlugin_ = PluginPtr(new fastjet::ATLASConePlugin(rParam_));
     fjJetDefinition_ = std::make_shared<fastjet::JetDefinition>(&*fjPlugin_);
 
   } else {
     throw cms::Exception("Invalid jetAlgorithm") << "Jet algorithm for VirtualJetProducer is invalid, Abort!\n";
   }
 
   jetTypeE = JetType::byName(jetType_);
 
   if (JetType::CaloJet == jetTypeE) {
     geometry_token_ = esConsumes();
     topology_token_ = esConsumes();
   }
 
   if (doPUOffsetCorr_) {
     if (puSubtractorName_.empty()) {
       LogWarning("VirtualJetProducer")
           << "Pile Up correction on; however, pile up type is not specified. Using default... \n";
       subtractor_ = std::make_shared<PileUpSubtractor>(iConfig, consumesCollector());
     } else
       subtractor_ = std::shared_ptr<PileUpSubtractor>(
           PileUpSubtractorFactory::get()->create(puSubtractorName_, iConfig, consumesCollector()));
   }
 
   // do approximate disk-based area calculation => warn if conflicting request
   if (doAreaDiskApprox_ && doAreaFastjet_)
     throw cms::Exception("Conflicting area calculations")
         << "Both the calculation of jet area via fastjet and via an analytical disk approximation have been requested. "
            "Please decide on one.\n";
 
   if (doAreaFastjet_ || doRhoFastjet_) {
     if (voronoiRfact_ <= 0) {
       fjActiveArea_ = std::make_shared<fastjet::GhostedAreaSpec>(ghostEtaMax_, activeAreaRepeats_, ghostArea_);
 
       if (!useExplicitGhosts_) {
         fjAreaDefinition_ = std::make_shared<fastjet::AreaDefinition>(fastjet::active_area, *fjActiveArea_);
       } else {
         fjAreaDefinition_ =
             std::make_shared<fastjet::AreaDefinition>(fastjet::active_area_explicit_ghosts, *fjActiveArea_);
       }
     }
     fjSelector_ = std::make_shared<fastjet::Selector>(fastjet::SelectorAbsRapMax(rhoEtaMax_));
   }
 
   if ((doFastJetNonUniform_) && (puCenters_.empty()))
     throw cms::Exception("doFastJetNonUniform")
         << "Parameter puCenters for doFastJetNonUniform is not defined." << std::endl;
 
   // make the "produces" statements
   makeProduces(moduleLabel_, jetCollInstanceName_);
   produces<vector<double>>("rhos");
   produces<vector<double>>("sigmas");
   produces<double>("rho");
   produces<double>("sigma");
 }

◆ ~VirtualJetProducer()

VirtualJetProducer::~VirtualJetProducer ( )

override

Definition at line 265 of file VirtualJetProducer.cc.

265 {}

Member Function Documentation

◆ addHTTTopJetTagInfoCollection()

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

inlineprotectedvirtual

Reimplemented in cms::HTTTopJetProducer.

Definition at line 116 of file VirtualJetProducer.h.

118 {};

◆ copyConstituents()

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

protectedvirtual

Definition at line 521 of file VirtualJetProducer.cc.

References mps_fire::i, and metsig::jet.

                                                                                                       {
   for (unsigned int i = 0; i < fjConstituents.size(); ++i) {
     int index = fjConstituents[i].user_index();
     if (index >= 0 && static_cast<unsigned int>(index) < inputs_.size())
       jet->addDaughter(inputs_[index]);
   }
 }

◆ fillDescriptions()

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

static

Definition at line 1039 of file VirtualJetProducer.cc.

References edm::ConfigurationDescriptions::addDefault(), and submitPVResolutionJobs::desc.

                                                                                     {
   edm::ParameterSetDescription desc;
   fillDescriptionsFromVirtualJetProducer(desc);
   desc.add<string>("jetCollInstanceName", "");
 
   // addDefault must be used here instead of add unless
   // all the classes that inherit from this class redefine
   // the fillDescriptions function. Otherwise, the autogenerated
   // cfi filenames are the same and conflict.
   descriptions.addDefault(desc);
 }

◆ fillDescriptionsFromVirtualJetProducer()

void VirtualJetProducer::fillDescriptionsFromVirtualJetProducer ( edm::ParameterSetDescription & desc )

static

Definition at line 1051 of file VirtualJetProducer.cc.

References submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

Referenced by cms::CSJetProducer::fillDescriptions(), FastjetJetProducer::fillDescriptions(), cms::CATopJetProducer::fillDescriptions(), and cms::HTTTopJetProducer::fillDescriptions().

                                                                                                 {
   desc.add<edm::InputTag>("src", edm::InputTag("particleFlow"));
   desc.add<edm::InputTag>("srcPVs", edm::InputTag(""));
   desc.add<string>("jetType", "PFJet");
   desc.add<string>("jetAlgorithm", "AntiKt");
   desc.add<double>("rParam", 0.4);
   desc.add<double>("inputEtMin", 0.0);
   desc.add<double>("inputEMin", 0.0);
   desc.add<double>("jetPtMin", 5.);
   desc.add<bool>("doPVCorrection", false);
   desc.add<bool>("doAreaFastjet", false);
   desc.add<bool>("doRhoFastjet", false);
   desc.add<bool>("doPUOffsetCorr", false);
   desc.add<double>("puPtMin", 10.);
   desc.add<double>("nSigmaPU", 1.0);
   desc.add<double>("radiusPU", 0.5);
   desc.add<string>("subtractorName", "");
   desc.add<bool>("useExplicitGhosts", false);
   desc.add<bool>("doAreaDiskApprox", false);
   desc.add<double>("voronoiRfact", -0.9);
   desc.add<double>("Rho_EtaMax", 4.4);
   desc.add<double>("Ghost_EtaMax", 5.);
   desc.add<int>("Active_Area_Repeats", 1);
   desc.add<double>("GhostArea", 0.01);
   desc.add<bool>("restrictInputs", false);
   desc.add<unsigned int>("maxInputs", 1);
   desc.add<bool>("writeCompound", false);
   desc.add<bool>("writeJetsWithConst", false);
   desc.add<bool>("doFastJetNonUniform", false);
   desc.add<bool>("useDeterministicSeed", false);
   desc.add<unsigned int>("minSeed", 14327);
   desc.add<int>("verbosity", 0);
   desc.add<double>("puWidth", 0.);
   desc.add<unsigned int>("nExclude", 0);
   desc.add<unsigned int>("maxBadEcalCells", 9999999);
   desc.add<unsigned int>("maxBadHcalCells", 9999999);
   desc.add<unsigned int>("maxProblematicEcalCells", 9999999);
   desc.add<unsigned int>("maxProblematicHcalCells", 9999999);
   desc.add<unsigned int>("maxRecoveredEcalCells", 9999999);
   desc.add<unsigned int>("maxRecoveredHcalCells", 9999999);
   vector<double> puCentersDefault;
   desc.add<vector<double>>("puCenters", puCentersDefault);
   desc.add<bool>("applyWeight", false);
   desc.add<edm::InputTag>("srcWeights", edm::InputTag(""));
   desc.add<double>("minimumTowersFraction", 0.);
 }

◆ getConstituents()

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

protectedvirtual

Definition at line 530 of file VirtualJetProducer.cc.

References mps_fire::i, and mps_fire::result.

Referenced by FastjetJetProducer::produceTrackJets(), and cms::SubEventGenJetProducer::runAlgorithm().

                                                                                                            {
   vector<reco::CandidatePtr> result;
   result.reserve(fjConstituents.size() / 2);
   for (unsigned int i = 0; i < fjConstituents.size(); i++) {
     auto index = fjConstituents[i].user_index();
     if (index >= 0 && static_cast<unsigned int>(index) < inputs_.size()) {
       result.emplace_back(inputs_[index]);
     }
   }
   return result;
 }

◆ getGeometry()

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

protected

Definition at line 1030 of file VirtualJetProducer.cc.

References edm::EventSetup::getData().

Referenced by SubjetFilterJetProducer::writeCompoundJets(), and cms::CompoundJetProducer::writeCompoundJets().

                                                                                      {
   return iSetup.getData(geometry_token_);
 }

◆ getTopology()

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

protected

Definition at line 1034 of file VirtualJetProducer.cc.

References edm::EventSetup::getData().

Referenced by SubjetFilterJetProducer::writeCompoundJets(), and cms::CompoundJetProducer::writeCompoundJets().

                                                                                      {
   return iSetup.getData(topology_token_);
 }

◆ inputTowers()

void VirtualJetProducer::inputTowers ( )

protectedvirtual

Reimplemented in cms::CompoundJetProducer, SubjetFilterJetProducer, and cms::SubEventGenJetProducer.

Definition at line 450 of file VirtualJetProducer.cc.

References geometryDiff::epsilon, mps_fire::i, input, edm::isNotFinite(), jetUpdater_cfi::sort, l1tHGCalTowerProducer_cfi::tower, and w().

Referenced by SubjetFilterJetProducer::inputTowers(), cms::CompoundJetProducer::inputTowers(), and FastjetJetProducer::produceTrackJets().

                                      {
   auto inBegin = inputs_.begin(), inEnd = inputs_.end(), i = inBegin;
   for (; i != inEnd; ++i) {
     auto const& input = **i;
     // std::cout << "CaloTowerVI jets " << input->pt() << " " << input->et() << ' '<< input->energy() << ' ' << (isAnomalousTower(input) ? " bad" : " ok") << std::endl;
     if (edm::isNotFinite(input.pt()))
       continue;
     if (input.et() < inputEtMin_)
       continue;
     if (input.energy() < inputEMin_)
       continue;
     if (isAnomalousTower(*i))
       continue;
     // Change by SRR : this is no longer an error nor warning, this can happen with PU mitigation algos.
     // Also switch to something more numerically safe. (VI: 10^-42GeV????)
     if (input.pt() < 100 * std::numeric_limits<double>::epsilon()) {
       continue;
     }
     if (makeCaloJet(jetTypeE) && doPVCorrection_) {
       const CaloTower& tower = dynamic_cast<const CaloTower&>(input);
       auto const& ct = tower.p4(vertex_);  // very expensive as computed in eta/phi
       fjInputs_.emplace_back(ct.px(), ct.py(), ct.pz(), ct.energy());
       fjInputs_.back().set_user_index(i - inBegin);
       //std::cout << "tower:" << *tower << '\n';
     } else {
       /*
       if(makePFJet(jetTypeE)) {
     reco::PFCandidate& pfc = (reco::PFCandidate&)input;
     std::cout << "PF cand:" << pfc << '\n';
       }
       */
       if (!applyWeight_) {
         fjInputs_.emplace_back(input.px(), input.py(), input.pz(), input.energy());
         fjInputs_.back().set_user_index(i - inBegin);
       } else {
         if (input_weights_token_.isUninitialized())
           throw cms::Exception("InvalidInput")
               << "applyWeight set to True, but no weights given in VirtualJetProducer\n";
         float w = weights_[*i];
         if (w > 0) {
           fjInputs_.emplace_back(input.px() * w, input.py() * w, input.pz() * w, input.energy() * w);
           fjInputs_.back().set_user_index(i - inBegin);
         }
       }
     }
   }
 
   if (restrictInputs_ && fjInputs_.size() > maxInputs_) {
     reco::helper::GreaterByPtPseudoJet pTComparator;
     std::sort(fjInputs_.begin(), fjInputs_.end(), pTComparator);
     fjInputs_.resize(maxInputs_);
     edm::LogWarning("JetRecoTooManyEntries")
         << "Too many inputs in the event, limiting to first " << maxInputs_ << ". Output is suspect.";
   }
 }

◆ isAnomalousTower()

bool VirtualJetProducer::isAnomalousTower ( reco::CandidatePtr input )

protectedvirtual

Definition at line 507 of file VirtualJetProducer.cc.

Referenced by cms::SubEventGenJetProducer::inputTowers().

                                                                 {
   if (!makeCaloJet(jetTypeE))
     return false;
   else
     return (*anomalousTowerDef_)(*input);
 }

◆ jetType()

std::string VirtualJetProducer::jetType ( ) const

inline

Definition at line 88 of file VirtualJetProducer.h.

88 { return jetType_; }

VirtualJetProducer::jetType_

std::string jetType_

Definition: VirtualJetProducer.h:157

◆ makeBasicJet()

bool VirtualJetProducer::makeBasicJet ( const JetType::Type & fTag )

inlineprotected

Definition at line 64 of file VirtualJetProducer.h.

64 { return fTag == JetType::BasicJet; }

VirtualJetProducer::JetType::BasicJet

Definition: VirtualJetProducer.h:45

◆ makeCaloJet()

bool VirtualJetProducer::makeCaloJet ( const JetType::Type & fTag )

inlineprotected

Definition at line 59 of file VirtualJetProducer.h.

References btagElecInJet_cfi::CaloJet.

59 { return fTag == JetType::CaloJet; }

VirtualJetProducer::JetType::CaloJet

Definition: VirtualJetProducer.h:47

◆ makeGenJet()

bool VirtualJetProducer::makeGenJet ( const JetType::Type & fTag )

inlineprotected

Definition at line 61 of file VirtualJetProducer.h.

References nanoDQM_cfi::GenJet.

61 { return fTag == JetType::GenJet; }

VirtualJetProducer::JetType::GenJet

Definition: VirtualJetProducer.h:46

◆ makePFClusterJet()

bool VirtualJetProducer::makePFClusterJet ( const JetType::Type & fTag )

inlineprotected

Definition at line 63 of file VirtualJetProducer.h.

63 { return fTag == JetType::PFClusterJet; }

VirtualJetProducer::JetType::PFClusterJet

Definition: VirtualJetProducer.h:50

◆ makePFJet()

bool VirtualJetProducer::makePFJet ( const JetType::Type & fTag )

inlineprotected

Definition at line 60 of file VirtualJetProducer.h.

60 { return fTag == JetType::PFJet; }

VirtualJetProducer::JetType::PFJet

Definition: VirtualJetProducer.h:48

◆ makeProduces()

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

protectedvirtual

Definition at line 86 of file VirtualJetProducer.cc.

References SiStripOfflineCRack_cfg::alias, and makeGlobalPositionRcd_cfg::tag.

Referenced by SubjetFilterJetProducer::SubjetFilterJetProducer().

                                                                     {
   if (writeCompound_) {
     produces<reco::BasicJetCollection>();
   }
 
   if (writeJetsWithConst_) {
     produces<reco::PFCandidateCollection>(tag).setBranchAlias(alias);
     produces<reco::PFJetCollection>();
   } else {
     if (makeCaloJet(jetTypeE)) {
       produces<reco::CaloJetCollection>(tag).setBranchAlias(alias);
     } else if (makePFJet(jetTypeE)) {
       produces<reco::PFJetCollection>(tag).setBranchAlias(alias);
     } else if (makeGenJet(jetTypeE)) {
       produces<reco::GenJetCollection>(tag).setBranchAlias(alias);
     } else if (makeTrackJet(jetTypeE)) {
       produces<reco::TrackJetCollection>(tag).setBranchAlias(alias);
     } else if (makePFClusterJet(jetTypeE)) {
       produces<reco::PFClusterJetCollection>(tag).setBranchAlias(alias);
     } else if (makeBasicJet(jetTypeE)) {
       produces<reco::BasicJetCollection>(tag).setBranchAlias(alias);
     }
   }
 }

◆ makeTrackJet()

bool VirtualJetProducer::makeTrackJet ( const JetType::Type & fTag )

inlineprotected

Definition at line 62 of file VirtualJetProducer.h.

Referenced by FastjetJetProducer::produce().

62 { return fTag == JetType::TrackJet; }

VirtualJetProducer::JetType::TrackJet

Definition: VirtualJetProducer.h:49

◆ offsetCorrectJets()

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

protected

◆ output()

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

protectedvirtual

Reimplemented in cms::CompoundJetProducer, and SubjetFilterJetProducer.

Definition at line 544 of file VirtualJetProducer.cc.

References btagElecInJet_cfi::CaloJet, Exception, nanoDQM_cfi::GenJet, and iEvent.

                                                                              {
   // Write jets and constitutents. Will use fjJets_, inputs_
   // and fjClusterSeq_
 
   if (writeCompound_) {
     // Write jets and subjets
     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;
     };
   } else if (writeJetsWithConst_) {
     // Write jets and new constituents.
     writeJetsWithConstituents<reco::PFJet>(iEvent, iSetup);
   } else {
     switch (jetTypeE) {
       case JetType::CaloJet:
         writeJets<reco::CaloJet>(iEvent, iSetup);
         break;
       case JetType::PFJet:
         writeJets<reco::PFJet>(iEvent, iSetup);
         break;
       case JetType::GenJet:
         writeJets<reco::GenJet>(iEvent, iSetup);
         break;
       case JetType::TrackJet:
         writeJets<reco::TrackJet>(iEvent, iSetup);
         break;
       case JetType::PFClusterJet:
         writeJets<reco::PFClusterJet>(iEvent, iSetup);
         break;
       case JetType::BasicJet:
         writeJets<reco::BasicJet>(iEvent, iSetup);
         break;
       default:
         throw cms::Exception("InvalidInput") << "invalid jet type in VirtualJetProducer\n";
         break;
     };
   }
 }

◆ produce()

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

override

Definition at line 272 of file VirtualJetProducer.cc.

References edm::View< T >::empty(), Exception, mps_fire::i, iEvent, LogDebug, SiStripPI::max, convertSQLitetoXML_cfg::output, edm::View< T >::ptrAt(), heavyFlavorDQMFirstStep_cff::pvCollection, DetachedQuadStep_cff::seeds, edm::View< T >::size(), and std::swap().

Referenced by cms::SubJetProducer::produce(), CMSInsideOutJetProducer::produce(), cms::CSJetProducer::produce(), SubjetFilterJetProducer::produce(), and FastjetJetProducer::produce().

                                                                               {
   // If requested, set the fastjet random seed to a deterministic function
   // of the run/lumi/event.
   // NOTE!!! The fastjet random number sequence is a global singleton.
   // Thus, we have to create an object and get access to the global singleton
   // in order to change it.
   if (useDeterministicSeed_) {
     fastjet::GhostedAreaSpec gas;
     std::vector<int> seeds(2);
     unsigned int runNum_uint = static_cast<unsigned int>(iEvent.id().run());
     unsigned int evNum_uint = static_cast<unsigned int>(iEvent.id().event());
     seeds[0] = std::max(runNum_uint, minSeed_ + 3) + 3 * evNum_uint;
     seeds[1] = std::max(runNum_uint, minSeed_ + 5) + 5 * evNum_uint;
     gas.set_random_status(seeds);
   }
 
   LogDebug("VirtualJetProducer") << "Entered produce\n";
   //determine signal vertex2
   vertex_ = reco::Jet::Point(0, 0, 0);
   if ((makeCaloJet(jetTypeE) || makePFJet(jetTypeE)) && doPVCorrection_) {
     LogDebug("VirtualJetProducer") << "Adding PV info\n";
     edm::Handle<reco::VertexCollection> pvCollection;
     iEvent.getByToken(input_vertex_token_, pvCollection);
     if (!pvCollection->empty())
       vertex_ = pvCollection->begin()->position();
   }
 
   // Get Weights Collection
   if ((applyWeight_) && (!input_weights_token_.isUninitialized()))
     weights_ = iEvent.get(input_weights_token_);
 
   // For Pileup subtraction using offset correction:
   // set up geometry map
   if (doPUOffsetCorr_) {
     subtractor_->setupGeometryMap(iEvent, iSetup);
   }
 
   // clear data
   LogDebug("VirtualJetProducer") << "Clear data\n";
   fjInputs_.clear();
   fjJets_.clear();
   inputs_.clear();
 
   // get inputs and convert them to the fastjet format (fastjet::PeudoJet)
   edm::Handle<reco::CandidateView> inputsHandle;
 
   edm::Handle<std::vector<edm::FwdPtr<reco::PFCandidate>>> pfinputsHandleAsFwdPtr;
   edm::Handle<std::vector<edm::FwdPtr<pat::PackedCandidate>>> packedinputsHandleAsFwdPtr;
   edm::Handle<std::vector<edm::FwdPtr<reco::GenParticle>>> geninputsHandleAsFwdPtr;
   edm::Handle<std::vector<edm::FwdPtr<pat::PackedGenParticle>>> packedgeninputsHandleAsFwdPtr;
 
   bool isView = iEvent.getByToken(input_candidateview_token_, inputsHandle);
   if (isView) {
     if (inputsHandle->empty()) {
       output(iEvent, iSetup);
       return;
     }
     for (size_t i = 0; i < inputsHandle->size(); ++i) {
       inputs_.push_back(inputsHandle->ptrAt(i));
     }
   } else {
     bool isPF = iEvent.getByToken(input_candidatefwdptr_token_, pfinputsHandleAsFwdPtr);
     bool isPFFwdPtr = iEvent.getByToken(input_packedcandidatefwdptr_token_, packedinputsHandleAsFwdPtr);
     bool isGen = iEvent.getByToken(input_gencandidatefwdptr_token_, geninputsHandleAsFwdPtr);
     bool isGenFwdPtr = iEvent.getByToken(input_packedgencandidatefwdptr_token_, packedgeninputsHandleAsFwdPtr);
 
     if (isPF) {
       if (pfinputsHandleAsFwdPtr->empty()) {
         output(iEvent, iSetup);
         return;
       }
       for (size_t i = 0; i < pfinputsHandleAsFwdPtr->size(); ++i) {
         if ((*pfinputsHandleAsFwdPtr)[i].ptr().isAvailable()) {
           inputs_.push_back((*pfinputsHandleAsFwdPtr)[i].ptr());
         } else if ((*pfinputsHandleAsFwdPtr)[i].backPtr().isAvailable()) {
           inputs_.push_back((*pfinputsHandleAsFwdPtr)[i].backPtr());
         }
       }
     } else if (isPFFwdPtr) {
       if (packedinputsHandleAsFwdPtr->empty()) {
         output(iEvent, iSetup);
         return;
       }
       for (size_t i = 0; i < packedinputsHandleAsFwdPtr->size(); ++i) {
         if ((*packedinputsHandleAsFwdPtr)[i].ptr().isAvailable()) {
           inputs_.push_back((*packedinputsHandleAsFwdPtr)[i].ptr());
         } else if ((*packedinputsHandleAsFwdPtr)[i].backPtr().isAvailable()) {
           inputs_.push_back((*packedinputsHandleAsFwdPtr)[i].backPtr());
         }
       }
     } else if (isGen) {
       if (geninputsHandleAsFwdPtr->empty()) {
         output(iEvent, iSetup);
         return;
       }
       for (size_t i = 0; i < geninputsHandleAsFwdPtr->size(); ++i) {
         if ((*geninputsHandleAsFwdPtr)[i].ptr().isAvailable()) {
           inputs_.push_back((*geninputsHandleAsFwdPtr)[i].ptr());
         } else if ((*geninputsHandleAsFwdPtr)[i].backPtr().isAvailable()) {
           inputs_.push_back((*geninputsHandleAsFwdPtr)[i].backPtr());
         }
       }
     } else if (isGenFwdPtr) {
       if (geninputsHandleAsFwdPtr->empty()) {
         output(iEvent, iSetup);
         return;
       }
       for (size_t i = 0; i < packedgeninputsHandleAsFwdPtr->size(); ++i) {
         if ((*packedgeninputsHandleAsFwdPtr)[i].ptr().isAvailable()) {
           inputs_.push_back((*packedgeninputsHandleAsFwdPtr)[i].ptr());
         } else if ((*packedgeninputsHandleAsFwdPtr)[i].backPtr().isAvailable()) {
           inputs_.push_back((*packedgeninputsHandleAsFwdPtr)[i].backPtr());
         }
       }
     } else {
       throw cms::Exception("Invalid Jet Inputs")
           << "Did not specify appropriate inputs for VirtualJetProducer, Abort!\n";
     }
   }
   LogDebug("VirtualJetProducer") << "Got inputs\n";
 
   // Convert candidates to fastjet::PseudoJets.
   // Also correct to Primary Vertex. Will modify fjInputs_
   // and use inputs_
   fjInputs_.reserve(inputs_.size());
   inputTowers();
   LogDebug("VirtualJetProducer") << "Inputted towers\n";
 
   // For Pileup subtraction using offset correction:
   // Subtract pedestal.
   if (doPUOffsetCorr_) {
     subtractor_->setDefinition(fjJetDefinition_);
     subtractor_->reset(inputs_, fjInputs_, fjJets_);
     subtractor_->calculatePedestal(fjInputs_);
     subtractor_->subtractPedestal(fjInputs_);
     LogDebug("VirtualJetProducer") << "Subtracted pedestal\n";
   }
   // Run algorithm. Will modify fjJets_ and allocate fjClusterSeq_.
   // This will use fjInputs_
   runAlgorithm(iEvent, iSetup);
 
   // if ( doPUOffsetCorr_ ) {
   //    subtractor_->setAlgorithm(fjClusterSeq_);
   // }
 
   LogDebug("VirtualJetProducer") << "Ran algorithm\n";
   // For Pileup subtraction using offset correction:
   // Now we find jets and need to recalculate their energy,
   // mark towers participated in jet,
   // remove occupied towers from the list and recalculate mean and sigma
   // put the initial towers collection to the jet,
   // and subtract from initial towers in jet recalculated mean and sigma of towers
   if (doPUOffsetCorr_) {
     LogDebug("VirtualJetProducer") << "Do PUOffsetCorr\n";
     vector<fastjet::PseudoJet> orphanInput;
     subtractor_->calculateOrphanInput(orphanInput);
     subtractor_->calculatePedestal(orphanInput);
     subtractor_->offsetCorrectJets();
   }
   // Write the output jets.
   // This will (by default) call the member function template
   // "writeJets", but can be overridden.
   // this will use inputs_
   output(iEvent, iSetup);
   LogDebug("VirtualJetProducer") << "Wrote jets\n";
 
   // Clear the work vectors so that memory is free for other modules.
   // Use the trick of swapping with an empty vector so that the memory
   // is actually given back rather than silently kept.
   decltype(fjInputs_)().swap(fjInputs_);
   decltype(fjJets_)().swap(fjJets_);
   decltype(inputs_)().swap(inputs_);
 
   return;
 }

◆ runAlgorithm()

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

protectedpure virtual

Implemented in cms::HTTTopJetProducer, cms::CATopJetProducer, FastjetJetProducer, SubjetFilterJetProducer, cms::CSJetProducer, CMSInsideOutJetProducer, cms::SubEventGenJetProducer, and cms::SubJetProducer.

◆ writeCompoundJets()

template<class T >

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

protected

function template to write out the outputs

Definition at line 790 of file VirtualJetProducer.cc.

References gather_cfg::cout, edm::EventSetup::getData(), iEvent, dqmdumpme::indices, metsig::jet, jetfilter_cfi::jetCollection, eostools::move(), point, reco::Jet::setJetArea(), and reco::writeSpecific().

                                                                                         {
   if (verbosity_ >= 1) {
     std::cout << "<VirtualJetProducer::writeCompoundJets (moduleLabel = " << moduleLabel_ << ")>:" << std::endl;
   }
 
   // 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<fastjet::PseudoJet>::const_iterator it = fjJets_.begin(), iEnd = fjJets_.end(), iBegin = fjJets_.begin();
   indices.resize(fjJets_.size());
   for (; it != iEnd; ++it) {
     fastjet::PseudoJet const& localJet = *it;
     unsigned int jetIndex = it - iBegin;
     // Get the 4-vector for the hard jet
     p4_hardJets.push_back(math::XYZTLorentzVector(localJet.px(), localJet.py(), localJet.pz(), localJet.e()));
     double localJetArea = 0.0;
     if (doAreaFastjet_ && localJet.has_area()) {
       localJetArea = localJet.area();
     }
     area_hardJets.push_back(localJetArea);
 
     // create the subjet list
     std::vector<fastjet::PseudoJet> constituents;
     if (it->has_pieces()) {
       constituents = it->pieces();
     } else if (it->has_constituents()) {
       constituents = it->constituents();
     }
 
     std::vector<fastjet::PseudoJet>::const_iterator itSubJetBegin = constituents.begin(), itSubJet = itSubJetBegin,
                                                     itSubJetEnd = constituents.end();
     for (; itSubJet != itSubJetEnd; ++itSubJet) {
       fastjet::PseudoJet const& subjet = *itSubJet;
       if (verbosity_ >= 1) {
         std::cout << "subjet #" << (itSubJet - itSubJetBegin) << ": Pt = " << subjet.pt() << ", eta = " << subjet.eta()
                   << ", phi = " << subjet.phi() << ", mass = " << subjet.m()
                   << " (#constituents = " << subjet.constituents().size() << ")" << std::endl;
         std::vector<fastjet::PseudoJet> subjet_constituents = subjet.constituents();
         int idx_constituent = 0;
         for (std::vector<fastjet::PseudoJet>::const_iterator constituent = subjet_constituents.begin();
              constituent != subjet_constituents.end();
              ++constituent) {
           if (constituent->pt() < 1.e-3)
             continue;  // CV: skip ghosts
           std::cout << "  constituent #" << idx_constituent << ": Pt = " << constituent->pt()
                     << ", eta = " << constituent->eta() << ", phi = " << constituent->phi() << ","
                     << " mass = " << constituent->m() << std::endl;
           ++idx_constituent;
         }
       }
 
       if (verbosity_ >= 1) {
         std::cout << "subjet #" << (itSubJet - itSubJetBegin) << ": Pt = " << subjet.pt() << ", eta = " << subjet.eta()
                   << ", phi = " << subjet.phi() << ", mass = " << subjet.m()
                   << " (#constituents = " << subjet.constituents().size() << ")" << std::endl;
         std::vector<fastjet::PseudoJet> subjet_constituents = subjet.constituents();
         int idx_constituent = 0;
         for (std::vector<fastjet::PseudoJet>::const_iterator constituent = subjet_constituents.begin();
              constituent != subjet_constituents.end();
              ++constituent) {
           if (constituent->pt() < 1.e-3)
             continue;  // CV: skip ghosts
           std::cout << " constituent #" << idx_constituent << ": Pt = " << constituent->pt()
                     << ", eta = " << constituent->eta() << ", phi = " << constituent->phi() << ","
                     << " mass = " << constituent->m() << std::endl;
           ++idx_constituent;
         }
       }
 
       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<fastjet::PseudoJet> subjetFastjetConstituents = subjet.constituents();
       std::vector<reco::CandidatePtr> constituents = getConstituents(subjetFastjetConstituents);
 
       indices[jetIndex].push_back(subjetCollection->size());
 
       // Add the concrete subjet type to the subjet list to write to event record
       subjetCollection->push_back(*std::make_unique<T>());
       auto& jet = subjetCollection->back();
       if ((applyWeight_) && (makePFJet(jetTypeE)))
         reco::writeSpecific(dynamic_cast<reco::PFJet&>(jet), p4Subjet, point, constituents, &weights_);
       else if constexpr (std::is_same_v<T, reco::CaloJet>) {
         reco::writeSpecific(
             jet, p4Subjet, point, constituents, iSetup.getData(geometry_token_), iSetup.getData(topology_token_));
       } else {
         reco::writeSpecific(jet, p4Subjet, point, constituents);
       }
       jet.setIsWeighted(applyWeight_);
       double subjetArea = 0.0;
       if (doAreaFastjet_ && itSubJet->has_area()) {
         subjetArea = itSubJet->area();
       }
       jet.setJetArea(subjetArea);
     }
   }
 
   // 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
   // Store the Orphan handle for adding HTT information
   edm::OrphanHandle<reco::BasicJetCollection> oh = iEvent.put(std::move(jetCollection));
 
   if (fromHTTTopJetProducer_) {
     addHTTTopJetTagInfoCollection(iEvent, iSetup, oh);
   }
 }

◆ writeJets()

template<typename T >

void VirtualJetProducer::writeJets	(	edm::Event &	iEvent,
		edm::EventSetup const &	iSetup
	)

protected

Definition at line 610 of file VirtualJetProducer.cc.

References runTheMatrix::const, reco::deltaR2(), HLT_2023v12_cff::distance, PVValHelper::eta, TrackingDataMCValidation_Standalone_cff::etamax, TrackingDataMCValidation_Standalone_cff::etamin, Exception, dqmdumpme::first, iEvent, reco::helper::VirtualJetProducerHelper::intersection(), edm::isNotFinite(), metsig::jet, PDWG_EXODelayedJetMET_cff::jets, dqmdumpme::k, M_PI, eostools::move(), HLT_2023v12_cff::nEta, fastjet::BackgroundEstimator::rho(), edm::second(), fastjet::BackgroundEstimator::set_excluded_jets(), fastjet::BackgroundEstimator::sigma(), mathSSE::sqrt(), and reco::writeSpecific().

                                                                                 {
   // std::cout << "writeJets " << typeid(T).name()
   //          << (doRhoFastjet_ ? " doRhoFastjet " : "")
   //          << (doAreaFastjet_ ? " doAreaFastjet " : "")
   //          << (doAreaDiskApprox_ ? " doAreaDiskApprox " : "")
   //          << std::endl;
 
   if (doRhoFastjet_) {
     // declare jet collection without the two jets,
     // for unbiased background estimation.
     std::vector<fastjet::PseudoJet> fjexcluded_jets;
     fjexcluded_jets = fjJets_;
 
     if (fjexcluded_jets.size() > 2)
       fjexcluded_jets.resize(nExclude_);
 
     if (doFastJetNonUniform_) {
       auto rhos = std::make_unique<std::vector<double>>();
       auto sigmas = std::make_unique<std::vector<double>>();
       int nEta = puCenters_.size();
       rhos->reserve(nEta);
       sigmas->reserve(nEta);
       fastjet::ClusterSequenceAreaBase const* clusterSequenceWithArea =
           dynamic_cast<fastjet::ClusterSequenceAreaBase const*>(fjClusterSeq_.get());
 
       if (clusterSequenceWithArea == nullptr) {
         if (!fjJets_.empty()) {
           throw cms::Exception("LogicError") << "fjClusterSeq is not initialized while inputs are present\n ";
         }
       } else {
         for (int ie = 0; ie < nEta; ++ie) {
           double eta = puCenters_[ie];
           double etamin = eta - puWidth_;
           double etamax = eta + puWidth_;
           fastjet::RangeDefinition range_rho(etamin, etamax);
           fastjet::BackgroundEstimator bkgestim(*clusterSequenceWithArea, range_rho);
           bkgestim.set_excluded_jets(fjexcluded_jets);
           rhos->push_back(bkgestim.rho());
           sigmas->push_back(bkgestim.sigma());
         }
       }
       iEvent.put(std::move(rhos), "rhos");
       iEvent.put(std::move(sigmas), "sigmas");
     } else {
       auto rho = std::make_unique<double>(0.0);
       auto sigma = std::make_unique<double>(0.0);
       double mean_area = 0;
 
       fastjet::ClusterSequenceAreaBase const* clusterSequenceWithArea =
           dynamic_cast<fastjet::ClusterSequenceAreaBase const*>(fjClusterSeq_.get());
       if (clusterSequenceWithArea == nullptr) {
         if (!fjJets_.empty()) {
           throw cms::Exception("LogicError") << "fjClusterSeq is not initialized while inputs are present\n ";
         }
       } else {
         clusterSequenceWithArea->get_median_rho_and_sigma(*fjSelector_, false, *rho, *sigma, mean_area);
         if ((*rho < 0) || (edm::isNotFinite(*rho))) {
           edm::LogError("BadRho") << "rho value is " << *rho << " area:" << mean_area
                                   << " and n_empty_jets: " << clusterSequenceWithArea->n_empty_jets(*fjSelector_)
                                   << " with range " << fjSelector_->description() << ". Setting rho to rezo.";
           *rho = 0;
         }
       }
       iEvent.put(std::move(rho), "rho");
       iEvent.put(std::move(sigma), "sigma");
     }
   }  // doRhoFastjet_
 
   // produce output jet collection
 
   using namespace reco;
 
   // allocate fjJets_.size() Ts in vector
   auto jets = std::make_unique<std::vector<T>>(fjJets_.size());
 
   if (!fjJets_.empty()) {
     // Distance between jet centers and overlap area -- for disk-based area calculation
     using RIJ = std::pair<double, double>;
     std::vector<RIJ> rijStorage(fjJets_.size() * (fjJets_.size() / 2));
     RIJ* rij[fjJets_.size()];
     unsigned int k = 0;
     for (unsigned int ijet = 0; ijet < fjJets_.size(); ++ijet) {
       rij[ijet] = &rijStorage[k];
       k += ijet;
     }
 
     float etaJ[fjJets_.size()], phiJ[fjJets_.size()];
 
     auto orParam_ = 1. / rParam_;
     // fill jets
     [[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);
     }
     for (unsigned int ijet = 0; ijet < fjJets_.size(); ++ijet) {
       auto& jet = (*jets)[ijet];
 
       // get the fastjet jet
       const fastjet::PseudoJet& fjJet = fjJets_[ijet];
       // get the constituents from fastjet
       std::vector<fastjet::PseudoJet> const& fjConstituents = fastjet::sorted_by_pt(fjJet.constituents());
       // convert them to CandidatePtr vector
       std::vector<CandidatePtr> const& constituents = getConstituents(fjConstituents);
 
       // write the specifics to the jet (simultaneously sets 4-vector, vertex).
       // These are overridden functions that will call the appropriate
       // specific allocator.
       if ((applyWeight_) && (makePFJet(jetTypeE)))
         writeSpecific(dynamic_cast<reco::PFJet&>(jet),
                       Particle::LorentzVector(fjJet.px(), fjJet.py(), fjJet.pz(), fjJet.E()),
                       vertex_,
                       constituents,
                       &weights_);
       else {
         if constexpr (std::is_same_v<T, reco::CaloJet>) {
           writeSpecific(jet,
                         Particle::LorentzVector(fjJet.px(), fjJet.py(), fjJet.pz(), fjJet.E()),
                         vertex_,
                         constituents,
                         *pGeometry,
                         *pTopology);
         } else {
           writeSpecific(
               jet, Particle::LorentzVector(fjJet.px(), fjJet.py(), fjJet.pz(), fjJet.E()), vertex_, constituents);
         }
       }
       phiJ[ijet] = jet.phi();
       etaJ[ijet] = jet.eta();
       jet.setIsWeighted(applyWeight_);
     }
 
     // calcuate the jet area
     for (unsigned int ijet = 0; ijet < fjJets_.size(); ++ijet) {
       // calcuate the jet area
       double jetArea = 0.0;
       // get the fastjet jet
       const auto& fjJet = fjJets_[ijet];
       if (doAreaFastjet_ && fjJet.has_area()) {
         jetArea = fjJet.area();
       } else if (doAreaDiskApprox_) {
         // Here it is assumed that fjJets_ is in decreasing order of pT,
         // which should happen in FastjetJetProducer::runAlgorithm()
         jetArea = M_PI;
         RIJ* distance = rij[ijet];
         for (unsigned jJet = 0; jJet < ijet; ++jJet) {
           distance[jJet].first = std::sqrt(reco::deltaR2(etaJ[ijet], phiJ[ijet], etaJ[jJet], phiJ[jJet])) * orParam_;
           distance[jJet].second = reco::helper::VirtualJetProducerHelper::intersection(distance[jJet].first);
           jetArea -= distance[jJet].second;
           for (unsigned kJet = 0; kJet < jJet; ++kJet) {
             jetArea += reco::helper::VirtualJetProducerHelper::intersection(distance[jJet].first,
                                                                             distance[kJet].first,
                                                                             rij[jJet][kJet].first,
                                                                             distance[jJet].second,
                                                                             distance[kJet].second,
                                                                             rij[jJet][kJet].second);
           }  // end loop over harder jets
         }    // end loop over harder jets
         jetArea *= (rParam_ * rParam_);
       }
       auto& jet = (*jets)[ijet];
       jet.setJetArea(jetArea);
 
       if (doPUOffsetCorr_) {
         jet.setPileup(subtractor_->getPileUpEnergy(ijet));
       } else {
         jet.setPileup(0.0);
       }
 
       // std::cout << "area " << ijet << " " << jetArea << " " << Area<T>::get(jet) << std::endl;
       // std::cout << "JetVI " << ijet << ' '<< jet.pt() << " " << jet.et() << ' '<< jet.energy() << ' '<< jet.mass() << std::endl;
     }
   }
   // put the jets in the collection
   iEvent.put(std::move(jets), jetCollInstanceName_);
 }

◆ writeJetsWithConstituents()

template<class T >

void VirtualJetProducer::writeJetsWithConstituents	(	edm::Event &	iEvent,
		edm::EventSetup const &	iSetup
	)

protected

function template to write out the outputs

Definition at line 936 of file VirtualJetProducer.cc.

References gather_cfg::cout, l1ctLayer2EG_cff::id, iEvent, dqmdumpme::indices, metsig::jet, jetfilter_cfi::jetCollection, eostools::move(), point, reco::LeafCandidate::setP4(), reco::PFCandidate::setSourceCandidatePtr(), reco::PFCandidate::translatePdgIdToType(), and reco::writeSpecific().

                                                                                                 {
   if (verbosity_ >= 1) {
     std::cout << "<VirtualJetProducer::writeJetsWithConstituents (moduleLabel = " << moduleLabel_ << ")>:" << std::endl;
   }
 
   // get a list of output jets  MV: make this compatible with template
   auto jetCollection = std::make_unique<reco::PFJetCollection>();
 
   // this is the mapping of jet to constituents
   std::vector<std::vector<int>> indices;
   // this is the list of jet 4-momenta
   std::vector<math::XYZTLorentzVector> p4_Jets;
   // this is the jet areas
   std::vector<double> area_Jets;
 
   // get a list of output constituents
   auto constituentCollection = std::make_unique<reco::PFCandidateCollection>();
 
   // This will store the handle for the constituents after we write them
   edm::OrphanHandle<reco::PFCandidateCollection> constituentHandleAfterPut;
 
   // Loop over the jets and extract constituents
   std::vector<fastjet::PseudoJet> constituentsSub;
   std::vector<fastjet::PseudoJet>::const_iterator it = fjJets_.begin(), iEnd = fjJets_.end(), iBegin = fjJets_.begin();
   indices.resize(fjJets_.size());
 
   for (; it != iEnd; ++it) {
     fastjet::PseudoJet const& localJet = *it;
     unsigned int jetIndex = it - iBegin;
     // Get the 4-vector for the hard jet
     p4_Jets.push_back(math::XYZTLorentzVector(localJet.px(), localJet.py(), localJet.pz(), localJet.e()));
     double localJetArea = 0.0;
     if (doAreaFastjet_ && localJet.has_area()) {
       localJetArea = localJet.area();
     }
     area_Jets.push_back(localJetArea);
 
     // create the constituent list
     std::vector<fastjet::PseudoJet> constituents, ghosts;
     if (it->has_pieces())
       constituents = it->pieces();
     else if (it->has_constituents())
       fastjet::SelectorIsPureGhost().sift(it->constituents(), ghosts, constituents);  //filter out ghosts
 
     //loop over constituents of jet (can be subjets or normal constituents)
     indices[jetIndex].reserve(constituents.size());
     constituentsSub.reserve(constituentsSub.size() + constituents.size());
     for (fastjet::PseudoJet const& constit : constituents) {
       indices[jetIndex].push_back(constituentsSub.size());
       constituentsSub.push_back(constit);
     }
   }
 
   //Loop over constituents and store in the event
   static const reco::PFCandidate dummySinceTranslateIsNotStatic;
   for (fastjet::PseudoJet const& constit : constituentsSub) {
     auto orig = inputs_[constit.user_index()];
     auto id = dummySinceTranslateIsNotStatic.translatePdgIdToType(orig->pdgId());
     reco::PFCandidate pCand(reco::PFCandidate(orig->charge(), orig->p4(), id));
     math::XYZTLorentzVector pVec;
     pVec.SetPxPyPzE(constit.px(), constit.py(), constit.pz(), constit.e());
     pCand.setP4(pVec);
     pCand.setSourceCandidatePtr(orig->sourceCandidatePtr(0));
     constituentCollection->push_back(pCand);
   }
   // put constituents into event record
   constituentHandleAfterPut = iEvent.put(std::move(constituentCollection), jetCollInstanceName_);
 
   // Now create the jets with ptr's to the constituents
   std::vector<math::XYZTLorentzVector>::const_iterator ip4 = p4_Jets.begin(), ip4Begin = p4_Jets.begin(),
                                                        ip4End = p4_Jets.end();
 
   for (; ip4 != ip4End; ++ip4) {
     int p4_index = ip4 - ip4Begin;
     std::vector<int>& ind = indices[p4_index];
     std::vector<reco::CandidatePtr> i_jetConstituents;
     // Add the constituents to the jet
     for (std::vector<int>::const_iterator iconst = ind.begin(); iconst != ind.end(); ++iconst) {
       reco::CandidatePtr candPtr(constituentHandleAfterPut, *iconst, false);
       i_jetConstituents.push_back(candPtr);
     }
     if (!i_jetConstituents.empty()) {  //only keep jets which have constituents after subtraction
       reco::Particle::Point point(0, 0, 0);
       reco::PFJet jet;
       reco::writeSpecific(jet, *ip4, point, i_jetConstituents);
       jet.setJetArea(area_Jets[ip4 - ip4Begin]);
       jetCollection->emplace_back(jet);
     }
   }
 
   // put jets into event record
   iEvent.put(std::move(jetCollection));
 }

Member Data Documentation

◆ activeAreaRepeats_

int VirtualJetProducer::activeAreaRepeats_

protected

Definition at line 182 of file VirtualJetProducer.h.

◆ anomalousTowerDef_

std::unique_ptr<AnomalousTower> VirtualJetProducer::anomalousTowerDef_

private

Definition at line 224 of file VirtualJetProducer.h.

◆ applyWeight_

bool VirtualJetProducer::applyWeight_

protected

Definition at line 216 of file VirtualJetProducer.h.

◆ doAreaDiskApprox_

bool VirtualJetProducer::doAreaDiskApprox_

protected

Definition at line 172 of file VirtualJetProducer.h.

◆ doAreaFastjet_

bool VirtualJetProducer::doAreaFastjet_

protected

Definition at line 170 of file VirtualJetProducer.h.

Referenced by cms::CSJetProducer::runAlgorithm(), FastjetJetProducer::runAlgorithm(), cms::CATopJetProducer::runAlgorithm(), and cms::HTTTopJetProducer::runAlgorithm().

◆ doFastJetNonUniform_

bool VirtualJetProducer::doFastJetNonUniform_

protected

Definition at line 175 of file VirtualJetProducer.h.

◆ doPUOffsetCorr_

bool VirtualJetProducer::doPUOffsetCorr_

protected

Definition at line 186 of file VirtualJetProducer.h.

◆ doPVCorrection_

bool VirtualJetProducer::doPVCorrection_

protected

Definition at line 163 of file VirtualJetProducer.h.

◆ doRhoFastjet_

bool VirtualJetProducer::doRhoFastjet_

protected

Definition at line 174 of file VirtualJetProducer.h.

Referenced by cms::CSJetProducer::runAlgorithm(), FastjetJetProducer::runAlgorithm(), cms::CATopJetProducer::runAlgorithm(), and cms::HTTTopJetProducer::runAlgorithm().

◆ fjActiveArea_

ActiveAreaSpecPtr VirtualJetProducer::fjActiveArea_

protected

Definition at line 195 of file VirtualJetProducer.h.

◆ fjAreaDefinition_

AreaDefinitionPtr VirtualJetProducer::fjAreaDefinition_

protected

Definition at line 196 of file VirtualJetProducer.h.

Referenced by FastjetJetProducer::FastjetJetProducer(), cms::CSJetProducer::runAlgorithm(), FastjetJetProducer::runAlgorithm(), cms::CATopJetProducer::runAlgorithm(), and cms::HTTTopJetProducer::runAlgorithm().

◆ fjClusterSeq_

ClusterSequencePtr VirtualJetProducer::fjClusterSeq_

protected

Definition at line 192 of file VirtualJetProducer.h.

Referenced by cms::CSJetProducer::produce(), FastjetJetProducer::produce(), FastjetJetProducer::produceTrackJets(), cms::SubEventGenJetProducer::runAlgorithm(), cms::CSJetProducer::runAlgorithm(), FastjetJetProducer::runAlgorithm(), cms::CATopJetProducer::runAlgorithm(), and cms::HTTTopJetProducer::runAlgorithm().

◆ fjInputs_

std::vector<fastjet::PseudoJet> VirtualJetProducer::fjInputs_

protected

Definition at line 198 of file VirtualJetProducer.h.

Referenced by cms::SubEventGenJetProducer::produce(), FastjetJetProducer::produceTrackJets(), cms::SubJetProducer::runAlgorithm(), cms::SubEventGenJetProducer::runAlgorithm(), CMSInsideOutJetProducer::runAlgorithm(), cms::CSJetProducer::runAlgorithm(), SubjetFilterJetProducer::runAlgorithm(), FastjetJetProducer::runAlgorithm(), cms::CATopJetProducer::runAlgorithm(), and cms::HTTTopJetProducer::runAlgorithm().

◆ fjJetDefinition_

JetDefPtr VirtualJetProducer::fjJetDefinition_

protected

Definition at line 193 of file VirtualJetProducer.h.

Referenced by cms::SubEventGenJetProducer::runAlgorithm(), cms::CSJetProducer::runAlgorithm(), FastjetJetProducer::runAlgorithm(), cms::CATopJetProducer::runAlgorithm(), and cms::HTTTopJetProducer::runAlgorithm().

◆ fjJets_

std::vector<fastjet::PseudoJet> VirtualJetProducer::fjJets_

protected

Definition at line 199 of file VirtualJetProducer.h.

Referenced by cms::HTTTopJetProducer::addHTTTopJetTagInfoCollection(), cms::SubEventGenJetProducer::produce(), FastjetJetProducer::produceTrackJets(), cms::SubEventGenJetProducer::runAlgorithm(), CMSInsideOutJetProducer::runAlgorithm(), cms::CSJetProducer::runAlgorithm(), FastjetJetProducer::runAlgorithm(), cms::CATopJetProducer::runAlgorithm(), and cms::HTTTopJetProducer::runAlgorithm().

◆ fjPlugin_

PluginPtr VirtualJetProducer::fjPlugin_

protected

Definition at line 194 of file VirtualJetProducer.h.

◆ fjSelector_

SelectorPtr VirtualJetProducer::fjSelector_

protected

Definition at line 197 of file VirtualJetProducer.h.

◆ fromHTTTopJetProducer_

bool VirtualJetProducer::fromHTTTopJetProducer_ = false

protected

Definition at line 215 of file VirtualJetProducer.h.

Referenced by cms::HTTTopJetProducer::HTTTopJetProducer().

◆ geometry_token_

edm::ESGetToken<CaloGeometry, CaloGeometryRecord> VirtualJetProducer::geometry_token_

private

Definition at line 221 of file VirtualJetProducer.h.

◆ ghostArea_

double VirtualJetProducer::ghostArea_

protected

Definition at line 183 of file VirtualJetProducer.h.

◆ ghostEtaMax_

double VirtualJetProducer::ghostEtaMax_

protected

Definition at line 181 of file VirtualJetProducer.h.

◆ input_candidatefwdptr_token_

edm::EDGetTokenT<std::vector<edm::FwdPtr<reco::PFCandidate> > > VirtualJetProducer::input_candidatefwdptr_token_

private

Definition at line 228 of file VirtualJetProducer.h.

◆ input_candidateview_token_

edm::EDGetTokenT<reco::CandidateView> VirtualJetProducer::input_candidateview_token_

private

Definition at line 227 of file VirtualJetProducer.h.

◆ input_gencandidatefwdptr_token_

edm::EDGetTokenT<std::vector<edm::FwdPtr<reco::GenParticle> > > VirtualJetProducer::input_gencandidatefwdptr_token_

private

Definition at line 230 of file VirtualJetProducer.h.

◆ input_packedcandidatefwdptr_token_

edm::EDGetTokenT<std::vector<edm::FwdPtr<pat::PackedCandidate> > > VirtualJetProducer::input_packedcandidatefwdptr_token_

private

Definition at line 229 of file VirtualJetProducer.h.

◆ input_packedgencandidatefwdptr_token_

edm::EDGetTokenT<std::vector<edm::FwdPtr<pat::PackedGenParticle> > > VirtualJetProducer::input_packedgencandidatefwdptr_token_

private

Definition at line 231 of file VirtualJetProducer.h.

◆ input_vertex_token_

edm::EDGetTokenT<reco::VertexCollection> VirtualJetProducer::input_vertex_token_

protected

Definition at line 234 of file VirtualJetProducer.h.

Referenced by FastjetJetProducer::produceTrackJets().

◆ input_weights_token_

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

protected

Definition at line 235 of file VirtualJetProducer.h.

◆ inputEMin_

double VirtualJetProducer::inputEMin_

protected

Definition at line 161 of file VirtualJetProducer.h.

Referenced by cms::SubEventGenJetProducer::inputTowers().

◆ inputEtMin_

double VirtualJetProducer::inputEtMin_

protected

Definition at line 160 of file VirtualJetProducer.h.

Referenced by cms::SubEventGenJetProducer::inputTowers().

◆ inputs_

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

protected

Definition at line 190 of file VirtualJetProducer.h.

Referenced by cms::SubEventGenJetProducer::inputTowers(), cms::SubEventGenJetProducer::produce(), FastjetJetProducer::produceTrackJets(), SubjetFilterJetProducer::writeCompoundJets(), and cms::CompoundJetProducer::writeCompoundJets().

◆ jetAlgorithm_

std::string VirtualJetProducer::jetAlgorithm_

protected

Definition at line 158 of file VirtualJetProducer.h.

◆ jetCollInstanceName_

std::string VirtualJetProducer::jetCollInstanceName_

protected

Definition at line 206 of file VirtualJetProducer.h.

Referenced by cms::CompoundJetProducer::writeCompoundJets().

◆ jetPtMin_

double VirtualJetProducer::jetPtMin_

protected

Definition at line 162 of file VirtualJetProducer.h.

Referenced by cms::SubEventGenJetProducer::runAlgorithm(), cms::CSJetProducer::runAlgorithm(), and FastjetJetProducer::runAlgorithm().

◆ jetType_

std::string VirtualJetProducer::jetType_

protected

Definition at line 157 of file VirtualJetProducer.h.

◆ jetTypeE

JetType::Type VirtualJetProducer::jetTypeE

protected

Definition at line 57 of file VirtualJetProducer.h.

Referenced by SubjetFilterJetProducer::output(), cms::CompoundJetProducer::output(), and FastjetJetProducer::produce().

◆ maxInputs_

unsigned int VirtualJetProducer::maxInputs_

protected

Definition at line 167 of file VirtualJetProducer.h.

◆ minSeed_

unsigned int VirtualJetProducer::minSeed_

protected

Definition at line 212 of file VirtualJetProducer.h.

◆ moduleLabel_

std::string VirtualJetProducer::moduleLabel_

protected

Definition at line 154 of file VirtualJetProducer.h.

Referenced by ExternalGeneratorFilter.ExternalGeneratorFilter::insertInto(), Modules.SwitchProducer::insertInto(), Mixins._TypedParameterizable::insertInto(), Modules.ESSource::nameInProcessDesc_(), Modules.ESProducer::nameInProcessDesc_(), and SubjetFilterJetProducer::SubjetFilterJetProducer().

◆ nExclude_

unsigned int VirtualJetProducer::nExclude_

protected

Definition at line 204 of file VirtualJetProducer.h.

◆ puCenters_

std::vector<double> VirtualJetProducer::puCenters_

protected

Definition at line 202 of file VirtualJetProducer.h.

◆ puSubtractorName_

std::string VirtualJetProducer::puSubtractorName_

protected

Definition at line 187 of file VirtualJetProducer.h.

◆ puWidth_

double VirtualJetProducer::puWidth_

protected

Definition at line 203 of file VirtualJetProducer.h.

◆ restrictInputs_

bool VirtualJetProducer::restrictInputs_

protected

Definition at line 166 of file VirtualJetProducer.h.

◆ rhoEtaMax_

double VirtualJetProducer::rhoEtaMax_

protected

Definition at line 180 of file VirtualJetProducer.h.

◆ rParam_

double VirtualJetProducer::rParam_

protected

Definition at line 159 of file VirtualJetProducer.h.

◆ src_

edm::InputTag VirtualJetProducer::src_

protected

Definition at line 155 of file VirtualJetProducer.h.

Referenced by cms::CATopJetProducer::CATopJetProducer(), and cms::SubEventGenJetProducer::SubEventGenJetProducer().

◆ srcPVs_

edm::InputTag VirtualJetProducer::srcPVs_

protected

Definition at line 156 of file VirtualJetProducer.h.

◆ subtractor_

std::shared_ptr<PileUpSubtractor> VirtualJetProducer::subtractor_

protected

Definition at line 209 of file VirtualJetProducer.h.

◆ topology_token_

edm::ESGetToken<HcalTopology, HcalRecNumberingRecord> VirtualJetProducer::topology_token_

private

Definition at line 222 of file VirtualJetProducer.h.

◆ useDeterministicSeed_

bool VirtualJetProducer::useDeterministicSeed_

protected

Definition at line 211 of file VirtualJetProducer.h.

◆ useExplicitGhosts_

bool VirtualJetProducer::useExplicitGhosts_

protected

Definition at line 171 of file VirtualJetProducer.h.

Referenced by FastjetJetProducer::FastjetJetProducer().

◆ verbosity_

int VirtualJetProducer::verbosity_

protected

Definition at line 214 of file VirtualJetProducer.h.

Referenced by FastjetJetProducer::runAlgorithm().

◆ vertex_

reco::Particle::Point VirtualJetProducer::vertex_

protected

Definition at line 191 of file VirtualJetProducer.h.

Referenced by FastjetJetProducer::produceTrackJets(), and cms::SubEventGenJetProducer::runAlgorithm().

◆ voronoiRfact_

double VirtualJetProducer::voronoiRfact_

protected

Definition at line 177 of file VirtualJetProducer.h.

Referenced by cms::CSJetProducer::runAlgorithm(), FastjetJetProducer::runAlgorithm(), cms::CATopJetProducer::runAlgorithm(), and cms::HTTTopJetProducer::runAlgorithm().

◆ weights_

edm::ValueMap<float> VirtualJetProducer::weights_

protected

Definition at line 217 of file VirtualJetProducer.h.

◆ writeCompound_

bool VirtualJetProducer::writeCompound_

protected

Definition at line 207 of file VirtualJetProducer.h.

◆ writeJetsWithConst_

bool VirtualJetProducer::writeJetsWithConst_

protected

Definition at line 208 of file VirtualJetProducer.h.

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ActiveAreaSpecPtr

◆ AreaDefinitionPtr

◆ ClusterSequencePtr

◆ JetDefPtr

◆ PluginPtr

◆ SelectorPtr

Constructor & Destructor Documentation

◆ VirtualJetProducer()

◆ ~VirtualJetProducer()

Member Function Documentation

◆ addHTTTopJetTagInfoCollection()

◆ copyConstituents()

◆ fillDescriptions()

◆ fillDescriptionsFromVirtualJetProducer()

◆ getConstituents()

◆ getGeometry()

◆ getTopology()

◆ inputTowers()

◆ isAnomalousTower()

◆ jetType()

◆ makeBasicJet()

◆ makeCaloJet()

◆ makeGenJet()

◆ makePFClusterJet()

◆ makePFJet()

◆ makeProduces()

◆ makeTrackJet()

◆ offsetCorrectJets()

◆ output()

◆ produce()

◆ runAlgorithm()

◆ writeCompoundJets()

◆ writeJets()

◆ writeJetsWithConstituents()

Member Data Documentation

◆ activeAreaRepeats_

◆ anomalousTowerDef_

◆ applyWeight_

◆ doAreaDiskApprox_

◆ doAreaFastjet_

◆ doFastJetNonUniform_

◆ doPUOffsetCorr_

◆ doPVCorrection_

◆ doRhoFastjet_

◆ fjActiveArea_

◆ fjAreaDefinition_

◆ fjClusterSeq_

◆ fjInputs_

◆ fjJetDefinition_

◆ fjJets_

◆ fjPlugin_

◆ fjSelector_

◆ fromHTTTopJetProducer_

◆ geometry_token_

◆ ghostArea_

◆ ghostEtaMax_

◆ input_candidatefwdptr_token_

◆ input_candidateview_token_

◆ input_gencandidatefwdptr_token_

◆ input_packedcandidatefwdptr_token_

◆ input_packedgencandidatefwdptr_token_

◆ input_vertex_token_

◆ input_weights_token_

◆ inputEMin_

◆ inputEtMin_

◆ inputs_

◆ jetAlgorithm_

◆ jetCollInstanceName_

◆ jetPtMin_

◆ jetType_

◆ jetTypeE