#include <RazorComputer.h>

Inheritance diagram for RazorComputer:

Public Member Functions
void	compute (const edm::Event &iEvent) const override

	RazorComputer (const CachingVariable::CachingVariableFactoryArg &arg, edm::ConsumesCollector &iC)

	~RazorComputer () override

Public Member Functions inherited from VariableComputer
void	assign (std::string var, double &value) const

void	declare (std::string var, edm::ConsumesCollector &iC)

void	doesNotCompute () const

void	doesNotCompute (std::string var) const

const std::string &	name () const

bool	notSeenThisEventAlready (const edm::Event &iEvent) const

	VariableComputer (const CachingVariable::CachingVariableFactoryArg &arg, edm::ConsumesCollector &iC)

virtual	~VariableComputer ()

Private Attributes
float	eta_

edm::InputTag	jet_

edm::EDGetTokenT< std::vector< pat::Jet > >	jetToken_

edm::InputTag	met_

edm::EDGetTokenT< std::vector< pat::MET > >	metToken_

float	pt_

Additional Inherited Members
Protected Attributes inherited from VariableComputer
const CachingVariable::CachingVariableFactoryArg &	arg_

edm::Event::CacheIdentifier_t	eventCacheID_ = 0

std::map< std::string, const ComputedVariable * >	iCompute_

std::string	method_

std::string	name_

std::string	separator_

Detailed Description

Definition at line 18 of file RazorComputer.h.

Constructor & Destructor Documentation

◆ RazorComputer()

RazorComputer::RazorComputer	(	const CachingVariable::CachingVariableFactoryArg &	arg,
		edm::ConsumesCollector &	iC
	)

Definition at line 9 of file RazorComputer.cc.

     : VariableComputer(arg, iC) {
   jet_ = edm::Service<InputTagDistributorService>()->retrieve("jet", arg.iConfig);
   met_ = edm::Service<InputTagDistributorService>()->retrieve("met", arg.iConfig);
   jetToken_ = iC.consumes<std::vector<pat::Jet>>(jet_);
   metToken_ = iC.consumes<std::vector<pat::MET>>(met_);
   pt_ = 40.;
   eta_ = 2.4;
  
   declare("MRT", iC);
   declare("MR", iC);
   declare("R2", iC);
   declare("R", iC);
 }

References edm::ConsumesCollector::consumes(), VariableComputer::declare(), eta_, jet_, jetToken_, met_, metToken_, and pt_.

◆ ~RazorComputer()

RazorComputer::~RazorComputer ( )

inlineoverride

Definition at line 21 of file RazorComputer.h.

21 {};

Member Function Documentation

◆ compute()

void RazorComputer::compute ( const edm::Event & iEvent ) const

overridevirtual

Implements VariableComputer.

Definition at line 47 of file RazorComputer.cc.

                                                         {
   //std::cout<<"getting into computation"<<std::endl;
  
   edm::Handle<std::vector<pat::Jet>> jetH;
   edm::Handle<std::vector<pat::MET>> metH;
   iEvent.getByToken(jetToken_, jetH);
   iEvent.getByToken(metToken_, metH);
  
   typedef reco::Candidate::LorentzVector LorentzVector;
  
   std::vector<LorentzVector> jets;
   jets.reserve(jetH.product()->size());
   for (std::vector<pat::Jet>::const_iterator jetit = jetH.product()->begin(); jetit != jetH.product()->end(); ++jetit) {
     if (jetit->et() > pt_ && fabs(jetit->eta()) < eta_) {
       jets.push_back(jetit->p4());
     }
   }
  
   reco::Candidate::LorentzVector HEM_1, HEM_2;
  
   HEM_1.SetPxPyPzE(0.0, 0.0, 0.0, 0.0);
   HEM_2.SetPxPyPzE(0.0, 0.0, 0.0, 0.0);
  
   if (jets.size() < 2) {
   } else {
     unsigned int N_comb = 1;
     for (unsigned int i = 0; i < jets.size(); i++) {
       N_comb *= 2;
     }
  
     double M_temp;
  
     double M_min = 9999999999.0;
     int j_count;
  
     for (unsigned int i = 1; i < N_comb - 1; i++) {
       LorentzVector j_temp1, j_temp2;
       int itemp = i;
       j_count = N_comb / 2;
       int count = 0;
       while (j_count > 0) {
         if (itemp / j_count == 1) {
           j_temp1 += jets[count];
         } else {
           j_temp2 += jets[count];
         }
         itemp -= j_count * (itemp / j_count);
         j_count /= 2;
         count++;
       }
  
       M_temp = j_temp1.M2() + j_temp2.M2();
  
       if (M_temp < M_min) {
         M_min = M_temp;
         HEM_1 = j_temp1;
         HEM_2 = j_temp2;
       }
     }
  
     if (HEM_2.Pt() > HEM_1.Pt()) {
       LorentzVector temp = HEM_1;
       HEM_1 = HEM_2;
       HEM_2 = temp;
     }
   }
  
   double mrt = razor::CalcMTR(HEM_1, HEM_2, metH.product()->at(0));
   double mr = razor::CalcMR(HEM_1, HEM_2);
  
   assign("MRT", mrt);
   assign("MR", mr);
   double r = -1, r2 = -1;
   if (mr != 0) {
     r = mrt / mr;
     r2 = r * r;
   }
   assign("R", r);
   assign("R2", r2);
  
   //std::cout<<"MR,R2 "<<mr<<" , "<<r2<<std::endl;
 }