VirtualJetProducer Class Reference

#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_2022v12_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.

{}

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.

                                                                                         {};

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 HLT_2022v12_cff::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, hgcalTowerProducer_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.

{ return jetType_; }

makeBasicJet()

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

inlineprotected

Definition at line 64 of file VirtualJetProducer.h.

{ return fTag == JetType::BasicJet; }

makeCaloJet()

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

inlineprotected

Definition at line 59 of file VirtualJetProducer.h.

References btagElecInJet_cfi::CaloJet.

{ return fTag == JetType::CaloJet; }

makeGenJet()

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

inlineprotected

Definition at line 61 of file VirtualJetProducer.h.

References nanoDQM_cfi::GenJet.

{ return fTag == JetType::GenJet; }

makePFClusterJet()

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

inlineprotected

Definition at line 63 of file VirtualJetProducer.h.

{ return fTag == JetType::PFClusterJet; }

makePFJet()

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

inlineprotected

Definition at line 60 of file VirtualJetProducer.h.

{ return fTag == JetType::PFJet; }

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

{ return fTag == JetType::TrackJet; }

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_2022v12_cff::distance, PVValHelper::eta, muonTiming_cfi::etamax, muonTiming_cfi::etamin, Exception, first, iEvent, reco::helper::VirtualJetProducerHelper::intersection(), edm::isNotFinite(), metsig::jet, PDWG_EXODelayedJetMET_cff::jets, dqmdumpme::k, M_PI, eostools::move(), HLT_2022v12_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, triggerObjects_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.