/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODBPhys/xAODBPhys/BPhysHelper.h

Go to the documentation of this file.

#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 "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_cachedMuons(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(const std::vector<float>& px,
                      const std::vector<float>& py,
                      const std::vector<float>& pz);

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

#if ( ! defined(XAOD_STANDALONE) ) && ( ! defined(XAOD_MANACORE) )

      bool setRefTrks();


#endif // not XAOD_STANDALONE and not XAOD_MANACORE      
      
      /************************************************************************/
      TVector3 totalP();

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

      float ptErr();

      bool setPtErr(const float val);
      
      /************************************************************************/
      int nMuons();
      
      const xAOD::Muon* muon(const size_t index);
      
      const std::vector<const xAOD::Muon*>& muons();
      
      bool setMuons(const std::vector<const xAOD::Muon*>& muons, 
                    const xAOD::MuonContainer* muonContainer);
      
      /************************************************************************/
      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 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); 
      
      /************************************************************************/
      /************************************************************************/
    protected:

      bool cacheCov();
      
      bool cacheRefTracks();

      bool cacheMuons();


      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;
      std::vector<const xAOD::Muon*> m_cachedMuons;
      
      /************************************************************************/
      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>            emptyVectorOfTVector3;
      static const std::vector<const xAOD::Muon*>   emptyVectorOfMuons;
      static const TMatrixTSym<double>              emptyMatrix;
      static const std::vector<const xAOD::Vertex*> emptyVectorOfVertices;
  }; // BPhysHelper

} // namespace xAOD

#ifdef ATH_MSG_WARNING
  #define BPHYS_CHECK( EXP ) { if( ! EXP ) ATH_MSG_WARNING ( "Call of \"" << #EXP << "\" failed" ); }
#else
  #define BPHYS_CHECK( EXP ) { if( ! EXP ) std::cout << "Warning in <BPhysHelper::BPHYS_CHECK> Call of \"" << #EXP << "\" failed" << std::endl; }
#endif

#endif // XAOD_BPHYSHELPER_H

---