met::METSignificance Class Reference

#include <METSignificance.h>

Inheritance diagram for met::METSignificance:

Collaboration diagram for met::METSignificance:

Public Member Functions
	METSignificance (const std::string &name)
	Constructor with parameters:
virtual	~METSignificance ()
	Destructor:
StatusCode	initialize ()
	Dummy implementation of the initialisation function.
StatusCode	finalize ()
StatusCode	varianceMET (xAOD::MissingETContainer *metCont, float avgmu, const std::string &jetTermName, const std::string &softTermName, const std::string &totalMETName)
StatusCode	RotateToPhi (float phi)
StatusCode	SetLambda (const float px, const float py, const bool GeV=true)
double	GetMETOverSqrtSumET () const
double	GetMETOverSqrtHT () const
double	GetSignificance () const
double	GetSigDirectional () const
double	GetRho () const
double	GetVarL () const
double	GetVarT () const
double	GetTermVarL (const int term) const
double	GetTermVarT (const int term) const
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
	METSignificance ()
	Default constructor:
StatusCode	AddMuon (const xAOD::IParticle *obj, float &pt_reso, float &phi_reso, float avgmu)
StatusCode	AddElectron (const xAOD::IParticle *obj, float &pt_reso, float &phi_reso, float avgmu)
StatusCode	AddPhoton (const xAOD::IParticle *obj, float &pt_reso, float &phi_reso)
StatusCode	AddJet (const xAOD::IParticle *obj, float &pt_reso, float &phi_reso, float &avgmu)
StatusCode	AddTau (const xAOD::IParticle *obj, float &pt_reso, float &phi_reso)
void	AddSoftTerm (const xAOD::MissingET *soft, const TVector3 &met_vect, double(&particle_sum)[2][2])
double	GetPUProb (double jet_eta, double jet_phi, double jet_pt, double jet_jvt, double jet_fjvt, float avgmu)
double	GetPhiUnc (double jet_eta, double jet_phi, double jet_pt)
std::tuple< double, double, double >	CovMatrixRotation (double var_x, double var_y, double cv_xy, double Phi)
double	Significance_LT (double Numerator, double var_parall, double var_perpen, double cov)
void	InvertMatrix (double(&mat)[2][2], double(&m)[2][2])
void	AddMatrix (double(&X)[2][2], double(&Y)[2][2], double(&mat_new)[2][2])
void	RotateXY (const double(&mat)[2][2], double(&mat_new)[2][2], double phi)
double	BiasPtSoftdir (const double PtSoft)
	Parameterization with PtSoft Direction //.
double	VarparPtSoftdir (const double PtSoft, const double SoftSumet)
double	Bias_PtSoftParall (const double PtSoft_Parall)
double	Var_Ptsoft (const double PtSoft)
void	AddResoMap (const double varL, const double varT, const double CvTV, const int term)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static unsigned int	getEtaBin (double jet_eta)

Private Attributes
ToolHandle< IJetCalibrationTool >	m_jetCalibTool {this, "jetCalibTool", "", "the IJetCalibrationTool we use"}
ToolHandle< CP::IMuonCalibrationAndSmearingTool >	m_muonCalibrationAndSmearingTool {this, "MuonCalibTool", "", "the IMuonCalibrationAndSmearingTool we use"}
ToolHandle< CP::IEgammaCalibrationAndSmearingTool >	m_egammaCalibTool {this, "egammaCalibTool", "", "the IEgammaCalibrationAndSmearingTool we use"}
ToolHandle< TauAnalysisTools::ITauResolutionTool >	m_tauResolutionTool {this, "tauResolutionTool", "", "the tau Resolution tool we use"}
Gaudi::Property< std::string >	m_jetCalibConfig {this, "JetCalibConfig", "", "Config file for jet calibration/resolution"}
Gaudi::Property< std::string >	m_jetCalibSeq {this, "JetCalibSequence", "", "Calibration sequence used for input jets"}
Gaudi::Property< std::string >	m_jetCalibArea {this, "JetCalibArea", "", "CalibArea for input jet calibration"}
Gaudi::Property< int >	m_muonCalibMode {this, "MuonCalibMode", -1, "CalibMode for muon momentum calibration"}
Gaudi::Property< std::string >	m_egESModel {this, "EgammaESModel", "", "ESModel for egamma calibration"}
Gaudi::Property< std::string >	m_egDecorrModel {this, "EgammaDecorrelationModel", "", "Decorrelation model for egamma calibration"}
Gaudi::Property< bool >	m_egUseFastsim {this, "EgammaUseFastsim", false, "Use fastsim resolutions for egamma?"}
Gaudi::Property< std::string >	m_tauTESConfig {this, "TauTESConfig", "tauRecTools/R22_preprod/CombinedTES_R22_Round2.5_v2.root", "Config file for tau energy scale calibration"}
double	m_GeV
bool	m_jetOK
bool	m_muonOK
bool	m_egammaOK
bool	m_tauOK
TVector3	m_met_vect
TVector3	m_soft_vect
TVector3	m_pthard_vect
TVector3	m_lamda_vect
int	m_softTermParam
double	m_softTermReso
bool	m_treatPUJets
bool	m_doPhiReso
bool	m_applyBias
bool	m_jerForEMu
bool	m_isDataJet
bool	m_isDataMuon
float	m_jetPtThr
float	m_jetEtaThr
double	m_scalarBias
double	m_significance
double	m_rho
double	m_VarL
double	m_VarT
double	m_CvLT
double	m_met_VarL
double	m_met_VarT
double	m_met_CvLT
std::map< int, double >	m_term_VarL
std::map< int, double >	m_term_VarT
std::map< int, double >	m_term_CvLT
double	m_met
double	m_metx
double	m_mety
double	m_metphi
double	m_metsoft
double	m_metsoftphi
double	m_ht
double	m_sumet
TFile *	m_file
TH2F *	m_phi_reso_pt20
TH2F *	m_phi_reso_pt50
TH2F *	m_phi_reso_pt100
std::string	m_configPrefix
std::string	m_configJetPhiResoFile
std::string	m_JetResoAux
std::string	m_EMuResoAux
std::string	m_JetCollection
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 44 of file METSignificance.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

METSignificance() [1/2]

met::METSignificance::METSignificance

(

const std::string &

name

)

Constructor with parameters:

Definition at line 54 of file METSignificance.cxx.

                                                        :
    AsgTool(name),
    m_GeV(1.0e3),
    m_jetOK(true),
    m_muonOK(true),
    m_egammaOK(true),
    m_tauOK(true),
    m_softTermParam(met::Random),
    m_jerForEMu(false),
    m_jetPtThr(-1.0),
    m_jetEtaThr(-1.0),
    m_significance(0.0),
    m_rho(0.0),
    m_VarL(0.0),
    m_VarT(0.0),
    m_CvLT(0.0),
    m_met_VarL(0.0),
    m_met_VarT(0.0),
    m_met_CvLT(0.0),
    m_met(0.0),
    m_metx(0.0),
    m_mety(0.0),
    m_metphi(0.0),
    m_metsoft(0.0),
    m_metsoftphi(0.0),
    m_ht(0.0),
    m_sumet(0.0),
    m_file(nullptr),
    m_phi_reso_pt20(nullptr),
    m_phi_reso_pt50(nullptr),
    m_phi_reso_pt100(nullptr)
  {
    declareProperty("SoftTermParam",        m_softTermParam = met::Random );
    declareProperty("SoftTermReso",         m_softTermReso  = 8.5        );
    declareProperty("TreatPUJets",          m_treatPUJets   = true        );
    declareProperty("DoPhiReso",            m_doPhiReso     = false       );
    declareProperty("ApplyBias",            m_applyBias     = false       );
    declareProperty("DoJerForEMu",          m_jerForEMu     = false       ); // run jet resolution for all electrons and muons
    declareProperty("ScalarBias",           m_scalarBias    = 0.0         );
    declareProperty("JetPtThr",             m_jetPtThr      = -1.0        );
    declareProperty("JetEtaThr",            m_jetEtaThr     = -1.0        );
    declareProperty("ConfigPrefix",         m_configPrefix  = "METUtilities/data17_13TeV/metsig_Aug15/");
    declareProperty("ConfigJetPhiResoFile", m_configJetPhiResoFile  = "jet_unc.root" );
    declareProperty("JetResoAux",           m_JetResoAux            = ""  ); // relative pT resolution in addition to normal JES
    declareProperty("EMuResoAux",           m_EMuResoAux            = ""  ); // aux string sets a bool for the leptons to run the jet resolation
    declareProperty("JetCollection",        m_JetCollection         = "AntiKt4EMPFlow" );
 
    // properties to delete eventually
    declareProperty("IsDataJet",   m_isDataJet     = false   );
    declareProperty("IsDataMuon",  m_isDataMuon    = false   );
 
    m_file = nullptr;
  }

~METSignificance()

met::METSignificance::~METSignificance ( )

virtualdefault

Destructor:

METSignificance() [2/2]

met::METSignificance::METSignificance ( )

private

Default constructor:

Member Function Documentation

AddElectron()

StatusCode met::METSignificance::AddElectron ( const xAOD::IParticle * obj, float & pt_reso, float & phi_reso, float avgmu )

private

Definition at line 479 of file METSignificance.cxx.

                                                                                                               {
 
    if(!m_egammaOK){
      ATH_MSG_ERROR("MET Significance received an electron but was not configured for egamma!");
      return StatusCode::FAILURE;
    }
 
    bool DoEMuReso = false;
    if(obj->type()==xAOD::Type::TruthParticle){
      pt_reso=m_egammaCalibTool->resolution(obj->e(),obj->eta(),obj->eta(),PATCore::ParticleType::Electron);
      if(m_doPhiReso) phi_reso = obj->pt()*0.004;
    }
    else{
      const xAOD::Electron* ele(static_cast<const xAOD::Electron*>(obj));
      const auto cl_etaCalo = xAOD::get_eta_calo(*(ele->caloCluster()), ele->author());
      pt_reso=m_egammaCalibTool->resolution(ele->e(),ele->caloCluster()->eta(),cl_etaCalo,PATCore::ParticleType::Electron);
      if(m_doPhiReso) phi_reso = ele->pt()*0.004;
      ATH_MSG_VERBOSE("el: " << pt_reso << " " << ele->pt() << " " << ele->p4().Eta() << " " << ele->p4().Phi());
 
      // run the jet resolution for muons. for validation region extrapolation
      if(!m_EMuResoAux.empty()){
        SG::ConstAccessor<bool>  acc_EMReso(m_EMuResoAux);
        DoEMuReso = acc_EMReso.isAvailable(*ele) ? acc_EMReso(*ele) : false;
      }
    }
 
    if(m_jerForEMu || DoEMuReso){
      bool treatPUJets = m_treatPUJets;
      m_treatPUJets=false; //turn off pileup jet treatement for this electron
      ATH_CHECK(AddJet(obj, pt_reso, phi_reso, avgmu));
      m_treatPUJets = treatPUJets; // reset value
    }
    return StatusCode::SUCCESS;
  }

AddJet()

StatusCode met::METSignificance::AddJet ( const xAOD::IParticle * obj, float & pt_reso, float & phi_reso, float & avgmu )

private

Definition at line 536 of file METSignificance.cxx.

                                                                                                           {
 
    const xAOD::Jet* jet(static_cast<const xAOD::Jet*>(obj));
    double pt_reso_dbl_data=0.0, pt_reso_dbl_mc=0.0, pt_reso_dbl_max=0.0;
 
    // setting limits on jets if requested
    if(m_jetPtThr>0.0 && m_jetPtThr>jet->pt())          return StatusCode::SUCCESS;
    if(m_jetEtaThr>0.0 && m_jetEtaThr<std::abs(jet->eta())) return StatusCode::SUCCESS;
 
    if(!m_jetOK){
      ATH_MSG_ERROR("MET Significance received a jet but was not configured for jets!");
      return StatusCode::FAILURE;
    }
 
    ATH_CHECK(m_jetCalibTool->getNominalResolutionData(*jet, pt_reso_dbl_data));
    ATH_CHECK(m_jetCalibTool->getNominalResolutionMC(*jet, pt_reso_dbl_mc));
    pt_reso_dbl_max = std::max(pt_reso_dbl_data,pt_reso_dbl_mc);
    pt_reso = pt_reso_dbl_max;
 
    ATH_MSG_VERBOSE("jet: " << pt_reso  << " jetpT: " << jet->pt() << " " << jet->p4().Eta() << " " << jet->p4().Phi());
 
    // Add extra uncertainty for PU jets based on JVT
    if(m_treatPUJets){
      double jet_pu_unc  = 0.;
      if(acc_fjvt.isAvailable(*jet))
        jet_pu_unc = GetPUProb(jet->eta(), jet->phi(),jet->pt()/m_GeV, acc_jvt(*jet), acc_fjvt(*jet), avgmu);
      else if(acc_fjvt_der.isAvailable(*jet))
        jet_pu_unc = GetPUProb(jet->eta(), jet->phi(),jet->pt()/m_GeV, acc_jvt(*jet), acc_fjvt_der(*jet), avgmu);
      else{
        ATH_MSG_ERROR("No fJVT decoration available - must have treat pileup jets set to off or provide fJVT!");
        return StatusCode::FAILURE;
      }
      pt_reso = std::sqrt(jet_pu_unc*jet_pu_unc + pt_reso*pt_reso);
      ATH_MSG_VERBOSE("jet_pu_unc: " << jet_pu_unc);
    }
 
    // Use the phi resolution of the jets
    // needs to be finished
    if(m_doPhiReso){
      double jet_phi_unc = std::abs(GetPhiUnc(jet->eta(), jet->phi(),jet->pt()/m_GeV));
      phi_reso = jet->pt()*jet_phi_unc;
    }
 
    // Add user defined additional resolutions. For example, b-tagged jets
    if(!m_JetResoAux.empty()){
      SG::ConstAccessor<float> acc_extra(m_JetResoAux);
      if(acc_extra.isAvailable(*jet)){
        float extra_relative_pt_reso = acc_extra(*jet);
        pt_reso = std::sqrt(pt_reso*pt_reso + extra_relative_pt_reso*extra_relative_pt_reso);
      }
    }
 
    return StatusCode::SUCCESS;
  }

AddMatrix()

void met::METSignificance::AddMatrix ( double(&) X[2][2], double(&) Y[2][2], double(&) mat_new[2][2] )

private

Definition at line 1016 of file METSignificance.cxx.

                                                                                             {
    mat_new[0][0]=X[0][0]+Y[0][0];
    mat_new[0][1]=X[0][1]+Y[0][1];
    mat_new[1][0]=X[1][0]+Y[1][0];
    mat_new[1][1]=X[1][1]+Y[1][1];
  }

AddMuon()

StatusCode met::METSignificance::AddMuon ( const xAOD::IParticle * obj, float & pt_reso, float & phi_reso, float avgmu )

private

Definition at line 427 of file METSignificance.cxx.

                                                                                                           {
 
    int dettype = 0;
    bool DoEMuReso = false;
    ATH_MSG_VERBOSE("Particle type: " << obj->type());
 
    if(obj->type()==xAOD::Type::TruthParticle){
      pt_reso =0.01;
      if(obj->pt()>0.5e6) pt_reso=0.03;
      if(obj->pt()>1.0e6) pt_reso=0.1;// this is just a rough estimate for the time being until the interface can handle truth muons
    }
    else{
      if(!m_muonOK){
        ATH_MSG_ERROR("MET Significance received a muon but was not configured for muons!");
        return StatusCode::FAILURE;
      }
      const xAOD::Muon* muon(static_cast<const xAOD::Muon*>(obj));
      if(muon->muonType()==xAOD::Muon::MuonType::Combined){
        dettype=3;//CB
      }
      else if(muon->muonType()==xAOD::Muon::MuonType::MuonStandAlone){
        dettype=1;//MS
      }
      else {//Segment, Calo, Silicon
        dettype=2;//ID
      }
 
      pt_reso=m_muonCalibrationAndSmearingTool->expectedResolution(dettype,*muon,!m_isDataMuon);
      if(m_doPhiReso) phi_reso = muon->pt()*0.001;
      // run the jet resolution for muons. for validation region extrapolation
      if(!m_EMuResoAux.empty()){
        SG::ConstAccessor<bool>  acc_EMReso(m_EMuResoAux);
        DoEMuReso = acc_EMReso.isAvailable(*muon) ? acc_EMReso(*muon) : false;
      }
      ATH_MSG_VERBOSE("muon: " << pt_reso << " dettype: " << dettype << " " << muon->pt() << " " << muon->p4().Eta() << " " << muon->p4().Phi());
    }// end reco setup
 
    // Common setup
    if(m_doPhiReso) phi_reso = obj->pt()*0.001;
    ATH_MSG_VERBOSE("muon: " << pt_reso << " dettype: " << dettype << " " << obj->pt() << " " << obj->p4().Eta() << " " << obj->p4().Phi());
 
    if(m_jerForEMu || DoEMuReso){
      bool treatPUJets = m_treatPUJets;
      m_treatPUJets=false; //turn off pileup jet treatement for this electron
      ATH_CHECK(AddJet(obj, pt_reso, phi_reso, avgmu));
      m_treatPUJets = treatPUJets; // reset value
    }
 
    return StatusCode::SUCCESS;
  }

AddPhoton()

StatusCode met::METSignificance::AddPhoton ( const xAOD::IParticle * obj, float & pt_reso, float & phi_reso )

private

Definition at line 515 of file METSignificance.cxx.

                                                                                                {
 
    if(!m_egammaOK){
      ATH_MSG_ERROR("MET Significance received a photon but was not configured for egamma!");
      return StatusCode::FAILURE;
    }
 
    if(obj->type()==xAOD::Type::TruthParticle){
      pt_reso=m_egammaCalibTool->resolution(obj->e(),obj->eta(),obj->eta(),PATCore::ParticleType::Electron); // leaving as an electron for the truth implementation rather than declaring a reco photon
      if(m_doPhiReso) phi_reso = obj->pt()*0.004;
    }
    else{
      const xAOD::Egamma* pho(static_cast<const xAOD::Egamma*>(obj));
      pt_reso=m_egammaCalibTool->getResolution(*pho);
      if(m_doPhiReso) phi_reso = pho->pt()*0.004;
      ATH_MSG_VERBOSE("pho: " << pt_reso << " " << pho->pt() << " " << pho->p4().Eta() << " " << pho->p4().Phi());
    }
    return StatusCode::SUCCESS;
  }

AddResoMap()

void met::METSignificance::AddResoMap ( const double varL, const double varT, const double CvTV, const int term )

private

Definition at line 1078 of file METSignificance.cxx.

                                                                                                         {
 
    m_term_VarL[term] += varL;
    m_term_VarT[term] += varT;
    m_term_CvLT[term] += CvLT;
 
  }

AddSoftTerm()

void met::METSignificance::AddSoftTerm ( const xAOD::MissingET * soft, const TVector3 & met_vect, double(&) particle_sum[2][2] )

private

Definition at line 618 of file METSignificance.cxx.

                                                                                                                    {
 
    if(m_softTermParam==met::Random){
 
      ATH_MSG_VERBOSE("Resolution Soft term set to 10GeV");
 
      m_soft_vect.SetXYZ(soft->mpx()/m_GeV, soft->mpy()/m_GeV, 0);
 
      double particle_u[2][2] = {{m_softTermReso*m_softTermReso,0.0},
                                 {0.0,m_softTermReso*m_softTermReso}};
      double particle_u_rot[2][2] = {{m_softTermReso*m_softTermReso,0.0},
                                     {0.0,m_softTermReso*m_softTermReso}};
 
      RotateXY(particle_u, particle_u_rot,met_vect.DeltaPhi(m_soft_vect));
      m_VarL+=particle_u_rot[0][0];
      m_VarT+=particle_u_rot[1][1];
      m_CvLT+=particle_u_rot[0][1];
 
      // Save the resolutions separated for each object type
      AddResoMap(particle_u_rot[0][0],
                 particle_u_rot[1][1],
                 particle_u_rot[0][1],
                 met::ResoSoft);
 
      RotateXY (particle_u,   particle_u_rot,-1.0*soft->phi()); // negative phi rotation
      AddMatrix(particle_sum, particle_u_rot,     particle_sum);
 
      ATH_MSG_VERBOSE("SOFT " << soft->name() <<" - pt_reso: " << m_softTermReso << " soft: " << soft->met() << " phi: " << soft->phi()
                   << " Var_L: " << particle_u_rot[0][0] << " Var_T: " << particle_u_rot[1][1]
                   << " " << particle_u_rot[0][1]);
    }
    else if (m_softTermParam==met::PthardParam){
 
      ATH_MSG_VERBOSE("Resolution Soft term parameterized in pthard direction");
 
      m_soft_vect.SetXYZ(soft->mpx()/m_GeV, soft->mpy()/m_GeV, 0);
 
      m_pthard_vect =  m_soft_vect - met_vect;
 
      double varTST = Var_Ptsoft(soft->met()/m_GeV);
 
      double particle_u[2][2] = {{varTST,0.0},
                                 {0.0,varTST}};
      double particle_u_rot[2][2] = {{varTST,0.0},
                                     {0.0,varTST}};
 
      RotateXY(particle_u, particle_u_rot,met_vect.DeltaPhi(m_pthard_vect));
      m_VarL+=particle_u_rot[0][0];
      m_VarT+=particle_u_rot[1][1];
      m_CvLT+=particle_u_rot[0][1];
 
      // Save the resolutions separated for each object type
      AddResoMap(particle_u_rot[0][0],
                 particle_u_rot[1][1],
                 particle_u_rot[0][1],
                 met::ResoSoft);
 
      RotateXY (particle_u,   particle_u_rot,-1.0*m_pthard_vect.Phi()); // negative phi rotation
      AddMatrix(particle_sum, particle_u_rot,     particle_sum);
 
    }
    else if (m_softTermParam==met::TSTParam){
 
      ATH_MSG_VERBOSE("Resolution Soft term parameterized in TST");
 
      m_soft_vect.SetXYZ(soft->mpx()/m_GeV, soft->mpy()/m_GeV, 0);
 
      double varTST = VarparPtSoftdir(soft->met()/m_GeV, soft->sumet()/m_GeV);
 
      double particle_u[2][2] = {{varTST,0.0},
                                 {0.0,varTST}};
      double particle_u_rot[2][2] = {{varTST,0.0},
                                     {0.0,varTST}};
 
      RotateXY(particle_u, particle_u_rot,met_vect.DeltaPhi(m_soft_vect));
      m_VarL+=particle_u_rot[0][0];
      m_VarT+=particle_u_rot[1][1];
      m_CvLT+=particle_u_rot[0][1];
 
      // Save the resolutions separated for each object type
      AddResoMap(particle_u_rot[0][0],
                 particle_u_rot[1][1],
                 particle_u_rot[0][1],
                 met::ResoSoft);
 
      RotateXY (particle_u,   particle_u_rot,-1.0*soft->phi()); // negative phi rotation
      AddMatrix(particle_sum, particle_u_rot,     particle_sum);
 
    }
    else{
      ATH_MSG_ERROR("Soft term parameterization is NOT defined for:" << m_softTermParam);
    }
 
  }

AddTau()

StatusCode met::METSignificance::AddTau ( const xAOD::IParticle * obj, float & pt_reso, float & phi_reso )

private

Definition at line 592 of file METSignificance.cxx.

                                                                                             {
 
    // tau objects
    if(obj->type()==xAOD::Type::TruthParticle){
      pt_reso= 0.1;
      if(m_doPhiReso) phi_reso = obj->pt()*0.01;
    }
    else{
      if(!m_tauOK){
        ATH_MSG_ERROR("MET Significance received a tau but was not configured for taus!");
        return StatusCode::FAILURE;
      }
      const xAOD::TauJet* tau(static_cast<const xAOD::TauJet*>(obj));
      if (auto *combp4 = dynamic_cast<TauAnalysisTools::TauResolutionTool*>(&*m_tauResolutionTool)) {
        pt_reso = combp4->getMvaEnergyResolution(*tau);
      }
 
      if(m_doPhiReso) phi_reso = tau->pt()*0.01;
      ATH_MSG_VERBOSE("tau: " << pt_reso << " " << tau->pt() << " " << tau->p4().Eta() << " " << tau->p4().Phi() << " phi reso: " << phi_reso);
    }
    return StatusCode::SUCCESS;
  }

Bias_PtSoftParall()

double met::METSignificance::Bias_PtSoftParall ( const double PtSoft_Parall )

private

Definition at line 1069 of file METSignificance.cxx.

  {
    if (-60.<=PtSoft_Parall && PtSoft_Parall<0.) return -8. -0.4*PtSoft_Parall;
    if (-60.>PtSoft_Parall) return -8. -0.4 * (-60.);
    if( PtSoft_Parall>=0. && PtSoft_Parall<60.) return -8. -PtSoft_Parall;
    if(PtSoft_Parall>60.) return -8. -60.;
    return 0.0;
  }

BiasPtSoftdir()

double met::METSignificance::BiasPtSoftdir ( const double PtSoft )

private

Parameterization with PtSoft Direction //.

Definition at line 1044 of file METSignificance.cxx.

                                                          {
    if (PtSoft<60.) return (0.145)+(-0.45)*PtSoft;
    else return (0.145)+(-0.45)*(60.);
  }

CovMatrixRotation()

std::tuple< double, double, double > met::METSignificance::CovMatrixRotation ( double var_x, double var_y, double cv_xy, double Phi )

private

Definition at line 973 of file METSignificance.cxx.

                                                                                                                       {
    // Covariance matrix parallel and transverse to the Phi direction
    Double_t V11 = std::pow(std::cos(Phi),2)*var_x + 2*std::sin(Phi)*std::cos(Phi)*cv_xy + std::pow(std::sin(Phi),2)*var_y;
    Double_t V22 = std::pow(std::sin(Phi),2)*var_x - 2*std::sin(Phi)*std::cos(Phi)*cv_xy + std::pow(std::cos(Phi),2)*var_y;
    Double_t V12 = std::pow(std::cos(Phi),2)*cv_xy -std::sin(Phi)*std::cos(Phi)*var_x + std::sin(Phi)*std::cos(Phi)*var_y - std::pow(std::sin(Phi),2)*cv_xy;   // rho is equal to one for just one jet
    return  std::make_tuple( V11, V22, V12);
  }

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode met::METSignificance::finalize

(

)

Definition at line 193 of file METSignificance.cxx.

                                      {
 
    ATH_MSG_INFO ("Finalizing " << name() << "...");
    delete m_phi_reso_pt20;
    delete m_phi_reso_pt50;
    delete m_phi_reso_pt100;
 
    return StatusCode::SUCCESS;
  }

getEtaBin()

unsigned int met::METSignificance::getEtaBin ( double jet_eta )

staticprivate

Definition at line 952 of file METSignificance.cxx.

                                                       {
    // For the phi uncertainty lookup
    if(-4.5<jet_eta && -3.8>=jet_eta)      return 1;
    else if(-3.8<jet_eta && -3.5>=jet_eta) return 2;
    else if(-3.5<jet_eta && -3.0>=jet_eta) return 3;
    else if(-3.0<jet_eta && -2.7>=jet_eta) return 4;
    else if(-2.7<jet_eta && -2.4>=jet_eta) return 5;
    else if(-2.4<jet_eta && -1.5>=jet_eta) return 6;
    else if(-1.5<jet_eta && -0.5>=jet_eta) return 7;
    else if(-0.5<jet_eta &&  0.0>=jet_eta) return 8;
    else if(0.0<jet_eta  &&  0.5>=jet_eta) return 9;
    else if(0.5<jet_eta  &&  1.5>=jet_eta) return 10;
    else if(1.5<jet_eta  &&  2.4>=jet_eta) return 11;
    else if(2.4<jet_eta  &&  2.7>=jet_eta) return 12;
    else if(2.7<jet_eta  &&  3.0>=jet_eta) return 13;
    else if(3.0<jet_eta  &&  3.5>=jet_eta) return 14;
    else if(3.5<jet_eta  &&  3.8>=jet_eta) return 15;
    else if(3.8<jet_eta                  ) return 16;
    return 0;
  }

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::Event both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::Event, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

GetMETOverSqrtHT()

double met::METSignificance::GetMETOverSqrtHT ( ) const

inlinevirtual

Implements IMETSignificance.

Definition at line 75 of file METSignificance.h.

{ if(m_ht>0.0)           return (m_met/std::sqrt(m_ht));    return -1.0; }

GetMETOverSqrtSumET()

double met::METSignificance::GetMETOverSqrtSumET ( ) const

inlinevirtual

Implements IMETSignificance.

Definition at line 74 of file METSignificance.h.

{ if(m_sumet>0.0)        return (m_met/std::sqrt(m_sumet)); return -1.0; }

getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::Event both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::Event, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

GetPhiUnc()

double met::METSignificance::GetPhiUnc ( double jet_eta, double jet_phi, double jet_pt )

private

Definition at line 933 of file METSignificance.cxx.

                                                                               {
 
    unsigned int xbin = getEtaBin(jet_eta);
    unsigned int ybin = jet_phi>0.0 ? int(jet_phi/0.4)+9 : int(jet_phi/0.4)+8;
 
    // Stored as bin content = Mean, error = RMS, we want to use the RMS.
    if(!m_phi_reso_pt20 || !m_phi_reso_pt50 || !m_phi_reso_pt100){
      ATH_MSG_ERROR("Jet Phi Resolution histograms are invalid.");
      return 0.0;
    }
 
    // Collect the phi resolution
    if(jet_pt<50.0)
      return m_phi_reso_pt20->GetBinError(xbin, ybin);
    else if(jet_pt<100.0)
      return m_phi_reso_pt50->GetBinError(xbin, ybin);
    return m_phi_reso_pt100->GetBinError(xbin, ybin);
  }

getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

GetPUProb()

double met::METSignificance::GetPUProb ( double jet_eta, double jet_phi, double jet_pt, double jet_jvt, double jet_fjvt, float avgmu )

private

Definition at line 713 of file METSignificance.cxx.

                                                 {
 
    double unc=0.0;
 
    // Coefficients from Doug Schaefer <schae@cern.ch> and the MET subgroup
    if(m_JetCollection == "AntiKt4EMTopoJets"){
      if(std::abs(jet_eta)<2.4){
        if(jet_pt<30){
          if(jet_jvt<0.11)      unc = 1;
          else if(jet_jvt<0.25) unc = 0.0730 + 0.0024 * avgmu + 0.00001 * avgmu * avgmu;
          else if(jet_jvt<0.85) unc = 0.0995 + 0.0031 * avgmu + 0.00005 * avgmu * avgmu;
          else if(jet_jvt<0.95) unc = 0.0311 + 0.0025 * avgmu + 0.00005 * avgmu * avgmu;
          else                  unc = 0.0308 -0.0010 * avgmu + 0.00006 * avgmu * avgmu ;
        }else if(jet_pt<40){
          if(jet_jvt<0.11)      unc = 1.;
          else if(jet_jvt<0.25) unc = 1.;
          else if(jet_jvt<0.85) unc = -0.0188 + 0.0039 * avgmu + 0.00002 * avgmu * avgmu;
          else if(jet_jvt<0.95) unc = 0.0252 -0.0009 * avgmu + 0.00006 * avgmu * avgmu  ;
          else                  unc = 0.0085 -0.0003 * avgmu + 0.00002 * avgmu * avgmu  ;
        }else if(jet_pt<50){
          if(jet_jvt<0.11)      unc = 1;
          else if(jet_jvt<0.25) unc = 0.0345 -0.0006 * avgmu + 0.00004 * avgmu * avgmu  ;
          else if(jet_jvt<0.85) unc = 0.1078 -0.0051 * avgmu + 0.00011 * avgmu * avgmu  ;
          else if(jet_jvt<0.95) unc = -0.0026 + 0.0005 * avgmu + 0.00002 * avgmu * avgmu;
          else                  unc = 0.0090 -0.0004 * avgmu + 0.00001 * avgmu * avgmu  ;
        }else if(jet_pt<60){
          if(jet_jvt<0.11)      unc = 1;
          else if(jet_jvt<0.25) unc = -0.0321 + 0.0030 * avgmu -0.00002 * avgmu * avgmu;
          else if(jet_jvt<0.85) unc = 0.0260 -0.0007 * avgmu + 0.00003 * avgmu * avgmu ;
          else                  unc = -0.0040 + 0.0003 * avgmu;
        }else if(jet_pt<100){
          unc = 0.9492 -2.0757 * jet_jvt + 1.13328 * jet_jvt * jet_jvt;
        }else if(jet_pt<150){
          unc = 0.7888 -1.8372 * jet_jvt + 1.05539 * jet_jvt * jet_jvt;
        }
      }else if(std::abs(jet_eta)<2.6){
        if(jet_pt<30){
          if(jet_jvt<0.11)      unc = 0.2633 + 0.0091 * avgmu + -0.00009 * avgmu * avgmu;
          else if(jet_jvt<0.25) unc = 0.1841 + 0.0144 * avgmu + -0.00008 * avgmu * avgmu;
          else if(jet_jvt<0.85) unc = 0.1401 + 0.0048 * avgmu + 0.00006 * avgmu * avgmu ;
          else if(jet_jvt<0.95) unc = -0.0118 + 0.0076 * avgmu + 0.00003 * avgmu * avgmu;
          else                  unc = 0.0534 + -0.0011 * avgmu + 0.00010 * avgmu * avgmu;
        }else if(jet_pt<40){
          if(jet_jvt<0.11)      unc = 0.1497 + 0.0133 * avgmu + -0.00015 * avgmu * avgmu  ;
          else if(jet_jvt<0.25) unc = -0.2260 + 0.0276 * avgmu + -0.00021 * avgmu * avgmu ;
          else if(jet_jvt<0.85) unc = 0.2743 + -0.0093 * avgmu + 0.00022 * avgmu * avgmu  ;
          else if(jet_jvt<0.95) unc = 0.0604 + 0.0006 * avgmu + 0.00006 * avgmu * avgmu   ;
          else                  unc = 0.0478 + -0.0009 * avgmu + 0.00004 * avgmu * avgmu  ;
        }else if(jet_pt<50){
          if(jet_jvt<0.11)      unc = -0.2187 + 0.0317 * avgmu + -0.00037 * avgmu * avgmu ;
          else if(jet_jvt<0.25) unc = 0.0964 + 0.0053 * avgmu + 0.00002 * avgmu * avgmu   ;
          else if(jet_jvt<0.85) unc = 1.1730 + -0.0624 * avgmu + 0.00088 * avgmu * avgmu  ;
          else if(jet_jvt<0.95) unc = -0.2011 + 0.0151 * avgmu + -0.00018 * avgmu * avgmu ;
          else                  unc = 0.0145 + -0.0003 * avgmu + 0.00002 * avgmu * avgmu  ;
        }else if(jet_pt<60){
          if(jet_jvt<0.11)      unc = 0.0051 + 0.0113 * avgmu + -0.00008 * avgmu * avgmu  ;
          else if(jet_jvt<0.25) unc = -0.1024 + 0.0109 * avgmu + -0.00006 * avgmu * avgmu ;
          else if(jet_jvt<0.85) unc = 1.2491 + -0.0501 * avgmu + 0.00052 * avgmu * avgmu  ;
          else                  unc = 0.0267 + -0.0014 * avgmu + 0.00003 * avgmu * avgmu  ;
        }else if(jet_pt<100){
          unc = 0.8951 -2.4995 * jet_jvt + 1.63229 * jet_jvt * jet_jvt;
        }else if(jet_pt<150){
          unc = 0.9998 -1.7319 * jet_jvt + 0.72680 * jet_jvt * jet_jvt;
        }
      }else if(std::abs(jet_eta)<2.7){
        if(jet_pt<30){
          if(jet_jvt<0.11)      unc = 0.3001 + 0.0054 * avgmu -0.00004 * avgmu * avgmu  ;
          else if(jet_jvt<0.25) unc = 0.0663 + 0.0198 * avgmu -0.00013 * avgmu * avgmu  ;
          else if(jet_jvt<0.85) unc = -0.0842 + 0.0163 * avgmu -0.00008 * avgmu * avgmu ;
          else if(jet_jvt<0.95) unc = -0.0219 + 0.0080 * avgmu + 0.00003 * avgmu * avgmu;
          else                  unc = 0.0461 -0.0003 * avgmu + 0.00012 * avgmu * avgmu  ;
        }else if(jet_pt<40){
          if(jet_jvt<0.11)      unc = 0.1885 + 0.0083 * avgmu -0.00006 * avgmu * avgmu ;
          else if(jet_jvt<0.25) unc = -0.0286 + 0.0150 * avgmu -0.00007 * avgmu * avgmu;
          else if(jet_jvt<0.85) unc = 0.0152 + 0.0028 * avgmu + 0.00005 * avgmu * avgmu;
          else if(jet_jvt<0.95) unc = 0.1815 -0.0076 * avgmu + 0.00018 * avgmu * avgmu ;
          else                  unc = 0.0192 -0.0003 * avgmu + 0.00007 * avgmu * avgmu ;
        }else if(jet_pt<50){
          if(jet_jvt<0.11)      unc = 0.1257 + 0.0074 * avgmu -0.00004 * avgmu * avgmu  ;
          else if(jet_jvt<0.25) unc = -0.0276 + 0.0080 * avgmu + 0.00000 * avgmu * avgmu;
          else if(jet_jvt<0.85) unc = 0.1403 -0.0051 * avgmu + 0.00009 * avgmu * avgmu  ;
          else if(jet_jvt<0.95) unc = 0.2078 -0.0101 * avgmu + 0.00017 * avgmu * avgmu  ;
          else                  unc = 0.2597 -0.0132 * avgmu + 0.00020 * avgmu * avgmu  ;
        }else if(jet_pt<60){
          if(jet_jvt<0.11)      unc = 0.1111 + 0.0045 * avgmu -0.00000 * avgmu * avgmu ;
          else if(jet_jvt<0.25) unc = 0.0975 -0.0011 * avgmu + 0.00008 * avgmu * avgmu ;
          else if(jet_jvt<0.85) unc = 0.0920 -0.0053 * avgmu + 0.00013 * avgmu * avgmu ;
          else                  unc = -0.0071 + 0.0016 * avgmu -0.00001 * avgmu * avgmu;
        }else if(jet_pt<100){
          unc = 0.4660 -1.2116 * jet_jvt + 0.78807 * jet_jvt * jet_jvt;
        }else if(jet_pt<150){
          unc = 0.2254 -0.5476 * jet_jvt + 0.32617 * jet_jvt * jet_jvt;
        }
      }// end eta 2.7
      else{//forward jets
        float fjvt = jet_fjvt>0.6 ? 0.6 : jet_fjvt; // the pileup more or less plateaus at 0.6
        if(jet_pt<30)       unc = 0.5106 + 1.2566 * fjvt -1.15060  * fjvt * fjvt;
        else if(jet_pt<40)  unc = 0.2972 + 1.9418 * fjvt -1.82694  * fjvt * fjvt;
        else if(jet_pt<50)  unc = 0.1543 + 1.9864 * fjvt -1.48429  * fjvt * fjvt;
        else if(jet_pt<60)  unc = 0.1050 + 1.3196 * fjvt + 0.03554 * fjvt * fjvt;
        else if(jet_pt<120) unc = 0.0400 + 0.5653 * fjvt + 1.96323 * fjvt * fjvt;
        // max of 0.9 seems reasonable
        if(jet_fjvt>0.6) unc = 0.9;
      }
      // end emtopo
      // Coefficients from Badr-eddine Ngair <badr-eddine.ngair@cern.ch>
    //  Pile-UP (resolution) estimatetd using Z->ee Events using exclusive jet_pt binning using RUN3 samples
    }else{//p-flow inputs
      if(std::abs(jet_eta)<2.4){
        if(jet_pt<30){
          if(jet_jvt<0.11)      unc = 0.524466 + 0.00750057 * avgmu -4.73422e-05 * avgmu * avgmu ;
          else if(jet_jvt<0.25) unc = 4.17584e-01 + 1.00112e-02  * avgmu -7.43546e-05 * avgmu * avgmu ;
          else if(jet_jvt<0.85) unc = 2.12625e-01 + 1.03484e-02 * avgmu  -5.68063e-05  * avgmu * avgmu;
          else if(jet_jvt<0.95) unc = 1.08396e-01 + 1.04273e-02 * avgmu -5.00299e-05 * avgmu * avgmu;
          else                  unc = 1.26304e-03 +2.10385e-04  * avgmu + 1.10086e-06 * avgmu * avgmu ;
        }else if(jet_pt<40){
          if(jet_jvt<0.11)      unc = 3.78090e-01 + 8.83535e-03 * avgmu  -5.38873e-05* avgmu * avgmu;
          else if(jet_jvt<0.25) unc = 2.67244e-01+ 9.81193e-03* avgmu  -5.87765e-05  * avgmu * avgmu;
          else if(jet_jvt<0.85) unc = 9.60892e-02 +8.11069e-03 * avgmu  -3.73101e-05 * avgmu * avgmu ;
          else if(jet_jvt<0.95) unc = 5.16235e-02 +6.27371e-03 * avgmu -1.95433e-05 * avgmu * avgmu ;
          else                  unc = -2.74714e-03 +2.45273e-04* avgmu -1.44731e-06* avgmu * avgmu ;
        }else if(jet_pt<50){
          if(jet_jvt<0.11)      unc = 2.44953e-01 + 1.23246e-02 * avgmu  -8.48696e-05 * avgmu * avgmu;
          else if(jet_jvt<0.25) unc = 1.78141e-01 + 1.09451e-02  * avgmu  -6.90796e-05 * avgmu * avgmu;
          else if(jet_jvt<0.85) unc = 9.60998e-02+6.21945e-03* avgmu -2.76203e-05* avgmu * avgmu  ;
          else if(jet_jvt<0.95) unc = 5.79210e-02+ 4.49780e-03 * avgmu + -1.15125e-05 * avgmu * avgmu ;
          else                  unc = -2.96644e-03 +2.27707e-04 * avgmu -1.86712e-06 * avgmu * avgmu  ;
        }else if(jet_pt<60){
          if(jet_jvt<0.11)      unc = 1.97017e-01 + 1.34089e-02 * avgmu  -9.18923e-05 * avgmu * avgmu  ;
          else if(jet_jvt<0.25) unc = 1.27602e-01 +  1.12287e-02  * avgmu -6.62192e-05  * avgmu * avgmu  ;
          else if(jet_jvt<0.85) unc = 6.94905e-02 + 6.27784e-03 * avgmu -3.07298e-05  * avgmu * avgmu;
          else if(jet_jvt<0.95) unc = 3.58417e-02  +4.62268e-03  * avgmu -2.12417e-05 * avgmu * avgmu ;
          else                  unc = 1.35616e-03  + 5.46723e-06* avgmu + 1.92327e-07 * avgmu * avgmu;
        }else if(jet_pt<100){
          unc = 6.19009e-01 -8.96042e-01 * jet_jvt + 2.89066e-01 * jet_jvt * jet_jvt;
        }else if(jet_pt<150){
          unc = 6.18350e-01 -8.97327e-01 * jet_jvt + 2.90998e-01 * jet_jvt * jet_jvt;
        }
      }else if(std::abs(jet_eta)<2.6){
        if(jet_pt<30){
          if(jet_jvt<0.11)      unc = 5.06496e-01 + 8.21123e-03 * avgmu -5.17501e-05  * avgmu * avgmu;
          else if(jet_jvt<0.25) unc = 4.26616e-01  + 9.25936e-03  * avgmu -5.68847e-05  * avgmu * avgmu;
          else if(jet_jvt<0.85) unc = 2.03333e-01 + 1.11951e-02 * avgmu-6.09233e-05 * avgmu * avgmu ;
          else if(jet_jvt<0.95) unc = 1.03167e-01  + 1.13444e-02 * avgmu  -5.43274e-05 * avgmu * avgmu;
          else                  unc = 1.51480e-03 + 2.08394e-04 * avgmu + 1.39579e-06 * avgmu * avgmu;
        }else if(jet_pt<40){
          if(jet_jvt<0.11)      unc = 3.40612e-01 + 9.94199e-03 * avgmu + -5.93760e-05* avgmu * avgmu  ;
          else if(jet_jvt<0.25) unc = 2.43360e-01 + 1.05579e-02* avgmu + -6.05403e-05* avgmu * avgmu ;
          else if(jet_jvt<0.85) unc = 8.34364e-02 + 8.76364e-03 * avgmu  -3.64035e-05  * avgmu * avgmu  ;
          else if(jet_jvt<0.95) unc = 4.40362e-02 + 6.92580e-03  * avgmu  -1.79853e-05 * avgmu * avgmu   ;
          else                  unc = -2.68670e-03 + 2.50861e-04 * avgmu + -1.46410e-06* avgmu * avgmu  ;
        }else if(jet_pt<50){
          if(jet_jvt<0.11)      unc = 2.36561e-01 + 1.14078e-02 * avgmu +-7.10025e-05 * avgmu * avgmu ;
          else if(jet_jvt<0.25) unc = 1.86653e-01 +9.61140e-03 * avgmu +-5.15356e-05 * avgmu * avgmu   ;
          else if(jet_jvt<0.85) unc = 9.37026e-02 +5.93028e-03 * avgmu +-2.02571e-05 * avgmu * avgmu  ;
          else if(jet_jvt<0.95) unc = 5.79210e-02+ 4.49780e-03 * avgmu + -1.15125e-05 * avgmu * avgmu ;
          else                  unc = -3.02487e-03 + 2.31337e-04* avgmu + -1.85225e-06  * avgmu * avgmu  ;
        }else if(jet_pt<60){
          if(jet_jvt<0.11)      unc =1.75215e-01+ 1.21805e-02 * avgmu + -7.48846e-05 * avgmu * avgmu  ;
          else if(jet_jvt<0.25) unc = 1.26276e-01+ 9.80117e-03  * avgmu + -4.99913e-05  * avgmu * avgmu ;
          else if(jet_jvt<0.85) unc = 7.91422e-02 + 5.26009e-03 * avgmu +-1.87388e-05 * avgmu * avgmu  ;
          else if(jet_jvt<0.95) unc = 4.39136e-02+ 4.09435e-03* avgmu +-1.35926e-05  * avgmu * avgmu ;
          else                  unc = 1.21410e-03 + 1.14188e-05 * avgmu + 1.53654e-07 * avgmu * avgmu  ;
        }else if( jet_pt<100){
          unc = 6.44179e-01 -9.20194e-01* jet_jvt + 2.89686e-01 * jet_jvt * jet_jvt;
        }else if(jet_pt<150){
          unc = 6.43423e-01 -9.21407e-01 * jet_jvt + 2.91648e-01 * jet_jvt * jet_jvt;
        }
      }else if(std::abs(jet_eta)<2.7){
        if(jet_pt<30){
          if(jet_jvt<0.11)      unc = 4.76243e-01 + 9.22046e-03 * avgmu -5.88765e-05 * avgmu * avgmu;
          else if(jet_jvt<0.25) unc = 4.07406e-01+ 1.01167e-02  * avgmu -6.30429e-05 * avgmu * avgmu;
          else if(jet_jvt<0.85) unc = 2.01324e-01+ 1.20631e-02 * avgmu  -6.75582e-05 * avgmu * avgmu;
          else if(jet_jvt<0.95) unc =  1.03815e-01 + 1.24007e-02 * avgmu  -6.26892e-05  * avgmu * avgmu;
          else                  unc = 1.63714e-03 +2.00682e-04  * avgmu +  1.53621e-06 * avgmu * avgmu;
        }else if(jet_pt<40){
          if(jet_jvt<0.11)      unc = 2.89505e-01 + 1.11643e-02 * avgmu  -6.45475e-05* avgmu * avgmu;
          else if(jet_jvt<0.25) unc = 2.15968e-01 + 1.14451e-02* avgmu  -6.32545e-05 * avgmu * avgmu;
          else if(jet_jvt<0.85) unc = 7.92319e-02 +9.66239e-03* avgmu -3.81872e-05 * avgmu * avgmu  ;
          else if(jet_jvt<0.95) unc = 4.25501e-02  +7.90022e-03  * avgmu  -1.93561e-05   * avgmu * avgmu;
          else                  unc = -2.68089e-03 +2.50117e-04 * avgmu -1.43591e-06 * avgmu * avgmu  ;
        }else if(jet_pt<50){
          if(jet_jvt<0.11)      unc = 1.66062e-01+ 1.21029e-02  * avgmu  -7.00743e-05 * avgmu * avgmu;
          else if(jet_jvt<0.25) unc = 1.36874e-01+ 1.03543e-02  * avgmu  -5.13482e-05 * avgmu * avgmu;
          else if(jet_jvt<0.85) unc = 7.24015e-02  +6.72611e-03 * avgmu  -1.98316e-05 * avgmu * avgmu;
          else if(jet_jvt<0.95) unc = 4.84508e-02  +5.10548e-03* avgmu -8.65067e-06  * avgmu * avgmu;
          else                  unc = -3.02710e-03  +2.31422e-04* avgmu  -1.84795e-06 * avgmu * avgmu;
        }else if(jet_pt<60){
          if(jet_jvt<0.11)      unc =1.33626e-01 +  1.02813e-02   * avgmu  -4.87698e-05 * avgmu * avgmu;
          else if(jet_jvt<0.25) unc = 1.06724e-01 + 8.45131e-03  * avgmu -3.26833e-05 * avgmu * avgmu;
          else if(jet_jvt<0.85) unc = 7.47468e-02 +4.85387e-03 * avgmu  -1.01430e-05* avgmu * avgmu;
          else if(jet_jvt<0.95) unc = 4.57521e-02   + 3.86782e-03 * avgmu -6.38948e-06  * avgmu * avgmu;
          else                  unc = 1.20495e-03   +1.18941e-05* avgmu  +1.47846e-07  * avgmu * avgmu;
        }else if( jet_pt<100){
          unc = 6.59079e-01 -9.29754e-01 * jet_jvt + 2.83653e-01 * jet_jvt * jet_jvt;
        }else if(jet_pt<150){
          unc = 6.58295e-01 -9.31032e-01 * jet_jvt + 2.85724e-01 * jet_jvt * jet_jvt;
        }
      }// end eta 2.7
      else{//forward jets
        float fjvt = jet_fjvt>0.6 ? 0.6 : jet_fjvt; // the pileup more or less plateaus at 0.6
        if(jet_pt<30)       unc = 0.605329 + 0.625734 * fjvt -0.42484  * fjvt * fjvt;
        else if(jet_pt<40)  unc = 0.409696 + 1.00173 * fjvt -0.609179 * fjvt * fjvt;
        else if(jet_pt<50)  unc = 0.173755 + 1.48847 * fjvt -0.803771    * fjvt * fjvt;
        else if(jet_pt<60)  unc = 0.0140303 + 1.79909 * fjvt -0.889274 * fjvt * fjvt;
        else if(jet_pt<120) unc = -0.0828333 + 1.81167  * fjvt -0.716881 * fjvt * fjvt;
        // max of 0.9 seems reasonable
        if(jet_fjvt>0.6) unc = 0.9;
      }
    }// end pflow
 
    unc = std::min(unc, 1.0);
    unc = std::max(unc, 0.0);
 
    return unc;
  }

GetRho()

double met::METSignificance::GetRho ( ) const

inlinevirtual

Implements IMETSignificance.

Definition at line 78 of file METSignificance.h.

{ return m_rho;  }

GetSigDirectional()

double met::METSignificance::GetSigDirectional ( ) const

inlinevirtual

Implements IMETSignificance.

Definition at line 77 of file METSignificance.h.

{ if(m_VarL>0.0)         return m_met/std::sqrt(m_VarL);    return -1.0; }

GetSignificance()

double met::METSignificance::GetSignificance ( ) const

inlinevirtual

Implements IMETSignificance.

Definition at line 76 of file METSignificance.h.

{ if(m_significance>0.0) return std::sqrt(m_significance);  return -1.0; }

GetTermVarL()

double met::METSignificance::GetTermVarL ( const int term ) const

inlinevirtual

Implements IMETSignificance.

Definition at line 81 of file METSignificance.h.

{ if(m_term_VarL.find(term)!=m_term_VarL.end()) return m_term_VarL.find(term)->second; return -1.0e3; }

GetTermVarT()

double met::METSignificance::GetTermVarT ( const int term ) const

inlinevirtual

Implements IMETSignificance.

Definition at line 82 of file METSignificance.h.

{ if(m_term_VarT.find(term)!=m_term_VarT.end()) return m_term_VarT.find(term)->second; return -1.0e3; }

GetVarL()

double met::METSignificance::GetVarL ( ) const

inlinevirtual

Implements IMETSignificance.

Definition at line 79 of file METSignificance.h.

{ return m_VarL; }

GetVarT()

double met::METSignificance::GetVarT ( ) const

inlinevirtual

Implements IMETSignificance.

Definition at line 80 of file METSignificance.h.

{ return m_VarT; }

initialize()

StatusCode met::METSignificance::initialize ( void )

virtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 110 of file METSignificance.cxx.

                                        {
 
    ATH_MSG_INFO ("Initializing " << name() << "...");
    ATH_MSG_INFO("Set up JER tools");
    if(m_JetCollection == "AntiKt4EMTopoJets"){
      ATH_MSG_WARNING(" tool wasn't updated for EMTopo jets so far and is not supported.");
    }
    // Phi resolution
    std::string configpath  = PathResolverFindCalibFile(m_configPrefix+m_configJetPhiResoFile);
    m_file = TFile::Open(configpath.c_str());
    if(m_file){
      m_phi_reso_pt20 = static_cast<TH2F *>(m_file->Get("phi_reso_pt20"));
      if(!m_phi_reso_pt20) ATH_MSG_ERROR("PU Jet Uncertainty Histogram not valid");
      m_phi_reso_pt50 = static_cast<TH2F *>(m_file->Get("phi_reso_pt50"));
      if(!m_phi_reso_pt50) ATH_MSG_ERROR("PU Jet Uncertainty Histogram not valid");
      m_phi_reso_pt100 = static_cast<TH2F *>(m_file->Get("phi_reso_pt100"));
      if(!m_phi_reso_pt100) ATH_MSG_ERROR("PU Jet Uncertainty Histogram not valid");
    }
    else{
      ATH_MSG_ERROR("PU Jet Uncertainty TFile is not valid: " << configpath);
      return StatusCode::FAILURE;
    }
 
    if (m_jetCalibTool.empty()){
      if(m_jetCalibConfig.empty() || m_jetCalibSeq.empty())
        m_jetOK = false;
      else{
        asg::AsgToolConfig toolConfig ("JetCalibrationTool/MetSigAutoConf_JetCalibTool_"+m_JetCollection);
        ATH_CHECK( toolConfig.setProperty("JetCollection",m_JetCollection) );
        ATH_CHECK( toolConfig.setProperty("ConfigFile",m_jetCalibConfig) );
        ATH_CHECK( toolConfig.setProperty("CalibSequence",m_jetCalibSeq) );
        if(!m_jetCalibArea.empty()) ATH_CHECK( toolConfig.setProperty("CalibArea",m_jetCalibArea) );
        ATH_CHECK( toolConfig.setProperty("IsData",false) ); // configure for MC due to technical reasons. Both data and MC smearing are available with this setting.
        ATH_CHECK( toolConfig.makePrivateTool (m_jetCalibTool) );
      }
    }
    if(m_jetOK) ATH_CHECK( m_jetCalibTool.retrieve() );
    else ATH_MSG_WARNING("No jet calibration tool or config provided for MET Significance");
 
    if (m_muonCalibrationAndSmearingTool.empty()) {
      if(m_muonCalibMode == -1)
        m_muonOK = false;
      else{
        asg::AsgToolConfig toolConfig ("CP::MuonCalibTool/METSigAutoConf_MuonCalibrationAndSmearingTool");
        ATH_CHECK(toolConfig.setProperty("calibMode", m_muonCalibMode));
        ATH_CHECK(toolConfig.makePrivateTool(m_muonCalibrationAndSmearingTool));
      }
    }
    if(m_muonOK) ATH_CHECK(m_muonCalibrationAndSmearingTool.retrieve());
    else ATH_MSG_WARNING("No muon calibration tool or config provided for MET Significance");
 
    if (m_egammaCalibTool.empty()){
      if(m_egESModel.empty() || m_egDecorrModel.empty())
        m_egammaOK = false;
      else{
        asg::AsgToolConfig toolConfig ("CP::EgammaCalibrationAndSmearingTool/METSigAutoConf_EgammaCalibrationAndSmearingTool");
        ATH_CHECK(toolConfig.setProperty("ESModel", m_egESModel));
        ATH_CHECK(toolConfig.setProperty("decorrelationModel", m_egDecorrModel));
        ATH_CHECK(toolConfig.setProperty("useFastSim", m_egUseFastsim ? 1 : 0));
        // only resolution() is used, which does not need the MVA BDTs
        ATH_CHECK(toolConfig.setProperty("useMVACalibration", 0));
        ATH_CHECK(toolConfig.makePrivateTool (m_egammaCalibTool));
      }
    }
    if(m_egammaOK) ATH_CHECK( m_egammaCalibTool.retrieve() );
    else ATH_MSG_WARNING("No egamma calibration tool or config provided for MET Significance");
 
    if (m_tauResolutionTool.empty()){
      if(m_tauTESConfig.empty())
        m_tauOK = false;
      else{
        asg::AsgToolConfig toolConfig ("TauAnalysisTools::TauResolutionTool/METSigAutoConf_TauPerfTool");
        ATH_CHECK( toolConfig.setProperty("WeightFileName", m_tauTESConfig) );
        ATH_CHECK( toolConfig.makePrivateTool(m_tauResolutionTool) );
      }
    }
    if(m_tauOK) ATH_CHECK( m_tauResolutionTool.retrieve() );
    else ATH_MSG_WARNING("No tau calibration tool or config provided for MET Significance");
 
 
    return StatusCode::SUCCESS;
  }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

InvertMatrix()

void met::METSignificance::InvertMatrix ( double(&) mat[2][2], double(&) m[2][2] )

private

Definition at line 998 of file METSignificance.cxx.

                                                                          {
 
    // determinant
    double det = mat[0][0]*mat[1][1]-mat[0][1]*mat[1][0];
 
    m[0][0]=0.0;
    m[0][1]=0.0;
    m[1][0]=0.0;
    m[1][1]=0.0;
 
    if(det==0.0) return;
 
    m[0][0]= 1.0/det*(mat[1][1]);
    m[1][0]=-1.0/det*(mat[1][0]);
    m[0][1]=-1.0/det*(mat[0][1]);
    m[1][1]= 1.0/det*(mat[0][0]);
  }

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

RotateToPhi()

StatusCode met::METSignificance::RotateToPhi ( float phi )

virtual

Implements IMETSignificance.

Definition at line 384 of file METSignificance.cxx.

                                                  {
 
    // Rotation (components)
    std::tie(m_VarL, m_VarT, m_CvLT) = CovMatrixRotation(m_met_VarL , m_met_VarT, m_met_CvLT, (phi-m_metphi));
 
    if( m_VarL != 0 ){
      m_significance = Significance_LT(m_met,m_VarL,m_VarT,m_CvLT );
      m_rho = m_CvLT  / std::sqrt( m_VarL * m_VarT ) ;
    }
    ATH_MSG_DEBUG("     Significance (squared) at new phi: " << m_significance
                << " rho: " << GetRho()
                << " MET: " << m_met
                << " sigmaL: " << GetVarL()
                << " sigmaT: " << GetVarT() );
 
    return StatusCode::SUCCESS;
  }

RotateXY()

void met::METSignificance::RotateXY ( const double(&) mat[2][2], double(&) mat_new[2][2], double phi )

private

Definition at line 1023 of file METSignificance.cxx.

                                                                                              {
 
    double c = std::cos(phi);
    double s = std::sin(phi);
    double cc = c*c;
    double ss = s*s;
    double cs = c*s;
 
    double V11 = mat[0][0]*cc + mat[1][1]*ss - cs*(mat[1][0] + mat[0][1]);
    double V12 = mat[0][1]*cc - mat[1][0]*ss + cs*(mat[0][0] - mat[1][1]);
    double V21 = mat[1][0]*cc - mat[0][1]*ss + cs*(mat[0][0] - mat[1][1]);
    double V22 = mat[0][0]*ss + mat[1][1]*cc + cs*(mat[1][0] + mat[0][1]);
 
    mat_new[0][0]=V11;
    mat_new[0][1]=V12;
    mat_new[1][0]=V21;
    mat_new[1][1]=V22;
  }

SetLambda()

StatusCode met::METSignificance::SetLambda ( const float px, const float py, const bool GeV = true )

virtual

Implements IMETSignificance.

Definition at line 402 of file METSignificance.cxx.

                                                                                     {
 
    // compute the new direction
    double GeVConv = GeV ? 1.0 : m_GeV;
    m_lamda_vect.SetXYZ(px/GeVConv, py/GeVConv, 0.0);
    m_lamda_vect = (m_met_vect - m_lamda_vect);
    const double met_m_lamda = m_lamda_vect.Pt();
 
    // Rotation (components)
    std::tie(m_VarL, m_VarT, m_CvLT) = CovMatrixRotation(m_met_VarL , m_met_VarT, m_met_CvLT, (m_lamda_vect.Phi()-m_metphi));
 
    if( m_VarL != 0 ){
      m_significance = Significance_LT(met_m_lamda,m_VarL,m_VarT,m_CvLT );
      m_rho = m_CvLT  / std::sqrt( m_VarL * m_VarT ) ;
    }
    ATH_MSG_DEBUG("     Significance (squared) at new phi: " << m_significance
                << " rho: " << GetRho()
                << " MET: " << m_met
                << " sigmaL: " << GetVarL()
                << " sigmaT: " << GetVarT() );
 
    return StatusCode::SUCCESS;
  }

Significance_LT()

double met::METSignificance::Significance_LT ( double Numerator, double var_parall, double var_perpen, double cov )

private

Definition at line 981 of file METSignificance.cxx.

                                                                                                           {
 
    Double_t rho = cov / std::sqrt( var_parall * var_perpen ) ;
    Double_t Significance = 0;
    if (std::abs( rho ) >= 0.9 ){  //Cov Max not invertible -> Significance diverges
      ATH_MSG_VERBOSE("rho is large: " << rho);
      Significance = std::pow( Numerator - m_scalarBias , 2 ) / (  var_parall  ) ;
    }
    else
      Significance = std::pow( Numerator - m_scalarBias , 2 ) / (  var_parall * ( 1 - std::pow(rho,2) ) ) ;
 
    if( std::abs(Significance) >= 10e+15)
      ATH_MSG_WARNING("warning -->"<< Significance);
 
    return Significance;
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Var_Ptsoft()

double met::METSignificance::Var_Ptsoft ( const double PtSoft )

private

Definition at line 1063 of file METSignificance.cxx.

                                                       {
    if (PtSoft<45.) return 40. + 2*PtSoft + 0.1*std::pow(PtSoft,2);
    else return 40. + 2*45 + 0.1*std::pow(45,2);
  }

varianceMET()

StatusCode met::METSignificance::varianceMET ( xAOD::MissingETContainer * metCont, float avgmu, const std::string & jetTermName, const std::string & softTermName, const std::string & totalMETName )

virtual

Implements IMETSignificance.

Definition at line 204 of file METSignificance.cxx.

                                                                                                                                                                                 {
 
    // reset variables
    m_VarL = 0.0;
    m_VarT = 0.0;
    m_CvLT = 0.0;
 
    int metTerm = 0;
    double particle_sum[2][2] = {{0.0,0.0}, {0.0,0.0}};
    m_metphi = 0.0; //Angle for rotation of the cov matrix
    m_met = -1.0; // Numerator
    m_metsoft = 0.0;
    m_metsoftphi = 0.0;
    m_sumet=-1.0;
    m_ht=0.0;
    m_term_VarL.clear();
    m_term_VarT.clear();
    m_term_CvLT.clear();
 
    unsigned nIterSoft=0;
    double softSumET=0.0;
 
    // first fill the total MET
    if(metCont->find(totalMETName)!=metCont->end()){
      const auto &tot_met = static_cast<xAOD::MissingET*>(*(metCont->find(totalMETName)));
      if(!MissingETBase::Source::isTotalTerm(tot_met->source())){
        ATH_MSG_ERROR("NOT the total MET with name:" <<totalMETName);
        return StatusCode::SUCCESS;
      }
      m_met    = tot_met->met()/m_GeV;
      m_metx   = tot_met->mpx()/m_GeV;
      m_mety   = tot_met->mpy()/m_GeV;
      m_metphi = tot_met->phi();
      m_sumet  = tot_met->sumet()/m_GeV;
      m_ht     = m_sumet;
      ATH_MSG_VERBOSE("total MET: " << m_met << " phi: " << m_metphi << " name: " << tot_met->name());
    }
    else{
      ATH_MSG_ERROR("Could not find the total MET with name:" <<totalMETName);
      return StatusCode::SUCCESS;
    }
    m_met_vect.SetXYZ(m_metx, m_mety, 0);
 
    // Fill the remaining terms
    for(const auto met : *metCont) {
 
      // skip the invisible and total MET
      if(MissingETBase::Source::isTotalTerm(met->source())){
        ATH_MSG_VERBOSE("Total: " << met->name() << " val: " << met->met());
        continue;
      }
      if(met->source()==invisSource) continue;
 
      // Soft term collection
      if(MissingETBase::Source::isSoftTerm(met->source())){
 
        if(!MissingETBase::Source::hasPattern(met->source(),MissingETBase::Source::Signal::Track)) continue;
        ATH_MSG_VERBOSE("Soft Name: " << met->name());
        // make sure the container name matches
        if(met->name()!=softTermName || nIterSoft>0){
          if(nIterSoft>0) ATH_MSG_ERROR("Found multiple soft terms with the name:" <<softTermName << ". Your MET configuration is wrong!!!");
          continue;
        }
        ++nIterSoft;
        softSumET=(met->sumet()/m_GeV);
 
        AddSoftTerm(met, m_met_vect, particle_sum);
        m_metsoft = met->met()/m_GeV;
        m_metsoftphi = met->phi();
        metTerm = 2; // this is actually filled in AddSoftTerm
        // done with the soft term. go to the next term.
        continue;
      }
      ATH_MSG_VERBOSE("Add MET term " << met->name() );
      for(const auto& el : acc_constitObjLinks(*met)) {
        const xAOD::IParticle* obj(*el);
        float pt_reso=0.0, phi_reso=0.0;
        if(!obj){
          ATH_MSG_ERROR("Particle pointer is not valid. This will likely result in a crash " << obj);
          return StatusCode::FAILURE;
        }
        ATH_MSG_VERBOSE("pT: " << obj->pt() << " type: " << obj->type() << " truth: " << (obj->type()==xAOD::Type::TruthParticle));
        if(obj->type()==xAOD::Type::Muon || (obj->type()==xAOD::Type::TruthParticle && std::abs(static_cast<const xAOD::TruthParticle*>(obj)->pdgId())==13)){
          ATH_CHECK(AddMuon(obj, pt_reso, phi_reso, avgmu));
          metTerm=4;
        }
        else if(obj->type()==xAOD::Type::Jet){
          // make sure the container name matches
          if(met->name()!=jetTermName) continue;
          ATH_CHECK(AddJet(obj, pt_reso, phi_reso, avgmu));
          metTerm=1;
        }
        else if(obj->type()==xAOD::Type::Electron || (obj->type()==xAOD::Type::TruthParticle && std::abs(static_cast<const xAOD::TruthParticle*>(obj)->pdgId())==11)){
          ATH_CHECK(AddElectron(obj, pt_reso, phi_reso, avgmu));
          metTerm=3;
        }
        else if(obj->type()==xAOD::Type::Photon || (obj->type()==xAOD::Type::TruthParticle && std::abs(static_cast<const xAOD::TruthParticle*>(obj)->pdgId())==22)){
          ATH_CHECK(AddPhoton(obj, pt_reso, phi_reso));
          metTerm=5;
        }
        else if(obj->type()==xAOD::Type::Tau || (obj->type()==xAOD::Type::TruthParticle && std::abs(static_cast<const xAOD::TruthParticle*>(obj)->pdgId())==15)){
          ATH_CHECK(AddTau(obj, pt_reso, phi_reso));
          metTerm=6;
        }
 
        // compute NEW
        double particle_u[2][2]     = {{pt_reso*pt_reso*obj->pt()*obj->pt()/m_GeV/m_GeV,0.0},
                                        {0.0,phi_reso*phi_reso/m_GeV/m_GeV}};
        double particle_u_rot[2][2] = {{pt_reso*pt_reso*obj->pt()*obj->pt()/m_GeV/m_GeV,0.0},
                                        {0.0,phi_reso*phi_reso/m_GeV/m_GeV}};
        RotateXY(particle_u, particle_u_rot,m_met_vect.DeltaPhi(obj->p4().Vect()));
        m_VarL+=particle_u_rot[0][0];
        m_VarT+=particle_u_rot[1][1];
        m_CvLT+=particle_u_rot[0][1];
 
        // Save the resolutions separated for each object type
        AddResoMap(particle_u_rot[0][0],
                    particle_u_rot[1][1],
                    particle_u_rot[0][1],
                    metTerm);
 
        RotateXY (particle_u,   particle_u_rot, obj->p4().Phi()); // positive phi rotation
        AddMatrix(particle_sum, particle_u_rot, particle_sum);
        // END compute NEW
 
        ATH_MSG_VERBOSE("Resolution: " << pt_reso << " phi reso: " << phi_reso );
      }
    }
 
    // setting the MET directed variables for later phi rotations if requested
    m_met_VarL=m_VarL;
    m_met_VarT=m_VarT;
    m_met_CvLT=m_CvLT;
 
    if( m_VarL != 0 ){
 
      if(m_applyBias){
        TVector3 met_vect = m_met_vect;
        TVector3 soft_vect = m_soft_vect;
 
        // should be done to reset the phi as well...
        if(m_softTermParam==met::TSTParam){
          Double_t Bias_TST = BiasPtSoftdir(m_metsoft);
          Double_t MEx = m_met * std::cos(m_metphi) - Bias_TST * std::cos(m_metsoftphi);
          Double_t MEy = m_met * std::sin(m_metphi) - Bias_TST * std::sin(m_metsoftphi);
          met_vect.SetXYZ(MEx,MEy,0.0);
        }
        else if(m_softTermParam==met::PthardParam){
          m_soft_vect.SetPtEtaPhi(m_metsoft, 0.0, m_metsoftphi);
          m_pthard_vect = m_soft_vect - m_met_vect;
          Double_t PtSoftparaPH = m_pthard_vect.Mag()>0.0 ? (m_soft_vect.Dot(m_pthard_vect))/m_pthard_vect.Mag() : 0.0;
          Double_t Bias_pthard = Bias_PtSoftParall(PtSoftparaPH);
          Double_t MEx = m_met * std::cos(m_metphi) - Bias_pthard * std::cos(m_metsoftphi);
          Double_t MEy = m_met * std::sin(m_metphi) - Bias_pthard * std::sin(m_metsoftphi);
          met_vect.SetXYZ(MEx,MEy,0.0);
        }
        // Rotate  & compute
        ATH_CHECK(RotateToPhi(met_vect.Phi()));
        m_significance = Significance_LT(met_vect.Pt(), m_VarL, m_VarT, m_CvLT);
        m_rho = m_CvLT / std::sqrt( m_VarL * m_VarT ) ;
      }
      else{
        // standard calculation
        m_significance = Significance_LT(m_met, m_VarL, m_VarT, m_CvLT);
        m_rho = m_CvLT / std::sqrt( m_VarL * m_VarT ) ;
      }
      m_ht-=softSumET;
      ATH_MSG_VERBOSE("     Significance (squared): " << m_significance << " rho: " << GetRho()
                    << " MET: " << m_met << " phi: " << m_metphi << " SUMET: " << m_sumet << " HT: " << m_ht << " sigmaL: " << GetVarL()
                    << " sigmaT: " << GetVarT() << " MET/sqrt(SumEt): " << GetMETOverSqrtSumET()
                    << " MET/sqrt(HT): " << GetMETOverSqrtHT()
                    << " sqrt(signif): " << GetSignificance()
                    << " sqrt(signifDirectional): " << GetSigDirectional());
    }
    else
      ATH_MSG_DEBUG("Var_L is 0");
 
    return StatusCode::SUCCESS;
  }

VarparPtSoftdir()

double met::METSignificance::VarparPtSoftdir ( const double PtSoft, const double SoftSumet )

private

Definition at line 1051 of file METSignificance.cxx.

                                                                                    {
    if (SoftSumet<25){
      if (PtSoft<50.) return 41.9+3.8*PtSoft+0.1*std::pow(PtSoft,2)-12.7+ 1.39*SoftSumet-0.03*std::pow(SoftSumet,2);
      else return 41.9+3.8*50.+0.1*std::pow(50.,2)-12.7+ 1.39*SoftSumet-0.03*std::pow(SoftSumet,2);
    }
    else{
      if (PtSoft<50.) return 41.9+3.8*PtSoft+0.1*std::pow(PtSoft,2);
      else return (40.5614)+(4.10965)*50.+(0.0955044)*std::pow(50.,2);
    }
  }

Member Data Documentation

m_applyBias

bool met::METSignificance::m_applyBias

private

Definition at line 149 of file METSignificance.h.

m_configJetPhiResoFile

std::string met::METSignificance::m_configJetPhiResoFile

private

Definition at line 190 of file METSignificance.h.

m_configPrefix

std::string met::METSignificance::m_configPrefix

private

Definition at line 189 of file METSignificance.h.

m_CvLT

double met::METSignificance::m_CvLT

private

Definition at line 164 of file METSignificance.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_doPhiReso

bool met::METSignificance::m_doPhiReso

private

Definition at line 148 of file METSignificance.h.

m_egammaCalibTool

ToolHandle<CP::IEgammaCalibrationAndSmearingTool> met::METSignificance::m_egammaCalibTool {this, "egammaCalibTool", "", "the IEgammaCalibrationAndSmearingTool we use"}

private

Definition at line 91 of file METSignificance.h.

{this, "egammaCalibTool", "", "the IEgammaCalibrationAndSmearingTool we use"};

m_egammaOK

bool met::METSignificance::m_egammaOK

private

Definition at line 137 of file METSignificance.h.

m_egDecorrModel

Gaudi::Property<std::string> met::METSignificance::m_egDecorrModel {this, "EgammaDecorrelationModel", "", "Decorrelation model for egamma calibration"}

private

Definition at line 99 of file METSignificance.h.

{this, "EgammaDecorrelationModel", "", "Decorrelation model for egamma calibration"};

m_egESModel

Gaudi::Property<std::string> met::METSignificance::m_egESModel {this, "EgammaESModel", "", "ESModel for egamma calibration"}

private

Definition at line 98 of file METSignificance.h.

{this, "EgammaESModel", "", "ESModel for egamma calibration"};

m_egUseFastsim

Gaudi::Property<bool> met::METSignificance::m_egUseFastsim {this, "EgammaUseFastsim", false, "Use fastsim resolutions for egamma?"}

private

Definition at line 100 of file METSignificance.h.

{this, "EgammaUseFastsim", false, "Use fastsim resolutions for egamma?"};

m_EMuResoAux

std::string met::METSignificance::m_EMuResoAux

private

Definition at line 192 of file METSignificance.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_file

TFile* met::METSignificance::m_file

private

Definition at line 184 of file METSignificance.h.

m_GeV

double met::METSignificance::m_GeV

private

Definition at line 133 of file METSignificance.h.

m_ht

double met::METSignificance::m_ht

private

Definition at line 180 of file METSignificance.h.

m_isDataJet

bool met::METSignificance::m_isDataJet

private

Definition at line 152 of file METSignificance.h.

m_isDataMuon

bool met::METSignificance::m_isDataMuon

private

Definition at line 153 of file METSignificance.h.

m_jerForEMu

bool met::METSignificance::m_jerForEMu

private

Definition at line 150 of file METSignificance.h.

m_jetCalibArea

Gaudi::Property<std::string> met::METSignificance::m_jetCalibArea {this, "JetCalibArea", "", "CalibArea for input jet calibration"}

private

Definition at line 96 of file METSignificance.h.

{this, "JetCalibArea", "", "CalibArea for input jet calibration"};

m_jetCalibConfig

Gaudi::Property<std::string> met::METSignificance::m_jetCalibConfig {this, "JetCalibConfig", "", "Config file for jet calibration/resolution"}

private

Definition at line 94 of file METSignificance.h.

{this, "JetCalibConfig", "", "Config file for jet calibration/resolution"};

m_jetCalibSeq

Gaudi::Property<std::string> met::METSignificance::m_jetCalibSeq {this, "JetCalibSequence", "", "Calibration sequence used for input jets"}

private

Definition at line 95 of file METSignificance.h.

{this, "JetCalibSequence", "", "Calibration sequence used for input jets"};

m_jetCalibTool

ToolHandle<IJetCalibrationTool> met::METSignificance::m_jetCalibTool {this, "jetCalibTool", "", "the IJetCalibrationTool we use"}

private

Definition at line 89 of file METSignificance.h.

{this, "jetCalibTool", "", "the IJetCalibrationTool we use"};

m_JetCollection

std::string met::METSignificance::m_JetCollection

private

Definition at line 193 of file METSignificance.h.

m_jetEtaThr

float met::METSignificance::m_jetEtaThr

private

Definition at line 157 of file METSignificance.h.

m_jetOK

bool met::METSignificance::m_jetOK

private

Definition at line 135 of file METSignificance.h.

m_jetPtThr

float met::METSignificance::m_jetPtThr

private

Definition at line 156 of file METSignificance.h.

m_JetResoAux

std::string met::METSignificance::m_JetResoAux

private

Definition at line 191 of file METSignificance.h.

m_lamda_vect

TVector3 met::METSignificance::m_lamda_vect

private

Definition at line 143 of file METSignificance.h.

m_met

double met::METSignificance::m_met

private

Definition at line 174 of file METSignificance.h.

m_met_CvLT

double met::METSignificance::m_met_CvLT

private

Definition at line 168 of file METSignificance.h.

m_met_VarL

double met::METSignificance::m_met_VarL

private

Definition at line 166 of file METSignificance.h.

m_met_VarT

double met::METSignificance::m_met_VarT

private

Definition at line 167 of file METSignificance.h.

m_met_vect

TVector3 met::METSignificance::m_met_vect

private

Definition at line 140 of file METSignificance.h.

m_metphi

double met::METSignificance::m_metphi

private

Definition at line 177 of file METSignificance.h.

m_metsoft

double met::METSignificance::m_metsoft

private

Definition at line 178 of file METSignificance.h.

m_metsoftphi

double met::METSignificance::m_metsoftphi

private

Definition at line 179 of file METSignificance.h.

m_metx

double met::METSignificance::m_metx

private

Definition at line 175 of file METSignificance.h.

m_mety

double met::METSignificance::m_mety

private

Definition at line 176 of file METSignificance.h.

m_muonCalibMode

Gaudi::Property<int> met::METSignificance::m_muonCalibMode {this, "MuonCalibMode", -1, "CalibMode for muon momentum calibration"}

private

Definition at line 97 of file METSignificance.h.

{this, "MuonCalibMode", -1, "CalibMode for muon momentum calibration"};

m_muonCalibrationAndSmearingTool

ToolHandle<CP::IMuonCalibrationAndSmearingTool> met::METSignificance::m_muonCalibrationAndSmearingTool {this, "MuonCalibTool", "", "the IMuonCalibrationAndSmearingTool we use"}

private

Definition at line 90 of file METSignificance.h.

{this, "MuonCalibTool", "", "the IMuonCalibrationAndSmearingTool we use"};

m_muonOK

bool met::METSignificance::m_muonOK

private

Definition at line 136 of file METSignificance.h.

m_phi_reso_pt100

TH2F* met::METSignificance::m_phi_reso_pt100

private

Definition at line 187 of file METSignificance.h.

m_phi_reso_pt20

TH2F* met::METSignificance::m_phi_reso_pt20

private

Definition at line 185 of file METSignificance.h.

m_phi_reso_pt50

TH2F* met::METSignificance::m_phi_reso_pt50

private

Definition at line 186 of file METSignificance.h.

m_pthard_vect

TVector3 met::METSignificance::m_pthard_vect

private

Definition at line 142 of file METSignificance.h.

m_rho

double met::METSignificance::m_rho

private

Definition at line 161 of file METSignificance.h.

m_scalarBias

double met::METSignificance::m_scalarBias

private

Definition at line 159 of file METSignificance.h.

m_significance

double met::METSignificance::m_significance

private

Definition at line 160 of file METSignificance.h.

m_soft_vect

TVector3 met::METSignificance::m_soft_vect

private

Definition at line 141 of file METSignificance.h.

m_softTermParam

int met::METSignificance::m_softTermParam

private

Definition at line 145 of file METSignificance.h.

m_softTermReso

double met::METSignificance::m_softTermReso

private

Definition at line 146 of file METSignificance.h.

m_sumet

double met::METSignificance::m_sumet

private

Definition at line 181 of file METSignificance.h.

m_tauOK

bool met::METSignificance::m_tauOK

private

Definition at line 138 of file METSignificance.h.

m_tauResolutionTool

ToolHandle<TauAnalysisTools::ITauResolutionTool> met::METSignificance::m_tauResolutionTool {this, "tauResolutionTool", "", "the tau Resolution tool we use"}

private

Definition at line 92 of file METSignificance.h.

{this, "tauResolutionTool", "", "the tau Resolution tool we use"};

m_tauTESConfig

Gaudi::Property<std::string> met::METSignificance::m_tauTESConfig {this, "TauTESConfig", "tauRecTools/R22_preprod/CombinedTES_R22_Round2.5_v2.root", "Config file for tau energy scale calibration"}

private

Definition at line 101 of file METSignificance.h.

{this, "TauTESConfig", "tauRecTools/R22_preprod/CombinedTES_R22_Round2.5_v2.root", "Config file for tau energy scale calibration"};

m_term_CvLT

std::map<int, double> met::METSignificance::m_term_CvLT

private

Definition at line 172 of file METSignificance.h.

m_term_VarL

std::map<int, double> met::METSignificance::m_term_VarL

private

Definition at line 170 of file METSignificance.h.

m_term_VarT

std::map<int, double> met::METSignificance::m_term_VarT

private

Definition at line 171 of file METSignificance.h.

m_treatPUJets

bool met::METSignificance::m_treatPUJets

private

Definition at line 147 of file METSignificance.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_VarL

double met::METSignificance::m_VarL

private

Definition at line 162 of file METSignificance.h.

m_VarT

double met::METSignificance::m_VarT

private

Definition at line 163 of file METSignificance.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• METSignificance.h
• METSignificance.cxx