#include <CSJetProducer.h>

Inheritance diagram for cms::CSJetProducer:

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

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

	~CSJetProducer () override

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

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

	VirtualJetProducer (const edm::ParameterSet &iConfig)

	~VirtualJetProducer () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

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

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

static void	fillDescriptionsFromCSJetProducer (edm::ParameterSetDescription &desc)

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

static void	fillDescriptionsFromVirtualJetProducer (edm::ParameterSetDescription &desc)

Protected Member Functions
double	getModulatedRhoFactor (double phi, double eventPlane2, double eventPlane3, double par1, double par2)

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

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

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

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

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

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

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

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
double	csAlpha_
	for constituent subtraction : R parameter More...

double	csRParam_

edm::EDGetTokenT< std::vector < double > >	etaToken_
	flowFit chi2/ndof minimum compatability requirement More...

double	maxFlowChi2Prob_
	flowFit chi2/ndof minimum compatability requirement More...

double	minFlowChi2Prob_
	flag to turn on/off flow-modulated rho and rhom More...

edm::EDGetTokenT< std::vector < double > >	rhoFlowFitParamsToken_

edm::EDGetTokenT< std::vector < double > >	rhomToken_

edm::EDGetTokenT< std::vector < double > >	rhoToken_

bool	useModulatedRho_
	for HI constituent subtraction : alpha (power of pt in metric) More...

Protected Attributes inherited from VirtualJetProducer
int	activeAreaRepeats_

bool	applyWeight_

bool	doAreaDiskApprox_

bool	doAreaFastjet_

bool	doFastJetNonUniform_

bool	doPUOffsetCorr_

bool	doPVCorrection_

bool	doRhoFastjet_

ActiveAreaSpecPtr	fjActiveArea_

AreaDefinitionPtr	fjAreaDefinition_

ClusterSequencePtr	fjClusterSeq_

std::vector< fastjet::PseudoJet >	fjInputs_

JetDefPtr	fjJetDefinition_

std::vector< fastjet::PseudoJet >	fjJets_

PluginPtr	fjPlugin_

SelectorPtr	fjSelector_

bool	fromHTTTopJetProducer_ = false

double	ghostArea_

double	ghostEtaMax_

edm::EDGetTokenT < reco::VertexCollection >	input_vertex_token_

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

double	inputEMin_

double	inputEtMin_

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

std::string	jetAlgorithm_

std::string	jetCollInstanceName_

double	jetPtMin_

std::string	jetType_

JetType::Type	jetTypeE

unsigned int	maxInputs_

unsigned int	minSeed_

std::string	moduleLabel_

unsigned int	nExclude_

std::vector< double >	puCenters_

std::string	puSubtractorName_

double	puWidth_

bool	restrictInputs_

double	rhoEtaMax_

double	rParam_

edm::InputTag	src_

edm::InputTag	srcPVs_

std::shared_ptr< PileUpSubtractor >	subtractor_

bool	useDeterministicSeed_

bool	useExplicitGhosts_

int	verbosity_

reco::Particle::Point	vertex_

double	voronoiRfact_

edm::ValueMap< float >	weights_

bool	writeCompound_

bool	writeJetsWithConst_

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

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

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

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

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

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

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

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 24 of file CSJetProducer.h.

Constructor & Destructor Documentation

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

Definition at line 18 of file CSJetProducer.cc.

References csAlpha_, csRParam_, etaToken_, edm::ParameterSet::getParameter(), rhoFlowFitParamsToken_, rhomToken_, rhoToken_, and useModulatedRho_.

     : VirtualJetProducer(conf),
       csRParam_(-1.0),
       csAlpha_(0.),
       useModulatedRho_(conf.getParameter<bool>("useModulatedRho")),
       minFlowChi2Prob_(conf.getParameter<double>("minFlowChi2Prob")),
       maxFlowChi2Prob_(conf.getParameter<double>("maxFlowChi2Prob")) {
   //get eta range, rho and rhom map
   etaToken_ = consumes<std::vector<double>>(conf.getParameter<edm::InputTag>("etaMap"));
   rhoToken_ = consumes<std::vector<double>>(conf.getParameter<edm::InputTag>("rho"));
   rhomToken_ = consumes<std::vector<double>>(conf.getParameter<edm::InputTag>("rhom"));
   csRParam_ = conf.getParameter<double>("csRParam");
   csAlpha_ = conf.getParameter<double>("csAlpha");
   if (useModulatedRho_)
     rhoFlowFitParamsToken_ = consumes<std::vector<double>>(conf.getParameter<edm::InputTag>("rhoFlowFitParams"));
 }

cms::CSJetProducer::~CSJetProducer ( )

inlineoverride

Definition at line 28 of file CSJetProducer.h.

28 {}

Member Function Documentation

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

static

Definition at line 162 of file CSJetProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), fillDescriptionsFromCSJetProducer(), and VirtualJetProducer::fillDescriptionsFromVirtualJetProducer().

                                                                                {
   edm::ParameterSetDescription descCSJetProducer;
   fillDescriptionsFromCSJetProducer(descCSJetProducer);
   descCSJetProducer.add<string>("jetCollInstanceName", "");
   VirtualJetProducer::fillDescriptionsFromVirtualJetProducer(descCSJetProducer);
   descCSJetProducer.add<bool>("sumRecHits", false);
 
   descriptions.add("CSJetProducer", descCSJetProducer);
 }

void CSJetProducer::fillDescriptionsFromCSJetProducer ( edm::ParameterSetDescription & desc )

static

Definition at line 175 of file CSJetProducer.cc.

References edm::ParameterSetDescription::add().

Referenced by fillDescriptions().

                                                                                       {
   desc.add<double>("csRParam", -1.);
   desc.add<double>("csAlpha", 2.);
   desc.add<bool>("useModulatedRho", false);
   desc.add<double>("minFlowChi2Prob", 0.05);
   desc.add<double>("maxFlowChi2Prob", 0.95);
   desc.add<edm::InputTag>("etaMap", {"hiFJRhoProducer", "mapEtaEdges"});
   desc.add<edm::InputTag>("rho", {"hiFJRhoProducer", "mapToRho"});
   desc.add<edm::InputTag>("rhom", {"hiFJRhoProducer", "mapToRhoM"});
   desc.add<edm::InputTag>("rhoFlowFitParams", {"hiFJRhoFlowModulationProducer", "rhoFlowFitParams"});
 }

double CSJetProducer::getModulatedRhoFactor	(	double	phi,
		double	eventPlane2,
		double	eventPlane3,
		double	par1,
		double	par2
	)

protected

Definition at line 187 of file CSJetProducer.cc.

References funct::cos().

Referenced by runAlgorithm().

                                                                                                                 {
   // get the rho modulation as function of phi
   // flow modulation fit is done in RecoHI/HiJetAlgos/plugins/HiFJRhoFlowModulationProducer
   return 1. + 2. * par1 * cos(2. * (phi - eventPlane2)) + par2 * cos(3. * (phi - eventPlane3));
 }

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

override

Definition at line 35 of file CSJetProducer.cc.

References VirtualJetProducer::fjClusterSeq_, and VirtualJetProducer::produce().

                                                                          {
   // use the default production from one collection
   VirtualJetProducer::produce(iEvent, iSetup);
   //use runAlgorithm of this class
 
   //Delete allocated memory. It is allocated every time runAlgorithm is called
   fjClusterSeq_.reset();
 }

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

overrideprotectedvirtual

Implements VirtualJetProducer.

Definition at line 45 of file CSJetProducer.cc.

                                                                               {
   // run algorithm
   if (!doAreaFastjet_ && !doRhoFastjet_) {
     fjClusterSeq_ = std::make_shared<fastjet::ClusterSequence>(fjInputs_, *fjJetDefinition_);
   } else if (voronoiRfact_ <= 0) {
     fjClusterSeq_ =
         ClusterSequencePtr(new fastjet::ClusterSequenceArea(fjInputs_, *fjJetDefinition_, *fjAreaDefinition_));
   } else {
     fjClusterSeq_ = ClusterSequencePtr(
         new fastjet::ClusterSequenceVoronoiArea(fjInputs_, *fjJetDefinition_, fastjet::VoronoiAreaSpec(voronoiRfact_)));
   }
 
   fjJets_.clear();
   std::vector<fastjet::PseudoJet> tempJets = fastjet::sorted_by_pt(fjClusterSeq_->inclusive_jets(jetPtMin_));
 
   //Get local rho and rhom map
   edm::Handle<std::vector<double>> etaRanges;
   edm::Handle<std::vector<double>> rhoRanges;
   edm::Handle<std::vector<double>> rhomRanges;
   edm::Handle<std::vector<double>> rhoFlowFitParams;
   iEvent.getByToken(etaToken_, etaRanges);
   iEvent.getByToken(rhoToken_, rhoRanges);
   iEvent.getByToken(rhomToken_, rhomRanges);
   if (useModulatedRho_)
     iEvent.getByToken(rhoFlowFitParamsToken_, rhoFlowFitParams);
 
   //Check if size of eta and background density vectors is the same
   unsigned int bkgVecSize = etaRanges->size();
   if (bkgVecSize < 1) {
     throw cms::Exception("WrongBkgInput") << "Producer needs vector with background estimates\n";
   }
   if (bkgVecSize != (rhoRanges->size() + 1) || bkgVecSize != (rhomRanges->size() + 1)) {
     throw cms::Exception("WrongBkgInput")
         << "Size of etaRanges (" << bkgVecSize << ") and rhoRanges (" << rhoRanges->size() << ") and/or rhomRanges ("
         << rhomRanges->size() << ") vectors inconsistent\n";
   }
   bool minProb = false;
   bool maxProb = false;
   if (useModulatedRho_) {
     if (!rhoFlowFitParams->empty()) {
       double val = ROOT::Math::chisquared_cdf_c(rhoFlowFitParams->at(5), rhoFlowFitParams->at(6));
       minProb = val > minFlowChi2Prob_;
       maxProb = val < maxFlowChi2Prob_;
     }
   }
 
   //Allow the background densities to change within the jet
 
   for (fastjet::PseudoJet& ijet : tempJets) {
     //----------------------------------------------------------------------
     // sift ghosts and particles in the input jet
     std::vector<fastjet::PseudoJet> particles, ghosts;
     fastjet::SelectorIsPureGhost().sift(ijet.constituents(), ghosts, particles);
     unsigned long nParticles = particles.size();
     if (nParticles == 0)
       continue;  //don't subtract ghost jets
 
     //assign rho and rhom to ghosts according to local eta-dependent map + modulation as function of phi
     for (fastjet::PseudoJet& ighost : ghosts) {
       double rhoModulationFactor = 1.;
       double ghostPhi = ighost.phi_std();
 
       if (useModulatedRho_) {
         if (!rhoFlowFitParams->empty()) {
           if (minProb && maxProb) {
             rhoModulationFactor = getModulatedRhoFactor(ghostPhi,
                                                         rhoFlowFitParams->at(2),
                                                         rhoFlowFitParams->at(4),
                                                         rhoFlowFitParams->at(1),
                                                         rhoFlowFitParams->at(3));
           }
         }
       }
 
       int32_t ghostPos = -1;
       auto const ighostEta = ighost.eta();
       if (ighostEta <= etaRanges->at(0) || bkgVecSize == 1) {
         ghostPos = 0;
       } else if (ighostEta >= etaRanges->at(bkgVecSize - 1)) {
         ghostPos = rhoRanges->size() - 1;
       } else {
         for (unsigned int ie = 0; ie < (bkgVecSize - 1); ie++) {
           if (ighostEta >= etaRanges->at(ie) && ighostEta < etaRanges->at(ie + 1)) {
             ghostPos = ie;
             break;
           }
         }
       }
       double pt = rhoRanges->at(ghostPos) * ighost.area() * rhoModulationFactor;
       double mass_squared =
           std::pow(rhoModulationFactor * rhomRanges->at(ghostPos) * ighost.area() + pt, 2) - std::pow(pt, 2);
       double mass = (mass_squared > 0) ? sqrt(mass_squared) : 0;
       ighost.reset_momentum_PtYPhiM(pt, ighost.rap(), ighost.phi(), mass);
     }
 
     //----------------------------------------------------------------------
     //from here use official fastjet contrib package
 
     fastjet::contrib::ConstituentSubtractor subtractor;
     subtractor.set_distance_type(fastjet::contrib::ConstituentSubtractor::deltaR);  // distance in eta-phi plane
     subtractor.set_max_distance(
         csRParam_);  // free parameter for the maximal allowed distance between particle i and ghost k
     subtractor.set_alpha(
         csAlpha_);  // free parameter for the distance measure (the exponent of particle pt). Note that in older versions of the package alpha was multiplied by two but in newer versions this is not the case anymore
     subtractor.set_do_mass_subtraction();
     subtractor.set_remove_all_zero_pt_particles(true);
 
     std::vector<fastjet::PseudoJet> subtracted_particles = subtractor.do_subtraction(particles, ghosts);
 
     //Create subtracted jets
     fastjet::PseudoJet subtracted_jet = join(subtracted_particles);
     if (subtracted_jet.perp() > 0.)
       fjJets_.push_back(subtracted_jet);
   }
   fjJets_ = fastjet::sorted_by_pt(fjJets_);
 }