CompositeParticle_v1.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: CompositeParticle_v1.h 696023 2015-09-21 17:09:08Z kkoeneke $
#ifndef XAODPARTICLEEVENT_VERSIONS_COMPOSITEPARTICLE_V1_H
#define XAODPARTICLEEVENT_VERSIONS_COMPOSITEPARTICLE_V1_H
 
// STL includes
#include <vector>
 
// xAOD include(s):
#include "AthContainers/ConstDataVector.h"
#include "AthContainers/ConstAccessor.h"
#include "xAODBase/IParticle.h"
#include "xAODBase/IParticleContainer.h"
#include "AthLinks/ElementLink.h"
#include "xAODMissingET/MissingET.h"
#include "xAODEgamma/Electron.h"
#include "xAODEgamma/Photon.h"
#include "xAODMuon/Muon.h"
#include "xAODTau/TauJet.h"
#include "xAODJet/Jet.h"
#include "xAODTruth/TruthParticle.h"
 
// Local include(s):
#include "xAODParticleEvent/IParticleLink.h"
#include "xAODParticleEvent/IParticleLinkContainer.h"
 
// ROOT include(s):
#include "Math/Vector4D.h"
 
namespace xAOD {

  class CompositeParticle_v1 : public IParticle {
 
  public:
    CompositeParticle_v1();


    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;

    typedef ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > GenVecFourMom_t;
    
    GenVecFourMom_t          genvecP4() const;

    virtual Type::ObjectType type() const;
 


    double   px() const;
    double   py() const;
    double   pz() const;
    double   et() const;
 

    void setP4(      const FourMom_t& vec );
    void setPxPyPzE( double px, double py, double pz, double e );
    void setPx(      double px );
    void setPy(      double py );
    void setPz(      double pz );
    void setE(       double e  );
 


    bool hasCharge() const;
    float charge() const;
    void setCharge( float charge );

    bool hasPdgId() const;
    int pdgId() const;
    void setPdgId( int pdgID );

 


    FourMom_t p4( const std::vector<int>& partIndices ) const;

    inline FourMom_t p4( int partIndexA, int partIndexB ) const {
      return this->p4( std::vector<int>{partIndexA, partIndexB} );
    }

    inline FourMom_t p4( int partIndexA, int partIndexB, int partIndexC ) const {
      return this->p4( std::vector<int>{partIndexA, partIndexB, partIndexC} );
    }

    inline FourMom_t p4( int partIndexA, int partIndexB, int partIndexC, int partIndexD ) const {
      return this->p4( std::vector<int>{partIndexA, partIndexB, partIndexC, partIndexD} );
    }

    double pt( const std::vector<int>& partIndices ) const;
    double eta( const std::vector<int>& partIndices ) const;
    double phi( const std::vector<int>& partIndices ) const;
    double m( const std::vector<int>& partIndices ) const;
    double p( const std::vector<int>& partIndices ) const;
    double e( const std::vector<int>& partIndices ) const;
    double rapidity( const std::vector<int>& partIndices ) const;

    double px( const std::vector<int>& partIndices ) const;
    double py( const std::vector<int>& partIndices ) const;
    double pz( const std::vector<int>& partIndices ) const;
    double et( const std::vector<int>& partIndices ) const;
 
 

    struct MT {
      enum Method {
        DEFAULT = 0
      };
    };

    double mt( const std::vector<int>& partIndices, MT::Method method=MT::DEFAULT ) const;
 

    inline double mt( int partIndexA, int partIndexB=-2, MT::Method method=MT::DEFAULT ) const {
      if ( partIndexB==-2 ) {
        return this->mt( std::vector<int>{partIndexA}, method );
      }
      return this->mt( std::vector<int>{partIndexA, partIndexB}, method );
    }

 
 
 


    float weight( const std::vector<std::string>& varNames,
                  const std::vector<int>& partIndices={} ) const;
 

    inline float weight( const std::string& varNameA ) const {
      return this->weight( std::vector<std::string>{varNameA} );
    }
    inline float weight( const std::string& varNameA,
                         const std::string& varNameB ) const {
      return this->weight( std::vector<std::string>{varNameA,varNameB} );
    }
    inline float weight( const std::string& varNameA,
                         const std::string& varNameB,
                         const std::string& varNameC ) const {
      return this->weight( std::vector<std::string>{varNameA,varNameB,varNameC} );
    }
    inline float weight( const std::string& varNameA,
                         const std::string& varNameB,
                         const std::string& varNameC,
                         const std::string& varNameD ) const {
      return this->weight( std::vector<std::string>{varNameA,varNameB,varNameC,varNameD} );
    }
    inline float weight( const std::string& varNameA,
                         const std::string& varNameB,
                         const std::string& varNameC,
                         const std::string& varNameD,
                         const std::string& varNameE ) const {
      return this->weight( std::vector<std::string>{varNameA,varNameB,varNameC,varNameD,varNameE} );
    }
 
 
  private:
    float weightHelper( const xAOD::IParticle* part,
                        const xAOD::IParticle::ConstAccessor<float>& varAcc ) const;
 
  public:
 
 
 


    void addPart( const xAOD::IParticle* part, bool updateFourMom=true );

    void addPart( const xAOD::IParticleLink& partLink, bool updateFourMom=true );

    void addParts( const xAOD::IParticleLinkContainer& partLinkCont,
                   bool updateFourMom=true );

    void removePart( const xAOD::IParticle* part, bool updateFourMom=true );

    void removePart( const xAOD::IParticleLink& partLink, bool updateFourMom=true );
 
 

    const xAOD::MissingET* missingET() const;

    void setMissingET( const xAOD::MissingET* met, bool updateFourMom=true );

    void removeMissingET( bool updateFourMom=true );
 

    bool contains( const xAOD::MissingET* met          ) const;
    bool contains( const xAOD::IParticle* part         ) const;
    bool contains( const xAOD::IParticleLink& partLink ) const;
 

    std::size_t nParts() const;

    std::size_t nCompParts() const;

    std::size_t nPhotons() const;

    std::size_t nTruthPhotons() const;

    std::size_t nElectrons() const;

    std::size_t nTruthElectrons() const;

    std::size_t nMuons() const;

    std::size_t nTruthMuons() const;

    std::size_t nTaus() const;

    std::size_t nTruthTaus() const;

    std::size_t nLeptons() const;

    std::size_t nTruthLeptons() const;

    std::size_t nJets() const;

    std::size_t nTruthParts() const;
 

    const xAOD::IParticle* part( std::size_t index = 0 ) const;

    const xAOD::IParticleLink& partLink( std::size_t index = 0 ) const;

    const xAOD::IParticleLinkContainer& partLinks() const;
 

    template<typename CONTTYPE>
    ConstDataVector<CONTTYPE>* parts( ) const;
 
 

    xAOD::CompositeParticle_v1* compPart( const std::vector<int>& partIndices,
                                          const std::vector<int>& otherPartIndices=std::vector<int>{},
                                          bool updateFourMom=true ) const;
 

    xAOD::CompositeParticle_v1* compPart( int partIndexA, int partIndexB, int partIndexC=-2,
                                          bool updateFourMom=true ) const {
      if ( partIndexC==-2 ) {
        return this->compPart( std::vector<int>{partIndexA, partIndexB}, std::vector<int>{}, updateFourMom );
      }
      return this->compPart( std::vector<int>{partIndexA, partIndexB, partIndexC}, std::vector<int>{}, updateFourMom );
    }
 

    const xAOD::CompositeParticle_v1* compPart( std::size_t index = 0 ) const;

    const xAOD::Photon* photon( std::size_t index = 0 ) const;

    const xAOD::Electron* electron( std::size_t index = 0 ) const;

    const xAOD::Muon* muon( std::size_t index = 0 ) const;

    const xAOD::TauJet* tau( std::size_t index = 0 ) const;

    const xAOD::Jet* jet( std::size_t index = 0 ) const;

    const xAOD::TruthParticle* truthPart( std::size_t index = 0 ) const;


 
 


    void addOtherPart( const xAOD::IParticle* part );

    void addOtherPart( const xAOD::IParticleLink& partLink );

    void addOtherParts( const xAOD::IParticleLinkContainer& partLinkCont );
 

    void removeOtherPart( const xAOD::IParticle* part );

    void removeOtherPart( const xAOD::IParticleLink& partLink );
 
 

    bool containsOther( const xAOD::IParticle* part         ) const;
    bool containsOther( const xAOD::IParticleLink& partLink ) const;
 

    std::size_t nOtherParts() const;

    std::size_t nOtherCompParts() const;

    std::size_t nOtherPhotons() const;

    std::size_t nOtherTruthPhotons() const;

    std::size_t nOtherElectrons() const;

    std::size_t nOtherTruthElectrons() const;

    std::size_t nOtherMuons() const;

    std::size_t nOtherTruthMuons() const;

    std::size_t nOtherTaus() const;

    std::size_t nOtherTruthTaus() const;

    std::size_t nOtherLeptons() const;

    std::size_t nOtherTruthLeptons() const;

    std::size_t nOtherJets() const;

    std::size_t nOtherTruthParts() const;
 

    const xAOD::IParticle* otherPart( std::size_t index = 0 ) const;

    const xAOD::IParticleLink& otherPartLink( std::size_t index = 0 ) const;

    const xAOD::IParticleLinkContainer& otherPartLinks() const;
 

    const xAOD::CompositeParticle_v1* otherCompPart( std::size_t index = 0 ) const;

    const xAOD::Photon* otherPhoton( std::size_t index = 0 ) const;

    const xAOD::Electron* otherElectron( std::size_t index = 0 ) const;

    const xAOD::Muon* otherMuon( std::size_t index = 0 ) const;

    const xAOD::TauJet* otherTau( std::size_t index = 0 ) const;

    const xAOD::Jet* otherJet( std::size_t index = 0 ) const;

    const xAOD::TruthParticle* otherTruthPart( std::size_t index = 0 ) const;


 


    inline bool getBool( const std::string& varName ) const {
      return SG::ConstAccessor<bool>(varName)(*this);
    }

    inline int getInt( const std::string& varName ) const {
      return SG::ConstAccessor<int>(varName)(*this);
    }

    inline unsigned int getUInt( const std::string& varName ) const {
      return SG::ConstAccessor<unsigned int>(varName)(*this);
    }

    inline float getFloat( const std::string& varName ) const {
      return SG::ConstAccessor<float>(varName)(*this);
    }

    inline double getDouble( const std::string& varName ) const {
      return SG::ConstAccessor<double>(varName)(*this);
    }
 

 
 
  protected:
    void setPartLinks( const xAOD::IParticleLinkContainer& constitLinks );

    void setOtherPartLinks( const xAOD::IParticleLinkContainer& otherPartLinks );
 
 
  public:

    void toPersistent();
 
 
  }; // class CompositeParticle_v1
 
 
} // namespace xAOD
 
 
// Inline methods
inline
const xAOD::CompositeParticle_v1*
xAOD::CompositeParticle_v1::compPart( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->part(index);
  if ( ipart->type() != xAOD::Type::CompositeParticle ){ return 0; }
  return static_cast<const xAOD::CompositeParticle_v1*>(ipart);
}
 
 
inline
const xAOD::Photon*
xAOD::CompositeParticle_v1::photon( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->part(index);
  if ( ipart->type() != xAOD::Type::Photon ){ return 0; }
  return static_cast<const xAOD::Photon*>(ipart);
}
 
 
inline
const xAOD::Electron*
xAOD::CompositeParticle_v1::electron( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->part(index);
  if ( ipart->type() != xAOD::Type::Electron ){ return 0; }
  return static_cast<const xAOD::Electron*>(ipart);
}
 
 
inline
const xAOD::Muon*
xAOD::CompositeParticle_v1::muon( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->part(index);
  if ( ipart->type() != xAOD::Type::Muon ){ return 0; }
  return static_cast<const xAOD::Muon*>(ipart);
}
 
 
inline
const xAOD::TauJet*
xAOD::CompositeParticle_v1::tau( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->part(index);
  if ( ipart->type() != xAOD::Type::Tau ){ return 0; }
  return static_cast<const xAOD::TauJet*>(ipart);
}
 
 
inline
const xAOD::Jet*
xAOD::CompositeParticle_v1::jet( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->part(index);
  if ( ipart->type() != xAOD::Type::Jet ){ return 0; }
  return static_cast<const xAOD::Jet*>(ipart);
}
 
 
inline
const xAOD::TruthParticle*
xAOD::CompositeParticle_v1::truthPart( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->part(index);
  if ( ipart->type() != xAOD::Type::TruthParticle ){ return 0; }
  return static_cast<const xAOD::TruthParticle*>(ipart);
}
 
 
 
inline
const xAOD::CompositeParticle_v1*
xAOD::CompositeParticle_v1::otherCompPart( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->otherPart(index);
  if ( ipart->type() != xAOD::Type::CompositeParticle ){ return 0; }
  return static_cast<const xAOD::CompositeParticle_v1*>(ipart);
}
 
 
inline
const xAOD::Photon*
xAOD::CompositeParticle_v1::otherPhoton( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->otherPart(index);
  if ( ipart->type() != xAOD::Type::Photon ){ return 0; }
  return static_cast<const xAOD::Photon*>(ipart);
}
 
 
inline
const xAOD::Electron*
xAOD::CompositeParticle_v1::otherElectron( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->otherPart(index);
  if ( ipart->type() != xAOD::Type::Electron ){ return 0; }
  return static_cast<const xAOD::Electron*>(ipart);
}
 
 
inline
const xAOD::Muon*
xAOD::CompositeParticle_v1::otherMuon( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->otherPart(index);
  if ( ipart->type() != xAOD::Type::Muon ){ return 0; }
  return static_cast<const xAOD::Muon*>(ipart);
}
 
 
inline
const xAOD::TauJet*
xAOD::CompositeParticle_v1::otherTau( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->otherPart(index);
  if ( ipart->type() != xAOD::Type::Tau ){ return 0; }
  return static_cast<const xAOD::TauJet*>(ipart);
}
 
 
inline
const xAOD::Jet*
xAOD::CompositeParticle_v1::otherJet( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->otherPart(index);
  if ( ipart->type() != xAOD::Type::Jet ){ return 0; }
  return static_cast<const xAOD::Jet*>(ipart);
}
 
 
inline
const xAOD::TruthParticle*
xAOD::CompositeParticle_v1::otherTruthPart( std::size_t index ) const
{
  const xAOD::IParticle* ipart = this->otherPart(index);
  if ( ipart->type() != xAOD::Type::TruthParticle ){ return 0; }
  return static_cast<const xAOD::TruthParticle*>(ipart);
}
 
 
 
 
#endif // XAODPARTICLEEVENT_VERSIONS_COMPOSITEPARTICLE_V1_H