met Namespace Reference

Namespaces
	jetTrkAffSyst
	softCaloAffSyst
	softTrkAffSyst

Classes
class	METAssociationTool
class	METAssociator
class	METAssocTestAlg
class	METBuilderTool
class	METCaloRegionsTool
class	METEgammaAssociator
class	METElectronAssociator
class	METJetAssocTool
class	METJetTool
class	METMaker
class	METMakerAlg
class	METMuonAssociator
class	METPhotonAssociator
class	METReaderAlg
class	METRecoAlg
class	METRecoTool
class	METRefinerTool
class	METRegionsTool
class	METSignificance
class	METSoftAssociator
class	METSoftTermsTool
class	METSystematicsTool
class	METTauAssociator
class	METTrackFilterTool
class	METTruthAssociator
class	METTruthTool
struct	missingEt

Typedefs
typedef ElementLink< xAOD::IParticleContainer >	obj_link_t
using	iplink_t = ElementLink< xAOD::IParticleContainer >

Enumerations
enum	SoftTermParams { Random = 0, PthardParam = 1, TSTParam = 2 }
enum	METSignificanceResoTerms {   ResoNone = 0, ResoJet = 1, ResoSoft = 2, ResoEle = 3,   ResoMuo = 4, ResoPho = 5, ResoTau = 6 }
enum	SystType { INVALID =-1, SOFTCALO, SOFTTRK, JETTRK }
enum	SWClusterMatchMethod { DeltaR, ClusterLink }
enum	SystApplied {   NONE, MET_SOFTTRK_SCALEUP, MET_SOFTTRK_SCALEDOWN, MET_SOFTTRK_RESOPARA,   MET_SOFTTRK_RESOPERP, MET_SOFTTRK_RESOCORR, MET_SOFTCALO_SCALEUP, MET_SOFTCALO_SCALEDOWN,   MET_SOFTCALO_RESO, MET_JETTRK_SCALEUP, MET_JETTRK_SCALEDOWN }

Functions
SystType	getSystType (const CP::SystematicVariation &systematic)
void	addGhostMuonsToJets (const xAOD::MuonContainer &muons, xAOD::JetContainer &jets)
StatusCode	buildMETSum (const std::string &totalName, xAOD::MissingETContainer *metCont)
StatusCode	buildMETSum (const std::string &totalName, xAOD::MissingETContainer *metCont, MissingETBase::Types::bitmask_t softTermsSource)
StatusCode	fillMET (xAOD::MissingET *&met, xAOD::MissingETContainer *metCont, const std::string &metKey, const MissingETBase::Types::bitmask_t metSource)

Typedef Documentation

iplink_t

typedef ElementLink< xAOD::IParticleContainer > met::iplink_t

Definition at line 63 of file METMaker.cxx.

obj_link_t

typedef ElementLink< xAOD::IParticleContainer > met::obj_link_t

Definition at line 38 of file METMaker.h.

Enumeration Type Documentation

METSignificanceResoTerms

enum met::METSignificanceResoTerms

Enumerator
ResoNone
ResoJet
ResoSoft
ResoEle
ResoMuo
ResoPho
ResoTau

Definition at line 31 of file IMETSignificance.h.

                               {
    ResoNone = 0,
        ResoJet  = 1,
    ResoSoft = 2,
        ResoEle  = 3,
        ResoMuo  = 4,
        ResoPho  = 5,
        ResoTau  = 6
  };

SoftTermParams

enum met::SoftTermParams

Enumerator
Random
PthardParam
TSTParam

Definition at line 26 of file IMETSignificance.h.

                     {
    Random      = 0,
        PthardParam = 1,
        TSTParam    = 2
  };

SWClusterMatchMethod

enum met::SWClusterMatchMethod

Enumerator
DeltaR
ClusterLink

Definition at line 10 of file METRecoCommon.h.

                            {
    DeltaR,
    ClusterLink
  };

SystApplied

enum met::SystApplied

Enumerator
NONE
MET_SOFTTRK_SCALEUP
MET_SOFTTRK_SCALEDOWN
MET_SOFTTRK_RESOPARA
MET_SOFTTRK_RESOPERP
MET_SOFTTRK_RESOCORR
MET_SOFTCALO_SCALEUP
MET_SOFTCALO_SCALEDOWN
MET_SOFTCALO_RESO
MET_JETTRK_SCALEUP
MET_JETTRK_SCALEDOWN

Definition at line 68 of file METSystematicsTool.h.

                   {
    NONE              ,
    MET_SOFTTRK_SCALEUP   ,
    MET_SOFTTRK_SCALEDOWN ,
    MET_SOFTTRK_RESOPARA  ,
    MET_SOFTTRK_RESOPERP  ,
    MET_SOFTTRK_RESOCORR  ,
    MET_SOFTCALO_SCALEUP  ,
    MET_SOFTCALO_SCALEDOWN,
    MET_SOFTCALO_RESO     ,
    MET_JETTRK_SCALEUP    ,
    MET_JETTRK_SCALEDOWN
  };

SystType

enum met::SystType

Enumerator
INVALID
SOFTCALO
SOFTTRK
JETTRK

Definition at line 46 of file IMETSystematicsTool.h.

                {
    INVALID=-1,
    SOFTCALO,
    SOFTTRK,
    JETTRK
  };

Function Documentation

addGhostMuonsToJets()

void met::addGhostMuonsToJets	(	const xAOD::MuonContainer &	muons,
		xAOD::JetContainer &	jets
	)

Definition at line 34 of file METHelpers.cxx.

  {
    std::vector<const xAOD::TrackParticle*> jet_tracks;
    for (xAOD::Jet* jet: jets) {
      // Fill this with muons to be associated
      std::vector<const xAOD::Muon*> muons_in_jet;
      // Get the tracks associated to the jet 
      jet_tracks.clear(); 
      if ( jet->getAssociatedObjects("GhostTrack", jet_tracks) ) {
 
        for(const auto *const muon : muons) {
          const xAOD::TrackParticle* idtrack = muon->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
          if(!idtrack) continue;
          // check if this is ghost associated to a jet
          // make sure the jet is close first
          if(xAOD::P4Helpers::deltaR2(*jet,*muon)>0.36) continue;
 
          for(unsigned jtrk=0; jtrk<jet_tracks.size(); ++jtrk) {
            // check if the track pointers match
            if(jet_tracks.at(jtrk)==idtrack) {
              muons_in_jet.push_back(muon);
              break; 
            }
          } // loop over jet tracks
        } // loop over muons
      } // jet has associated tracks
      jet->setAssociatedObjects( "GhostMuon", muons_in_jet) ;
    } // loop over jets
  }

buildMETSum() [1/2]

StatusCode met::buildMETSum	(	const std::string &	totalName,
		xAOD::MissingETContainer *	metCont
	)

Definition at line 64 of file METHelpers.cxx.

  {
    using namespace msgMET;
    ANA_MSG_DEBUG("Build MET total: " << totalName);
 
    xAOD::MissingET* metFinal = nullptr;
    if(fillMET(metFinal, metCont, totalName, MissingETBase::Source::total()) != StatusCode::SUCCESS){
      ANA_MSG_ERROR("failed to fill MET term");
      return StatusCode::FAILURE;
    }
 
    for(xAOD::MissingETContainer::const_iterator iMET=metCont->begin(); iMET!=metCont->end(); ++iMET) {
      if(*iMET==metFinal) continue;
      *metFinal += **iMET;
    }
 
    ANA_MSG_DEBUG( "Rebuilt MET Final --"
                  << " mpx: " << metFinal->mpx()
                  << " mpy: " << metFinal->mpy()
                 );
 
    return StatusCode::SUCCESS;
  }

buildMETSum() [2/2]

StatusCode met::buildMETSum	(	const std::string &	totalName,
		xAOD::MissingETContainer *	metCont,
		MissingETBase::Types::bitmask_t	softTermsSource
	)

Definition at line 89 of file METHelpers.cxx.

  {
    using namespace msgMET;
    ANA_MSG_DEBUG("Build MET total: " << totalName);
 
    xAOD::MissingET* metFinal = nullptr;
    if( fillMET(metFinal, metCont, totalName, MissingETBase::Source::total()) != StatusCode::SUCCESS) {
      ANA_MSG_ERROR("failed to fill MET term \"" << totalName << "\"");
      return StatusCode::FAILURE;
    }
 
    // not using a reference, because the iterator doesn't return a reference
    for(const auto met : *metCont) {
      if(MissingETBase::Source::isTotalTerm(met->source())) continue;
      if(met->source()==invisSource) continue;
      if(softTermsSource && MissingETBase::Source::isSoftTerm(met->source())) {
        if(!MissingETBase::Source::hasPattern(met->source(),softTermsSource)) continue;
      }
      ANA_MSG_VERBOSE("Add MET term " << met->name() );
      *metFinal += *met;
    }
 
    ANA_MSG_DEBUG( "Rebuilt MET Final --"
                  << " mpx: " << metFinal->mpx()
                  << " mpy: " << metFinal->mpy()
                  );
 
    return StatusCode::SUCCESS;
  }

fillMET()

StatusCode met::fillMET	(	xAOD::MissingET *&	met,
		xAOD::MissingETContainer *	metCont,
		const std::string &	metKey,
		const MissingETBase::Types::bitmask_t	metSource
	)

Definition at line 123 of file METHelpers.cxx.

                                                                  {
    using namespace msgMET;
    if(met != nullptr){
      ANA_MSG_ERROR("You can't fill a filled MET value");
      return StatusCode::FAILURE;
    }
    if(metCont->find(metKey)!=metCont->end()){
      ANA_MSG_ERROR("Attempted to add a duplicate MET term: " << metKey);
      return StatusCode::FAILURE;
    }
    
    met = new xAOD::MissingET();
    metCont->push_back(met);
 
    met->setName  (metKey);
    met->setSource(metSource);
 
    return StatusCode::SUCCESS;
  }

getSystType()

SystType met::getSystType ( const CP::SystematicVariation &  systematic )

inline

Definition at line 53 of file IMETSystematicsTool.h.

  {
    if(systematic == met::softCaloAffSyst::MET_SoftCalo_ScaleUp ||
       systematic == met::softCaloAffSyst::MET_SoftCalo_ScaleDown ||
       systematic == met::softCaloAffSyst::MET_SoftCalo_Reso ) return SOFTCALO;
    if(systematic == met::softTrkAffSyst::MET_SoftTrk_ScaleUp ||
       systematic == met::softTrkAffSyst::MET_SoftTrk_ScaleDown ||
       systematic == met::softTrkAffSyst::MET_SoftTrk_ResoPara ||
       systematic == met::softTrkAffSyst::MET_SoftTrk_ResoPerp ) return SOFTTRK;
    if(systematic == met::jetTrkAffSyst::MET_JetTrk_ScaleUp ||
       systematic == met::jetTrkAffSyst::MET_JetTrk_ScaleDown ) return JETTRK;
    return INVALID;
  }