/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODPFlow/xAODPFlow/versions/PFO_v1.h

// Dear emacs, this is -*- c++ -*-
// $Id: PFO_v1.h 744541 2016-05-03 15:55:30Z krasznaa $
#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"
#include "AthLinks/ElementLinkVector.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"

namespace xAOD {


  class PFO_v1 : public IParticle {

  public:
    PFO_v1();
    PFO_v1(const PFO_v1& other);

    
    
    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 const FourMom_t& p4() const;
    
    virtual Type::ObjectType type() const;
    

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

    const FourMom_t& p4EM() 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);
    
    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;

    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);
    
    bool setTrackLink(const ElementLink<xAOD::TrackParticleContainer>& theTrack);
    bool setClusterLink(const ElementLink<xAOD::CaloClusterContainer>& theCluster);
    bool setAssociatedParticleLink(PFODetails::PFOParticleType ParticleType, const ElementLink<IParticleContainer>& theParticle);
    void setAssociatedParticleLink(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:

    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;

    mutable FourMom_t m_p4;
    mutable bool m_p4Cached;
    mutable FourMom_t m_p4EM;
    mutable bool m_p4EMCached;
    int m_floatCompressionFactor;

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

---