BPhysHelper.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/

 *  @code
 *    void myFunction(xAOD::Vertex* vtx) {
 *      // Let "vtx" be some xAOD::Vertex created by the b-physics software
 *      // We gain access to augmentations through the helper class:
 *      xAOD::BPhysHelper bVtx(vtx);
 *
 *      std::cout << "Refitted pT of the 1st track: ";
 *      if(bVtx.nRefTrks()>0) {
 *        std::cout <<  bVtx.refTrk(0).Pt();
 *      }
 *      std::cout << std::endl;
 *
 *    }
 *  @endcode
 *
 */  
 
#ifndef XAOD_BPHYSHELPER_H
#define XAOD_BPHYSHELPER_H
 
#include "xAODTracking/TrackParticleFwd.h"
#include "xAODTracking/VertexFwd.h"
#include "xAODTracking/VertexContainerFwd.h"
#include "xAODMuon/MuonContainer.h"
#include "xAODEgamma/ElectronContainer.h"
 
 
#include "TVector3.h"
#include "TLorentzVector.h"
#include "TMatrixTSym.h"
 
#include <assert.h>
 

namespace xAOD {
  class BPhysHelper {
 
 
    public:
      
      /************************************************************************/
      
      BPhysHelper(const xAOD::Vertex* b) :
        m_b(b),
        m_covCached(false),
        m_cachedCov(0),
        m_refTracksCached(false),
        m_cachedRefTracks(0),
        m_muonsCached(false),
        m_electronsCached(false),
        m_cachedMuons(0),
        m_cachedElectrons(0),
        m_precedingVerticesCached(false),
        m_cachedPrecedingVertices(0),
        m_cascadeVerticesCached(false),
        m_cachedCascadeVertices(0)
      { 
        assert(m_b!=0); // sanity check: m_b must not be null
      }
 
      /************************************************************************/
      
      const xAOD::Vertex* vtx() const { return m_b; }
      
      /************************************************************************/
      
      const TMatrixTSym<double>& covariance();
 
      /************************************************************************/
      
      
      int nRefTrks();
      
      
      TVector3 refTrk(const size_t index);

      
      const std::vector<TVector3>& refTrks();
      
      
      TLorentzVector refTrk(const size_t index, const float mass);
      
      
      const xAOD::IParticle* refTrkOrigin(const size_t index) const;

      
      TVector3 refTrkOriginP(const size_t index) const;
            
      
      TLorentzVector refTrkOriginP(const size_t index, const float mass) const;
            
      
      float refTrkCharge(const size_t index) const;
      
      
      bool setRefTrks(std::vector<float> px,
                      std::vector<float> py,
                      std::vector<float> pz);

      
      bool setRefTrks(const std::vector<TVector3>& refTrks);
 
#ifndef XAOD_ANALYSIS

      
      bool setRefTrks();
 
 
#endif // not XAOD_ANALYSIS
      
      
      /************************************************************************/
      
      
      TVector3 totalP();

      
      TLorentzVector totalP(std::span<const double> masses);

      
      float ptErr();

      
      bool setPtErr(const float val);
      
      
      /************************************************************************/

      
      int nMuons();
      int nElectrons();
      
      
      const xAOD::Muon* muon(const size_t index);
      const xAOD::Electron* electron(const size_t index);
      
      
      const std::vector<const xAOD::Muon*>& muons();
      const std::vector<const xAOD::Electron*>& electrons();
      
      
      bool setMuons(const std::vector<const xAOD::Muon*>& muons, 
                    const xAOD::MuonContainer* muonContainer);
      
      bool setElectrons(const std::vector<const xAOD::Electron*>& electrons, 
                    const xAOD::ElectronContainer* electronContainer);
      
      /************************************************************************/

      
      int nPrecedingVertices();
            
      
      const xAOD::Vertex* precedingVertex(const size_t index);

      
      const std::vector<const xAOD::Vertex*>& precedingVertices();
      
      
      bool setPrecedingVertices(const std::vector<const xAOD::Vertex*>& vertices,
                                const xAOD::VertexContainer* vertexContainer);
      
      
      
      /************************************************************************/

      
      int nCascadeVertices();
            
      
      const xAOD::Vertex* cascadeVertex(const size_t index);

      
      const std::vector<const xAOD::Vertex*>& cascadeVertices();
      
      
      bool setCascadeVertices(const std::vector<const xAOD::Vertex*>& vertices,
                                const xAOD::VertexContainer* vertexContainer);
      
      
      int nRefTrksCascade();
      
      
      /************************************************************************/
      
      enum pv_type {PV_MAX_SUM_PT2, PV_MIN_A0, PV_MIN_Z0, PV_MIN_Z0_BA};
      
      /************************************************************************/
      
      
      const xAOD::Vertex* pv    (const pv_type vertexType  = BPhysHelper::PV_MIN_A0); 
      const xAOD::Vertex* origPv(const pv_type vertexType = BPhysHelper::PV_MIN_A0);  

      bool setOrigPv(const xAOD::Vertex* pv, 
                 const xAOD::VertexContainer* vertexContainer,
                 const pv_type vertexType = BPhysHelper::PV_MIN_A0);
      
      
      bool setPv(const xAOD::Vertex* pv, 
                 const xAOD::VertexContainer* vertexContainer,
                 const pv_type vertexType = BPhysHelper::PV_MIN_A0);
      
      bool setRefitPVStatus(int code, const pv_type vertexType = BPhysHelper::PV_MIN_A0);

      int RefitPVStatus(const pv_type vertexType = BPhysHelper::PV_MIN_A0);      

 
      /************************************************************************/
      
      
      float lxy   (const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      float lxyErr(const pv_type vertexType = BPhysHelper::PV_MIN_A0); 

      
      bool setLxy   (const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      bool setLxyErr(const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
 
      float lxyz   (const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      float lxyzErr(const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      bool setLxyz   (const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      bool setLxyzErr(const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0); 

      
      /************************************************************************/
      
      
      float a0     (const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      float a0Err  (const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      float a0xy   (const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      float a0xyErr(const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      float z0     (const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      float z0Err  (const pv_type vertexType = BPhysHelper::PV_MIN_A0); 

      
      float setA0     (const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      float setA0Err  (const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      float setA0xy   (const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      float setA0xyErr(const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      float setZ0     (const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      float setZ0Err  (const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0); 
      
      
      /************************************************************************/
      
      static const std::string pv_type_str[];
      
      /************************************************************************/
      
      static const unsigned int n_pv_types;
      
      /************************************************************************/
      /************************************************************************/
    protected:

      
      bool cacheCov();
      
      
      bool cacheRefTracks();

      
      bool cacheMuons();
      bool cacheElectrons();
 

      
      bool cachePrecedingVertices();

      
      bool cacheCascadeVertices();
 
      /************************************************************************/
      const xAOD::Vertex* m_b;
 
      /************************************************************************/
      
      bool                m_covCached;
      TMatrixTSym<double> m_cachedCov;
      
 
      /************************************************************************/
      
      bool                  m_refTracksCached;
      std::vector<TVector3> m_cachedRefTracks;
      
 
      /************************************************************************/
      
      bool                           m_muonsCached;
      bool                           m_electronsCached;
      std::vector<const xAOD::Muon*> m_cachedMuons;
      std::vector<const xAOD::Electron*> m_cachedElectrons;
      
 
      /************************************************************************/
      
      bool                             m_precedingVerticesCached;
      std::vector<const xAOD::Vertex*> m_cachedPrecedingVertices;
      bool                             m_cascadeVerticesCached;
      std::vector<const xAOD::Vertex*> m_cachedCascadeVertices;
      
      
      /************************************************************************/
      
      static const std::vector<TVector3>            s_emptyVectorOfTVector3;
      static const std::vector<const xAOD::Muon*>   s_emptyVectorOfMuons;
      static const std::vector<const xAOD::Electron*>   s_emptyVectorOfElectrons;
      static const TMatrixTSym<double>              s_emptyMatrix;
      static const std::vector<const xAOD::Vertex*> s_emptyVectorOfVertices;
      
  }; // BPhysHelper
 
} // namespace xAOD

#define BPHYS_CHECK( EXP ) { if( ! EXP ) ATH_MSG_WARNING ( "Call of \"" << #EXP << "\" failed" ); }
 
#endif // XAOD_BPHYSHELPER_H