Inheritance diagram for JetDeltaRValueMapProducer< T, C, TN >:

Public Types
typedef edm::ValueMap< value_type >	JetValueMap

typedef TN	value_type

typedef std::vector< value_type >	ValueVector

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
	JetDeltaRValueMapProducer (edm::ParameterSet const &params)

	~JetDeltaRValueMapProducer () 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

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

Private Attributes
const double	distMax_

std::map< std::string, std::unique_ptr< const StringObjectFunction< C > > >	evaluationMap_

const bool	lazyParser_

const edm::EDGetTokenT< typename edm::View< C > >	matchedToken_

bool	multiValue_

const edm::EDGetTokenT< typename edm::View< T > >	srcToken_

const std::string	value_

const std::vector< std::string >	valueLabels_

const std::vector< std::string >	values_

Detailed Description

template<class T, class C = T, typename TN = float>
class JetDeltaRValueMapProducer< T, C, TN >

Definition at line 31 of file JetDeltaRValueMapProducer.cc.

Member Typedef Documentation

◆ JetValueMap

template<class T , class C = T, typename TN = float>

typedef edm::ValueMap<value_type> JetDeltaRValueMapProducer< T, C, TN >::JetValueMap

Definition at line 34 of file JetDeltaRValueMapProducer.cc.

◆ value_type

template<class T , class C = T, typename TN = float>

typedef TN JetDeltaRValueMapProducer< T, C, TN >::value_type

Definition at line 33 of file JetDeltaRValueMapProducer.cc.

◆ ValueVector

template<class T , class C = T, typename TN = float>

typedef std::vector<value_type> JetDeltaRValueMapProducer< T, C, TN >::ValueVector

Definition at line 35 of file JetDeltaRValueMapProducer.cc.

Constructor & Destructor Documentation

◆ JetDeltaRValueMapProducer()

template<class T , class C = T, typename TN = float>

JetDeltaRValueMapProducer< T, C, TN >::JetDeltaRValueMapProducer ( edm::ParameterSet const & params )

inline

Definition at line 37 of file JetDeltaRValueMapProducer.cc.

References JetDeltaRValueMapProducer< T, C, TN >::evaluationMap_, mps_fire::i, JetDeltaRValueMapProducer< T, C, TN >::lazyParser_, JetDeltaRValueMapProducer< T, C, TN >::multiValue_, JetDeltaRValueMapProducer< T, C, TN >::value_, JetDeltaRValueMapProducer< T, C, TN >::valueLabels_, and JetDeltaRValueMapProducer< T, C, TN >::values_.

       : srcToken_(consumes<typename edm::View<T> >(params.getParameter<edm::InputTag>("src"))),
         matchedToken_(consumes<typename edm::View<C> >(params.getParameter<edm::InputTag>("matched"))),
         distMax_(params.getParameter<double>("distMax")),
         value_(params.existsAs<std::string>("value") ? params.getParameter<std::string>("value") : ""),
         values_(params.existsAs<std::vector<std::string> >("values")
                     ? params.getParameter<std::vector<std::string> >("values")
                     : std::vector<std::string>()),
         valueLabels_(params.existsAs<std::vector<std::string> >("valueLabels")
                          ? params.getParameter<std::vector<std::string> >("valueLabels")
                          : std::vector<std::string>()),
         lazyParser_(params.existsAs<bool>("lazyParser") ? params.getParameter<bool>("lazyParser") : false),
         multiValue_(false) {
     if (!value_.empty()) {
       if (value_ != "index") {
         evaluationMap_.insert(std::make_pair(
             value_, std::unique_ptr<StringObjectFunction<C> >(new StringObjectFunction<C>(value_, lazyParser_))));
       }
       produces<JetValueMap>();
     }
 
     if (!valueLabels_.empty() || !values_.empty()) {
       if (valueLabels_.size() == values_.size()) {
         multiValue_ = true;
         for (size_t i = 0; i < valueLabels_.size(); ++i) {
           evaluationMap_.insert(std::make_pair(
               valueLabels_[i],
               std::unique_ptr<StringObjectFunction<C> >(new StringObjectFunction<C>(values_[i], lazyParser_))));
           produces<JetValueMap>(valueLabels_[i]);
         }
       } else
         edm::LogWarning("ValueLabelMismatch")
             << "The number of value labels does not match the number of values. Values will not be evaluated.";
     }
   }

◆ ~JetDeltaRValueMapProducer()

template<class T , class C = T, typename TN = float>

JetDeltaRValueMapProducer< T, C, TN >::~JetDeltaRValueMapProducer ( )

inlineoverride

Definition at line 73 of file JetDeltaRValueMapProducer.cc.

73 {}

Member Function Documentation

◆ produce()

template<class T , class C = T, typename TN = float>

void JetDeltaRValueMapProducer< T, C, TN >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

inlineoverrideprivate

Definition at line 76 of file JetDeltaRValueMapProducer.cc.

References reco::deltaR2(), JetDeltaRValueMapProducer< T, C, TN >::distMax_, JetDeltaRValueMapProducer< T, C, TN >::evaluationMap_, trigObjTnPSource_cfi::filler, mps_fire::i, iEvent, JetDeltaRValueMapProducer< T, C, TN >::matchedToken_, eostools::move(), JetDeltaRValueMapProducer< T, C, TN >::multiValue_, JetDeltaRValueMapProducer< T, C, TN >::srcToken_, JetDeltaRValueMapProducer< T, C, TN >::value_, JetDeltaRValueMapProducer< T, C, TN >::valueLabels_, and contentValuesCheck::values.

                                                                        {
     edm::Handle<typename edm::View<T> > h_jets1;
     iEvent.getByToken(srcToken_, h_jets1);
     edm::Handle<typename edm::View<C> > h_jets2;
     iEvent.getByToken(matchedToken_, h_jets2);
 
     ValueVector values(h_jets1->size(), -99999);
 
     std::map<std::string, std::vector<float> > valuesMap;
     if (multiValue_) {
       for (size_t i = 0; i < valueLabels_.size(); ++i)
         valuesMap.insert(std::make_pair(valueLabels_[i], std::vector<float>(h_jets1->size(), -99999)));
     }
     std::vector<bool> jets1_locks(h_jets1->size(), false);
 
     for (typename edm::View<C>::const_iterator ibegin = h_jets2->begin(), iend = h_jets2->end(), ijet = ibegin;
          ijet != iend;
          ++ijet) {
       float matched_dR2 = 1e9;
       int matched_index = -1;
       int iindex = ijet - ibegin;
 
       for (typename edm::View<T>::const_iterator jbegin = h_jets1->begin(), jend = h_jets1->end(), jjet = jbegin;
            jjet != jend;
            ++jjet) {
         int jindex = jjet - jbegin;
 
         if (jets1_locks.at(jindex))
           continue;  // skip jets that have already been matched
 
         float temp_dR2 = reco::deltaR2(ijet->eta(), ijet->phi(), jjet->eta(), jjet->phi());
         if (temp_dR2 < matched_dR2) {
           matched_dR2 = temp_dR2;
           matched_index = jindex;
         }
       }  // end loop over src jets
 
       if (matched_index >= 0) {
         if (matched_dR2 > distMax_ * distMax_)
           edm::LogInfo("MatchedJetsFarApart") << "Matched jets separated by dR greater than distMax=" << distMax_;
         else {
           jets1_locks.at(matched_index) = true;
           if (!value_.empty()) {
             if (value_ == "index") {
               values.at(matched_index) = iindex;
             } else {
               values.at(matched_index) = (*(evaluationMap_.at(value_)))(*ijet);
             }
           }
           if (multiValue_) {
             for (size_t i = 0; i < valueLabels_.size(); ++i)
               valuesMap.at(valueLabels_[i]).at(matched_index) = (*(evaluationMap_.at(valueLabels_[i])))(*ijet);
           }
         }
       }
     }  // end loop over matched jets
 
     if (!value_.empty()) {
       std::unique_ptr<JetValueMap> jetValueMap(new JetValueMap());
 
       typename JetValueMap::Filler filler(*jetValueMap);
       filler.insert(h_jets1, values.begin(), values.end());
       filler.fill();
 
       // put in Event
       iEvent.put(std::move(jetValueMap));
     }
     if (multiValue_) {
       for (size_t i = 0; i < valueLabels_.size(); ++i) {
         std::unique_ptr<JetValueMap> jetValueMap(new JetValueMap());
 
         typename JetValueMap::Filler filler(*jetValueMap);
         filler.insert(h_jets1, valuesMap.at(valueLabels_[i]).begin(), valuesMap.at(valueLabels_[i]).end());
         filler.fill();
 
         // put in Event
         iEvent.put(std::move(jetValueMap), valueLabels_[i]);
       }
     }
   }