ParticleJetTools::FatVertex::FatVertex Struct Reference

#include <FatVertex.h>

Collaboration diagram for ParticleJetTools::FatVertex::FatVertex:

Public Member Functions
	FatVertex (std::vector< const xAOD::TruthParticle * > in_parts, std::vector< const xAOD::TruthParticle * > intern, std::vector< const xAOD::TruthParticle * > out_parts, bool pv)
float	getPT () const
void	doParentChildLinks (std::vector< FatVertex > &vertices)
int	getNumChargedDecays (float minPt=0.0) const
int	getNumNeutralDecays (float minPt=0.0, bool include_neutrinos=false) const
VertexType	getType (const SG::ConstAccessor< int > &uid_accessor) const
bool	operator< (const FatVertex &other) const
bool	operator== (const FatVertex &other) const

Public Attributes
std::vector< const xAOD::TruthParticle * >	inparts
std::vector< const xAOD::TruthParticle * >	internal
std::vector< const xAOD::TruthParticle * >	outparts
bool	is_pv
const FatVertex *	parent =nullptr
std::vector< const FatVertex * >	children

Private Member Functions
std::optional< DetailedVertexType >	classifyTauVertex (DetailedVertexType parent_type, bool has_parent) const
std::optional< DetailedVertexType >	classifyStrangeVertex (DetailedVertexType parent_type, bool has_parent) const
std::optional< DetailedVertexType >	classifyPhotonVertex (size_t truth_out_parts, size_t truth_valid_out_parts, const std::vector< const xAOD::TruthParticle * > &truth_children) const
std::optional< DetailedVertexType >	classifyLeptonVertex (const SG::ConstAccessor< int > &uid_accessor, size_t truth_out_parts, size_t truth_valid_out_parts, const std::vector< const xAOD::TruthParticle * > &truth_children) const

Detailed Description

Definition at line 120 of file FatVertex.h.

Constructor & Destructor Documentation

FatVertex()

ParticleJetTools::FatVertex::FatVertex::FatVertex ( std::vector< const xAOD::TruthParticle * > in_parts, std::vector< const xAOD::TruthParticle * > intern, std::vector< const xAOD::TruthParticle * > out_parts, bool pv )

inline

Definition at line 128 of file FatVertex.h.

                                                                                                                                                                        :
              inparts(std::move(in_parts)), internal(std::move(intern)),
              outparts(std::move(out_parts)), is_pv(pv) {}

Member Function Documentation

classifyLeptonVertex()

std::optional< DetailedVertexType > ParticleJetTools::FatVertex::FatVertex::classifyLeptonVertex ( const SG::ConstAccessor< int > & uid_accessor, size_t truth_out_parts, size_t truth_valid_out_parts, const std::vector< const xAOD::TruthParticle * > & truth_children ) const

private

Definition at line 495 of file FatVertex.cxx.

                {
          // Standard lep->lep+gamma : Bremsstrahlung
          if ( outparts.size() == 2 &&
               ((outparts[0]->isPhoton() && outparts[1]->isChLepton()) ||
                (outparts[1]->isPhoton() && outparts[0]->isChLepton())) ) {
            return DetailedVertexType::Bremsstrahlung;
          }
          // e->e+gamma but the electron doesn't stay in the truth record
          if ( (truth_out_parts == 2 || truth_out_parts == 1) && truth_valid_out_parts == 1 &&
               outparts[0]->isPhoton() ) {
            return DetailedVertexType::Bremsstrahlung;
          }
          // l -> gamma + l which is still brem
          if ( truth_valid_out_parts == 2 &&
               ((truth_children[0]->isPhoton() && truth_children[1]->pdgId() == inparts[0]->pdgId()) ||
                (truth_children[1]->isPhoton() && truth_children[0]->pdgId() == inparts[0]->pdgId())) ) {
            return DetailedVertexType::Bremsstrahlung;
          }
          // e+ e- annihilation: e+ -> gamma gamma
          if ( inparts[0]->pdgId() == -11 && outparts.size() == 2 &&
               outparts[0]->isPhoton() && outparts[1]->isPhoton() ) {
            return DetailedVertexType::EPAnnihilation;
          }
          // e+ -> gamma (boosted, partner low energy)
          if ( inparts[0]->pdgId() == -11 && outparts.size() == 1 &&
               outparts[0]->isPhoton() ) {
            return DetailedVertexType::EPAnnihilation;
          }
          // e+ -> child is single photon
          if ( inparts[0]->pdgId() == -11 && inparts[0]->nChildren() == 1 &&
               inparts[0]->child(0)->isPhoton() ) {
            return DetailedVertexType::EPAnnihilation;
          }
          // Lepton scattering via Geant (same base UID → material interaction)
          int in_base_bar = uid_accessor(*inparts[0]) % HepMC::SIM_REGENERATION_INCREMENT;
          if ( truth_valid_out_parts == 2 && truth_out_parts == 2 &&
               (in_base_bar == uid_accessor(*outparts[0]) % HepMC::SIM_REGENERATION_INCREMENT ||
                in_base_bar == uid_accessor(*outparts[1]) % HepMC::SIM_REGENERATION_INCREMENT) ) {
            return DetailedVertexType::MaterialInteraction;
          }
          return std::nullopt;
        }

classifyPhotonVertex()

std::optional< DetailedVertexType > ParticleJetTools::FatVertex::FatVertex::classifyPhotonVertex ( size_t truth_out_parts, size_t truth_valid_out_parts, const std::vector< const xAOD::TruthParticle * > & truth_children ) const

private

Definition at line 452 of file FatVertex.cxx.

                {
          // Gamma -> e+e- : Conversion
          if ( outparts.size() == 2 && outparts[0]->isChLepton() && outparts[1]->isChLepton() &&
               (outparts[0]->pdgId() + outparts[1]->pdgId()) == 0 ) {
            return DetailedVertexType::Conversion;
          }
          // Conversion from truth children (handles cases where fat vertex merging changed outparts)
          if ( truth_valid_out_parts == 2 &&
               (truth_children[0]->pdgId() + truth_children[1]->pdgId()) == 0 ) {
            return DetailedVertexType::Conversion;
          }
          // Photon -> single electron: photoelectric emission
          if ( std::abs(outparts[0]->pdgId()) == 11 ) {
            return DetailedVertexType::PhotoelectricEmission;
          }
          // Conversion where one lepton was absorbed by material
          if ( outparts.size() == 1 && internal.size() == 1 &&
               internal[0]->isChLepton() && outparts[0]->isChLepton() ) {
            return DetailedVertexType::Conversion;
          }
          // Conversion with missing truth record for one lepton
          if ( outparts.size() == 1 && internal.empty() && truth_out_parts == 2 &&
               truth_valid_out_parts == 1 && outparts[0]->isChLepton() ) {
            return DetailedVertexType::Conversion;
          }
          // gamma -> gamma + e : Compton scattering
          if ( outparts.size() == 2 &&
               ((outparts[0]->isPhoton() && outparts[1]->pdgId() == 11) ||
                (outparts[1]->isPhoton() && outparts[0]->pdgId() == 11)) ) {
            return DetailedVertexType::ComptonScattering;
          }
          // Catch-all for photon vertices with 3+ outparts containing electrons:
          // conversion + bremsstrahlung merged by fat vertex builder
          for (auto p : outparts) {
            if (p && p->isChLepton()) return DetailedVertexType::Conversion;
          }
          // Photon interaction with no electrons — generic material interaction
          return DetailedVertexType::MaterialInteraction;
        }

classifyStrangeVertex()

std::optional< DetailedVertexType > ParticleJetTools::FatVertex::FatVertex::classifyStrangeVertex ( DetailedVertexType parent_type, bool has_parent ) const

private

Definition at line 430 of file FatVertex.cxx.

                {
          if ( outparts.size() == 1 && outparts[0]->isStrangeHadron() )
            return DetailedVertexType::StrangeOscillation;
          if ( !has_parent ) return DetailedVertexType::StrangeDecay;
          switch (parent_type) {
            case DetailedVertexType::BHadronDecay:
              return DetailedVertexType::StrangeFromBHadron;
            case DetailedVertexType::CHadronDecay:
              return DetailedVertexType::StrangeFromCHadron;
            case DetailedVertexType::TauDecay:
              return DetailedVertexType::StrangeFromTau;
            case DetailedVertexType::CHadronDecayFromBHadron:
              return DetailedVertexType::StrangeFromCFromBHadron;
            case DetailedVertexType::TauDecayFromBHadron:
              return DetailedVertexType::StrangeFromTauFromBHadron;
            default:
              return DetailedVertexType::StrangeDecay;
          }
        }

classifyTauVertex()

std::optional< DetailedVertexType > ParticleJetTools::FatVertex::FatVertex::classifyTauVertex ( DetailedVertexType parent_type, bool has_parent ) const

private

Definition at line 411 of file FatVertex.cxx.

                {
          int num_child_taus = 0;
          int num_child_photons = 0;
          for ( auto child : outparts ) {
            if ( child->isTau() ) num_child_taus++;
            else if ( child->isPhoton() ) num_child_photons++;
          }
          if ( num_child_taus == 0 ) {
            if (has_parent && parent_type == DetailedVertexType::BHadronDecay)
              return DetailedVertexType::TauDecayFromBHadron;
            return DetailedVertexType::TauDecay;
          }
          if ( num_child_taus == 1 && num_child_photons == 1 )
            return DetailedVertexType::Bremsstrahlung;
          return std::nullopt;
        }

doParentChildLinks()

void ParticleJetTools::FatVertex::FatVertex::doParentChildLinks

(

std::vector< FatVertex > &

vertices

)

Definition at line 558 of file FatVertex.cxx.

                                                                         {
          // Iterates through all the vertices to set parent and children
 
          FatVertex* found_parent = nullptr;
          std::vector<const FatVertex*> found_children;
 
          for (auto& vertex2 : vertices) {
            if ( this == &vertex2) continue; // Compare addresses, not objects
 
            // Check if any of vertex2's outputs match vertex's inputs
            if (std::find(vertex2.outparts.begin(), vertex2.outparts.end(), inparts[0]) != vertex2.outparts.end()) {
              if (found_parent) {
                throw std::runtime_error("Multiple parents detected for a vertex");
              }
              found_parent = &vertex2;
            }
 
            // Check if vertex2 is a child
            if (std::find(outparts.begin(), outparts.end(), vertex2.inparts[0]) != outparts.end()) {
              found_children.push_back(&vertex2);
            }
          }
 
          parent = found_parent;
          children = std::move(found_children);
        }

getNumChargedDecays()

int ParticleJetTools::FatVertex::FatVertex::getNumChargedDecays

(

float

minPt = 0.0

)

const

Definition at line 285 of file FatVertex.cxx.

                                                            {
          int num_charged = 0;
          for ( auto part : outparts ) {
            if ( part->isCharged() && part->pt() >= minPt ) num_charged++;
          }
          return num_charged;
        }

getNumNeutralDecays()

int ParticleJetTools::FatVertex::FatVertex::getNumNeutralDecays	(	float	minPt = 0.0,
		bool	include_neutrinos = false ) const

Definition at line 293 of file FatVertex.cxx.

                                                                                    {
          int num_neutral = 0;
          for ( auto part : outparts ) {
            if ( part->isNeutral() && part->pt() >= minPt && (include_neutrinos || !part->isNeutrino()) )
              num_neutral++;
          }
          return num_neutral;
        }

getPT()

float ParticleJetTools::FatVertex::FatVertex::getPT

(

)

const

Definition at line 280 of file FatVertex.cxx.

                                     {
          if ( inparts.size() == 1 ) { return inparts[0]->pt(); }
          return sum_4vec(inparts).Pt();
        }

getType()

VertexType ParticleJetTools::FatVertex::FatVertex::getType

(

const SG::ConstAccessor< int > &

uid_accessor

)

const

Definition at line 302 of file FatVertex.cxx.

                {
          if ( is_pv ) return DetailedVertexType::PrimaryVertex;
          if ( inparts.size() != 1 ) return DetailedVertexType::OtherNInparts;
          if ( outparts.empty() ) return DetailedVertexType::OtherNoOutparts;
 
          // Get first valid child
          const xAOD::TruthParticle* input_child = nullptr;
          for (auto child : inparts[0]->decayVtx()->particles_out()) {
            if (child) { input_child = child; break; }
          }
          if ( !input_child ) return DetailedVertexType::Other;
 
          bool has_parent = parent != nullptr;
          DetailedVertexType parent_type = has_parent
              ? parent->getType(uid_accessor).detailedType
              : DetailedVertexType::Other;
 
          // Heavy flavor: B and C hadron decays
          if ( inparts[0]->isBottomHadron() ) return DetailedVertexType::BHadronDecay;
          if ( inparts[0]->isCharmHadron() ) {
            if (has_parent && parent_type == DetailedVertexType::BHadronDecay)
              return DetailedVertexType::CHadronDecayFromBHadron;
            return DetailedVertexType::CHadronDecay;
          }
 
          // Tau decay (can fall through if it's tau bremsstrahlung that doesn't match)
          if ( inparts[0]->isTau() ) {
            if (auto t = classifyTauVertex(parent_type, has_parent)) return *t;
          }
 
          // Compute shared context for remaining classifiers
          size_t truth_out_parts = inparts[0]->nChildren();
          size_t truth_valid_out_parts = num_valid_children(inparts[0]);
          std::vector<const xAOD::TruthParticle*> truth_children;
          for ( auto child : inparts[0]->decayVtx()->particles_out() ) {
            if ( child ) truth_children.push_back(child);
          }
          TLorentzVector in4 = inparts[0]->p4();
          TLorentzVector out4 = sum_4vec(inparts[0]->decayVtx()->particles_out());
          float deltaE = std::abs(in4.E() - out4.E());
 
          // Energy-based material interaction (all valid children, large energy loss)
          if ( truth_out_parts == truth_valid_out_parts && truth_valid_out_parts > 1 ) {
            if ( deltaE > 100.0 ) return DetailedVertexType::MaterialInteraction;
          }
 
          // Mass-based material interaction: if the sum of children rest masses
          // exceeds the parent rest mass, mass was created from kinetic energy
          // via nuclear interaction with detector material. In a genuine decay,
          // parent >= sum(m_children) always holds by conservation.
          if ( truth_valid_out_parts > 1 ) {
            double children_mass_sum = 0.0;
            for (const auto& child : truth_children) {
              children_mass_sum += child->p4().M();
            }
            if ( children_mass_sum > in4.M() + 1.0 ) {  // 1 MeV tolerance
              return DetailedVertexType::MaterialInteraction;
            }
          }
 
          // Strange hadron
          if ( inparts[0]->isStrangeHadron() ) {
            if (auto t = classifyStrangeVertex(parent_type, has_parent)) return *t;
          }
 
          // Photon (conversion, photoelectric, compton)
          if ( inparts[0]->isPhoton() ) {
            if (auto t = classifyPhotonVertex(truth_out_parts, truth_valid_out_parts, truth_children)) return *t;
          }
 
          // Charged lepton (bremsstrahlung, e+e- annihilation, material interaction)
          if ( inparts[0]->isChLepton() ) {
            if (auto t = classifyLeptonVertex(uid_accessor, truth_out_parts, truth_valid_out_parts, truth_children)) return *t;
          }
 
          // Pion decay: pi0 -> gamma gamma is always a decay.
          // Charged pi -> mu + nu: check for muon+neutrino signature.
          // Anything else from a charged pion (hadronic products, nuclear
          // fragments) is a material interaction.
          if ( std::abs(inparts[0]->pdgId()) == 111 ) {
            return DetailedVertexType::PionDecay;
          }
          if ( std::abs(inparts[0]->pdgId()) == 211 ) {
            bool has_muon = false, has_neutrino = false;
            for (auto c : truth_children) {
              if (std::abs(c->pdgId()) == 13) has_muon = true;
              if (std::abs(c->pdgId()) == 14) has_neutrino = true;
            }
            if (has_muon && has_neutrino) return DetailedVertexType::PionDecay;
            return DetailedVertexType::MaterialInteraction;
          }
 
          // Fallback: simulation particle with missing children
          if ( truth_out_parts > truth_valid_out_parts && truth_out_parts > 1 &&
               inparts[0]->child(0) && HepMC::is_simulation_particle(inparts[0]->child(0)) ) {
            return DetailedVertexType::MaterialInteraction;
          }
 
          // Single output particle fallbacks
          if ( truth_out_parts == 1 && truth_valid_out_parts == 1 ) {
            if ( deltaE > 10 ) return DetailedVertexType::MaybeMaterialInteraction;
            return DetailedVertexType::OtherSingleOutpart;
          }
 
          return DetailedVertexType::Other;
        }

operator<()

bool ParticleJetTools::FatVertex::FatVertex::operator<

(

const FatVertex &

other

)

const

Definition at line 542 of file FatVertex.cxx.

                                                              {
          if ( inparts.size() != other.inparts.size() )
            return inparts.size() < other.inparts.size();
          if ( internal.size() != other.internal.size() )
            return internal.size() < other.internal.size();
          if ( outparts.size() != other.outparts.size() )
            return outparts.size() < other.outparts.size();
          return getPT() < other.getPT();
        }

operator==()

bool ParticleJetTools::FatVertex::FatVertex::operator==

(

const FatVertex &

other

)

const

Definition at line 552 of file FatVertex.cxx.

                                                             {
          return this->inparts == other.inparts && this->internal == other.internal &&
                 this->outparts == other.outparts;
        }

Member Data Documentation

children

std::vector<const FatVertex*> ParticleJetTools::FatVertex::FatVertex::children

Definition at line 126 of file FatVertex.h.

inparts

std::vector<const xAOD::TruthParticle*> ParticleJetTools::FatVertex::FatVertex::inparts

Definition at line 121 of file FatVertex.h.

internal

std::vector<const xAOD::TruthParticle*> ParticleJetTools::FatVertex::FatVertex::internal

Definition at line 122 of file FatVertex.h.

is_pv

bool ParticleJetTools::FatVertex::FatVertex::is_pv

Definition at line 124 of file FatVertex.h.

outparts

std::vector<const xAOD::TruthParticle*> ParticleJetTools::FatVertex::FatVertex::outparts

Definition at line 123 of file FatVertex.h.

parent

const FatVertex* ParticleJetTools::FatVertex::FatVertex::parent =nullptr

Definition at line 125 of file FatVertex.h.

---

The documentation for this struct was generated from the following files:

• FatVertex.h
• FatVertex.cxx