Inheritance diagram for JetDeltaRValueMapProducer< T, C >:

Public Types
typedef edm::ValueMap< float >	JetValueMap

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Member Functions
	JetDeltaRValueMapProducer (edm::ParameterSet const &params)

	~JetDeltaRValueMapProducer () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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>
class JetDeltaRValueMapProducer< T, C >

Definition at line 31 of file JetDeltaRValueMapProducer.cc.

Member Typedef Documentation

◆ JetValueMap

template<class T , class C = T>

typedef edm::ValueMap<float> JetDeltaRValueMapProducer< T, C >::JetValueMap

Definition at line 33 of file JetDeltaRValueMapProducer.cc.

Constructor & Destructor Documentation

◆ JetDeltaRValueMapProducer()

template<class T , class C = T>

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

inline

Definition at line 35 of file JetDeltaRValueMapProducer.cc.

       : 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()) {
       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.";
     }
   }

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

◆ ~JetDeltaRValueMapProducer()

template<class T , class C = T>

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

inlineoverride

Definition at line 69 of file JetDeltaRValueMapProducer.cc.

69 {}

Member Function Documentation

◆ produce()

template<class T , class C = T>

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

inlineoverrideprivate

Definition at line 72 of file JetDeltaRValueMapProducer.cc.

                                                                        {
     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);
  
     std::vector<float> 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;
  
       for (typename edm::View<T>::const_iterator jbegin = h_jets1->begin(), jend = h_jets1->end(), jjet = jbegin;
            jjet != jend;
            ++jjet) {
         int index = jjet - jbegin;
  
         if (jets1_locks.at(index))
           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 = index;
         }
       }  // 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())
             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());
  
       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());
  
         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]);
       }
     }
   }