DerivationFramework::BPhysAddMuonBasedInvMass Class Reference

Augment secondary vertices with muon-information-based mass. More...

#include <BPhysAddMuonBasedInvMass.h>

Inheritance diagram for DerivationFramework::BPhysAddMuonBasedInvMass:

Collaboration diagram for DerivationFramework::BPhysAddMuonBasedInvMass:

Public Member Functions
	BPhysAddMuonBasedInvMass (const std::string &t, const std::string &n, const IInterface *p)
	Main contructor. More...
virtual StatusCode	initialize ()
	Initialize augmentation tool. More...
virtual StatusCode	finalize ()
	Finalize augmentation tool. More...
virtual StatusCode	addBranches () const
	Main method called for each event. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	AlgTool interface methods. More...

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...
Internal protected methods
Calculate muon-information based mass values if available. Parameters [in] vtx secondary vertex [in] trkMasses ordered vector of track mass values [in] nMuRequested number of muons requested Returns muon-information based invariant mass for secondary vertex and the corresponding uncertainty
std::pair< double, double >	getMuCalcMass (xAOD::BPhysHelper &vtx, const std::vector< double > &trkMasses, int nMuRequested, BasedInvCache &cache) const
std::pair< TrackBag, int >	getTracksWithMuons (xAOD::BPhysHelper &vtx, BasedInvCache &) const
	Obtain a set of tracks with muon track information if available. More...
std::pair< double, double >	getInvariantMassWithError (TrackBag trksIn, const std::vector< double > &massHypotheses, const Amg::Vector3D &pos, BasedInvCache &) const
	Calculate invariant mass and uncertainty from a set of tracks. More...
double	getMinChi2ToAnyPV (xAOD::BPhysHelper &vtx, const xAOD::VertexContainer *pvContainer, const std::vector< int > &pvtypes, const int minNTracksInPV, const int mode, const xAOD::BPhysHelper::pv_type &pvAssocType, BasedInvCache &cache) const
	Determine minimum log chi2 of signal muon tracks w.r.t. More...
double	getTrackPVChi2 (const xAOD::TrackParticle &track, const Amg::Vector3D &pos, BasedInvCache &cache) const
	Calculate log chi2 value of a track w.r.t. More...
MuonBag	findAllMuonsInDecay (xAOD::BPhysHelper &vtx) const
	Find all muons associated to secondary vertex. More...
TrackBag	getIdTracksForMuons (MuonBag &muons) const
	Obtain a set of ID tracks for a set of muons. More...
const xAOD::TrackParticle *	adjustTrackParticle (const xAOD::Muon *muon, BasedInvCache &cache) const
	Extract TrackParticle for Muon and adjust kinematics. More...
void	initPvAssocTypeVec ()
	Initialize PV-to-SV association type vector. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
std::vector< xAOD::BPhysHelper::pv_type >	m_pvAssocTypes
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared
job options
std::string	m_branchPrefix
std::string	m_vertexContainerName
std::vector< double >	m_trkMasses
ToolHandle< Reco::ITrackToVertex >	m_trackToVertexTool
bool	m_adjustToMuonKinematics
int	m_addMinChi2ToAnyPVMode
std::string	m_pvContainerName
int	m_minNTracksInPV
std::vector< int >	m_pvTypesToConsider
int	m_doVertexType

Detailed Description

Augment secondary vertices with muon-information-based mass.

Author

Wolfgang Walkowiak wolfg.nosp@m.ang..nosp@m.walko.nosp@m.wiak.nosp@m.@cern.nosp@m..ch

Add muon-information based invarient mass to secondary vertices using a four vector sum. Optionally, it also calculates the minimum chi2 for all muon tracks of the secondary vertex candidate w.r.t. any primary vertex matching the selection criteria.

Job options provided by this class:

Name	Description
BranchPrefix	assign the prefix of added branches (possibly the derivation format's name)
VertexContainerName	name of container for vertices
TrkMasses	ordered list of track masses (Important to keep proper order: J/psi muons go first!)
TrackToVertexTool	ToolHandle for track-to-vertex tool
AdjustToMuonKinematics	Adjust the primary track particle's kinematics to the one of the muon.
AddMinChi2ToAnyPVMode	mode of minLogChi2ToAnyPV calculation: (default: 0) Value Explanation 0 no such calculation 1 use all PVs of requested type(s) 2 exclude PVs associated to SVs 3 replace PVs associated to SVs by corresponding refitted PVs
PrimaryVertexContainerName	name of container for primary vertices
MinNTracksInPV	minimum number of tracks in PV for PV to be considered in calculation of minChi2MuToAnyPV variable.
PVTypesToConsider	list of primary vertex types to consider (default: {1, 3})
DoVertexType	PV-to-SV association types to be considered (bitwise variable, see xAODBPhys::BPhysHelper) Note: only needed for AddMinChi2ToAnyPVMode > 1

Note

For a usage example see BPHY8.py .

Definition at line 105 of file BPhysAddMuonBasedInvMass.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

BPhysAddMuonBasedInvMass()

DerivationFramework::BPhysAddMuonBasedInvMass::BPhysAddMuonBasedInvMass	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Main contructor.

Definition at line 44 of file BPhysAddMuonBasedInvMass.cxx.

    : AthAlgTool(t,n,p), m_trackToVertexTool("Reco::TrackToVertex") {
 
    declareInterface<DerivationFramework::IAugmentationTool>(this);
    
    // Declare branch prefix
    declareProperty("BranchPrefix", m_branchPrefix = "_NONE_");
    // Necessary containers
    declareProperty("VertexContainerName"    , m_vertexContainerName = "");
    // track mass assignment
    declareProperty("TrkMasses", m_trkMasses = std::vector<double>());
    // track-to-vertex tool
    declareProperty("TrackToVertexTool"     , m_trackToVertexTool);
    // adjust track from muon kinematics?
    declareProperty("AdjustToMuonKinematics", m_adjustToMuonKinematics = false);
    // add minChi2ToAnyPV decoration
    declareProperty("AddMinChi2ToAnyPVMode" , m_addMinChi2ToAnyPVMode = 0);
    // name of container for primary vertices
    declareProperty("PrimaryVertexContainerName", m_pvContainerName = "");
    // minimum number of tracks in PV for PV to be considered in calculation
    // of minChi2MuToAnyPV variable    
    declareProperty("MinNTracksInPV"        , m_minNTracksInPV = 0);
    // list of primary vertex types to consider
    declareProperty("PVTypesToConsider"     , m_pvTypesToConsider = {1,3});
    // PV-to-SV association types to be considered
    declareProperty("DoVertexType"          , m_doVertexType = 63);
  }

Member Function Documentation

addBranches()

StatusCode DerivationFramework::BPhysAddMuonBasedInvMass::addBranches ( ) const

virtual

Main method called for each event.

Implements DerivationFramework::IAugmentationTool.

Definition at line 123 of file BPhysAddMuonBasedInvMass.cxx.

                                                         {
 
    ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::addBranches() -- begin");
    BasedInvCache cache;
    // vertex container and its auxilliary store
    xAOD::VertexContainer*     vtxContainer    = NULL;
    xAOD::VertexAuxContainer*  vtxAuxContainer = NULL;
 
    // retrieve from StoreGate
    CHECK(evtStore()->retrieve(vtxContainer   , m_vertexContainerName));
    CHECK(evtStore()->retrieve(vtxAuxContainer, m_vertexContainerName+"Aux."));
 
    const xAOD::VertexContainer* pvContainer = NULL;
    if ( m_addMinChi2ToAnyPVMode > 0 ) {
      CHECK(evtStore()->retrieve(pvContainer   , m_pvContainerName));
    }
 
    // apply the decorations
    std::string branchPrefix("");
    if ( m_branchPrefix != "" && m_branchPrefix != "_NONE_" ) {
      branchPrefix = m_branchPrefix + "_";
    }
    
    // loop over secondary vertices
    for (xAOD::VertexContainer::iterator vtxItr = vtxContainer->begin();
     vtxItr!=vtxContainer->end(); ++vtxItr) {
 
      xAOD::BPhysHelper vtx(*vtxItr);
      
      SG::AuxElement::Decorator< float >
    d_mucalc_mass(branchPrefix+"MUCALC_mass");
      SG::AuxElement::Decorator< float >
    d_mucalc_massErr(branchPrefix+"MUCALC_massErr");
 
      // TODO: check number of muons requested!
      std::pair<double,double> MuCalcCandMass =
    getMuCalcMass(vtx, m_trkMasses, 2, cache);
 
      // fill default values
      d_mucalc_mass(**vtxItr)    = MuCalcCandMass.first;
      d_mucalc_massErr(**vtxItr) = MuCalcCandMass.second;
 
      // add MinChi2ToAnyPV information if requested
      if ( m_addMinChi2ToAnyPVMode > 0 ) {
 
    if (m_addMinChi2ToAnyPVMode == 1) {
    // w.r.t. to all PVs
      SG::AuxElement::Decorator< float >
        d_minChi2ToAnyPV(branchPrefix+"minLogChi2ToAnyPV");
      // fill it
      d_minChi2ToAnyPV(**vtxItr) =
        getMinChi2ToAnyPV(vtx, pvContainer, m_pvTypesToConsider,
                  m_minNTracksInPV, m_addMinChi2ToAnyPVMode,
                  xAOD::BPhysHelper::PV_MIN_A0, cache); // dummy
    } else if (m_addMinChi2ToAnyPVMode > 1 && m_addMinChi2ToAnyPVMode < 4) {
      // skip or replace associated PVs
      for (auto pvAssocType : m_pvAssocTypes) {
        SG::AuxElement::Decorator< float >
          d_minChi2ToAnyPV(branchPrefix+"minLogChi2ToAnyPV_"
                   +xAOD::BPhysHelper::pv_type_str[pvAssocType]);
        // fill it
        d_minChi2ToAnyPV(**vtxItr) =
          getMinChi2ToAnyPV(vtx, pvContainer, m_pvTypesToConsider,
                m_minNTracksInPV, m_addMinChi2ToAnyPVMode,
                pvAssocType, cache);
        
      } // for pvAssocType
    } else {
      ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::addBranches():"
              << " Undefined AddMinChi2ToAnyPVMode value: "
              << m_addMinChi2ToAnyPVMode);
    }
      } // if m_addMinChi2ToAnyPVMode
    } // end of loop over vertices
      
    
    ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::addBranches() -- end");
 
    // nothing to do here
    return StatusCode::SUCCESS;
  }  

adjustTrackParticle()

const xAOD::TrackParticle * DerivationFramework::BPhysAddMuonBasedInvMass::adjustTrackParticle ( const xAOD::Muon *  muon, BasedInvCache &  cache  ) const

protected

Extract TrackParticle for Muon and adjust kinematics.

Extract primary track particle from muon; if configured adjust pt, eta and phi of it before returning a pointer to it.

Parameters

[in]

muon

pointer to muon

Returns

TrackParticle pointer

Definition at line 316 of file BPhysAddMuonBasedInvMass.cxx.

                                                                        {
 
    const xAOD::TrackParticle* tp  = NULL;    
    const xAOD::TrackParticle* org = muon->primaryTrackParticle();
 
    if ( m_adjustToMuonKinematics ) {
      if ( org != NULL ) {
    auto it = cache.adjTpCache.find(org);
    if ( it != cache.adjTpCache.end() ) {
      // copy cached link
      tp = it->second;
      ATH_MSG_DEBUG("adjustTrackParticle(): from cache: tp = " << tp);
    } else {
      // copy object -- this does not work because of seg fault later
      // xAOD::TrackParticle* newTp = new xAOD::TrackParticle(*org);
 
      // create new object and copy properties
      xAOD::TrackParticle* newTp = new xAOD::TrackParticle();
      newTp->makePrivateStore(*org);
 
      // ajdust pt, eta and phi to the muon's properties
      xAOD::IParticle::FourMom_t p4 = muon->p4();
      float qoverp = p4.P() > 0. ? 1./p4.P() : 10.e6;
      if ( org->qOverP() < 0. ) qoverp *= -1.;
      newTp->setDefiningParameters(org->d0(), org->z0(),
                       p4.Phi(), p4.Theta(), qoverp);
      // cache new TrackParticle
      cache.adjTpCache[org] = newTp;
      tp = newTp;
      ATH_MSG_DEBUG("adjustTrackParticle(): new tp = " << tp
            << " org = " << org);
    } // if it != end()
      } // if != NULL
    } else {
      // copy pointer
      tp = org;
      ATH_MSG_DEBUG("adjustTrackParticle(): copy: org: " << org
            << " -> tp: " << tp);
    }
      
    // debug output
    if ( org != NULL ) { 
      ATH_MSG_DEBUG("adjustTrackParticle(): org: " << org << " ("
            << org->d0() << "," << org->z0() << "," << org->phi0()
            << "," << org->theta() << "," << org->qOverP() << ") pt: "
            << org->pt());
    } else {
      ATH_MSG_DEBUG("adjustTrackParticle(): org = NULL");
    }
    if ( org != NULL ) { 
      ATH_MSG_DEBUG("adjustTrackParticle(): tp : " << tp << " ("
            << tp->d0() << "," << tp->z0() << "," << tp->phi0()
            << "," << tp->theta() << "," << tp->qOverP() << ") pt: "
            << tp->pt());
    } else {
      ATH_MSG_DEBUG("adjustTrackParticle(): tp = NULL");
    }
    return tp;
  }

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  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() [1/2]

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

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 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 DerivationFramework::BPhysAddMuonBasedInvMass::finalize ( )

virtual

Finalize augmentation tool.

Definition at line 115 of file BPhysAddMuonBasedInvMass.cxx.

                                                {
 
    ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::finalize()");
 
    // everything all right
    return StatusCode::SUCCESS;
  }

findAllMuonsInDecay()

MuonBag DerivationFramework::BPhysAddMuonBasedInvMass::findAllMuonsInDecay ( xAOD::BPhysHelper &  vtx ) const

protected

Find all muons associated to secondary vertex.

Returns a vector of xAOD::Muon objects found in this vertex and subsequent decay vertices. Recursively calls itself if necessary.

Parameters

[in]

vtx

secondary vertex

Returns

container of muons found

Definition at line 382 of file BPhysAddMuonBasedInvMass.cxx.

          {
 
    MuonBag muons = vtx.muons();
 
    // loop over preceeding vertices
    for (int ivtx = 0; ivtx < vtx.nPrecedingVertices(); ++ivtx) {
      xAOD::BPhysHelper precVtx(vtx.precedingVertex(ivtx));
      MuonBag muonsForVtx = findAllMuonsInDecay(precVtx);
      muons.insert(muons.end(), muonsForVtx.begin(), muonsForVtx.end());
    }
    return muons;
  }

getIdTracksForMuons()

TrackBag DerivationFramework::BPhysAddMuonBasedInvMass::getIdTracksForMuons ( MuonBag &  muons ) const

protected

Obtain a set of ID tracks for a set of muons.

Parameters

[in]

muons

container of muon objects

Returns

container of associated ID tracks

Definition at line 239 of file BPhysAddMuonBasedInvMass.cxx.

                                                                             {
 
    TrackBag muTracks;
    
    for (auto &muon : muons) {
      if ( muon != nullptr ) {
    const xAOD::TrackParticle* trk = 
      muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
    if ( trk != nullptr ) {
      muTracks.push_back(trk);
    } else {
      ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getIdTracksForMuon:"
              << " no ID track for muon found.");
    }
      } else {
    ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getIdTracksForMuon:"
            << " muon pointer is NULL!");
      }
    } // for muon
    return muTracks;
  }

getInvariantMassWithError()

std::pair< double, double > DerivationFramework::BPhysAddMuonBasedInvMass::getInvariantMassWithError ( TrackBag  trksIn, const std::vector< double > &  massHypotheses, const Amg::Vector3D &  pos, BasedInvCache &  cache  ) const

protected

Calculate invariant mass and uncertainty from a set of tracks.

Returns invariant mass and mass error given a set of tracks, their mass hypotheses and a reference position. Each track must have a separate mass hypothesis in the vector, and they must be in the same order as the tracks in the track vector. Otherwise it will go horribly wrong.

Parameters

[in]	trksIn	container with tracks to be considered
[in]	massHypoTheses	vector of mass hypotheses in the same order as the tracks
[in]	pos	position of the vertex

Returns

invariant mass value and uncertainty

Definition at line 518 of file BPhysAddMuonBasedInvMass.cxx.

                                                         {
    
  std::pair<double, double> mass(0.,0.);
 
  // ensure there is a mass hypothesis for each track
  if ( trksIn.size() == massHypotheses.size() ) {
    std::vector<const xAOD::TrackParticle*>::iterator trItr = trksIn.begin();
    std::vector<const xAOD::TrackParticle*>::iterator trItrEnd  =trksIn.end();
    auto massHypItr = massHypotheses.cbegin();
    
    double pxTmp,pyTmp,pzTmp,massTmp,eTmp;
    
    std::vector<TLorentzVector> trkMom;
    TLorentzVector totMom;
    std::vector<const Trk::Perigee*> trkPer;
    const auto &ctx = cache.ctx;
    for (;trItr != trItrEnd; ++trItr,++massHypItr){
      auto trkPerigee = 
        m_trackToVertexTool->perigeeAtVertex(ctx, *(*trItr), pos);
 
      if ( trkPerigee != NULL ) {
        // try to get the correct momentum measurement
        pxTmp = trkPerigee->momentum()[Trk::px];
        pyTmp = trkPerigee->momentum()[Trk::py];
        pzTmp = trkPerigee->momentum()[Trk::pz];
    ATH_MSG_DEBUG("getInvariantMassWithError(): pvec = ("
              << pxTmp << "," << pyTmp << "," << pzTmp << ")");
      } else {
    // otherwise default to this one
        pxTmp = ((*trItr)->p4()).Px();
        pyTmp = ((*trItr)->p4()).Py();
        pzTmp = ((*trItr)->p4()).Pz();
        ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getInvariantMassError: "
            "defaulting to simple momentum!");
      }
      trkPer.push_back(trkPerigee.release());
      massTmp = *massHypItr;
      eTmp    = pxTmp*pxTmp+pyTmp*pyTmp+pzTmp*pzTmp+massTmp*massTmp;
      eTmp    = eTmp > 0. ? sqrt(eTmp) : 0.; 
      TLorentzVector tmpMom(pxTmp, pyTmp, pzTmp, eTmp);
      trkMom.push_back(tmpMom);
      totMom += tmpMom;
    }
    mass.first = totMom.M();
    double mErr2 = 0.;
    // reset trItr
    trItr   = trksIn.begin();
    std::vector<TLorentzVector>::iterator      tmItr  = trkMom.begin();
    std::vector<const Trk::Perigee*>::iterator perItr = trkPer.begin();
    AmgVector(3) dMdP;
    dMdP.setZero();
    for (; tmItr != trkMom.end(); ++tmItr, ++trItr, ++perItr) {
      dMdP(0) = (totMom.E() * tmItr->Px()/tmItr->E() - totMom.Px())/totMom.M();
      dMdP(1) = (totMom.E() * tmItr->Py()/tmItr->E() - totMom.Py())/totMom.M();
      dMdP(2) = (totMom.E() * tmItr->Pz()/tmItr->E() - totMom.Pz())/totMom.M();
      if ( *perItr != NULL ) {
        mErr2 += (dMdP.transpose() * getMomentumCov(*perItr) * dMdP)(0,0);
      } else {
        mErr2 += (dMdP.transpose() * getMomentumCov(*trItr ) * dMdP)(0,0);
      }
    }
    mass.second = mErr2 > 0. ? sqrt(mErr2) : 0.;
    // clean up 
    for ( perItr = trkPer.begin(); perItr != trkPer.end(); ++perItr) {
      delete (*perItr);
    }
  } else {
    ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getInvariantMassError: "
            "size mismatch of tracks and mass hypotheses vectors!");
  } // if size comparison
 
  return mass;
  }

getMinChi2ToAnyPV()

double DerivationFramework::BPhysAddMuonBasedInvMass::getMinChi2ToAnyPV ( xAOD::BPhysHelper &  vtx, const xAOD::VertexContainer *  pvContainer, const std::vector< int > &  pvtypes, const int  minNTracksInPV, const int  mode, const xAOD::BPhysHelper::pv_type &  pvAssocType, BasedInvCache &  cache  ) const

protected

Determine minimum log chi2 of signal muon tracks w.r.t.

Find minimum log chi2 distance of signal muons w.r.t any primary vertex of required types and with a minimum number of tracks cut. It also depends on the mode w.r.t. the treatment of the associated primary vertex and the type of PV-to-SV association. Returns this minimum chi2.

Parameters

[in]	vtx	secondary vertex
[in]	pvContainer	container of primary vertices @parma[in] pvtypes vector of primary vertex types to be considered
[in]	minNTracksInPV	minimum number of tracks in primary vertex for it to be considered
[in]	mode	mode of operation (possible values: 0, 1, 2 ,3)
[in]	pv_type	type of PV-to-SV association

Returns

minimum log chi2 = log(d0^2/d0e^+z0^2/z0e^2) w.r.t. any primary vertex

Definition at line 404 of file BPhysAddMuonBasedInvMass.cxx.

                                                                          {
 
    MuonBag  muons  = findAllMuonsInDecay(vtx);
    TrackBag tracks = getIdTracksForMuons(muons);
    const xAOD::Vertex* origPV = nullptr;
    const xAOD::Vertex* refPV  = nullptr;
 
    if ( mode > 1 ) {
      // need to obtain original PV
      origPV = vtx.origPv(pvAssocType);
      if ( origPV == nullptr ) {
    ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getMinChi2ToAnyPV:"
            << " origPV == NULL for pvAssocType = "
            << pvAssocType);
      }
      if ( mode > 2 ) {
    refPV  = vtx.pv(pvAssocType);
    if ( refPV == nullptr ) {
      ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getMinChi2ToAnyPV:"
              << " refPV == NULL for pvAssocType = "
              << pvAssocType);
    }
      }
    }
    
    double minChi2 = std::numeric_limits<double>::max();
 
    for (const auto pvtx : *pvContainer) {
      if ( pvtx != nullptr ) {
    if ( std::find(pvtypes.begin(),pvtypes.end(),pvtx->vertexType())
         != pvtypes.end() ) {
      const xAOD::Vertex* cvtx = pvtx;
      // switch if PV matches original PV and replacement is requested
      if ( mode > 1 && pvtx == origPV ) {
        // mode 2 -- skip
        switch(mode) {
        case 2: // skip current PV
          continue;
          break;
        case 3: // replace by refitted PV
          if ( refPV != nullptr ) {
        cvtx = refPV;
          } else {
        ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getMinChi2ToAnyPV:"
                << " refPV == NULL!");
        continue;
          }
          break;
        }
      }
      if ( (int)cvtx->nTrackParticles() >= minNTracksInPV ) {
        for (auto &track : tracks) {
          const Amg::Vector3D pos = cvtx->position();
          minChi2 = std::min(minChi2, getTrackPVChi2(*track, pos, cache));
        } // for track
      } // if minNTracksInPV
    } // if pvTypes in pvtypes vector
      }  else {
    ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getMinChi2ToAnyPV:"
            << " pvtx == NULL!");
      } // if vtx != nullptr
    } // for pvtx
    
    return minChi2;
  }

getMuCalcMass()

std::pair< double, double > DerivationFramework::BPhysAddMuonBasedInvMass::getMuCalcMass ( xAOD::BPhysHelper &  vtx, const std::vector< double > &  trkMasses, int  nMuRequested, BasedInvCache &  cache  ) const

protected

Definition at line 208 of file BPhysAddMuonBasedInvMass.cxx.

                                                                    {
 
    std::pair<double, double> mpe(0., -1.);
 
    std::pair<TrackBag, int> tracksWithMu = getTracksWithMuons(vtx, cache);
 
    if ( tracksWithMu.second == nMuRequested ) {
      if ( tracksWithMu.first.size() == trkMasses.size() ) {
    mpe = getInvariantMassWithError(tracksWithMu.first,
                    trkMasses,
                    vtx.vtx()->position(), cache);
      } else {
    ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getMuCalcMass:"
            << " vector sizes disagree!"
            << " tracksWithMu: " << tracksWithMu.first.size()
            << " BtrkMasses: " << trkMasses.size());
      }
    } else {
      mpe.second = -10 - tracksWithMu.second;
      ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::getMuCalcMass:"
            << " muon number mismatch:"
            << " tracksWithMu: " << tracksWithMu.second
            << " requested: " << nMuRequested);
    }
    return mpe;
  }

getTrackPVChi2()

double DerivationFramework::BPhysAddMuonBasedInvMass::getTrackPVChi2 ( const xAOD::TrackParticle &  track, const Amg::Vector3D &  pos, BasedInvCache &  cache  ) const

protected

Calculate log chi2 value of a track w.r.t.

a position.

Calculate the log chi2 ( = log((d0/d0e)^2+(z0/z0e)^2) contribution of a track at the position closest to the given PV.

Parameters

[in]	track	track considered
[in]	pos	position considered

Returns

log chi2 value

Definition at line 483 of file BPhysAddMuonBasedInvMass.cxx.

                                                                           {
    
  double chi2 = -100.;
 
  auto trkPerigee =
    m_trackToVertexTool->perigeeAtVertex(cache.ctx, track, pos);
  if ( trkPerigee != NULL ) {
    const AmgSymMatrix(5)* locError = trkPerigee->covariance();
    if ( locError != NULL ) {
      double d0    = trkPerigee->parameters()[Trk::d0];
      double z0    = trkPerigee->parameters()[Trk::z0];
      double d0Err = Amg::error(*locError, Trk::d0);
      double z0Err = Amg::error(*locError, Trk::z0);
      if (fabs(d0Err) > 0. && fabs(z0Err) > 0.) { 
    chi2 = log( pow(d0/d0Err,2.0) + pow(z0/z0Err,2.0) );
      } else {
    ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getTrackPVChi2():"
            << " d0 = " << d0 << ", d0Err = " << d0Err
            << ", z0 = " << z0 << ", z0Err = " << z0Err);
      }
    } // locError != NULL
  } else {
    ATH_MSG_WARNING("getTrackPVChi2: Could not get perigee");
  }
 
  return chi2;
}

getTracksWithMuons()

std::pair< TrackBag, int > DerivationFramework::BPhysAddMuonBasedInvMass::getTracksWithMuons ( xAOD::BPhysHelper &  vtx, BasedInvCache &  cache  ) const

protected

Obtain a set of tracks with muon track information if available.

Parameters

[in]

vtx

secondary vertex

Returns

container of muon tracks, number of muons found

Definition at line 264 of file BPhysAddMuonBasedInvMass.cxx.

                                                                                               {
    
    TrackBag            tracksWithMu;
    int                 nMuFound = 0;
    std::vector<int>    vnMuFound;
 
    MuonBag muons = findAllMuonsInDecay(vtx);
 
    if ( muons.size() > 0 ) {
      for (int itrk=0; itrk<vtx.nRefTrks(); ++itrk) {
    // only charged tracks are of interest
    if ( abs(vtx.refTrkCharge(itrk)) > 0. ) {
      const xAOD::TrackParticle* trkParticle =
        (xAOD::TrackParticle*)vtx.refTrkOrigin(itrk);
      for (unsigned int imu = 0; imu<muons.size(); ++imu) {
        if ( vtx.refTrkOrigin(itrk) ==
         muons.at(imu)->trackParticle(xAOD::Muon::InnerDetectorTrackParticle) ) {
          const xAOD::TrackParticle* trkMuon = 
        adjustTrackParticle(muons.at(imu), cache);
          if ( trkMuon != NULL ) {
        trkParticle    = trkMuon;
        nMuFound++;
        break;
          }
        }
      } // for imu
      tracksWithMu.push_back(trkParticle);
      vnMuFound.push_back(nMuFound);
    } // for charged track
      } // for itrk
    } else {
      ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::getTracksWithMuons: "
            "vertex contains no muons, but "
            << vtx.nRefTrks() << " refitted tracks ...");
    }
    // debug output
    std::string svnMuFound    = "[";
    for (unsigned int i=0; i<vnMuFound.size(); ++i) {
      svnMuFound  += std::to_string(vnMuFound[i]) + ',';
    }
    svnMuFound.back()    = ']';
    ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::getTracksWithMuons: "
          "nMuFound     = " << nMuFound
          << "\nvnMuFound    = " << svnMuFound );
    
    return std::pair<TrackBag, int>(std::move(tracksWithMu), nMuFound);
  }

initialize()

StatusCode DerivationFramework::BPhysAddMuonBasedInvMass::initialize ( )

virtual

Initialize augmentation tool.

Definition at line 74 of file BPhysAddMuonBasedInvMass.cxx.

                                                  {
  
    ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::initialize() -- begin");
 
    // candidate vertices container
    if ( m_vertexContainerName == "" ) {
      ATH_MSG_ERROR("No vertex container name provided!");
    }
    
    // TrackToVertexTool
    CHECK(m_trackToVertexTool.retrieve());
 
    // PV container if needed
    if ( m_addMinChi2ToAnyPVMode > 0 && m_pvContainerName == "" ) {
      ATH_MSG_ERROR("No primary vertex container name provided!");
    }
 
    // PV type list if needed
    if ( m_addMinChi2ToAnyPVMode > 0 && m_pvTypesToConsider.size() == 0 ) {
      ATH_MSG_ERROR("No primary vertex types to be considered provided!");
    }
 
    // PV-to-SV association type if needed
    if ( m_addMinChi2ToAnyPVMode > 1 && m_doVertexType < 1 ) {
      ATH_MSG_ERROR("No PV-to-SV association types to be considered provided!");
    }
    
    ATH_MSG_INFO("BPhysAddMuonBasedInvMass::initialize(): "
         << "AdjustToMuonKinematics = " << m_adjustToMuonKinematics);
    
    ATH_MSG_INFO("BPhysAddMuonBasedInvMass::initialize(): "
         << "AddMinChi2ToAnyPVMode = " << m_addMinChi2ToAnyPVMode);
 
    // initialize PV-to-SV association type vector
    initPvAssocTypeVec();
    
    ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::initialize() -- end");
 
    return StatusCode::SUCCESS;
  }  

initPvAssocTypeVec()

void DerivationFramework::BPhysAddMuonBasedInvMass::initPvAssocTypeVec ( )

protected

Initialize PV-to-SV association type vector.

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.

interfaceID()

static const InterfaceID& DerivationFramework::IAugmentationTool::interfaceID ( )

inlinestaticinherited

AlgTool interface methods.

Definition at line 31 of file IAugmentationTool.h.

{ return IID_IAugmentationTool; }

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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.

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 380 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 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

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 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_addMinChi2ToAnyPVMode

int DerivationFramework::BPhysAddMuonBasedInvMass::m_addMinChi2ToAnyPVMode

private

Definition at line 282 of file BPhysAddMuonBasedInvMass.h.

m_adjustToMuonKinematics

bool DerivationFramework::BPhysAddMuonBasedInvMass::m_adjustToMuonKinematics

private

Definition at line 281 of file BPhysAddMuonBasedInvMass.h.

m_branchPrefix

std::string DerivationFramework::BPhysAddMuonBasedInvMass::m_branchPrefix

private

Definition at line 277 of file BPhysAddMuonBasedInvMass.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doVertexType

int DerivationFramework::BPhysAddMuonBasedInvMass::m_doVertexType

private

Definition at line 286 of file BPhysAddMuonBasedInvMass.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_minNTracksInPV

int DerivationFramework::BPhysAddMuonBasedInvMass::m_minNTracksInPV

private

Definition at line 284 of file BPhysAddMuonBasedInvMass.h.

m_pvAssocTypes

std::vector<xAOD::BPhysHelper::pv_type> DerivationFramework::BPhysAddMuonBasedInvMass::m_pvAssocTypes

private

cache for individual vertex types

Definition at line 291 of file BPhysAddMuonBasedInvMass.h.

m_pvContainerName

std::string DerivationFramework::BPhysAddMuonBasedInvMass::m_pvContainerName

private

Definition at line 283 of file BPhysAddMuonBasedInvMass.h.

m_pvTypesToConsider

std::vector<int> DerivationFramework::BPhysAddMuonBasedInvMass::m_pvTypesToConsider

private

Definition at line 285 of file BPhysAddMuonBasedInvMass.h.

m_trackToVertexTool

ToolHandle<Reco::ITrackToVertex> DerivationFramework::BPhysAddMuonBasedInvMass::m_trackToVertexTool

private

Definition at line 280 of file BPhysAddMuonBasedInvMass.h.

m_trkMasses

std::vector<double> DerivationFramework::BPhysAddMuonBasedInvMass::m_trkMasses

private

Definition at line 279 of file BPhysAddMuonBasedInvMass.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vertexContainerName

std::string DerivationFramework::BPhysAddMuonBasedInvMass::m_vertexContainerName

private

Definition at line 278 of file BPhysAddMuonBasedInvMass.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• BPhysAddMuonBasedInvMass.h
• BPhysAddMuonBasedInvMass.cxx