#include <TopDQMHelpers.h>

Public Member Functions
	Calculate_miniAOD (int maxNJets, double wMass)
	default constructor More...

double	massBTopQuark (const std::vector< pat::Jet > &jets, std::vector< double > VbtagWP, double btagWP_)
	calculate b-tagged t-quark mass estimate More...

double	massTopQuark (const std::vector< pat::Jet > &jets)
	calculate t-quark mass estimate More...

double	massWBoson (const std::vector< pat::Jet > &jets)
	calculate W boson mass estimate More...

double	tmassTopQuark (pat::Muon *lep, const pat::MET &met, const pat::Jet &b)
	calculate top quark transverse mass estimate More...

double	tmassTopQuark (pat::Electron *lep, const pat::MET &met, const pat::Jet &b)
	calculate top quark transverse mass estimate More...

double	tmassWBoson (pat::Muon *lep, const pat::MET &met, const pat::Jet &b)
	calculate W boson transverse mass estimate More...

double	tmassWBoson (pat::Electron *lep, const pat::MET &met, const pat::Jet &b)
	calculate W boson transverse mass estimate More...

	~Calculate_miniAOD ()
	default destructor More...

Private Member Functions
void	operator() (const std::vector< pat::Jet > &jets)

void	operator() (const pat::Jet &bJet, pat::Electron *lepton, const pat::MET &met)
	do the calculation of the transverse top and W masses More...

void	operator() (const pat::Jet &bJet, pat::Muon *lepton, const pat::MET &met)

void	operator2 (const std::vector< pat::Jet > &, std::vector< double >, double)
	do the calculation of the t-quark mass with one b-jet More...

Private Attributes
bool	failed_
	indicate failed associations More...

double	massBTopQuark_
	cache of b-tagged top quark mass estimate More...

double	massTopQuark_
	cache of top quark mass estimate More...

double	massWBoson_
	cache of w boson mass estimate More...

int	maxNJets_
	max. number of jets to be considered More...

double	tmassTopQuark_
	cache of top quark transverse mass estimate More...

double	tmassWBoson_
	cache of W boson transverse mass estimate More...

double	wMass_
	paramater of the w boson mass More...

Detailed Description

Definition at line 71 of file TopDQMHelpers.h.

Constructor & Destructor Documentation

Calculate_miniAOD::Calculate_miniAOD	(	int	maxNJets,
		double	wMass
	)

default constructor

Definition at line 155 of file TopDQMHelpers.cc.

     : failed_(false),
       maxNJets_(maxNJets),
       wMass_(wMass),
       massWBoson_(-1.),
       massTopQuark_(-1.),
       massBTopQuark_(-1.),
       tmassWBoson_(-1),
       tmassTopQuark_(-1) {}

Calculate_miniAOD::~Calculate_miniAOD ( )

inline

default destructor

Definition at line 76 of file TopDQMHelpers.h.

76 {};

Member Function Documentation

double Calculate_miniAOD::massBTopQuark	(	const std::vector< pat::Jet > &	jets,
		std::vector< double >	VbtagWP,
		double	btagWP_
	)

calculate b-tagged t-quark mass estimate

Definition at line 177 of file TopDQMHelpers.cc.

References failed_, massBTopQuark_, and operator2().

Referenced by TopSingleLepton_miniAOD::MonitorEnsemble::fill().

                                                         {
   if (!failed_ && massBTopQuark_ < 0)
     operator2(jets, VbtagWP, btagWP_);
   return massBTopQuark_;
 }

double Calculate_miniAOD::massTopQuark ( const std::vector< pat::Jet > & jets )

calculate t-quark mass estimate

Definition at line 171 of file TopDQMHelpers.cc.

References failed_, massTopQuark_, and operator()().

Referenced by SingleTopTChannelLepton_miniAOD::MonitorEnsemble::fill(), and TopSingleLepton_miniAOD::MonitorEnsemble::fill().

                                                                     {
   if (!failed_ && massTopQuark_ < 0)
     operator()(jets);
   return massTopQuark_;
 }

double Calculate_miniAOD::massWBoson ( const std::vector< pat::Jet > & jets )

calculate W boson mass estimate

Definition at line 165 of file TopDQMHelpers.cc.

References failed_, massWBoson_, and operator()().

Referenced by SingleTopTChannelLepton_miniAOD::MonitorEnsemble::fill(), and TopSingleLepton_miniAOD::MonitorEnsemble::fill().

                                                                   {
   if (!failed_ && massWBoson_ < 0)
     operator()(jets);
   return massWBoson_;
 }

void Calculate_miniAOD::operator() ( const std::vector< pat::Jet > & jets )

private

do the calculation; this is called only once per event by the first function call to return a mass estimate. The once calculated values are cached afterwards

Definition at line 229 of file TopDQMHelpers.cc.

References failed_, ResonanceBuilder::mass, massTopQuark_, massWBoson_, maxNJets_, and wMass_.

Referenced by massTopQuark(), massWBoson(), tmassTopQuark(), and tmassWBoson().

                                                                 {
   if (maxNJets_ < 0)
     maxNJets_ = jets.size();
   failed_ = jets.size() < (unsigned int)maxNJets_;
   if (failed_) {
     return;
   }
 
   // associate those jets with maximum pt of the vectorial
   // sum to the hadronic decay chain
   double maxPt = -1.;
   std::vector<int> maxPtIndices;
   maxPtIndices.push_back(-1);
   maxPtIndices.push_back(-1);
   maxPtIndices.push_back(-1);
 
   for (int idx = 0; idx < maxNJets_; ++idx) {
     for (int jdx = idx + 1; jdx < maxNJets_; ++jdx) {
       //if (jdx <= idx) continue;
       for (int kdx = 0; kdx < maxNJets_; ++kdx) {
         if (kdx == idx || kdx == jdx)
           continue;
         reco::Particle::LorentzVector sum = jets[idx].p4() + jets[jdx].p4() + jets[kdx].p4();
         if (maxPt < 0. || maxPt < sum.pt()) {
           maxPt = sum.pt();
           maxPtIndices.clear();
           maxPtIndices.push_back(idx);
           maxPtIndices.push_back(jdx);
           maxPtIndices.push_back(kdx);
         }
       }
     }
   }
   massTopQuark_ = (jets[maxPtIndices[0]].p4() + jets[maxPtIndices[1]].p4() + jets[maxPtIndices[2]].p4()).mass();
 
   // associate those jets that get closest to the W mass
   // with their invariant mass to the W boson
   double wDist = -1.;
   std::vector<int> wMassIndices;
   wMassIndices.push_back(-1);
   wMassIndices.push_back(-1);
   for (unsigned idx = 0; idx < maxPtIndices.size(); ++idx) {
     for (unsigned jdx = 0; jdx < maxPtIndices.size(); ++jdx) {
       if (jdx == idx || maxPtIndices[idx] > maxPtIndices[jdx])
         continue;
       reco::Particle::LorentzVector sum = jets[maxPtIndices[idx]].p4() + jets[maxPtIndices[jdx]].p4();
       if (wDist < 0. || wDist > fabs(sum.mass() - wMass_)) {
         wDist = fabs(sum.mass() - wMass_);
         wMassIndices.clear();
         wMassIndices.push_back(maxPtIndices[idx]);
         wMassIndices.push_back(maxPtIndices[jdx]);
       }
     }
   }
   massWBoson_ = (jets[wMassIndices[0]].p4() + jets[wMassIndices[1]].p4()).mass();
 }

void Calculate_miniAOD::operator()	(	const pat::Jet &	bJet,
		pat::Electron *	lepton,
		const pat::MET &	met
	)

private

do the calculation of the transverse top and W masses

Definition at line 219 of file TopDQMHelpers.cc.

References reco::RecoCandidate::p4, reco::LeafCandidate::p4(), reco::GsfElectron::p4(), funct::pow(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), mathSSE::sqrt(), tmassTopQuark_, and tmassWBoson_.

                                                                                              {
   double metT = sqrt(pow(met.px(), 2) + pow(met.py(), 2));
   double lepT = sqrt(pow(lepton->px(), 2) + pow(lepton->py(), 2));
   double bT = sqrt(pow(bJet.px(), 2) + pow(bJet.py(), 2));
   reco::Particle::LorentzVector WT = lepton->p4() + met.p4();
   tmassWBoson_ = sqrt(pow(metT + lepT, 2) - (WT.px() * WT.px()) - (WT.py() * WT.py()));
   reco::Particle::LorentzVector topT = WT + bJet.p4();
   tmassTopQuark_ = sqrt(pow((metT + lepT + bT), 2) - (topT.px() * topT.px()) - (topT.py() * topT.py()));
 }

void Calculate_miniAOD::operator()	(	const pat::Jet &	bJet,
		pat::Muon *	lepton,
		const pat::MET &	met
	)

private

Definition at line 209 of file TopDQMHelpers.cc.

References reco::RecoCandidate::p4, reco::LeafCandidate::p4(), funct::pow(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), mathSSE::sqrt(), tmassTopQuark_, and tmassWBoson_.

                                                                                          {
   double metT = sqrt(pow(met.px(), 2) + pow(met.py(), 2));
   double lepT = sqrt(pow(lepton->px(), 2) + pow(lepton->py(), 2));
   double bT = sqrt(pow(bJet.px(), 2) + pow(bJet.py(), 2));
   reco::Particle::LorentzVector WT = lepton->p4() + met.p4();
   tmassWBoson_ = sqrt(pow(metT + lepT, 2) - (WT.px() * WT.px()) - (WT.py() * WT.py()));
   reco::Particle::LorentzVector topT = WT + bJet.p4();
   tmassTopQuark_ = sqrt(pow((metT + lepT + bT), 2) - (topT.px() * topT.px()) - (topT.py() * topT.py()));
 }

void Calculate_miniAOD::operator2	(	const std::vector< pat::Jet > &	jets,
		std::vector< double >	bjet,
		double	btagWP
	)

private

do the calculation of the t-quark mass with one b-jet

Definition at line 286 of file TopDQMHelpers.cc.

References failed_, ResonanceBuilder::mass, massBTopQuark_, and maxNJets_.

Referenced by massBTopQuark().

                                                                                                       {
   if (maxNJets_ < 0)
     maxNJets_ = jets.size();
   failed_ = jets.size() < (unsigned int)maxNJets_;
 
   if (failed_) {
     return;
   }
 
   if (jets.size() != bjet.size()) {
     return;
   }
 
   // associate those jets with maximum pt of the vectorial
   // sum to the hadronic decay chain. Require ONLY 1 btagged jet
   double maxBPt = -1.;
   std::vector<int> maxBPtIndices;
   maxBPtIndices.push_back(-1);
   maxBPtIndices.push_back(-1);
   maxBPtIndices.push_back(-1);
   for (int idx = 0; idx < maxNJets_; ++idx) {
     for (int jdx = idx + 1; jdx < maxNJets_; ++jdx) {
       //if (jdx <= idx) continue;
       for (int kdx = 0; kdx < maxNJets_; ++kdx) {
         if (kdx == idx || kdx == jdx)
           continue;
         // require only 1b-jet
         if ((bjet[idx] > btagWP && bjet[jdx] <= btagWP && bjet[kdx] <= btagWP) ||
             (bjet[idx] <= btagWP && bjet[jdx] > btagWP && bjet[kdx] <= btagWP) ||
             (bjet[idx] <= btagWP && bjet[jdx] <= btagWP && bjet[kdx] > btagWP)) {
           reco::Particle::LorentzVector sum = jets[idx].p4() + jets[jdx].p4() + jets[kdx].p4();
           if (maxBPt < 0. || maxBPt < sum.pt()) {
             maxBPt = sum.pt();
             maxBPtIndices.clear();
             maxBPtIndices.push_back(idx);
             maxBPtIndices.push_back(jdx);
             maxBPtIndices.push_back(kdx);
           }
         }
       }
     }
   }
   if (maxBPtIndices[0] < 0 || maxBPtIndices[1] < 0 || maxBPtIndices[2] < 0)
     return;
   massBTopQuark_ = (jets[maxBPtIndices[0]].p4() + jets[maxBPtIndices[1]].p4() + jets[maxBPtIndices[2]].p4()).mass();
 }

double Calculate_miniAOD::tmassTopQuark	(	pat::Muon *	lep,
		const pat::MET &	met,
		const pat::Jet &	b
	)

calculate top quark transverse mass estimate

Definition at line 203 of file TopDQMHelpers.cc.

References operator()(), and tmassTopQuark_.

Referenced by SingleTopTChannelLepton_miniAOD::MonitorEnsemble::fill().

                                                                                            {
   if (tmassTopQuark_ < 0)
     operator()(b, lepton, met);
   return tmassTopQuark_;
 }

double Calculate_miniAOD::tmassTopQuark	(	pat::Electron *	lep,
		const pat::MET &	met,
		const pat::Jet &	b
	)

calculate top quark transverse mass estimate

Definition at line 197 of file TopDQMHelpers.cc.

References operator()(), and tmassTopQuark_.

                                                                                                {
   if (tmassTopQuark_ < 0)
     operator()(b, lepton, met);
   return tmassTopQuark_;
 }

double Calculate_miniAOD::tmassWBoson	(	pat::Muon *	lep,
		const pat::MET &	met,
		const pat::Jet &	b
	)

calculate W boson transverse mass estimate

Definition at line 185 of file TopDQMHelpers.cc.

References operator()(), and tmassWBoson_.

Referenced by SingleTopTChannelLepton_miniAOD::MonitorEnsemble::fill().

                                                                                      {
   if (tmassWBoson_ < 0)
     operator()(b, mu, met);
   return tmassWBoson_;
 }

double Calculate_miniAOD::tmassWBoson	(	pat::Electron *	lep,
		const pat::MET &	met,
		const pat::Jet &	b
	)

calculate W boson transverse mass estimate

Definition at line 191 of file TopDQMHelpers.cc.

References operator()(), and tmassWBoson_.

                                                                                          {
   if (tmassWBoson_ < 0)
     operator()(b, mu, met);
   return tmassWBoson_;
 }