egamma.h

Go to the documentation of this file.

// dear emacs, this is really -*- C++ -*-
 
/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef EGAMMAEVENT_EGAMMA_H
#define EGAMMAEVENT_EGAMMA_H 1
/********************************************************************
NAME:     egamma.h
PACKAGE:  offline/Reconstruction/egammaRec
CREATED:  Nov, 2000
REWRITTEN Nov, 2006
UPDATED:
          Jun 14, 2007 (FD) Doxygen documentation
          Nov 24, 2009 (FD) add isElectron, isPhoton and use unsigned int
          Jan 20, 2010 (MS) add enumeration and code for uncombined 4mom 
********************************************************************/
 
// INCLUDE HEADER FILES:
 
#include "FourMom/Lib/P4ImplEEtaPhiM.h"
#include "EventKernel/INavigable4Momentum.h"
 
#include "AthLinks/ElementLink.h"
#include "AthLinks/ElementLinkVector.h"
 
#include "ParticleEvent/ParticleImpl.h"
 
#include "CaloEvent/CaloClusterContainer.h"
#include "Particle/TrackParticleContainer.h"
#include "VxVertex/VxContainer.h"
#include "egammaEvent/egDetailContainer.h"
#include "egammaEvent/egDetail.h"
 
#include "egammaEvent/egPID.h"
#include "egammaEvent/egammaPIDdefsObs.h"
 
#include "egammaEvent/CaloRingsContainer.h"
 
#include <any>
#include <memory>
 
class EMErrorDetail;
class CaloCluster;
typedef NavigableTerminalNode egammaNavigation;
 
class egamma
  : public ParticleImpl<
             egammaNavigation, // not really a terminal node: done here
             P4ImplEEtaPhiM >
{

  // Public typedefs: 
 public: 
 
  // for readability and lazy people
  typedef ParticleImpl< egammaNavigation,
            P4ImplEEtaPhiM
      > egammaImpl_t;
  typedef egammaImpl_t::navigable_type navigable_type;
  typedef egammaImpl_t::momentum_type  momentum_type;
  typedef egammaImpl_t::particle_type  particle_type;
 
 public:
  
  enum eg4MomType {
    // standard cluster-track combined 4Mom
    Combined   = 0,
    // uncombined cluster 4Mom
    Uncombined = 1
  };      
 
 public:

  egamma();
  egamma(unsigned int author);
  virtual ~egamma();
  egamma(const egamma &rhs, bool copyDetails=true, bool copyMinimal=false);
  egamma& operator=(const egamma& rhs);
  egamma& operator=(egamma&& rhs) = default;

  void print() const;

  void setE (double theE);
  void setEta (double theEta);
  void setPhi (double thePhi);
  void setM (double theM);
  
  void set4Mom (const I4Momentum & theI4Mom );  
  void set4Mom (const I4Momentum * const theI4Mom );  
  void set4Mom (const CLHEP::HepLorentzVector & theHlv );  

  void setUncombinedE (double theE);
  void setUncombinedEta (double theEta);
  void setUncombinedPhi (double thePhi);
  void setUncombinedM (double theM);
  
  void setUncombined4Mom (const I4Momentum & theI4Mom );  
  void setUncombined4Mom (const I4Momentum * const theI4Mom );  
  void setUncombined4Mom (const CLHEP::HepLorentzVector & theHlv );  

  const CaloCluster*        cluster()            const;
  const CaloRings*        rings()            const;
  const Rec::TrackParticle* trackParticle (unsigned int index = 0) const;
  unsigned int nTrackParticles() const;
  const Trk::VxCandidate* conversion (unsigned int index = 0) const;
  unsigned int nConversions() const;

  template <typename T>
  const T* detail(const std::string& name = "", unsigned int index = 0) const;

  const egDetail* detail (const std::string& className,
                          const std::string& name = "",
              unsigned int index = 0) const;
  const egDetail* detail (int i) const;
  ElementLink<egDetailContainer> detailElementLink (int i) const;
  const ElementLinkVector<egDetailContainer>& detailElementLinkVector() const;
  std::string detailName (int i) const;
  int nDetails() const;
  double detailValue (egammaParameters::ParamDef key, 
              const std::string& name = "", 
              unsigned int index = 0) const;

  ElementLink<Rec::TrackParticleContainer> trackParticleElementLink(unsigned int index = 0) const;
  const ElementLinkVector<Rec::TrackParticleContainer>& trackParticleElementLinkVector() const;
  const ElementLink<CaloClusterContainer>& clusterElementLink() const;
  ElementLink<VxContainer> conversionElementLink(unsigned int index = 0) const;
  const ElementLinkVector<VxContainer>& conversionElementLinkVector() const;
  const ElementLink<CaloRingsContainer>& ringsElementLink() const;

  double egammaID(egammaPIDObs::PID, bool *found) const;
  double egammaID(egammaPIDObs::PID) const;
  const egPID* pid() const;

  void setDetail(const egDetailContainer*, const egDetail*); 
  void setDetailElementLink(const ElementLink<egDetailContainer>& link); 
 
  void setDetailElementLinkVector(const ElementLinkVector<egDetailContainer>& v); 
  void setDetailElementLinkVector(ElementLinkVector<egDetailContainer>&& v); 
 
 
  bool set_egammaID(egammaPIDObs::PID id, double result);

  bool set_egammaIDint(egammaPIDObs::PID id, unsigned int result);
 
  // move this in egPID and just provide return of egPID 
  //  const std::vector< std::pair<egammaPIDObs::PID,double> > & get_egammaID()       const;
 
  // to save pointers to access the different objects of the e/g data class
 
  void setCluster(const CaloClusterContainer*, int);
  void setCluster(const CaloClusterContainer*, const CaloCluster*); 
  void setClusterElementLink(const ElementLink<CaloClusterContainer>& link);
  void resetCluster();

  void setRings(const CaloRingsContainer*, int);
  void setRings(const CaloRingsContainer*, const CaloRings*);
  void setRingsElementLink(const ElementLink<CaloRingsContainer>& link);
  void resetRings();
 

  void setTrackParticle(const Rec::TrackParticleContainer *, int) ;
  void setTrackParticle(const Rec::TrackParticleContainer*, const Rec::TrackParticle*);
  void setTrackParticleElementLink(const ElementLink<Rec::TrackParticleContainer>& link);
  void resetTrackParticle(unsigned int index = 0);
 
  void setTrackParticleElementLinkVector(const ElementLinkVector<Rec::TrackParticleContainer>& v);
  void setTrackParticleElementLinkVector(ElementLinkVector<Rec::TrackParticleContainer>&& v);

  void setConversion(const VxContainer *, int) ;
  void setConversion(const VxContainer*, const Trk::VxCandidate*);
  void setConversionElementLink(const ElementLink<VxContainer>& link);
  void resetConversion(unsigned int index = 0);
 
  void setConversionElementLinkVector(const ElementLinkVector<VxContainer>& link);
  void setConversionElementLinkVector(ElementLinkVector<VxContainer>&& link);

  unsigned int author() const {return m_author; }
  bool author(const unsigned int author) const;
  void addAuthor(unsigned int author) {m_author |= author; }
  void resetAuthor() {m_author = 0; }
 

  virtual void fillToken( INavigationToken & thisToken ) const;
  virtual void fillToken( INavigationToken & thisToken, const std::any& ) const;

  bool isElectron(unsigned int mask= egammaPIDObs::ALL, 
          egammaPIDObs::PID pid=egammaPIDObs::IsEM, 
          bool *found = nullptr) const;
  bool isPhoton(unsigned int mask= egammaPIDObs::ALL, 
        egammaPIDObs::PID pid=egammaPIDObs::IsEM, 
        bool *found = nullptr) const; // exactly the same as isElectron

  bool passID(egammaPIDObs::egammaIDQuality id) const;

  bool isSofte(unsigned int mask= egammaPIDObs::ALL, bool *found = nullptr) const;

  unsigned int isem(unsigned int mask= egammaPIDObs::ALL, 
            egammaPIDObs::PID pid=egammaPIDObs::IsEM) const;
  unsigned int isem(unsigned int mask, 
            egammaPIDObs::PID pid,
            bool *found) const;
  unsigned int isemse(unsigned int mask= egammaPIDObs::ALL) const;
  unsigned int isemse(unsigned int mask, bool *found) const;
  
  bool isGoodOQ(unsigned int mask= egammaPIDObs::ALLOQ, bool *found = nullptr) const;
  unsigned int isgoodoq(unsigned int mask= egammaPIDObs::ALLOQ, bool *found = nullptr) const;
 
  
  virtual const I4MomentumError* errors() const;
 
  void setErrorMatrix(Amg::MatrixX);
  void setUncombinedErrorMatrix(Amg::MatrixX);

  //  P4ImplEEtaPhiM&  get4Mom() { return m_momentumCluster; } 
  const momentum_type&  get4Mom( egamma::eg4MomType type=egamma::Combined ) const;
 
 private:
 
  ElementLink<CaloClusterContainer> m_cluster;
  ElementLinkVector<Rec::TrackParticleContainer>  m_trackParticle;
  ElementLinkVector<VxContainer>  m_conversion;
  ElementLinkVector<egDetailContainer> m_egDetails;
  ElementLink<CaloRingsContainer> m_rings;
 
  unsigned int m_author;
 
  std::unique_ptr<egPID> m_egPID;
 
 protected:
 
  // extra 4 momentum for the cluster based egamma object 
  // P4ImplEEtaPhiM  m_momentumCluster; 
  momentum_type  m_momentumCluster; 
 
};
 
template <typename T>
const T* egamma::detail(const std::string& key, unsigned int index) const {
    std::size_t nsize = m_egDetails.size();
    std::size_t iloop = 0;
//     int nptr = 0;
    const T* ptr = 0;
//     const T* tmp = 0;
 
    for (; iloop != nsize; iloop++) {
      if (key.empty()) {
    if(!m_egDetails[iloop]) continue;
        ptr = dynamic_cast<const T*>(*(m_egDetails[iloop]));
    if (0 != ptr && ptr->linkIndex() == (int)index) {
//    nptr++; //this is potentially highly confusing now with the ElementLinkVectors and the conversion refits, rather return the first match if there are multiple matches
//    ptr = tmp;
      return ptr;
    }
      }
      else if (m_egDetails[iloop].isValid() &&
               key == m_egDetails.elementDataID(iloop))
      {
    if(!m_egDetails[iloop]) continue;
        ptr = dynamic_cast<const T*>(*(m_egDetails[iloop]));
    if (0 != ptr && ptr->linkIndex() == (int)index){
      return ptr;
    }
      }
    }
    return ptr;
//     return (nptr==1) ? ptr : 0;
}
 
// inline methods

inline
void
egamma::setE (double ene)
{ this->momentumBase().setE (ene); }

inline
void
egamma::setEta (double eta)
{ this->momentumBase().setEta (eta); }

inline
void
egamma::setPhi (double phi)
{ this->momentumBase().setPhi (phi); }

inline
void
egamma::setM (double m)
{ this->momentumBase().setM (m); }
  
inline
void 
egamma::set4Mom (const I4Momentum & mom )
{ this->momentumBase().set4Mom (mom); }
  
inline
void 
egamma::set4Mom (const I4Momentum * const mom )
{ this->momentumBase().set4Mom (mom); }
  
inline
void 
egamma::set4Mom (const CLHEP::HepLorentzVector & hlv )
{ this->momentumBase().set4Mom (hlv); }

inline                                                       
const egamma::momentum_type&  egamma::get4Mom( egamma::eg4MomType type ) const
{ 
  if ( type==egamma::Combined ) return this->momentumBase(); 
  else                          return m_momentumCluster;    
}                                                            
 
 
  
 
#endif