DerivationFramework::BPhysPVCascadeTools Class Reference

#include <BPhysPVCascadeTools.h>

Inheritance diagram for DerivationFramework::BPhysPVCascadeTools:

Collaboration diagram for DerivationFramework::BPhysPVCascadeTools:

Public Member Functions
	BPhysPVCascadeTools (const CascadeTools *cascadeTools)
	BPhysPVCascadeTools (const CascadeTools *cascadeTools, const xAOD::EventInfo *)
void	ProcessVertex (const std::vector< TLorentzVector > &mom, Amg::MatrixX cov, xAOD::BPhysHypoHelper &vtx, xAOD::BPhysHelper::pv_type pvtype, double mass) const
void	FillBPhysHelper (const std::vector< TLorentzVector > &mom, Amg::MatrixX cov, xAOD::BPhysHelper &vtx, const xAOD::Vertex *refPV, const xAOD::VertexContainer *refPvContainer, xAOD::BPhysHelper::pv_type pvtype, int) const
	Fills the BPhysHelper object with the standard parameters.
size_t	FindLowZIndex (const std::vector< TLorentzVector > &mom, const xAOD::BPhysHelper &Obj, const std::vector< const xAOD::Vertex * > &PVlist, const size_t PV_minNTracks=0) const
	Returns the index integer of the vertex with the lowest Z in relation to the given vertex.
size_t	FindLowA0Index (const std::vector< TLorentzVector > &mom, const xAOD::BPhysHelper &Obj, const std::vector< const xAOD::Vertex * > &PVlist, const size_t PV_minNTracks=0) const
	Returns the index integer of the vertex with the lowest A0 in relation to the given vertex.
void	SetMinNTracksInPV (size_t PV_minNTracks)
	Set the minimum number of tracks required for primary vertices to be considered for primary vertex association to a secondary vertex.
Amg::Vector3D	GetBeamSpot () const
	Get the current beamspot position either from cache or from BeamCondSvc.
size_t	FindLowZ0BAIndex (const std::vector< TLorentzVector > &mom, const xAOD::BPhysHelper &obj, const std::vector< const xAOD::Vertex * > &PVlist, const size_t PV_minNTracks=0) const
	Find the index for the PV with the lowest distance in z of the SV's DOCA point w.r.t.
double	DistInZtoDOCA (const std::vector< TLorentzVector > &mom, const xAOD::BPhysHelper &obj, const xAOD::Vertex *vertex) const
	Calculate the distance along z axis between the PV and SV's DOCA point w.r.t.
Amg::Vector3D	DocaExtrapToBeamSpot (const std::vector< TLorentzVector > &mom, const xAOD::BPhysHelper &obj) const
	Point of DOCA w.r.t.
StatusCode	FillCandwithRefittedVertices (bool refitPV, const xAOD::VertexContainer *pvContainer, xAOD::VertexContainer *refPvContainer, const Analysis::PrimaryVertexRefitter *pvRefitter, size_t in_PV_max, int DoVertexType, Trk::VxCascadeInfo *casc, int index, double mass, xAOD::BPhysHypoHelper &vtx)
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Static Public Member Functions
template<size_t NTracks>
static bool	VerticesMatchTracks (const xAOD::Vertex *v1, const xAOD::Vertex *v2)
template<size_t NTracks>
static const xAOD::Vertex *	FindVertex (const xAOD::VertexContainer *c, const xAOD::Vertex *v)
static std::vector< const xAOD::Vertex * >	GetGoodPV (const xAOD::VertexContainer *pvContainer)
	Static method call with DerivationFramework::BPhysDerHelpers::GetGoodPV Returns a std::vector containing only PVs of type 1 and 3 - HighPt and Pileup, which have at least PV_minNTracks tracks.
static void	PrepareVertexLinks (Trk::VxCascadeInfo *result, const xAOD::TrackParticleContainer *importedTrackCollection)
static void	PrepareVertexLinks (Trk::VxCascadeInfo *result, const std::vector< const xAOD::TrackParticleContainer * > &)
static std::vector< const xAOD::TrackParticle * >	CollectAllChargedTracks (const std::vector< xAOD::Vertex * > &cascadeVertices)
static void	SetVectorInfo (xAOD::BPhysHelper &, const Trk::VxCascadeInfo *)
static bool	uniqueCollection (const std::vector< const xAOD::TrackParticle * > &)
static bool	uniqueCollection (const std::vector< const xAOD::TrackParticle * > &, const std::vector< const xAOD::TrackParticle * > &)
static bool	LinkVertices (SG::AuxElement::Decorator< VertexLinkVector > &decor, const std::vector< const xAOD::Vertex * > &vertices, const xAOD::VertexContainer *vertexContainer, const xAOD::Vertex *vert)
static double	getParticleMass (const HepPDT::ParticleDataTable *pdt, int pdg)

Public Attributes
bool	m_copyAllVertices

Private Types
typedef ElementLink< xAOD::VertexContainer >	VertexLink
typedef std::vector< VertexLink >	VertexLinkVector

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
const CascadeTools *	m_cascadeTools
const xAOD::EventInfo *	m_eventInfo
size_t	m_PV_minNTracks
	minimum number of tracks required in PVs considered
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Definition at line 34 of file BPhysPVCascadeTools.h.

Member Typedef Documentation

VertexLink

typedef ElementLink<xAOD::VertexContainer> DerivationFramework::BPhysPVCascadeTools::VertexLink

private

Definition at line 35 of file BPhysPVCascadeTools.h.

VertexLinkVector

typedef std::vector<VertexLink> DerivationFramework::BPhysPVCascadeTools::VertexLinkVector

private

Definition at line 36 of file BPhysPVCascadeTools.h.

Constructor & Destructor Documentation

BPhysPVCascadeTools() [1/2]

DerivationFramework::BPhysPVCascadeTools::BPhysPVCascadeTools

(

const CascadeTools *

cascadeTools

)

Definition at line 17 of file BPhysPVCascadeTools.cxx.

                                                                                            :
  AthMessaging("BPhysPVCascadeTools"),
  m_cascadeTools(cascadeTools), m_eventInfo(nullptr), m_PV_minNTracks(0),
  m_copyAllVertices(true)
{
}

BPhysPVCascadeTools() [2/2]

DerivationFramework::BPhysPVCascadeTools::BPhysPVCascadeTools	(	const CascadeTools *	cascadeTools,
		const xAOD::EventInfo *	eventinfo )

Definition at line 24 of file BPhysPVCascadeTools.cxx.

                                                                                :
  AthMessaging("BPhysPVCascadeTools"),
  m_cascadeTools(cascadeTools), m_eventInfo(eventinfo), m_PV_minNTracks(0),
  m_copyAllVertices(true)
{
}

Member Function Documentation

CollectAllChargedTracks()

std::vector< const xAOD::TrackParticle * > DerivationFramework::BPhysPVCascadeTools::CollectAllChargedTracks ( const std::vector< xAOD::Vertex * > & cascadeVertices )

static

Definition at line 246 of file BPhysPVCascadeTools.cxx.

{
  std::vector<const xAOD::TrackParticle*> exclTrk;
  for( size_t jt=0; jt<cascadeVertices.size(); jt++) {
    for( size_t it=0; it<cascadeVertices[jt]->vxTrackAtVertex().size(); it++) {
     if(cascadeVertices[jt]->trackParticle(it)->charge() != 0) exclTrk.push_back(cascadeVertices[jt]->trackParticle(it));
    }
  }
  return exclTrk;
}

DistInZtoDOCA()

double DerivationFramework::BPhysPVCascadeTools::DistInZtoDOCA	(	const std::vector< TLorentzVector > &	mom,
		const xAOD::BPhysHelper &	obj,
		const xAOD::Vertex *	vertex ) const

Calculate the distance along z axis between the PV and SV's DOCA point w.r.t.

the beamline.

Definition at line 174 of file BPhysPVCascadeTools.cxx.

                                                                                                                                                             {
 
  Amg::Vector3D pv    = vertex->position();
  Amg::Vector3D xDOCA = DocaExtrapToBeamSpot(mom, obj);
  Amg::Vector3D vec   = pv - xDOCA;
  return vec.z();
}

DocaExtrapToBeamSpot()

Amg::Vector3D DerivationFramework::BPhysPVCascadeTools::DocaExtrapToBeamSpot	(	const std::vector< TLorentzVector > &	mom,
		const xAOD::BPhysHelper &	obj ) const

Point of DOCA w.r.t.

the beamline backward extrapolated along the B candidate's momentum direction.

Definition at line 183 of file BPhysPVCascadeTools.cxx.

                                                                                                                                               {
 
  Amg::Vector3D xDOCA(-99999., -99999., -99999.);
  TLorentzVector totalMom;
  unsigned int NTrk = mom.size();
  for( unsigned int it=0; it<NTrk; it++) totalMom += mom[it];
  TVector3      totP = totalMom.Vect();
  Amg::Vector3D pSV(totP.X(), totP.Y(), totP.Z());
  Amg::Vector3D pT(pSV.x(), pSV.y(), 0.);
  if ( pT.mag2() > 0 ) {
    Amg::Vector3D xBS = GetBeamSpot();
    Amg::Vector3D xSV = obj.vtx()->position();
    Amg::Vector3D xT(xSV.x()-xBS.x(), xSV.y()-xBS.y(), 0.);
    xDOCA = xSV - pSV*pT.dot(xT)/pT.mag2();
  } else {
    std::cout << "BPhysPVCascadeTools::DocaExtrapToBeamSpot: WARNING pT == 0."
          << std::endl;
  }
  return xDOCA;
}

FillBPhysHelper()

void DerivationFramework::BPhysPVCascadeTools::FillBPhysHelper	(	const std::vector< TLorentzVector > &	mom,
		Amg::MatrixX	cov,
		xAOD::BPhysHelper &	vtx,
		const xAOD::Vertex *	refPV,
		const xAOD::VertexContainer *	refPvContainer,
		xAOD::BPhysHelper::pv_type	pvtype,
		int	refitCode ) const

Fills the BPhysHelper object with the standard parameters.

Definition at line 32 of file BPhysPVCascadeTools.cxx.

                                                                                {
 
  BPHYS_CHECK( vtx.setPv      ( PV, PvContainer, pvtype ) );
 
  // cout << "BPhysPVCascadeTools::FillBPhysHelper for pvtype = " << pvtype << endl;
  // cout << "lxy " << m_cascadeTools->lxy(mom, vtx.vtx(), PV) << " error " << m_cascadeTools->lxyError(mom, cov, vtx.vtx(), PV) << endl;
 
  // set variables calculated from PV
  BPHYS_CHECK( vtx.setLxy    ( m_cascadeTools->lxy       (mom, vtx.vtx(), PV), pvtype ) );
  BPHYS_CHECK( vtx.setLxyErr ( m_cascadeTools->lxyError  (mom, cov, vtx.vtx(), PV), pvtype ) );
  BPHYS_CHECK( vtx.setA0     ( m_cascadeTools->a0        (mom, vtx.vtx(), PV), pvtype ) );
  BPHYS_CHECK( vtx.setA0Err  ( m_cascadeTools->a0Error   (mom, cov, vtx.vtx(), PV), pvtype ) );
  BPHYS_CHECK( vtx.setA0xy   ( m_cascadeTools->a0xy      (mom, vtx.vtx(), PV), pvtype ) );
  BPHYS_CHECK( vtx.setA0xyErr( m_cascadeTools->a0xyError (mom, cov, vtx.vtx(), PV), pvtype ) );
  BPHYS_CHECK( vtx.setZ0     ( m_cascadeTools->a0z       (mom, vtx.vtx(), PV), pvtype ) );
  BPHYS_CHECK( vtx.setZ0Err  ( m_cascadeTools->a0zError  (mom, cov, vtx.vtx(), PV), pvtype ) );
  BPHYS_CHECK( vtx.setRefitPVStatus  ( refitCode, pvtype ) );
 
}

FillCandwithRefittedVertices()

StatusCode DerivationFramework::BPhysPVCascadeTools::FillCandwithRefittedVertices	(	bool	refitPV,
		const xAOD::VertexContainer *	pvContainer,
		xAOD::VertexContainer *	refPvContainer,
		const Analysis::PrimaryVertexRefitter *	pvRefitter,
		size_t	in_PV_max,
		int	DoVertexType,
		Trk::VxCascadeInfo *	casc,
		int	index,
		double	mass,
		xAOD::BPhysHypoHelper &	vtx )

Definition at line 257 of file BPhysPVCascadeTools.cxx.

{
    static const Trk::V0Tools* const dummy = nullptr;
    static const DerivationFramework::BPhysPVTools pvtool(dummy);
 
    const std::vector<TLorentzVector> &mom = casc->getParticleMoms()[index];
    const Amg::MatrixX &cov = casc->getCovariance()[index];
    const std::vector<xAOD::Vertex*> &cascadeVertices = casc->vertices();
    const bool doPt   = (DoVertexType & 1) != 0;
    const bool doA0   = (DoVertexType & 2) != 0;
    const bool doZ0   = (DoVertexType & 4) != 0;
    const bool doZ0BA = (DoVertexType & 8) != 0;
 
    // Collect the tracks that should be excluded from the PV
    std::vector<const xAOD::TrackParticle*> exclTrk = CollectAllChargedTracks(cascadeVertices);
 
 
    const std::vector<const xAOD::Vertex*> GoodPVs = GetGoodPV(pvContainer);
    // 2) PV dependent variables
    if (GoodPVs.empty() == false) {
       if (refitPV) {
         size_t pVmax =std::min((size_t)in_PV_max, GoodPVs.size());
         std::vector<const xAOD::Vertex*> refPVvertexes;
         std::vector<xAOD::Vertex*> refPVvertexes_toDelete;
         std::vector<int> exitCode;
         refPVvertexes.reserve(pVmax);
         refPVvertexes_toDelete.reserve(pVmax);
         exitCode.reserve(pVmax);
 
         // Refit the primary vertex and set the related decorations.
 
         for (size_t i =0; i < pVmax ; i++) {
           const xAOD::Vertex* oldPV = GoodPVs.at(i);
           // when set to false this will return null when a new vertex is not required
//           ATH_MSG_DEBUG("old PV x " << oldPV->x() << " y " << oldPV->y() << " z " << oldPV->z());
           int exitcode = 0;
           xAOD::Vertex* refPV = pvRefitter->refitVertex(oldPV, exclTrk, m_copyAllVertices, &exitcode);
//           if (refPV) ATH_MSG_DEBUG("ref PV x " << refPV->x() << " y " << refPV->y() << " z " << refPV->z());
           exitCode.push_back(exitcode);
           // we want positioning to match the goodPrimaryVertices
           if (refPV == nullptr) {
              refPVvertexes.push_back(oldPV);
              refPVvertexes_toDelete.push_back(nullptr);
           } else {
              refPVvertexes.push_back(refPV);
              refPVvertexes_toDelete.push_back(refPV);
           }
        }
         boost::container::static_vector<size_t, 4> indexesUsed;
         boost::container::static_vector<std::pair<size_t, xAOD::BPhysHelper::pv_type>, 4> indexestoProcess;
 
         if(doPt){
            indexestoProcess.push_back(std::make_pair
                (pvtool.FindHighPtIndex(refPVvertexes), xAOD::BPhysHelper::PV_MAX_SUM_PT2));
         }
         if(doA0) {
            indexestoProcess.push_back(std::make_pair( FindLowA0Index(mom, vtx, refPVvertexes, m_PV_minNTracks),  
              xAOD::BPhysHelper::PV_MIN_A0));
         }
         if(doZ0) {
            indexestoProcess.push_back(std::make_pair(FindLowZIndex(mom, vtx, refPVvertexes, m_PV_minNTracks),
                    xAOD::BPhysHelper::PV_MIN_Z0));
         }
         if(doZ0BA) {
            size_t lowZBA = FindLowZ0BAIndex(mom, vtx, refPVvertexes, m_PV_minNTracks);
            if( lowZBA < pVmax ) { 
               indexestoProcess.push_back(std::make_pair(lowZBA, xAOD::BPhysHelper::PV_MIN_Z0_BA));
            }
            else pvtool.FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA);
         }
 
         for(size_t i =0 ; i<indexestoProcess.size(); i++){
             //if refitted add to refitted container
             auto index  = indexestoProcess[i].first;
             auto pvtype = indexestoProcess[i].second;
             const xAOD::VertexContainer* ParentContainer =
                 (refPVvertexes_toDelete.at(index)) ? refPvContainer : pvContainer;
             if(ParentContainer == refPvContainer && std::find(indexesUsed.begin(),
                                      indexesUsed.end(), index) == indexesUsed.end()) {
                 // store the new vertex
                 refPvContainer->push_back(refPVvertexes_toDelete.at(index));
                 indexesUsed.push_back(index);
             }
             FillBPhysHelper(mom, cov, vtx, refPVvertexes[index],
                  ParentContainer, pvtype, exitCode[index]);
             vtx.setOrigPv(GoodPVs[index], pvContainer, pvtype);               
         }
          //nullify ptrs we want to keep so these won't get deleted
         //"delete null" is valid in C++ and does nothing so this is quicker than a lot of if statements
         for(size_t x : indexesUsed) refPVvertexes_toDelete[x] = nullptr;
          //Loop over toDELETE container, anything that is used or was not refitted is null
         //This cleans up all extra vertices that were created and not used
         for(const xAOD::Vertex* ptr : refPVvertexes_toDelete) delete ptr;
         refPVvertexes.clear(); // Clear lists of now dangling ptrs
         refPVvertexes_toDelete.clear();
         exitCode.clear();
 
       } else {
            // 2.a) the first PV with the largest sum pT.
         if(doPt) {
           size_t highPtindex = pvtool.FindHighPtIndex(GoodPVs); // Should be 0 in PV ordering
           FillBPhysHelper(mom, cov, vtx, GoodPVs[highPtindex], pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2, 0);
         }
         // 2.b) the closest in 3D:
         if(doA0) {
           size_t lowA0 =  FindLowA0Index(mom, vtx, GoodPVs, m_PV_minNTracks);
           FillBPhysHelper(mom, cov, vtx, GoodPVs[lowA0], pvContainer, xAOD::BPhysHelper::PV_MIN_A0, 0);
         }
         // 2.c) the closest in Z:
         if(doZ0) {
           size_t lowZ  = FindLowZIndex(mom, vtx, GoodPVs, m_PV_minNTracks);
           FillBPhysHelper(mom, cov, vtx, GoodPVs[lowZ], pvContainer, xAOD::BPhysHelper::PV_MIN_Z0, 0);
         }
         // 2.d) the closest in Z (DOCA w.r.t. beam axis):
         if(doZ0BA) {
           size_t lowZBA = FindLowZ0BAIndex(mom, vtx, GoodPVs, m_PV_minNTracks);
           if ( lowZBA < GoodPVs.size() ) { // safety against vector index out-of-bounds
             FillBPhysHelper(mom, cov, vtx, GoodPVs[lowZBA], pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, 0);
           } else {
             // nothing found -- fill NULL
             pvtool.FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA);
           }
         }
       } // refitPV
     } else {
 
      if(pvContainer->empty()) return StatusCode::FAILURE;
      const xAOD::Vertex* Dummy = pvContainer->at(0);
 
          // 2.a) the first PV with the largest sum pT.
      if(doPt) {
        FillBPhysHelper(mom, cov, vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2, 0);
        if(refitPV) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2);
      }
      // 2.b) the closest in 3D:
      if(doA0) {
        FillBPhysHelper(mom, cov, vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_A0, 0);
        if(refitPV) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_A0);
      }
      // 2.c) the closest in Z:
      if(doZ0) {
        FillBPhysHelper(mom, cov, vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0, 0);
        if(refitPV) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0);
      }
      // 2.d) the closest in Z (DOCA w.r.t. beam axis):
      if(doZ0BA) {
        FillBPhysHelper(mom, cov, vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, 0);
        if(refitPV) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA);
      }
   } // GoodPVs.empty()
 
   // 3) proper decay time and error:
   // retrieve the refitted PV (or the original one, if the PV refitting was turned off)
   if(doPt)   ProcessVertex(mom, cov, vtx, xAOD::BPhysHelper::PV_MAX_SUM_PT2, mass);
   if(doA0)   ProcessVertex(mom, cov, vtx, xAOD::BPhysHelper::PV_MIN_A0, mass);
   if(doZ0)   ProcessVertex(mom, cov, vtx, xAOD::BPhysHelper::PV_MIN_Z0, mass);
   if(doZ0BA) ProcessVertex(mom, cov, vtx, xAOD::BPhysHelper::PV_MIN_Z0_BA, mass);
 
   return StatusCode::SUCCESS;
}

FindLowA0Index()

size_t DerivationFramework::BPhysPVCascadeTools::FindLowA0Index	(	const std::vector< TLorentzVector > &	mom,
		const xAOD::BPhysHelper &	Obj,
		const std::vector< const xAOD::Vertex * > &	PVlist,
		const size_t	PV_minNTracks = 0 ) const

Returns the index integer of the vertex with the lowest A0 in relation to the given vertex.

Definition at line 98 of file BPhysPVCascadeTools.cxx.

                                                               {
    size_t lowA0  = 0;
    if(PVlist.empty()) {
        lowA0=std::numeric_limits<std::size_t>::max();
        return lowA0;
    }
    size_t size = PVlist.size();
    double lowA0calc  = m_cascadeTools->a0(mom, Obj.vtx(), PVlist[0]);
    for(size_t i =1; i<size; i++) {
      if ( PVlist[i]->nTrackParticles() >= PV_minNTracks ) {
    double a0 =  m_cascadeTools->a0(mom, Obj.vtx(), PVlist[i]);
    if(a0 < lowA0calc) {
      lowA0calc = a0;
      lowA0 =i;
    }
      }
    }
    return lowA0;
}

FindLowZ0BAIndex()

size_t DerivationFramework::BPhysPVCascadeTools::FindLowZ0BAIndex	(	const std::vector< TLorentzVector > &	mom,
		const xAOD::BPhysHelper &	obj,
		const std::vector< const xAOD::Vertex * > &	PVlist,
		const size_t	PV_minNTracks = 0 ) const

Find the index for the PV with the lowest distance in z of the SV's DOCA point w.r.t.

the beamline and the PV.

Definition at line 155 of file BPhysPVCascadeTools.cxx.

                                                                 {
  
  size_t ilowZ0BA   = std::numeric_limits<std::size_t>::max();
  double lowZ0BAcalc = std::numeric_limits<double>::max(); 
  for (size_t i = 0; i<PVlist.size(); ++i) {
    if ( PVlist[i]->nTrackParticles() >= PV_minNTracks ) {
      double z0BA =  m_cascadeTools->a0(mom, obj.vtx(), PVlist[i]);
      if (z0BA < lowZ0BAcalc) {
    lowZ0BAcalc = z0BA;
    ilowZ0BA = i;
      }
    }
  }
  return ilowZ0BA;
}

FindLowZIndex()

size_t DerivationFramework::BPhysPVCascadeTools::FindLowZIndex	(	const std::vector< TLorentzVector > &	mom,
		const xAOD::BPhysHelper &	Obj,
		const std::vector< const xAOD::Vertex * > &	PVlist,
		const size_t	PV_minNTracks = 0 ) const

Returns the index integer of the vertex with the lowest Z in relation to the given vertex.

Definition at line 76 of file BPhysPVCascadeTools.cxx.

                                                              {
  size_t lowZ  = 0;
  if(PVlist.empty()) {
    lowZ=std::numeric_limits<std::size_t>::max();
    return lowZ;
  }
  size_t size = PVlist.size();
  double lowA0zcalc = fabs(m_cascadeTools->a0z       (mom, Obj.vtx(), PVlist[0]));
  for(size_t i =1; i<size; i++) {
    if ( PVlist[i]->nTrackParticles() >= PV_minNTracks ) {
      double a0z =  fabs(m_cascadeTools->a0z(mom, Obj.vtx(), PVlist[i]));
      if(a0z < lowA0zcalc) {
    lowA0zcalc = a0z;
    lowZ =i;
      }
    }
  }
  return lowZ;
}

FindVertex()

template<size_t NTracks>

const xAOD::Vertex * DerivationFramework::BPhysPVCascadeTools::FindVertex ( const xAOD::VertexContainer * c, const xAOD::Vertex * v )

static

Definition at line 145 of file BPhysPVCascadeTools.h.

                                                                                                                     {
   for (const xAOD::Vertex* a : *c){
      if(VerticesMatchTracks<NTracks>(a,v)) return a;
   }
   return nullptr;
}

GetBeamSpot()

Amg::Vector3D DerivationFramework::BPhysPVCascadeTools::GetBeamSpot ( ) const

nodiscard

Get the current beamspot position either from cache or from BeamCondSvc.

Before processing a new event, make sure to call GetBeamSpot();

Definition at line 146 of file BPhysPVCascadeTools.cxx.

                                                                      {
  if(m_eventInfo) return Amg::Vector3D(m_eventInfo->beamPosX(), m_eventInfo->beamPosY(), m_eventInfo->beamPosZ());
  else {
    static const Amg::Vector3D defaultBS(-10000.,-10000.,-10000.);
    return defaultBS;
  } 
}

GetGoodPV()

std::vector< const xAOD::Vertex * > DerivationFramework::BPhysPVCascadeTools::GetGoodPV ( const xAOD::VertexContainer * pvContainer )

static

Static method call with DerivationFramework::BPhysDerHelpers::GetGoodPV Returns a std::vector containing only PVs of type 1 and 3 - HighPt and Pileup, which have at least PV_minNTracks tracks.

Definition at line 120 of file BPhysPVCascadeTools.cxx.

                                                                                                                     {
    typedef xAOD::VxType::VertexType VertexType;
    VertexType Pvtx = xAOD::VxType::PriVtx;
    VertexType Pileupvtx = xAOD::VxType::PileUp;
    std::vector<const xAOD::Vertex*> goodPrimaryVertices;
    goodPrimaryVertices.reserve(pvContainer->size());
 
    for (auto ptr = pvContainer->begin(); ptr!= pvContainer->end(); ++ptr) {
        VertexType thistype = (*ptr)->vertexType();
        if ( thistype == Pileupvtx || thistype == Pvtx ) {
      goodPrimaryVertices.push_back(*ptr);
        } else {
//             cout << "vertex type  " << thistype << endl;
        }
    }
    return goodPrimaryVertices;
}

getParticleMass()

double DerivationFramework::BPhysPVCascadeTools::getParticleMass ( const HepPDT::ParticleDataTable * pdt, int pdg )

static

Definition at line 491 of file BPhysPVCascadeTools.cxx.

                                                                                                             {
    auto ptr = pdt->particle( pdgcode );
    return ptr ? ptr->mass() : 0.;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

LinkVertices()

bool DerivationFramework::BPhysPVCascadeTools::LinkVertices ( SG::AuxElement::Decorator< VertexLinkVector > & decor, const std::vector< const xAOD::Vertex * > & vertices, const xAOD::VertexContainer * vertexContainer, const xAOD::Vertex * vert )

static

Definition at line 460 of file BPhysPVCascadeTools.cxx.

                                                                                                                    {
  // create tmp vector of preceding vertex links
  VertexLinkVector precedingVertexLinks;
 
  // loop over input precedingVertices  
  auto precedingVerticesItr = vertices.begin();
  for(; precedingVerticesItr!=vertices.end(); ++precedingVerticesItr) {
       // sanity check 1: protect against null pointers
       if( !(*precedingVerticesItr) )
         return false;
    
    // create element link
    VertexLink vertexLink;
    vertexLink.setElement(*precedingVerticesItr);
    vertexLink.setStorableObject(*vertexContainer);
    
       // sanity check 2: is the link valid?
    if( !vertexLink.isValid() )
       return false;
    
    // link is OK, store it in the tmp vector
    precedingVertexLinks.push_back( vertexLink );
 
  } // end of loop over preceding vertices
  
    // all OK: store preceding vertex links in the aux store
   decor(*vert) = precedingVertexLinks;
   return true;
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

PrepareVertexLinks() [1/2]

void DerivationFramework::BPhysPVCascadeTools::PrepareVertexLinks ( Trk::VxCascadeInfo * result, const std::vector< const xAOD::TrackParticleContainer * > & trackCols )

static

Definition at line 221 of file BPhysPVCascadeTools.cxx.

{
    auto &collection = result->vertices();
    for(auto  v : collection) {
      std::vector<ElementLink<DataVector<xAOD::TrackParticle> > > newLinkVector;
      for(auto mylink : v->trackParticleLinks()) {
        const xAOD::TrackParticle* myptr= *mylink;
        const xAOD::TrackParticleContainer* foundcontainer = nullptr;
        for(auto col : trackCols){
           if(std::find(col->begin(), col->end(), myptr) != col->end()){
            foundcontainer =col;
            break;
           }
        }
        if(foundcontainer == nullptr){
          throw std::runtime_error("Could not find track in original containers");
        }
        mylink.setStorableObject(*foundcontainer, true);
        newLinkVector.push_back( mylink ); 
      }
      v->clearTracks();
      v->setTrackParticleLinks( newLinkVector );
    }
}

PrepareVertexLinks() [2/2]

void DerivationFramework::BPhysPVCascadeTools::PrepareVertexLinks ( Trk::VxCascadeInfo * result, const xAOD::TrackParticleContainer * importedTrackCollection )

static

Definition at line 204 of file BPhysPVCascadeTools.cxx.

{
    auto &collection = result->vertices();
    for(auto v : collection)
    {
       std::vector<ElementLink<DataVector<xAOD::TrackParticle> > > newLinkVector;
       for(unsigned int i=0; i< v->trackParticleLinks().size(); i++)
       {
         ElementLink<DataVector<xAOD::TrackParticle> > mylink=v->trackParticleLinks()[i]; // makes a copy (non-const) 
         mylink.setStorableObject(*importedTrackCollection, true);
         newLinkVector.push_back( mylink ); 
       }
       v->clearTracks();
       v->setTrackParticleLinks( newLinkVector );
    }
}

ProcessVertex()

void DerivationFramework::BPhysPVCascadeTools::ProcessVertex	(	const std::vector< TLorentzVector > &	mom,
		Amg::MatrixX	cov,
		xAOD::BPhysHypoHelper &	vtx,
		xAOD::BPhysHelper::pv_type	pvtype,
		double	mass ) const

Definition at line 54 of file BPhysPVCascadeTools.cxx.

                                                                              {
 
  const xAOD::Vertex* pv = vtx.pv(pvtype);
  if (pv) {
    // decorate the vertex.
    vtx.setTau( m_cascadeTools->tau(mom, vtx.vtx(), pv), pvtype, xAOD::BPhysHypoHelper::TAU_INV_MASS );
    vtx.setTauErr( m_cascadeTools->tauError(mom, cov, vtx.vtx(), pv), pvtype, xAOD::BPhysHypoHelper::TAU_INV_MASS );
    // Proper decay time assuming constant mass hypothesis
    vtx.setTau( m_cascadeTools->tau(mom, vtx.vtx(), pv, mass), pvtype, xAOD::BPhysHypoHelper::TAU_CONST_MASS );
    vtx.setTauErr( m_cascadeTools->tauError(mom, cov, vtx.vtx(), pv, mass), pvtype, xAOD::BPhysHypoHelper::TAU_CONST_MASS );
    //enum pv_type {PV_MAX_SUM_PT2, PV_MIN_A0, PV_MIN_Z0, PV_MIN_Z0_BA};
  } else {
    const float errConst = -9999999.;
    BPHYS_CHECK( vtx.setTau( errConst, pvtype, xAOD::BPhysHypoHelper::TAU_INV_MASS) );
    BPHYS_CHECK( vtx.setTauErr( errConst, pvtype, xAOD::BPhysHypoHelper::TAU_INV_MASS) );
    BPHYS_CHECK( vtx.setTau(errConst, pvtype, xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
    BPHYS_CHECK( vtx.setTauErr( errConst, pvtype, xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
  }
 
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

SetMinNTracksInPV()

void DerivationFramework::BPhysPVCascadeTools::SetMinNTracksInPV

(

size_t

PV_minNTracks

)

Set the minimum number of tracks required for primary vertices to be considered for primary vertex association to a secondary vertex.

Note that this requirement will not be applied for finding the vertex with the highest pT sum (FindHighPtIndex()) since it would possibly exclude this vertex which has been marked earlier in the tool chain.

Definition at line 139 of file BPhysPVCascadeTools.cxx.

{
 
  m_PV_minNTracks = PV_minNTracks;
}

SetVectorInfo()

void DerivationFramework::BPhysPVCascadeTools::SetVectorInfo ( xAOD::BPhysHelper & vtx, const Trk::VxCascadeInfo * casc )

static

Definition at line 424 of file BPhysPVCascadeTools.cxx.

                                                                                                            {
 
    const std::vector< std::vector<TLorentzVector> > &moms = casc->getParticleMoms();
    const std::vector<xAOD::Vertex*> &cascadeVertices = casc->vertices();
    // Get refitted track momenta from all vertices, charged tracks only
    std::vector<float> px;
    std::vector<float> py;
    std::vector<float> pz;
    for( size_t jt=0; jt<moms.size(); jt++) {
       for( size_t it=0; it<cascadeVertices[jt]->vxTrackAtVertex().size(); it++) {
        px.push_back( moms[jt][it].Px() );
        py.push_back( moms[jt][it].Py() );
        pz.push_back( moms[jt][it].Pz() );
      }
    }
    vtx.setRefTrks(std::move(px),std::move(py),std::move(pz));
    
}

uniqueCollection() [1/2]

bool DerivationFramework::BPhysPVCascadeTools::uniqueCollection ( const std::vector< const xAOD::TrackParticle * > & col )

static

Definition at line 443 of file BPhysPVCascadeTools.cxx.

                                                                                                          {
    for(auto p : col){
        if(std::count(col.begin(), col.end(), p) > 1) return false;
    }
    return true;
}

uniqueCollection() [2/2]

bool DerivationFramework::BPhysPVCascadeTools::uniqueCollection ( const std::vector< const xAOD::TrackParticle * > & col1, const std::vector< const xAOD::TrackParticle * > & col2 )

static

Definition at line 450 of file BPhysPVCascadeTools.cxx.

                                                                                                                                                           {
    for(auto p : col1){
        if((std::count(col1.begin(), col1.end(), p) + std::count(col2.begin(), col2.end(), p)) > 1) return false;
    }
    for(auto p : col2){
        if((std::count(col1.begin(), col1.end(), p) + std::count(col2.begin(), col2.end(), p)) > 1) return false;
    }
    return true;
}

VerticesMatchTracks()

template<size_t NTracks>

bool DerivationFramework::BPhysPVCascadeTools::VerticesMatchTracks ( const xAOD::Vertex * v1, const xAOD::Vertex * v2 )

static

Definition at line 129 of file BPhysPVCascadeTools.h.

{
    if(v1->nTrackParticles() != v2->nTrackParticles()) return false;
    assert(v1->nTrackParticles() == NTracks);
    std::array<const xAOD::TrackParticle*, NTracks> a1;
    std::array<const xAOD::TrackParticle*, NTracks> a2;
    for(size_t i=0;i<NTracks;i++){
       a1[i] = v1->trackParticle(i);
       a2[i] = v2->trackParticle(i);
    }
    std::sort(a1.begin(), a1.end());
    std::sort(a2.begin(), a2.end());
    return a1 == a2;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_cascadeTools

const CascadeTools* DerivationFramework::BPhysPVCascadeTools::m_cascadeTools

private

Definition at line 38 of file BPhysPVCascadeTools.h.

m_copyAllVertices

bool DerivationFramework::BPhysPVCascadeTools::m_copyAllVertices

Definition at line 45 of file BPhysPVCascadeTools.h.

m_eventInfo

const xAOD::EventInfo* DerivationFramework::BPhysPVCascadeTools::m_eventInfo

private

Definition at line 39 of file BPhysPVCascadeTools.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_PV_minNTracks

size_t DerivationFramework::BPhysPVCascadeTools::m_PV_minNTracks

private

minimum number of tracks required in PVs considered

Definition at line 42 of file BPhysPVCascadeTools.h.

---

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

• BPhysPVCascadeTools.h
• BPhysPVCascadeTools.cxx