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           e() const  override;

    virtual double           rapidity() const override;

    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 setPtEtaPhi(float pt, float eta, float phi);

    void setPt(float pt);

    void setEta(float eta);

    void setPhi(float phi);



    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