Reconstruction/Jet/JetEvent/JetEvent/Jet.h

Go to the documentation of this file.

// emacs, this is -*- C++ -*-
 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef JETEVENT_JET_H
#define JETEVENT_JET_H
 
// navigation
#include "NavFourMom/INavigable4MomentumCollection.h"
#include "Navigation/Navigable.h"
 
// four-momentum
#include "FourMom/Lib/P4ImplPxPyPzE.h"
 
// signal state
#include "EventKernel/ISignalState.h"
 
// particle character
#include "ParticleEvent/ParticleSigStateImpl.h"
 
#include "JetEvent/JetKeyDescriptor.h"
#include "JetEvent/JetAssociationBase.h"
#include "JetEvent/JetTagInfoBase.h"
#include "JetEvent/JetMoment.h"
//#include "JetEvent/JetMomentMap.h"
 
#include <vector>
#include <any>

// Signal State Friend //
 
class JetCollection;
class JetMomentMap;
 
struct JetSignalState;
 
namespace fastjet {
  class PseudoJet;
}
 
class Jet : public ParticleSigStateImpl<Navigable<INavigable4MomentumCollection,double>,
        P4ImplPxPyPzE>
{
  // make the templated converter base friend
  template <class PERS>
  friend class JetConverterBase;
 
  // make the JetCollection a friend
  friend class JetCollection;
 

  // Jet Types //
  
protected:

  
private:
 
  // cling 6.20.02 fails to parse this properly if the third template
  // argument is defaulted.
  typedef 
  ParticleSigStateImpl<Navigable<INavigable4MomentumCollection,double>,P4ImplPxPyPzE,ParticleEvent::Base>
  base_t;
  
  typedef base_t::navigable_type                                 navigable_t;
  typedef base_t::momentum_type                                   momentum_t; 
  typedef base_t::particle_type                                   particle_t;
 
public:
  typedef INavigable4MomentumCollection                     collection_type;
  typedef INavigable4Momentum                              constituent_type;
  typedef navigable_t::object_iter                      constituent_iterator;
  typedef navigable_t::external_index_type                        index_type;

  typedef INavigable4MomentumCollection                         collection_t;  
  typedef INavigable4Momentum                                  constituent_t;
  typedef navigable_t::object_iter                            const_iterator;
  typedef navigable_t::external_index_type                           index_t;
  typedef navigable_t::constituent_coll                   constituent_coll_t;
 
  typedef size_t                                                numconstit_t;
 
  // types for categories and keys 
  typedef JetKeyDescriptor::key_t                                     mkey_t;
  typedef JetKeyDescriptor::category_t                                mcat_t;
 
 
  // types for jet shape (moment) information
  typedef JetMoment::float_t                                         shape_t;
  typedef JetMomentMap                                           shape_map_t;
 
 
  // types for associations
  typedef JetAssociationBase                                         assoc_t;
  typedef std::vector<const assoc_t*>                            assostore_t;
  
  // types for tag info
  typedef JetTagInfoBase                                           taginfo_t;
  typedef std::vector<const taginfo_t*>                           tagstore_t;
  
  // types for kinematics
  typedef CLHEP::HepLorentzVector                                             hlv_t;
  typedef I4Momentum                                               fourmom_t;
  typedef P4SignalState::State                                 signalstate_t;
  typedef P4SignalState                                          statename_t;
  
  typedef double (Jet::*GET_VALUE)() const;
  typedef void   (Jet::*SET_VALUE)(double v);
  
  // Enumeration               //

  enum CopyDataMembers { CopyNone = 0x0,
             CopyMoments = 0x1,
             CopyTagInfos = 0x2,
             CopyAssociations = 0x4,
             CopyConstituents = 0x8,
             CopyAll = 0xF };
  
  // Constructors & Destructor //
  
  Jet();
  Jet(const collection_t* pColl,const constituent_t* pConst,double wght=1.0);
  Jet(const collection_t* pColl,index_t ind,double wght=1.0);
  Jet(const fourmom_t* pMom);
  Jet(const fourmom_t& rMom);
  Jet(const hlv_t& rVec); 
  Jet(double px, double py, double pz, double e); 
  Jet(const Jet* pJet );  
  Jet(const Jet* pJet , bool copyStores, bool copyConstituents); 
  Jet(const Jet& rJet);
 
  Jet(const Jet* pJet,
      CopyDataMembers cdm0, CopyDataMembers cdm1 = CopyNone,
      CopyDataMembers cdm2 = CopyNone, CopyDataMembers cdm3 = CopyNone); 
  
  virtual Jet* clone() const ; 
  virtual Jet* clone(bool copyStores, bool copyConstituents = true ) const ; 
 
 
 

  virtual ~Jet(); 
 
protected:
 
  void setup(const hlv_t& v);
  void copy_from_jet( const Jet* pjet, CopyDataMembers cdm0, CopyDataMembers cdm1 = CopyNone,
              CopyDataMembers cdm2 = CopyNone, CopyDataMembers cdm3 = CopyNone);
 
 
  const shape_map_t* getMomentMap(bool addIfMissing) const;
 
public:
 
  const shape_map_t* getMomentMap() const;
  std::string getMomentMapName() const;
  
 
  virtual void setupKine(const hlv_t& v);

  // Kinematic with SignalState //
 
public:
  
  // Signal State functions already implemented generically in ParticleSigStateImpl
  
  virtual void setE (double e );
  virtual void setPx(double Px);
  virtual void setPy(double py);
  virtual void setPz(double pz);
 
  virtual void setE (double e , signalstate_t s);
  virtual void setPx(double Px, signalstate_t s);
  virtual void setPy(double py, signalstate_t s);
  virtual void setPz(double pz, signalstate_t s);
  
  virtual double ei()  const; 
  virtual double pxi() const;
  virtual double pyi() const;
  virtual double pzi() const;
  virtual double pti() const;

  void setPxPyPzE(double px, double py, double pz, double e);
  void setPtEtaPhiE( double a, double b, double c, double d );
  void setPtEtaPhiM( double a, double b, double c, double d );
  void setEEtaPhiM( double a, double b, double c, double d );
  // void setPhi(double phi);
  // void setEta(double phi); NOT provided on purpose to avoid potential confusion with PtEtaPhiE/M based implementations.

  void setP(const hlv_t& rVec);

  hlv_t constituent_sum4Mom() const;
  
  hlv_t constituent_sum4Mom(signalstate_t s) const;

  void scale_momentum(double scale_factor);

  Jet * get_scaled_copy(double scale_factor) const;
    
  // Constituent Management //
 
public:

  bool addConstituent(const collection_t*  pColl,
              const constituent_t* pConst, 
              double              wght=1.0); 
  bool addConstituent(const collection_t*  pColl,index_t ind,double wght=1.0);
  bool addConstituent(const collection_t*  pColl,
                      index_t ind,
                      size_t sizeHint,
                      bool noKine,
                      double wght=1.0);
  bool removeConstituent(const constituent_t* pConst);
  bool removeConstituent(const collection_t* pColl,index_t ind);
  bool removeConstituent(bool reset=false);

  bool addJet(const Jet* pJet,double wght=1.0);

  bool reweight(const constituent_t* pConst,double wght);
  bool reweight(const collection_t* pColl,index_t ind,double wght);

  bool cleanUp();

  numconstit_t constituentsN()const {return m_constituentsN;}

  void setConstituentsN(numconstit_t n){m_constituentsN = n;}
 
protected:
  
  numconstit_t m_constituentsN;

  void putElement(const collection_t*  pColl,
          const constituent_t* pConst,
          double               wght = 1.0,
                  size_t               sizeHint = 0);
  void putElement(const collection_t*  pColl,
          index_t              ind,
          double               wght = 1.0,
                  size_t               sizeHint = 0);
  void insertElement(const collection_t*  pColl,
             const constituent_t* pConst,
             double              wght = 1.0,
             size_t               sizeHint = 0);
  void insertElement(const collection_t*  pColl,
             index_t              ind,
             double              wght = 1.0,
             size_t               sizeHint = 0);

  bool remove(const constituent_t* pConst);
  bool remove(const collection_t*  pColl,index_t ind);
  bool remove();

  // Constituent Access //
 
public:
 
  const_iterator firstConstituent()  const;
  const_iterator lastConstituent()   const;
   
  const_iterator begin() const;
  const_iterator end() const;
  size_t size() const;
  bool contains(const constituent_t* pConst) const;
  bool contains(const collection_t* pColl,index_t ind) const;

  double getWeight(const constituent_t* pConst) const;
  double getWeight(const collection_t* pColl,index_t ind) const;
  double getWeight(const_iterator fConst) const;

  virtual void fillToken(INavigationToken& navToken) const;
  virtual void fillToken(INavigationToken& navToken, 
             const std::any& par) const;
 
protected:

  double getParameter(const constituent_t* pConst)            const;
  double getParameter(const collection_t*  pColl,index_t ind) const;
  double getParameter(const_iterator fConst)                  const;
 
public:
  const collection_t* getContainer(const constituent_t* pConst) const;
  const collection_t* getContainer(const_iterator fConst)       const;

  bool getIndex(const constituent_t* pConst,index_t& ind) const;
  bool getIndex(const_iterator fConst,index_t& ind)       const;
 
 

  // Access jet key system  //
 
protected :
  JetKeyDescriptorInstance * keyDesc() const;

  // Comparators & Overlap //
 
public: 
 
  
  bool isIdentical(const Jet& rJet) const;
  bool isIdentical(const Jet* pJet) const;

  Jet* getOverlap(const Jet& rJet, bool noKine = false) const;
  Jet* getOverlap(const Jet* pJet, bool noKine = false) const;

  // Shapes //

  void    setShape(const mkey_t& shapeName,shape_t shape,
           bool addIfMissing=true) const ;
  shape_t getShape(const mkey_t& shapeName,bool addIfMissing=false) const;

  std::vector<mkey_t> getShapeKeys() const;

  void    setMoment(const mkey_t& shapeName,shape_t shape,
            bool addIfMissing=true) const; 
  shape_t getMoment(const mkey_t& shapeName,bool addIfMissing=false) const; 
  
  std::vector<mkey_t> getMomentKeys() const;
 

  template<typename T>
  T get(const std::string & mName) const ;
 
  template<typename T>
  void set(const std::string & mName, const T & v) const ;
 
  
  // Associations //
 
public:
  
  template<typename ASSOC>
  const ASSOC* getAssociation(const mkey_t& key, bool useLink = true) const;
  const std::vector<mkey_t>& getAssociationKeys() const;
  const assoc_t* getAssociationBase (const mkey_t& key) const;
  
  template <class T>
  void setAssociation(const T* pAssoc,bool useLink = false );
  
  void removeAssociation( const mkey_t& key );
//   /** @brief Fill a token with association objects */  
//   void fillAssoToken(INavigationToken& token) const;
 
private:
  void removeAssociation(size_t index);
  
  // TagInfo //
 
public:
  
  template<typename TAGINFO>
  const TAGINFO* getTagInfo(const mkey_t& key,bool useLink=true ) const ;
  
  void setTagInfo(const mkey_t& key,const taginfo_t* pTagInfo,
          bool useLink=false);
  
  const tagstore_t jetTagInfoVector() const;
  
  const std::vector<mkey_t> infoKeys() const;
  
  const taginfo_t* tagInfo(const mkey_t& key) const;
  
  template<class TAGINFO>
  const TAGINFO* tagInfo(const mkey_t& key) const;
  
  template<class TAGINFO>
  void addInfo(const TAGINFO* tag);
   
  void removeInfo(const mkey_t& key);
 
private:
  void removeInfo(unsigned int index);
      
 
 
public:
  // weight for Flavour tagging //

  double getFlavourTagWeight() const;
  
  double getFlavourTagWeight(const std::string& infoName) const;

  signalstate_t constituentSignalState() const;
  
  void setConstituentSignalState( signalstate_t s );

  bool has_calibrated_constit() const {return int(constituentSignalState())>0;};
  
  bool finalScaleEqualsEMScale() const ;
  
 
 private:
  unsigned int m_RoIword;
  
 public:
  unsigned int RoIword() const {return m_RoIword;};
  
  bool set_RoIword( unsigned int word ) {m_RoIword = word; return true;};
  
  // Operators //
  
  bool operator==(const Jet& rJet) const;
  bool operator==(const Jet* pJet) const;
  bool operator!=(const Jet& rJet) const;
  bool operator!=(const Jet* pJet) const;
  Jet& operator=(const Jet& rJet);
  MsgStream& operator<<(MsgStream& out);

  // Offline/Online Trigger Comparisons //

  std::string str();
 
 protected:

  // Protected SignalState Management //

  friend class JetSignalStateHelper;
  friend class JetCollSigStateHelper;
 
  friend class JetAssociationBase;
  friend class JetTagInfoBase;
 
public:
  void setRawE(double e);    
  void setRawPx(double px);  
  void setRawPy(double py);  
  void setRawPz(double pz);  
 
  void setCScaleE(double e);    
  void setCScalePx(double px);  
  void setCScalePy(double py);  
  void setCScalePz(double pz);  
 
  void setCalE(double e);    
  void setCalPx(double px);  
  void setCalPy(double py);  
  void setCalPz(double pz);  
 
  double getRawE()  const;
  double getRawPx() const;
  double getRawPy() const;
  double getRawPz() const;
 
  double getCScaleE()  const;
  double getCScalePx() const;
  double getCScalePy() const;
  double getCScalePz() const;
 
  double getCalE()  const;
  double getCalPx() const;
  double getCalPy() const;
  double getCalPz() const;
 
private:

  static const double m_ignoreWeight;

  // Protected Kinematics Recombination Scheme //

  virtual void updateKine(const constituent_t* pConst,double wght=1.0);
  virtual void updateKine(const hlv_t& pVec,double wght=1.0);
  virtual void updateKine();
  
 public:

  static bool nullOp( const constituent_type* /* constituent */ )
  { return true; };
  
 
 protected:  
  // Protected Index Construction Support //
 
  // /** @brief Index category for jet shapes */
  // static mcat_t m_shpCat;
  // /** @brief Index category for jet associations */
  // static mcat_t m_assCat;
  // /** @brief Index category for jet tag info */
  // static mcat_t m_tagCat;
  // /** @brief Index category for general jet info */
  // static mcat_t m_infCat;
 

  // Jet Identification //
public:
  
  size_t id() const ;
  
  const JetCollection * parentCollection() const ;
 
protected:
 
  void setJetId(size_t id);
  
  static const size_t s_defaultJetId;
  mutable size_t m_jetId;

  //mutable DataLink<shape_map_t> m_momentMapLink;
  const JetCollection * m_collection;
 

  // Jet Author //
 
public:
  

  std::string jetAuthor() const;

  std::string jetAuthorAndCalibTags() const;
  

  void setJetAuthor(const std::string& author) ;

  void setJetAuthorAndCalibTags(const std::string& author) ;
  
  bool hasCalibTag(const std::string& tag) const;
  int  numCalibTag() const ;
  std::string getCalibTag(int i) const;
  void addCalibTag(const std::string& tag);
 
 
protected:
  friend class ParticleJetCnv_p1;
  friend class JetCnv_p1;
  friend class JetCnv_p2;
  friend class JetCnv_p3;
  friend class JetCnv_p4;
  friend class JetCollectionCnv_p6;
 
  static const size_t s_defaultJetAuthor;
  size_t m_jetAuthor;
 
  
  // Protected Store //
 

  //JetKeyDescriptorInstance* m_jetKeyDescr;
 

  assostore_t* m_assocStore;

  tagstore_t*  m_tagInfoStore;

  signalstate_t m_constituentSigState;

  // Helpers //
 
  

  template<typename STORE>
  bool checkKeyStore(const mcat_t& cat,
             const mkey_t& key,
             const STORE*  store,
             size_t&       aInd) const
  {
    // invalid store pointer
    if ( store == 0 )
      {
    return false;
      }
 
    // check index
    aInd = keyDesc()->getIndex(cat,key,false);
    if ( keyDesc()->isValid(aInd) && aInd < store->size() )
      {
        return true;
      }
    return false;
  }

  template<typename STORE>
  bool checkKeyStore(const mcat_t& cat,
             const mkey_t& key,
             STORE*&       store,
             size_t&       aInd,
             bool createIfMissing ) const
  {
    // invalid store pointer
    if ( store == 0 ) 
      {
    if ( !createIfMissing ) return false;
    store = new STORE();
      }
 
    // check index
    aInd = keyDesc()->getIndex(cat,key,createIfMissing);
    if ( keyDesc()->isValid(aInd) )
      {
    if ( aInd >= store->size() )
      {
        if ( ! createIfMissing ) return false;
        store->resize(aInd+1);
      }
    return true;
      }
    else
      {
    return false;
      }
  }
 
  /* @brief Check validity of key */  
  bool checkKey(const mcat_t& cat,
        const mkey_t& key,
        size_t& aInd,
        bool createIfMissing) const;
 
  
  template<typename OBJ,class STORE>
  const OBJ* getObject(const mkey_t& key,
               const STORE* store,
               const mcat_t& cat) const
  {
    size_t aInd(0);
    return this->checkKeyStore(cat,key,store,aInd)
      ? dynamic_cast<const OBJ*>((store->operator[])(aInd))
      : (const OBJ*)0;
    }
 

  template<typename DATA,class STORE>
  bool getData(const mkey_t& key,
           STORE*  store, // not very nice but can not be const if using checkKey (P.A.)
           const mcat_t& cat,
           DATA&         data,
           bool createIfMissing ) const
  {
    size_t aInd(0);
    if ( this->checkKeyStore(cat,key,store,aInd, createIfMissing) )
      {
    data = (store->operator[])(aInd);
    return true;
      }
    else
      {
    return false;
      }
  }

  // Obsolete Methods //
  
 
  
private:
  // remember number of combinedLikelihood values stored in shapes
  size_t m_num_combinedLikelihood;
public:

  std::vector<double> combinedLikelihood() const;
  
  void setCombinedLikelihood(const std::vector<double>& combinedLikelihood);
 
 
protected:
  const fastjet::PseudoJet *m_pseudoJet;
 
public:
  const fastjet::PseudoJet * fastjetPtr() const {return m_pseudoJet;} 
  void setFastjetPtr(const fastjet::PseudoJet * fj){ m_pseudoJet = fj;}
 
};
 

void diff(const Jet& rJet1, const Jet& rJet2, std::map<std::string,double> varDiff);
 
#include "JetEvent/Jet.icc"
 
 

#endif //JETEVENT_JET_H