#include <METCorrectionAlgorithm.h>

Classes
struct	type2BinningEntryType

Public Member Functions
CorrMETData	compMETCorrection (edm::Event &, const edm::EventSetup &)

	METCorrectionAlgorithm (const edm::ParameterSet &, edm::ConsumesCollector &&iConsumesCollector)

	~METCorrectionAlgorithm ()

Private Types
typedef std::vector < edm::InputTag >	vInputTag

typedef std::vector< std::string >	vstring

Private Attributes
bool	applyType0Corrections_

bool	applyType1Corrections_

bool	applyType2Corrections_

std::vector< edm::EDGetTokenT < CorrMETData > >	chsSumTokens_

double	type0Cuncl_

double	type0Rsoft_

std::vector< edm::EDGetTokenT < CorrMETData > >	type1Tokens_

std::vector < type2BinningEntryType * >	type2Binning_

Detailed Description

Algorithm for o propagating jet energy corrections to MET (Type 1 MET corrections) o calibrating momentum of particles not within jets ("unclustered energy") and propagating those corrections to MET (Type 2 MET corrections)

Authors: Michael Schmitt, Richard Cavanaugh, The University of Florida Florent Lacroix, University of Illinois at Chicago Christian Veelken, LLR Tai Sakuma, Texas A&M

Definition at line 32 of file METCorrectionAlgorithm.h.

Member Typedef Documentation

typedef std::vector<edm::InputTag> METCorrectionAlgorithm::vInputTag

private

Definition at line 43 of file METCorrectionAlgorithm.h.

typedef std::vector<std::string> METCorrectionAlgorithm::vstring

private

Definition at line 55 of file METCorrectionAlgorithm.h.

Constructor & Destructor Documentation

METCorrectionAlgorithm::METCorrectionAlgorithm	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &&	iConsumesCollector
	)

explicit

Definition at line 9 of file METCorrectionAlgorithm.cc.

References applyType0Corrections_, applyType1Corrections_, applyType2Corrections_, chsSumTokens_, data, edm::hlt::Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, type0Cuncl_, type0Rsoft_, type1Tokens_, and type2Binning_.

 {
   applyType1Corrections_ = cfg.getParameter<bool>("applyType1Corrections");
   if ( applyType1Corrections_ )
     {
       vInputTag srcType1Corrections = cfg.getParameter<vInputTag>("srcType1Corrections");
       for (vInputTag::const_iterator inputTag = srcType1Corrections.begin(); inputTag != srcType1Corrections.end(); ++inputTag)
     {
       type1Tokens_.push_back(iConsumesCollector.consumes<CorrMETData>(*inputTag));
     }
     }
   
   applyType2Corrections_ = cfg.getParameter<bool>("applyType2Corrections");
   if ( applyType2Corrections_ )
     {
       vInputTag srcUnclEnergySums = cfg.getParameter<vInputTag>("srcUnclEnergySums");
     
       if ( cfg.exists("type2Binning") ) 
     {
       typedef std::vector<edm::ParameterSet> vParameterSet;
       vParameterSet cfgType2Binning = cfg.getParameter<vParameterSet>("type2Binning");
       for ( vParameterSet::const_iterator cfgType2BinningEntry = cfgType2Binning.begin();
         cfgType2BinningEntry != cfgType2Binning.end(); ++cfgType2BinningEntry ) {
         type2Binning_.push_back(new type2BinningEntryType(*cfgType2BinningEntry, srcUnclEnergySums, iConsumesCollector));
       }
     }
       else
     {
       std::string type2CorrFormula = cfg.getParameter<std::string>("type2CorrFormula").data();
       edm::ParameterSet type2CorrParameter = cfg.getParameter<edm::ParameterSet>("type2CorrParameter");
       type2Binning_.push_back(new type2BinningEntryType(type2CorrFormula, type2CorrParameter, srcUnclEnergySums, iConsumesCollector));
     }
     }
 
   applyType0Corrections_ = cfg.exists("applyType0Corrections") ? cfg.getParameter<bool>("applyType0Corrections") : false;
   if ( applyType0Corrections_ )
     {
       vInputTag srcCHSSums = cfg.getParameter<vInputTag>("srcCHSSums");
       for (vInputTag::const_iterator inputTag = srcCHSSums.begin(); inputTag != srcCHSSums.end(); ++inputTag)
     {
       chsSumTokens_.push_back(iConsumesCollector.consumes<CorrMETData>(*inputTag));
     }
 
       type0Rsoft_ = cfg.getParameter<double>("type0Rsoft");
       type0Cuncl_ = 1.0;
       if (applyType2Corrections_)
     {
       if (cfg.exists("type2Binning")) throw cms::Exception("Invalid Arg") << "Currently, applyType0Corrections and type2Binning cannot be used together!";
       std::string type2CorrFormula = cfg.getParameter<std::string>("type2CorrFormula").data();
       if (!(type2CorrFormula == "A")) throw cms::Exception("Invalid Arg") << "type2CorrFormula must be \"A\" if applyType0Corrections!";
       edm::ParameterSet type2CorrParameter = cfg.getParameter<edm::ParameterSet>("type2CorrParameter");
       type0Cuncl_ = type2CorrParameter.getParameter<double>("A");
     }
     }
 }

METCorrectionAlgorithm::~METCorrectionAlgorithm ( )

Definition at line 65 of file METCorrectionAlgorithm.cc.

References type2Binning_.

 {
   for ( std::vector<type2BinningEntryType*>::const_iterator it = type2Binning_.begin();
     it != type2Binning_.end(); ++it ) {
     delete (*it);
   }
 }

Member Function Documentation

CorrMETData METCorrectionAlgorithm::compMETCorrection	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

Definition at line 73 of file METCorrectionAlgorithm.cc.

References applyType0Corrections_, applyType1Corrections_, applyType2Corrections_, chsSumTokens_, edm::Event::getByToken(), CorrMETData::mex, CorrMETData::mey, mathSSE::sqrt(), CorrMETData::sumet, type0Cuncl_, type0Rsoft_, type1Tokens_, and type2Binning_.

Referenced by CorrectedMETProducerT< T >::produce().

 {
   CorrMETData metCorr;
   metCorr.mex   = 0.;
   metCorr.mey   = 0.;
   metCorr.sumet = 0.;
 
   if ( applyType0Corrections_ ) {
 //--- sum all Type 0 MET correction terms
     edm::Handle<CorrMETData> chsSum;
     for (std::vector<edm::EDGetTokenT<CorrMETData> >::const_iterator corrToken = chsSumTokens_.begin(); corrToken != chsSumTokens_.end(); ++corrToken)
       {
     evt.getByToken(*corrToken, chsSum);
 
     metCorr.mex   += type0Cuncl_*(1 - type0Rsoft_)*chsSum->mex;
     metCorr.mey   += type0Cuncl_*(1 - type0Rsoft_)*chsSum->mey;
     metCorr.sumet += type0Cuncl_*(1 - type0Rsoft_)*chsSum->sumet;
       }
   }
 
   if ( applyType1Corrections_ ) {
 //--- sum all Type 1 MET correction terms
     edm::Handle<CorrMETData> type1Correction;
     for (std::vector<edm::EDGetTokenT<CorrMETData> >::const_iterator corrToken = type1Tokens_.begin(); corrToken != type1Tokens_.end(); ++corrToken)
       {
     evt.getByToken(*corrToken, type1Correction);
 
     metCorr.mex   += type1Correction->mex;
     metCorr.mey   += type1Correction->mey;
     metCorr.sumet += type1Correction->sumet;
       }
   }
 
   if ( applyType2Corrections_ )
     {
 //--- compute momentum sum of all "unclustered energy" in the event
 //
 //    NOTE: calibration factors/formulas for Type 2 MET correction may depend on eta
 //         (like the jet energy correction factors do)
 //
     
       for ( std::vector<type2BinningEntryType*>::const_iterator type2BinningEntry = type2Binning_.begin();
       type2BinningEntry != type2Binning_.end(); ++type2BinningEntry )
     {
       CorrMETData unclEnergySum;
       edm::Handle<CorrMETData> unclEnergySummand;
       for (std::vector<edm::EDGetTokenT<CorrMETData> >::const_iterator corrToken = (*type2BinningEntry)->corrTokens_.begin(); corrToken != (*type2BinningEntry)->corrTokens_.end(); ++corrToken)
         {
           evt.getByToken(*corrToken, unclEnergySummand);
     
           unclEnergySum.mex   += unclEnergySummand->mex;
           unclEnergySum.mey   += unclEnergySummand->mey;
           unclEnergySum.sumet += unclEnergySummand->sumet;
         }
 
 //--- calibrate "unclustered energy"
       double unclEnergySumPt = sqrt(unclEnergySum.mex*unclEnergySum.mex + unclEnergySum.mey*unclEnergySum.mey);
       double unclEnergyScaleFactor = (*type2BinningEntry)->binCorrFormula_->Eval(unclEnergySumPt);
 
 //--- MET balances momentum of reconstructed particles,
 //    hence correction to "unclustered energy" and corresponding Type 2 MET correction are of opposite sign
       metCorr.mex   -= (unclEnergyScaleFactor - 1.)*unclEnergySum.mex;
       metCorr.mey   -= (unclEnergyScaleFactor - 1.)*unclEnergySum.mey;
       metCorr.sumet += (unclEnergyScaleFactor - 1.)*unclEnergySum.sumet;
     }
     }
 
   return metCorr;
 }