PFO_v1.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: PFO_v1.h 783497 2016-11-10 15:00:53Z mhodgkin $
#ifndef XAODPFLOW_VERSIONS_PFO_V1_H
#define XAODPFLOW_VERSIONS_PFO_V1_H
 
//Author Mark Hodgkinson and Michel Janus
 
// Core include(s):
#include "AthLinks/ElementLink.h"
 
// xAOD include(s):
#include "xAODBase/IParticle.h"
#include "xAODBase/IParticleContainer.h"
#include "xAODPFlow/PFODefs.h"
#include "xAODCaloEvent/CaloCluster.h"
#include "xAODCaloEvent/CaloClusterContainer.h"
#include "xAODTracking/VertexContainer.h"
#include "xAODTracking/TrackParticle.h"
#include "xAODTracking/TrackParticleContainer.h"
 
//ROOT includes
#include "TVector3.h"
#include "Math/Vector4D.h"
 
namespace xAOD {
 

  class PFO_v1 : public IParticle {
 
  public:
    PFO_v1();
    PFO_v1(const PFO_v1& other);
 
    PFO_v1& operator=(const PFO_v1& other) = default;
 
    
    
    virtual double           pt() const;
    virtual double           eta() const;
    virtual double           phi() const;
    virtual double           m() const;
    virtual double           e() const;
    virtual double           rapidity() const;
    
    virtual FourMom_t        p4() const;
    
    virtual Type::ObjectType type() const;
    

    typedef ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<double> > GenVecFourMom_t;

    GenVecFourMom_t genvecP4() const; 

    void setP4(const FourMom_t& vec);
    
    void setP4(float pt, float eta, float phi, float m=0.0);

    FourMom_t p4EM() const;
    GenVecFourMom_t genvecP4EM() const;
    void setP4EM(const FourMom_t& p4EM);
    void setP4EM(float pt, float eta, float phi, float m);

    virtual double           ptEM() const;
    virtual double           etaEM() const;
    virtual double           phiEM() const;
    virtual double           mEM() const;
    virtual double           eEM() const;
 
 

    float bdtPi0Score() const;
    void setBDTPi0Score(float BDTPi0Score);

    float centerMag() const;
    void setCenterMag(float CenterMag);
    
    bool isCharged() const;
    float charge() const;
    void setCharge(float charge);

    template<class T> void setAttribute(PFODetails::PFOAttributes AttributeType, const T& anAttribute) ;
    template<class T> bool attribute(PFODetails::PFOAttributes AttributeType, T& anAttribute) const;

    template<class T> void setAttribute(const std::string& AttributeType, const T& anAttribute) ;
    template<class T> bool attribute(const std::string& AttributeType, T& anAttribute) const;

    bool getClusterMoment(float& theMoment, xAOD::CaloCluster::MomentType momentType) const;

    unsigned int nCaloCluster() const;
    
    const CaloCluster* cluster(unsigned int index) const;
    const TrackParticle* track(unsigned int index) const;
    const xAOD::Vertex* vertex() const;

    bool setVertexLink(const ElementLink< xAOD::VertexContainer>& theVertexLink);

    template<class T> void convertLink(ElementLink<IParticleContainer>& IParticleLink, const ElementLink<T>& templateLink);
    
    bool setTrackLink(const ElementLink<xAOD::TrackParticleContainer>& theTrack);
    bool setClusterLink(const ElementLink<xAOD::CaloClusterContainer>& theCluster);
    bool addClusterLink(const ElementLink<xAOD::CaloClusterContainer>& theCluster);
    bool setAssociatedParticleLink(PFODetails::PFOParticleType ParticleType, const ElementLink<IParticleContainer>& theParticle);
    void setAssociatedParticleLink(const std::string& ParticleType, const ElementLink<IParticleContainer>& theParticle);
    bool addAssociatedParticleLink(PFODetails::PFOParticleType ParticleType,  const ElementLink<IParticleContainer>& theParticle);
    void addAssociatedParticleLink(const std::string& ParticleType,  const ElementLink<IParticleContainer>& theParticle);
    
    //switch to elementlinkvector
    bool setAssociatedParticleLinks(PFODetails::PFOParticleType ParticleType,  const std::vector<ElementLink<IParticleContainer> >& theParticles) ;
    bool associatedParticles(PFODetails::PFOParticleType ParticleType, std::vector<const IParticle*>& theParticles ) const;
    void setAssociatedParticleLinks(const std::string& ParticleType,  const std::vector<ElementLink<IParticleContainer> >& theParticles) ;
    bool associatedParticles(const std::string& ParticleType, std::vector<const IParticle*>& theParticles ) const;

    TLorentzVector GetVertexCorrectedFourVec(const xAOD::Vertex& vertexToCorrectTo) const;
    TLorentzVector GetVertexCorrectedFourVec(const TVector3& vertexToCorrectTo) const;

    TLorentzVector GetVertexCorrectedEMFourVec(const xAOD::Vertex& vertexToCorrectTo) const;
    TLorentzVector GetVertexCorrectedEMFourVec(const TVector3& vertexToCorrectTo) const;

    void toPersistent();
 
   private:

    bool getClusterMomentFromPFO(float& theMoment, xAOD::CaloCluster::MomentType momentType) const;
    
    void VertexCorrectTheFourVector(const TVector3& vertexToCorrectTo, TLorentzVector& theFourVector) const;

    bool getAttributeName_FromClusterMoment(xAOD::PFODetails::PFOAttributes& myAttribute, xAOD::CaloCluster::MomentType& momentType) const;

    bool isJetETMissFloatForCompression(xAOD::PFODetails::PFOAttributes AttributeType) const;

    const static int s_floatCompressionFactor = 1000;
 
  }; // class PFO
 
} // namespace xAOD
 
// Declare IParticle as a base class of PFO_v1:
#include "AthContainers/DataVector.h"
DATAVECTOR_BASE( xAOD::PFO_v1, xAOD::IParticle );
 
#include "xAODPFlow/versions/PFO_v1.icc"
 
#endif // XAODPFLOW_VERSIONS_PFO_V1_H