Inheritance diagram for JetDeltaRValueMapProducer< T, C >:

Public Types
typedef edm::ValueMap< float >	JetValueMap

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>
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]);
       }
     }
   }