#include <RazorComputer.h>

Inheritance diagram for RazorComputer:

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

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

	~RazorComputer ()

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	(	const CachingVariable::CachingVariableFactoryArg &	arg,
		edm::ConsumesCollector &	iC
	)

Definition at line 13 of file RazorComputer.cc.

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

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

RazorComputer::~RazorComputer ( )

inline

Definition at line 21 of file RazorComputer.h.

21 {};

Member Function Documentation

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

virtual

Implements VariableComputer.

Definition at line 53 of file RazorComputer.cc.

References VariableComputer::assign(), razor::CalcMR(), razor::CalcMTR(), KineDebug3::count(), eta_, edm::Event::getByToken(), i, fwrapper::jets, jetToken_, metToken_, edm::Handle< T >::product(), pt_, alignCSCRings::r, diffTwoXMLs::r2, and groupFilesInBlocks::temp.

                                                         {
   //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;
 }