Egamma_v1.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef XAODEGAMMA_VERSIONS_EGAMMA_V1_H
#define XAODEGAMMA_VERSIONS_EGAMMA_V1_H
 
// Core include(s):
#include "AthLinks/ElementLink.h"
 
// xAOD include(s):
#include "xAODBase/IParticle.h"
 
//Egamma includes
#include "xAODEgamma/EgammaDefs.h"
#include "xAODEgamma/EgammaEnums.h"
 
//CaloCluster include
#include  "xAODCaloEvent/CaloCluster.h"
#include  "xAODCaloEvent/CaloClusterContainer.h"
 
//xAOD Primitives
#include "xAODPrimitives/IsolationCorrection.h"
#include "xAODPrimitives/IsolationType.h"
#include "xAODPrimitives/IsolationFlavour.h"
 
//Eigen/Amg includes , prefer to do it via EventPrimitives for now
#include "EventPrimitives/EventPrimitives.h"
 
//std Include
#include <stdint.h>
 
// ROOT include(s):
#include "Math/Vector4D.h"
 
//Already include the DataVector specialization for this type
#include "xAODEgamma/EgammaContainerFwd.h"
 
 
namespace xAOD {
 
  class Egamma_v1 :public IParticle {
 
  protected:
 
 
    Egamma_v1();
 
    Egamma_v1(const Egamma_v1& eg );
 
  public:
 
 
    Egamma_v1& operator=(const Egamma_v1& eg);
 
 
 
 
    virtual double           pt() const  override final;
 
    virtual double           eta() const override final;
 
    virtual double           phi() const override final;
 
    virtual double           m() const override final;
 
    virtual double           e() const  override final;
 
    virtual double           rapidity() const override final;
 
    typedef IParticle::FourMom_t FourMom_t;
 
    virtual FourMom_t         p4() const override final;
 
    virtual Type::ObjectType type() const override =0 ;
 
 
 
 
    typedef ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<double> > GenVecFourMom_t;
 
    GenVecFourMom_t genvecP4() const;
 
    void setP4(float pt, float eta, float phi, float m);
 
    void setPt(float pt);
 
    void setEta(float eta);
 
    void setPhi(float phi);
 
    void setM(float m);
 
 
 
    typedef Eigen::Matrix<float,4,4>  EgammaCovMatrix_t;
 
    EgammaCovMatrix_t covMatrix() const;
 
    void setCovMatrix(const EgammaCovMatrix_t& cov);
 
 
    size_t nCaloClusters() const;
 
    const xAOD::CaloCluster* caloCluster( size_t index = 0 ) const;
 
    const ElementLink< CaloClusterContainer >&
    caloClusterLink( size_t index = 0 ) const;
 
    typedef std::vector< ElementLink< CaloClusterContainer > > CLELVec_t;
 
    const CLELVec_t& caloClusterLinks() const;
    void setCaloClusterLinks( const CLELVec_t& links );
 
 
 
 
    uint16_t author(uint16_t bitmask=EgammaParameters::AuthorALL) const;
 
    void addAuthor( uint16_t );
 
    void setAuthor( uint16_t );
 
 
    const Egamma_v1* ambiguousObject() const;
 
 
 
    bool showerShapeValue(float& value,const EgammaParameters::ShowerShapeType information) const;
 
    float showerShapeValue(const EgammaParameters::ShowerShapeType information) const;
 
    bool setShowerShapeValue(float value, const EgammaParameters::ShowerShapeType information) ;
 
 
 
 
    bool isGoodOQ(uint32_t mask ) const;
 
    uint32_t OQ( ) const;
 
    void setOQ(uint32_t newOQ);
 
 
 
    bool isolation(float& value,   const Iso::IsolationType information) const;
 
    float isolation(const Iso::IsolationType information) const;
 
    bool setIsolation(float value, const Iso::IsolationType information);
 
 
    bool isolationValue(float& value,   const Iso::IsolationType information) const{
 
      return isolation(value,information);
    }
    float isolationValue(const Iso::IsolationType information) const{
 
      return isolation(information);
    }
    bool setIsolationValue(float value, const Iso::IsolationType information){
      return setIsolation(value,information);
    }
 
 
 
    bool isolationCaloCorrection(float& value, const Iso::IsolationFlavour flavour, const Iso::IsolationCaloCorrection corr,
                 const Iso::IsolationCorrectionParameter param) const;
 
    float isolationCaloCorrection(const Iso::IsolationFlavour flavour, const Iso::IsolationCaloCorrection corr,
                  const Iso::IsolationCorrectionParameter param) const;
 
    bool setIsolationCaloCorrection(float value, const Iso::IsolationFlavour flavour, const Iso::IsolationCaloCorrection corr,
                    const Iso::IsolationCorrectionParameter param);
 
    bool isolationCaloCorrection(float& value,  Iso::IsolationType type , Iso::IsolationCaloCorrection corr) const;
 
    float isolationCaloCorrection(Iso::IsolationType type, Iso::IsolationCaloCorrection corr) const;
 
    bool setIsolationCaloCorrection(float value, Iso::IsolationType type, Iso::IsolationCaloCorrection corr);
 
    bool isolationTrackCorrection(float& value, const Iso::IsolationFlavour flavour , const Iso::IsolationTrackCorrection corr ) const;
 
    float isolationTrackCorrection(const Iso::IsolationFlavour flavour , const Iso::IsolationTrackCorrection corr) const;
 
    bool setIsolationTrackCorrection(float value, const Iso::IsolationFlavour flavour , const Iso::IsolationTrackCorrection corr);
 
 
    bool isolationCorrectionBitset(std::bitset<32>& value, const Iso::IsolationFlavour flavour ) const;
 
    std::bitset<32> isolationCorrectionBitset(const Iso::IsolationFlavour flavour ) const;
 
    bool setIsolationCorrectionBitset(uint32_t value, const Iso::IsolationFlavour flavour );
 
 
 
 
 
 
    bool passSelection(bool& value, const std::string& menu ) const;
 
    bool passSelection( const std::string& menu ) const;
 
    void setPassSelection(bool value, const std::string& menu);
 
    bool selectionisEM(unsigned int&  value, const std::string& isEM) const;
 
    unsigned int selectionisEM(const std::string& isEM) const;
 
    void setSelectionisEM(unsigned int value, const std::string& isEM);
 
    bool likelihoodValue(float&  value, const std::string& LHValue=std::string("LHValue")) const;
 
    float likelihoodValue(const std::string& LHValue=std::string("LHValue")) const;
 
    void setLikelihoodValue(float value, const std::string& LHValue=std::string("LHValue"));
 
 
 
  }; // class Egamma
 
 
} // namespace xAOD
 
//Finish declaration of IParticle as a base class of Egamma
DATAVECTOR_BASE_FIN(xAOD::Egamma_v1, xAOD::IParticle);
 
#endif // XAODEGAMMA_VERSIONS_EGAMMA_V1_H