#include <HLTRHemisphere.h>

Inheritance diagram for HLTRHemisphere:

Public Member Functions
virtual bool	filter (edm::Event &, const edm::EventSetup &)

	HLTRHemisphere (const edm::ParameterSet &)

	~HLTRHemisphere ()

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

Public Member Functions inherited from edm::stream::EDFilterBase
	EDFilterBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDFilterBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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

Static Public Member Functions inherited from edm::stream::EDFilterBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	ComputeHemispheres (std::unique_ptr< std::vector< math::XYZTLorentzVector > > &hlist, const std::vector< math::XYZTLorentzVector > &JETS, std::vector< math::XYZTLorentzVector > *extraJets=0)

Private Attributes
bool	accNJJets_

bool	doMuonCorrection_

edm::InputTag	inputTag_

edm::EDGetTokenT< edm::View< reco::Jet > >	m_theJetToken

edm::EDGetTokenT< std::vector< reco::RecoChargedCandidate > >	m_theMuonToken

double	max_Eta_

int	max_NJ_

double	min_Jet_Pt_

double	muonEta_

edm::InputTag	muonTag_

Additional Inherited Members
Public Types inherited from edm::stream::EDFilter<>
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 Types inherited from edm::stream::EDFilterBase
typedef EDFilterAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 28 of file HLTRHemisphere.h.

Constructor & Destructor Documentation

HLTRHemisphere::HLTRHemisphere ( const edm::ParameterSet & iConfig )

explicit

Definition at line 29 of file HLTRHemisphere.cc.

References accNJJets_, edm::InputTag::encode(), inputTag_, LogDebug, m_theJetToken, m_theMuonToken, max_Eta_, max_NJ_, min_Jet_Pt_, muonTag_, and ~HLTRHemisphere().

                                                              :
   inputTag_    (iConfig.getParameter<edm::InputTag>("inputTag")),
   muonTag_    (iConfig.getParameter<edm::InputTag>("muonTag")),
   doMuonCorrection_(iConfig.getParameter<bool>         ("doMuonCorrection" )),
   muonEta_     (iConfig.getParameter<double>       ("maxMuonEta" )),
   min_Jet_Pt_  (iConfig.getParameter<double>       ("minJetPt" )),
   max_Eta_     (iConfig.getParameter<double>       ("maxEta" )),
   max_NJ_      (iConfig.getParameter<int>          ("maxNJ" )),
   accNJJets_   (iConfig.getParameter<bool>         ("acceptNJ" ))
 {
    LogDebug("") << "Input/minJetPt/maxEta/maxNJ/acceptNJ : "
         << inputTag_.encode() << " "
         << min_Jet_Pt_ << "/"
         << max_Eta_ << "/"
         << max_NJ_ << "/"
         << accNJJets_ << ".";
 
    m_theJetToken = consumes<edm::View<reco::Jet>>(inputTag_);
    m_theMuonToken = consumes<std::vector<reco::RecoChargedCandidate>>(muonTag_);
    //register your products
    produces<std::vector<math::XYZTLorentzVector> >();
 }

HLTRHemisphere::~HLTRHemisphere ( )

default

Referenced by HLTRHemisphere().

Member Function Documentation

void HLTRHemisphere::ComputeHemispheres	(	std::unique_ptr< std::vector< math::XYZTLorentzVector > > &	hlist,
		const std::vector< math::XYZTLorentzVector > &	JETS,
		std::vector< math::XYZTLorentzVector > *	extraJets = `0`
	)

private

Definition at line 157 of file HLTRHemisphere.cc.

References KineDebug3::count(), DEFINE_FWK_MODULE, mps_fire::i, and funct::pow().

Referenced by filter().

                                                                {
   using namespace math;
   using namespace reco;
   XYZTLorentzVector j1R(0.1, 0., 0., 0.1);
   XYZTLorentzVector j2R(0.1, 0., 0., 0.1);
   int nJets = JETS.size();
   if(extraJets) nJets+=extraJets->size();
 
   if(nJets<2){ // put empty hemispheres if not enough jets
     hlist->push_back(j1R);
     hlist->push_back(j2R);
     return;
   }
   unsigned int N_comb = pow(2,nJets); // compute the number of combinations of jets possible
   //Make the hemispheres
   double M_minR = 9999999999.0;
   unsigned int j_count;
   for (unsigned int i = 0; i < N_comb; i++) {       
     XYZTLorentzVector j_temp1, j_temp2;
     unsigned int itemp = i;
     j_count = N_comb/2;
     unsigned int count = 0;
     while (j_count > 0) {
       if (itemp/j_count == 1){
     if(count<JETS.size()) j_temp1 += JETS.at(count);
     else j_temp1 +=extraJets->at(count-JETS.size());
       } else {
     if(count<JETS.size()) j_temp2 += JETS.at(count);
     else j_temp2 +=extraJets->at(count-JETS.size());
       }
       itemp -= j_count * (itemp/j_count);
       j_count /= 2;
       count++;
     }
     double M_temp = j_temp1.M2() + j_temp2.M2();
     if (M_temp < M_minR) {
       M_minR = M_temp;
       j1R = j_temp1; 
       j2R = j_temp2; 
     }
   }
 
   hlist->push_back(j1R);
   hlist->push_back(j2R);
   return;
 }

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

static

Definition at line 55 of file HLTRHemisphere.cc.

References edm::ConfigurationDescriptions::add(), and edm::ParameterSetDescription::add().

                                                                            {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("inputTag",edm::InputTag("hltMCJetCorJetIcone5HF07"));
   desc.add<edm::InputTag>("muonTag",edm::InputTag(""));
   desc.add<bool>("doMuonCorrection",false);
   desc.add<double>("maxMuonEta",2.1);
   desc.add<double>("minJetPt",30.0);
   desc.add<double>("maxEta",3.0);
   desc.add<int>("maxNJ",7);
   desc.add<bool>("acceptNJ",true);
   descriptions.add("hltRHemisphere",desc);
 }

bool HLTRHemisphere::filter	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

virtual

Definition at line 74 of file HLTRHemisphere.cc.

References funct::abs(), accNJJets_, ComputeHemispheres(), doMuonCorrection_, edm::Event::getByToken(), mps_fire::i, diffTreeTool::index, fwrapper::jets, m_theJetToken, m_theMuonToken, max_Eta_, max_NJ_, min_Jet_Pt_, eostools::move(), muonEta_, electronCleaner_cfi::muons, gen::n, reco::LeafCandidate::p4(), and edm::Event::put().

 {
    using namespace std;
    using namespace edm;
    using namespace reco;
    using namespace math;
    using namespace trigger;
    
    typedef XYZTLorentzVector LorentzVector;
 
    // get hold of collection of objects
    //   Handle<CaloJetCollection> jets;
    Handle<View<Jet> > jets;
    iEvent.getByToken (m_theJetToken,jets);
 
    // get hold of the muons, if necessary
    Handle<vector<reco::RecoChargedCandidate> > muons;
    if(doMuonCorrection_) iEvent.getByToken( m_theMuonToken,muons );
 
    // The output Collection
    std::unique_ptr<vector<math::XYZTLorentzVector> > Hemispheres(new vector<math::XYZTLorentzVector> );
 
    // look at all objects, check cuts and add to filter object
    int n(0);
    vector<math::XYZTLorentzVector> JETS;
    for (auto const & i : *jets) {
      if(std::abs(i.eta()) < max_Eta_ && i.pt() >= min_Jet_Pt_){
        JETS.push_back(i.p4());
        n++;
      }
    }
 
   if(n>max_NJ_ && max_NJ_!=-1){
     iEvent.put(std::move(Hemispheres));
     return accNJJets_; // too many jets, accept for timing
   }
 
   if(doMuonCorrection_){
     const int nMu = 2;
     int muonIndex[nMu] = { -1, -1 };
     std::vector<reco::RecoChargedCandidate>::const_iterator muonIt;
     int index   = 0;
     int nPassMu = 0;
     for(muonIt = muons->begin(); muonIt!=muons->end(); muonIt++,index++){ 
       if(std::abs(muonIt->eta()) > muonEta_ || muonIt->pt() < min_Jet_Pt_) continue; // skip muons out of eta range or too low pT
       if(nPassMu >= 2){ // if we have already accepted two muons, accept the event
     iEvent.put(std::move(Hemispheres)); // too many muons, accept for timing      
     return true;
       }
       muonIndex[nPassMu++] = index;    
     }
     //muons as MET
     this->ComputeHemispheres(Hemispheres,JETS);
     //lead muon as jet
     if(nPassMu>0){
       std::vector<math::XYZTLorentzVector> muonJets;
       reco::RecoChargedCandidate leadMu = muons->at(muonIndex[0]);
       muonJets.push_back(leadMu.p4());
       Hemispheres->push_back(leadMu.p4());
       this->ComputeHemispheres(Hemispheres,JETS,&muonJets); // lead muon as jet
       if(nPassMu>1){ // two passing muons
     muonJets.pop_back();
     reco::RecoChargedCandidate secondMu = muons->at(muonIndex[1]);
     muonJets.push_back(secondMu.p4());
     Hemispheres->push_back(secondMu.p4());
     this->ComputeHemispheres(Hemispheres,JETS,&muonJets); // lead muon as v, second muon as jet
     muonJets.push_back(leadMu.p4());
     this->ComputeHemispheres(Hemispheres,JETS,&muonJets); // both muon as jets
       }
     }
   }else{ // do MuonCorrection==false
     if(n<2) return false; // not enough jets and not adding in muons
     this->ComputeHemispheres(Hemispheres,JETS); // don't do the muon isolation, just run once and done
   }
   //Format: 
   // 0 muon: 2 hemispheres (2)
   // 1 muon: 2 hemisheress + leadMuP4 + 2 hemispheres (5)
   // 2 muon: 2 hemispheres + leadMuP4 + 2 hemispheres + 2ndMuP4 + 4 Hemispheres (10)
   iEvent.put(std::move(Hemispheres));
   return true;
 }