MissingETAssociation_v1.h

Go to the documentation of this file.

// -*- c++ -*-
 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef XAODMISSINGET_VERSIONS_MISSINGETASSOCIATION_v1_H
#define XAODMISSINGET_VERSIONS_MISSINGETASSOCIATION_v1_H
 
#include "AthContainers/AuxElement.h"
 
#include "xAODBase/IParticleContainer.h"
 
#include "xAODMissingET/versions/MissingETCompositionBase.h" //MissingETBase::UsageHandler
 
#include <vector>
 
namespace xAOD
{
  // Forward declaration
  class MissingETAssociationHelper;
  class IParticle; 
  class MissingETAssociation_v1 : public SG::AuxElement
  {
  public:
 
    static bool testPolicy(const xAOD::IParticle& part, MissingETBase::UsageHandler::Policy p);
                                                                                                            
    class ConstVec
    {
    public:
      ConstVec();                                 
      ConstVec(float cpx,float cpy,float cpz,float ce,float sumpt); 
      ConstVec(const IParticle& ipar);            
      // ConstVec(const ConstVec& cvec);             /*!< @brief Copy constructor */
      ~ConstVec();                                
      float cpx() const; 
      float cpy() const; 
      float cpz() const; 
      float cpt() const; 
      float ce() const;  
      float sumpt() const;  
      void setCpx(float px); 
      void setCpy(float py); 
      void setCpz(float pz); 
      void setCe (float e);  
      void setSumpt (float sumpt);  
      float& cpx(); 
      float& cpy(); 
      float& cpz(); 
      float& ce();  
      float& sumpt(); 
      ConstVec& operator+=(const ConstVec& cvec); 
      ConstVec& operator-=(const ConstVec& cvec); 
      ConstVec& operator*=(float scale);          
      ConstVec& operator/=(float scale);         
      bool operator==(const ConstVec& cvec) const; 
      bool operator!=(const ConstVec& cvec) const; 
     private:
      float m_cpx; 
      float m_cpy; 
      float m_cpz; 
      float m_ce;  
      float m_sumpt;  
    }; // MissingETComponent_v1::ConstVec
 
    explicit MissingETAssociation_v1(bool createStore=false);     
    MissingETAssociation_v1(const Jet* pjet, bool isMisc=false); 
    MissingETAssociation_v1(const MissingETAssociation_v1& assocDescr);                                    
    MissingETAssociation_v1& operator=(const MissingETAssociation_v1& assocDescr);                         
    virtual ~MissingETAssociation_v1();                                                                 

    bool setRefJet(const Jet* pJet);
    bool setRefJet(const JetContainer* pJetCont,size_t pJetIdx);
 
    bool addObject(const IParticle* pPart,const std::vector<const IParticle*>& constlist);     

    const std::vector<float>& calpx() const;                
    float calpx(const IParticle* pPart) const;              
    float calpx(size_t keyIdx) const;                       
    //
    bool setCalPx(const std::vector<float>& calpxvec);      
    bool setCalPx(size_t keyIdx,float calpx);               
    //
    const std::vector<float>& calpy() const;                
    float calpy(size_t keyIdx) const;                       
    //
    bool setCalPy(const std::vector<float>& calpyvec);      
    bool setCalPy(size_t keyIdx,float calpy);               
    //
    const std::vector<float>& calpz() const;                
    float calpz(size_t keyIdx) const;                       
    //
    bool setCalPz(const std::vector<float>& calpzvec);      
    bool setCalPz(size_t keyIdx,float calpz);               
    //
    const std::vector<float>& cale() const;                 
    float cale(size_t keyIdx) const;                        
    //
    bool setCalE(const std::vector<float>& calevec);        
    bool setCalE(size_t keyIdx,float cale);                 
    //
    const std::vector<float>& calsumpt() const;             
    float calsumpt(size_t keyIdx) const;                    
    //
    bool setCalSumpt(const std::vector<float>& calsumptvec); 
    bool setCalSumpt(size_t keyIdx,float calsumpt);          
    //
    const std::vector<MissingETBase::Types::bitmask_t>& calkey() const;   
    MissingETBase::Types::bitmask_t calkey(size_t keyIdx) const;          
    //
    bool setCalKey(const std::vector<MissingETBase::Types::bitmask_t>& calkeyvec); 
    bool setCalKey(size_t keyIdx,MissingETBase::Types::bitmask_t calkey);          
    //
    bool setCalVec(size_t keyIdx,const ConstVec& cvec=ConstVec());           
    bool setCalVec(size_t keyIdx,float calpx,float calpy,float calpz,float ce,float sumpt);            
    //
    bool addCalVec(MissingETBase::Types::bitmask_t key,float calpx,float calpy,float calpz,float cale,float sumpt);            
    //
    bool clearCalVecs();           
    //
    const std::vector<float>& trkpx() const;                
    float trkpx(size_t keyIdx) const;                       
    //
    bool setTrkPx(const std::vector<float>& trkpxvec);      
    bool setTrkPx(size_t keyIdx,float trkpx);               
    //
    const std::vector<float>& trkpy() const;                
    float trkpy(size_t keyIdx) const;                       
    //
    bool setTrkPy(const std::vector<float>& trkpyvec);      
    bool setTrkPy(size_t keyIdx,float trkpy);               
    //
    const std::vector<float>& trkpz() const;                
    float trkpz(size_t keyIdx) const;                       
    //
    bool setTrkPz(const std::vector<float>& trkpzvec);      
    bool setTrkPz(size_t keyIdx,float trkpz);               
    //
    const std::vector<float>& trke() const;                 
    float trke(size_t keyIdx) const;                        
    //
    bool setTrkE(const std::vector<float>& trkevec);        
    bool setTrkE(size_t keyIdx,float trke);                 
    //
    const std::vector<float>& trksumpt() const;             
    float trksumpt(size_t keyIdx) const;                    
    //
    bool setTrkSumpt(const std::vector<float>& trksumptvec); 
    bool setTrkSumpt(size_t keyIdx,float trksumpt);          
    //
    const std::vector<MissingETBase::Types::bitmask_t>& trkkey() const;   
    MissingETBase::Types::bitmask_t trkkey(size_t keyIdx) const;          
    //
    bool setTrkKey(const std::vector<MissingETBase::Types::bitmask_t>& trkkeyvec); 
    bool setTrkKey(size_t keyIdx,MissingETBase::Types::bitmask_t trkkey);          
    //
    bool setTrkVec(size_t keyIdx,const ConstVec& cvec=ConstVec());           
    bool setTrkVec(size_t keyIdx,float trkpx,float trkpy,float trkpz,float trke,float sumpt);            
    //
    bool addTrkVec(MissingETBase::Types::bitmask_t key,float trkpx,float trkpy,float trkpz,float ce,float sumpt);            
    //
    bool clearTrkVecs();           
    //
    float jettrkpx() const;              
    float jettrkpy() const;              
    float jettrkpz() const;              
    float jettrke() const;               
    float jettrksumpt() const;           
    //
    void setJetTrkPx(float px);    
    void setJetTrkPy(float py);    
    void setJetTrkPz(float pz);    
    void setJetTrkE(float e);      
    void setJetTrkSumpt(float sumpt);      
    void setJetTrkVec(const ConstVec& cvec=ConstVec());  
    void setJetTrkVec(float px,float py,float pz,float ce,float sumpt);    
    //
    const MissingETBase::Types::jetlink_t& jetLink() const;                     
    bool setJetLink(const MissingETBase::Types::jetlink_t& jetLnk);             
    const MissingETBase::Types::objlink_vector_t& objectLinks() const;          
    bool setObjectLinks(const MissingETBase::Types::objlink_vector_t& objLnks); 
 
    //
    const std::vector<std::vector<size_t> >& overlapIndices() const;            
    std::vector<size_t> overlapIndices(const IParticle* pPart) const;           
    std::vector<size_t> overlapIndices(size_t objIdx) const;                    
    //
    const std::vector<std::vector<unsigned char> >& overlapTypes() const;            
    std::vector<unsigned char> overlapTypes(const IParticle* pPart) const;           
    std::vector<unsigned char> overlapTypes(size_t objIdx) const;                    
    //
    void clearOverlaps();  
    bool setOverlaps(const std::vector<std::vector<size_t> >& overlapIndices,
             const std::vector<std::vector<unsigned char> >& overlapTypes);            
    bool setOverlaps(const IParticle* pPart,const std::vector<size_t>& overlapIndices,
             const std::vector<unsigned char>& overlapTypes);  
    bool setOverlaps(size_t objIdx,const std::vector<size_t>& overlapIndices,
             const std::vector<unsigned char>& overlapTypes);           
    void setOverrideMom(const std::map<const IParticle*,ConstVec>& pOverride);         
    std::map<const IParticle*,ConstVec> overrideMom();                          
    void addOverrideMom(std::map<const IParticle*,ConstVec> &pOverride);        


    bool removeContrib(const IParticle* pPart);               
    bool removeContrib(size_t objIdx);                        
    bool removeContrib();                                     
    bool resetContrib(const IParticle* pPart);                
    bool resetContrib(size_t objIdx);                         
    bool resetContrib();                                      

    const Jet* refJet() const;                                
    const JetContainer* refJetContainer() const;              
    size_t refJetIndex() const;                               
    std::vector<const IParticle*> objects() const;            
    std::vector<const IParticle*> objects(std::vector<ConstVec>& calVecs,std::vector<ConstVec>& trkVecs) const; 
    std::vector<const IParticle*> objects(const std::vector<float>*& calpxPtr,    
                      const std::vector<float>*& calpyPtr,
                      const std::vector<float>*& calpzPtr,
                      const std::vector<float>*& calePtr,
                      const std::vector<float>*& calsumptPtr,
                      const std::vector<float>*& trkpxPtr,
                      const std::vector<float>*& trkpyPtr,
                      const std::vector<float>*& trkpzPtr,
                      const std::vector<float>*& trkePtr,
                      const std::vector<float>*& trksumptPtr) const; 
    ConstVec calVec(const IParticle* pPart) const;            
    ConstVec calVec(size_t keyIdx) const;                     
    ConstVec trkVec(const IParticle* pPart) const;            
    ConstVec trkVec(size_t keyIdx) const;                     
    ConstVec jetTrkVec() const;                                

    bool addOverlap(const IParticle* pPart,size_t index, unsigned char type);  
    bool addOverlap(size_t objIdx,size_t index, unsigned char type);           
 
    bool identifyOverlaps();                                              
    bool identifyOverlaps(size_t objIdx);                                 
    bool identifyOverlaps(const IParticle* pPart);                        
 
    bool hasOverlaps(const MissingETAssociationHelper& helper, size_t objIdx,MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster) const;
    bool hasOverlaps(const MissingETAssociationHelper& helper, const IParticle* pPart,
             MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster) const;
 
    bool hasAlternateConstVec() const;
    xAOD::JetFourMom_t getAlternateConstVec() const;
 
    ConstVec overlapCalVec(const MissingETAssociationHelper& helper) const;    
    ConstVec overlapTrkVec(const MissingETAssociationHelper& helper) const;    
 
    bool containsSignal(const IParticle* pSig) const;                     
    bool containsPhysics(const IParticle* pPhys) const;                   
    bool isMisc() const;                                                  
    bool checkUsage(const MissingETAssociationHelper& helper, const IParticle* pSig, MissingETBase::UsageHandler::Policy p) const; 

    size_t findIndex(const IParticle* pPart) const;
    size_t findCalIndex(MissingETBase::Types::bitmask_t mask) const;
    size_t findTrkIndex(MissingETBase::Types::bitmask_t mask) const;

    // void updateLinks();
    // /*! @brief [Deprecated] Update link to reference jet only */
    // void updateJetLink();
    size_t size() const;
    size_t sizeCal() const;
    size_t sizeTrk() const;
    bool empty() const;

    bool operator==(const MissingETAssociation_v1& contrib) const; 
    bool operator!=(const MissingETAssociation_v1& contrib) const;
 
  protected:
 
    static bool testPolicy(xAOD::Type::ObjectType type, MissingETBase::UsageHandler::Policy p);

    void createPrivateStore();

    MissingETBase::Types::objlink_vector_t&  f_objectLinks(); 
    MissingETBase::Types::jetlink_t&         f_jetLink();     
    //
    std::vector<float>&                     f_calpx();
    std::vector<float>&                     f_calpy();
    std::vector<float>&                     f_calpz();
    std::vector<float>&                     f_cale();
    std::vector<float>&                     f_calsumpt();
    std::vector<MissingETBase::Types::bitmask_t>& f_calkey();
    //
    std::vector<float>&                     f_trkpx();
    std::vector<float>&                     f_trkpy();
    std::vector<float>&                     f_trkpz();
    std::vector<float>&                     f_trke();
    std::vector<float>&                     f_trksumpt();
    std::vector<MissingETBase::Types::bitmask_t>& f_trkkey();
    //
    float&                                  f_jettrkpx();
    float&                                  f_jettrkpy();
    float&                                  f_jettrkpz();
    float&                                  f_jettrke();
    float&                                  f_jettrksumpt();
    //
    char&                                    f_isMisc();
    //
    std::vector<std::vector<size_t> >&       f_overlapIndices(); 
    std::vector<std::vector<unsigned char> >& f_overlapTypes();  

    bool f_removeContrib(size_t objIdx);
    void copyData(const MissingETAssociation_v1& assocDescr);
    template<class POBJ,class LINK> void f_setObject(const POBJ* pObj,LINK& elemLink);
    template<class LINK> bool f_setLink(LINK& elemLink);

 
    void initCache(); 

    std::vector<std::vector<ElementLink<IParticleContainer> > > m_objConstLinks;   
  private:
    std::map<const IParticle*,ConstVec> m_override;
 
    static const SG::AuxElement::Accessor<std::vector<float> > m_acc_calpx;
    static const SG::AuxElement::Accessor<std::vector<float> > m_acc_calpy;
    static const SG::AuxElement::Accessor<std::vector<float> > m_acc_calpz;
    static const SG::AuxElement::Accessor<std::vector<float> > m_acc_cale;
    static const SG::AuxElement::Accessor<std::vector<float> > m_acc_calsumpt;
 
    static const SG::AuxElement::Accessor<std::vector<float> > m_acc_trkpx;
    static const SG::AuxElement::Accessor<std::vector<float> > m_acc_trkpy;
    static const SG::AuxElement::Accessor<std::vector<float> > m_acc_trkpz;
    static const SG::AuxElement::Accessor<std::vector<float> > m_acc_trke;
    static const SG::AuxElement::Accessor<std::vector<float> > m_acc_trksumpt;
 
    static const SG::AuxElement::Accessor<float> m_acc_jettrkpx;
    static const SG::AuxElement::Accessor<float> m_acc_jettrkpy;
    static const SG::AuxElement::Accessor<float> m_acc_jettrkpz;
    static const SG::AuxElement::Accessor<float> m_acc_jettrke;
    static const SG::AuxElement::Accessor<float> m_acc_jettrksumpt;
 
  }; // MissingETAssociation_v1
}
 
namespace MissingETBase
{
  namespace Types
  {
    typedef xAOD::MissingETAssociation_v1::ConstVec constvec_t; 
    typedef std::vector<constvec_t> constvec_vector_t; 
  }
}

MissingETBase::Types::constvec_t operator+(const MissingETBase::Types::constvec_t& v0,const MissingETBase::Types::constvec_t& v2);
MissingETBase::Types::constvec_t operator-(const MissingETBase::Types::constvec_t& v0,const MissingETBase::Types::constvec_t& v2);
MissingETBase::Types::constvec_t operator*(const MissingETBase::Types::constvec_t& cvec,float scale);
MissingETBase::Types::constvec_t operator*(float scale,const MissingETBase::Types::constvec_t& cvec);
MissingETBase::Types::constvec_t operator/(const MissingETBase::Types::constvec_t& cvec,float scale);
#include "xAODMissingET/versions/MissingETAssociation_v1.icc"
#endif