de/dfd/PanTauSeed_8h_source.html

/*

  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration

*/


#ifndef PANTAUALGS_PANTAUSEED_H

#define PANTAUALGS_PANTAUSEED_H


#include <vector>

#include <string>


#include "xAODBase/IParticle.h"


#include "PanTauAlgs/TauConstituent.h"

#include "PanTauAlgs/TauFeature.h"


#include "xAODTau/TauJet.h"


namespace PanTau {


  class PanTauSeed : public xAOD::IParticle {

    // IParticle implementation as in

    // http://acode-browser.usatlas.bnl.gov/lxr/source/atlas/Event/xAOD/xAODEgamma/xAODEgamma/versions/Egamma_v1.h

    // http://acode-browser.usatlas.bnl.gov/lxr/source/atlas/Event/xAOD/xAODEgamma/Root/Egamma_v1.cxx


  public:


    //enumeration to describe technical status of the seed

    // i.e. numTrack ok? pT ok? etc...

    enum TechnicalQuality {

      t_NoValidInputTau, //use this when there's no substructure info available

      t_NoConstituentsAtAll, //use when no constituent was found

      t_NoSelectedConstituents, //use when no constituent passes the cuts (all below pT, none in cone...)

      t_BadPtValue, //for cases when pT is not in the range of any BDT PT bin

      t_GoodSeed,

      t_nTechnicalQualities

    };


    // enumeration to describe extended PanTau decay mode (number of tracks, pi0 tagged neutrals and other neutrals)

    enum DecayModeExtended {

      t_ExtMode100 = 1,

      t_ExtMode10X = 2,

      t_ExtMode110 = 3,

      t_ExtMode11X = 4,

      t_ExtMode1XX = 5,

      t_ExtMode300 = 6,

      t_ExtMode30X = 7,

      t_ExtMode3XX = 8,

      t_ExtModeOther = 9,

      t_ExtModeNotSet = 10,

      t_ExtModeError = 11,

      t_ExtMode11shots = 12 // for taus which have been classified as 1p1n but have >2 shots

    };


    static int          getDecayMode(int nCharged, int nNeutral);

    static std::string  getDecayModeName(int decayMode);


    PanTauSeed();

    ~PanTauSeed();

    PanTauSeed(const PanTauSeed& seed);

    PanTauSeed& operator=(const PanTauSeed& seed);


    virtual double           pt() const;


    virtual double           eta() const;


    virtual double           phi() const;


    virtual double           m() const;


    virtual double           e() const;


    virtual double           rapidity() const;


    typedef IParticle::FourMom_t FourMom_t;


    virtual FourMom_t p4() const;


    virtual xAOD::Type::ObjectType type() 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);


    PanTauSeed( xAOD::TauJet*                        tauJet,

        const std::vector<PanTau::TauConstituent*>& tauConstituents,

        const std::vector<PanTau::TauConstituent*>& tauConstituentsWithUnselected,

        const std::vector<int>&              pantauSeed_TechnicalQuality

        );


    PanTauSeed(  xAOD::TauJet*                        tauJet,

         const std::vector<int>&              pantauSeed_TechnicalQuality

         );


    const xAOD::TauJet*                                 getTauJet() const;

    xAOD::TauJet*                                       getTauJet();

    const PanTau::TauFeature*                           getFeatures() const;

    PanTau::TauFeature*                                 getFeatures();

    TLorentzVector                                      getProtoMomentumCore() const;


    bool                                                getIsValidSeed() const;

    const std::vector<int>&                             getTechnicalQuality() const;

    bool                                                isOfTechnicalQuality(int pantauSeed_TechnicalQuality) const;

    const std::vector< std::vector<PanTau::TauConstituent*> >& getConstituents() const;

    const std::vector<PanTau::TauConstituent*>&         getConstituentsAsList_Core() const;

    const std::vector<PanTau::TauConstituent*>&         getConstituentsAsList_All() const;


    std::vector<PanTau::TauConstituent*>                getConstituentsOfType(int tauConstituent_Type, bool& foundit);

    int                                                 getNumberOfConstituentsOfType(int tauConstituent_Type);

    TLorentzVector                                      getSubsystemHLV(int tauConstituent_Type, bool& foundit);


    TLorentzVector                                      getFinalMomentum() const;

    int                                                 getDecayModeBySubAlg() const;

    int                                                 getDecayModeByPanTau() const;


    void                                                setFinalMomentum(TLorentzVector finalMom);

    void                                                setDecayModeByPanTau(int decayModePanTau);


    void                                                setModeHackedByCellBased(bool f) {m_decayModeHack_CellBasedShots = f;}

    bool                                                getModeHackedByCellBased() {return m_decayModeHack_CellBasedShots;}


  private:


    FourMom_t m_p4;


  protected:


    //flag that tells whether the seed is valid

    bool                                                m_IsValidSeed;


    std::vector<int>                                    m_TechnicalQuality;


    //pointer to the TauJet this PanTauSeed was build from (pointer not owned by PanTauSeed)

    xAOD::TauJet*                                       m_TauJet;


    //for each type of tauConstituent, a list of constituents (of that type)

    // the TauConstituent objects are owned by PanTauSeed (this class), so they need to be deleted in the destructor

    std::vector< std::vector<PanTau::TauConstituent*> > m_Constituents;


    //the momentum as calculated by using only core constituents

    TLorentzVector                                      m_ProtoMomentum_Core;


    //the momentum as calculated by using info about decay mode

    TLorentzVector                                      m_FinalMomentum;


    //a list of hlvs for the different subsystems (charged, neutral, pi0Neut...)

    std::vector< TLorentzVector >                       m_TypeHLVs;


    //also store constituents as flat list for easier access later on

    std::vector<PanTau::TauConstituent*>                m_ConstituentsList_Core; //only objects in core region

    std::vector<PanTau::TauConstituent*>                m_ConstituentsList_AllSelected;  //all selected objects for this seed


    //for memory reasons:

    // pass list of selected AND unselected pfos to seed, which will take ownership

    std::vector<PanTau::TauConstituent*>                m_ConstituentsList_All; //all objects for this seed, selected and unselected


    //the decay mode

    int                                                 m_DecayMode_BySubAlg;

    int                                                 m_DecayMode_ByPanTau;


    bool                                                m_decayModeHack_CellBasedShots;


    //the features of this pantauseed

    PanTau::TauFeature*                                 m_Features;


  };


  static void                                            SetP4EEtaPhiM(TLorentzVector& hlv, double e, double eta, double phi, double m );


} //end name space pantau


inline const xAOD::TauJet*                                  PanTau::PanTauSeed::getTauJet() const                   {return m_TauJet;}

inline xAOD::TauJet*                                        PanTau::PanTauSeed::getTauJet()                         {return m_TauJet;}

inline const PanTau::TauFeature*                            PanTau::PanTauSeed::getFeatures() const                 {return m_Features;}

inline PanTau::TauFeature*                                  PanTau::PanTauSeed::getFeatures()                       {return m_Features;}

inline TLorentzVector                                       PanTau::PanTauSeed::getProtoMomentumCore() const        {return m_ProtoMomentum_Core;}

inline const std::vector< std::vector<PanTau::TauConstituent*> >&  PanTau::PanTauSeed::getConstituents() const      {return m_Constituents;}

inline const std::vector<PanTau::TauConstituent*>&          PanTau::PanTauSeed::getConstituentsAsList_Core() const  {return m_ConstituentsList_Core;}

inline const std::vector<PanTau::TauConstituent*>&          PanTau::PanTauSeed::getConstituentsAsList_All() const   {return m_ConstituentsList_All;}

inline TLorentzVector                                       PanTau::PanTauSeed::getFinalMomentum() const            {return m_FinalMomentum;}

inline int                                                  PanTau::PanTauSeed::getDecayModeBySubAlg() const        {return m_DecayMode_BySubAlg;}

inline int                                                  PanTau::PanTauSeed::getDecayModeByPanTau() const        {return m_DecayMode_ByPanTau;}

inline bool                                                 PanTau::PanTauSeed::getIsValidSeed() const              {return m_IsValidSeed;}

inline const std::vector<int>&                              PanTau::PanTauSeed::getTechnicalQuality() const         {return m_TechnicalQuality;}


inline void                                                 PanTau::PanTauSeed::setFinalMomentum(TLorentzVector finalMom)  {m_FinalMomentum = finalMom;}

inline void                                                 PanTau::PanTauSeed::setDecayModeByPanTau(int decayModePanTau)  {m_DecayMode_ByPanTau = decayModePanTau;}


inline static void                                          PanTau::SetP4EEtaPhiM(TLorentzVector& hlv, double e, double eta, double phi, double m ){

  // FIXME: what is wrong with eta=0?

  if( eta == 0. ) return;

  double pt = std::sqrt( e*e - m*m) / std::cosh( eta ); // not really safe.

  hlv.SetPtEtaPhiE(pt, eta, phi, e);

  return;

}


#endif // PANTAUALGS_PANTAUSEED_H