ParticleJetTools::FatVertex Namespace Reference

Classes
struct	VertexType
struct	FatVertex

Enumerations
enum class	DetailedVertexType {   PrimaryVertex , BHadronDecay , CHadronDecay , CHadronDecayFromBHadron ,   TauDecay , TauDecayFromBHadron , StrangeDecay , StrangeFromBHadron ,   StrangeFromCHadron , StrangeFromCFromBHadron , StrangeFromTau , StrangeFromTauFromBHadron ,   PionDecay , MaterialInteraction , MaybeMaterialInteraction , StrangeOscillation ,   OtherSecondaryVertex , PhotoelectricEmission , ComptonScattering , EPAnnihilation ,   Bremsstrahlung , Conversion , Other , OtherNInparts ,   OtherNoOutparts , OtherSingleOutpart }
enum class	SimpleVertexType {   PrimaryVertex , BHadronDecay , CHadronDecay , TauDecay ,   StrangeDecay , PionDecay , MaterialInteraction , OtherSecondaryVertex ,   Other }

Functions
TLorentzVector	sum_4vec (const std::vector< const xAOD::TruthParticle * > &parts)
float	vertex_distance (const xAOD::TruthVertex *v1, const xAOD::TruthVertex *v2)
float	vertex_distance_xy (const xAOD::TruthVertex *v1, const xAOD::TruthVertex *v2)
int	num_valid_children (const xAOD::TruthParticle *part)
bool	has_valid_child (const xAOD::TruthParticle *part)
std::vector< const xAOD::TruthParticle * >	get_valid_children_by_pt (const xAOD::TruthParticle *part)
void	generateFatVertex (const xAOD::TruthVertex *vertex, std::vector< const xAOD::TruthParticle * > &fat_inparts, std::vector< const xAOD::TruthParticle * > &fat_internal, std::vector< const xAOD::TruthParticle * > &fat_outparts, bool internal, const float truthVertexMergeDistance, const std::vector< const xAOD::TruthParticle * > &additional_in_parts)
	Generates a fat vertex by recursively searching children of the provided truth vertex and adding them to either the in parts, internal parts, or out parts.
std::vector< FatVertex >	generateFatVertices (const xAOD::TruthVertex *pv, const float truthVertexMergeDistance, const std::vector< const xAOD::TruthParticle * > &truth_particles)

Enumeration Type Documentation

DetailedVertexType

enum class ParticleJetTools::FatVertex::DetailedVertexType

strong

Enumerator
PrimaryVertex
BHadronDecay
CHadronDecay
CHadronDecayFromBHadron
TauDecay
TauDecayFromBHadron
StrangeDecay
StrangeFromBHadron
StrangeFromCHadron
StrangeFromCFromBHadron
StrangeFromTau
StrangeFromTauFromBHadron
PionDecay
MaterialInteraction
MaybeMaterialInteraction
StrangeOscillation
OtherSecondaryVertex
PhotoelectricEmission
ComptonScattering
EPAnnihilation
Bremsstrahlung
Conversion
Other
OtherNInparts
OtherNoOutparts
OtherSingleOutpart

Definition at line 27 of file FatVertex.h.

                                     {
            PrimaryVertex,
            BHadronDecay,
            CHadronDecay,
            CHadronDecayFromBHadron,
            TauDecay,
            TauDecayFromBHadron,
            StrangeDecay,
            StrangeFromBHadron,
            StrangeFromCHadron,
            StrangeFromCFromBHadron,
            StrangeFromTau,
            StrangeFromTauFromBHadron,
            PionDecay,
            MaterialInteraction,
            MaybeMaterialInteraction,
            StrangeOscillation,
            OtherSecondaryVertex,
            PhotoelectricEmission,
            ComptonScattering,
            EPAnnihilation,
            Bremsstrahlung,
            Conversion,
            Other,
            OtherNInparts,
            OtherNoOutparts,
            OtherSingleOutpart,
        };

SimpleVertexType

enum class ParticleJetTools::FatVertex::SimpleVertexType

strong

Enumerator
PrimaryVertex
BHadronDecay
CHadronDecay
TauDecay
StrangeDecay
PionDecay
MaterialInteraction
OtherSecondaryVertex
Other

Definition at line 55 of file FatVertex.h.

                                   {
          PrimaryVertex,
          BHadronDecay,
          CHadronDecay,
          TauDecay,
          StrangeDecay,
          PionDecay,
          MaterialInteraction,
          OtherSecondaryVertex,
          Other,
      };

Function Documentation

generateFatVertex()

void ParticleJetTools::FatVertex::generateFatVertex	(	const xAOD::TruthVertex *	vertex,
		std::vector< const xAOD::TruthParticle * > &	fat_inparts,
		std::vector< const xAOD::TruthParticle * > &	fat_internal,
		std::vector< const xAOD::TruthParticle * > &	fat_outparts,
		bool	internal,
		const float	truthVertexMergeDistance,
		const std::vector< const xAOD::TruthParticle * > &	additional_in_parts )

Generates a fat vertex by recursively searching children of the provided truth vertex and adding them to either the in parts, internal parts, or out parts.

Parameters

vertex	The truth vertex to search truth particles from
fat_inparts	The vector of incoming particles to the fat vertex
fat_internal	The vector of internal particles to the fat vertex
fat_outparts	The vector of outgoing particles to the fat vertex
internal	Whether the current vertex is internal to the process
truthVertexMergeDistance	The distance in mm to merge two vertices
additional	input particles which come from the PV

Definition at line 77 of file FatVertex.cxx.

          {
          if ( !vertex ) return;
          std::vector<const xAOD::TruthParticle*> out_particles = vertex->particles_out();
          std::vector<const xAOD::TruthParticle*> in_particles = vertex->particles_in();
 
          for(auto part : additional_in_parts){
            if(part){
              if (std::find(in_particles.begin(), in_particles.end(), part) == in_particles.end()){
                in_particles.push_back(part);
              }
 
              if(part->hasDecayVtx() && part->decayVtx()){
              for(auto child : part->decayVtx()->particles_out()){
                if(child && std::find(out_particles.begin(), out_particles.end(), child) == out_particles.end()){
                  out_particles.push_back(child);
                }
              }
            }
            }
          }
          for ( auto part : in_particles ) {
              if ( !part ) continue;
              // Check that the current particle being checked is not already in the fat vertex
              if ( std::find(fat_inparts.begin(), fat_inparts.end(), part) == fat_inparts.end()
                && std::find(fat_internal.begin(), fat_internal.end(), part) == fat_internal.end()
                && std::find(fat_outparts.begin(), fat_outparts.end(), part) == fat_outparts.end() ) {
              // If 'internal' is false, we treat any 'internal' parts of a process as inputs
              if ( internal ) fat_internal.push_back(part);
              else fat_inparts.push_back(part);
              }
          }
          for ( auto part : out_particles ) {
            if ( !part ) continue;
            if (
              std::find(fat_inparts.begin(), fat_inparts.end(), part) != fat_inparts.end() ||
              std::find(fat_internal.begin(), fat_internal.end(), part) != fat_internal.end() ||
              std::find(fat_outparts.begin(), fat_outparts.end(), part) != fat_outparts.end()
            ) continue;
            // Simulation particles (status != 1,2) without a usable decay vertex:
            // add as outparts (they're stable children of the current vertex).
            // Sim particles WITH a decay vertex fall through to normal processing
            // (merge distance check, single-child skip, outpart logic).
            if (!(part->status() == 1 || part->status() == 2)){
              if (!part->hasDecayVtx() || !part->decayVtx() || !has_valid_child(part)) {
                fat_outparts.push_back(part);
                continue;
              }
            }
 
            // We have a particle which says it has a child, but its invalid -> end state particle,
            // ->we add it to the outputs
            if ( !has_valid_child(part) || !(part->hasDecayVtx() && part->decayVtx()) ) {
              fat_outparts.push_back(part);
              continue;
            }
 
            if(
            !fat_inparts.empty() &&
            part->hasDecayVtx() &&  part->decayVtx() &&
            fat_inparts[0]->hasDecayVtx() && fat_inparts[0]->decayVtx() &&
            vertex_distance(part->decayVtx(), fat_inparts[0]->decayVtx()) < truthVertexMergeDistance
            ){
              generateFatVertex(
                  part->decayVtx(), fat_inparts, fat_internal, fat_outparts, true, truthVertexMergeDistance
                );
                continue;
            }
 
            // Check valid children sorted by pT
            std::vector<const xAOD::TruthParticle*> valid_children = get_valid_children_by_pt(part);
 
            // Single valid child with same pdgId = simple scattering (e- -> e-, pi -> pi)
            // Not a reconstructable vertex — absorb as internal and continue
            if ( valid_children.size() == 1 &&
                 valid_children[0]->pdgId() == part->pdgId() ) {
                generateFatVertex(
                    part->decayVtx(), fat_inparts, fat_internal, fat_outparts, true,
                    truthVertexMergeDistance
                );
                continue;
            }
 
            // Multiple children but highest-pT has same pdgId = brem/scattering + radiation
            // (e- -> e- + gamma). The leading child is the same particle continuing —
            // absorb as internal so the vertex is attributed to where it actually interacts
            if ( valid_children.size() >= 2 &&
                 valid_children[0]->pdgId() == part->pdgId() ) {
                generateFatVertex(
                    part->decayVtx(), fat_inparts, fat_internal, fat_outparts, true,
                    truthVertexMergeDistance
                );
                continue;
            }
 
            // Strange hadron oscillation (K0 -> K0bar etc)
            if ( valid_children.size() == 1 &&
                 part->isStrangeHadron() && valid_children[0]->isStrangeHadron() ) {
                generateFatVertex(
                    part->decayVtx(), fat_inparts, fat_internal, fat_outparts, true,
                    truthVertexMergeDistance
                );
                continue;
            }
            fat_outparts.push_back(part);
          }
        }

generateFatVertices()

std::vector< FatVertex > ParticleJetTools::FatVertex::generateFatVertices	(	const xAOD::TruthVertex *	pv,
		const float	truthVertexMergeDistance,
		const std::vector< const xAOD::TruthParticle * > &	truth_particles )

Definition at line 192 of file FatVertex.cxx.

          {
          std::vector<FatVertex> fat_vertices;
          std::vector<const xAOD::TruthParticle*> searched;
          std::vector<const xAOD::TruthParticle*> to_search;
 
          to_search.push_back(pv->incomingParticle(0));
 
          bool is_pv = true;
          while ( !to_search.empty() ) {
              const xAOD::TruthParticle* part = to_search.back();
 
              to_search.pop_back();
              searched.push_back(part);
              if (!part || !part->hasDecayVtx() ) continue;
              // If the particles first child is invalid, then all are, and we can skip it...
              if(num_valid_children(part) == 0){
                continue;
              }
              std::vector<const xAOD::TruthParticle*> inparts, internal, outparts;
              generateFatVertex(
                  part->decayVtx(), inparts, internal, outparts,
                  false, truthVertexMergeDistance,
                  is_pv ? truth_particles : std::vector<const xAOD::TruthParticle*>(0, nullptr)
              );
              // A vertex requires multiple outgoing particles. Accept if either:
              // - multiple outparts survived thinning, OR
              // - the inpart's nChildren >= 2 (truth record says real multi-body
              //   decay/interaction, even if some children were thinned)
              bool is_real_vertex = outparts.size() > 1;
              if (!is_real_vertex && !inparts.empty() && inparts[0] && inparts[0]->nChildren() >= 2) {
                is_real_vertex = true;
              }
              if ( is_real_vertex ){
                  fat_vertices.push_back(FatVertex(inparts, internal, outparts, is_pv));
                  is_pv = false;
              }
 
              // Once a fat-vertex is completed, we ensure we don't search any of its particles
              // again
              for ( auto inp : inparts ) {
                if ( std::find(searched.begin(), searched.end(), inp) == searched.end() ) {
                  searched.push_back(inp);
                }
                if(std::find(to_search.begin(), to_search.end(), inp) != to_search.end()){
                  to_search.erase(
                    std::remove(to_search.begin(), to_search.end(), inp),
                    to_search.end());
                }
              }
              for ( auto intern : internal ) {
                if ( std::find(searched.begin(), searched.end(), intern) == searched.end() ) {
                  searched.push_back(intern);
                }
                if(std::find(to_search.begin(), to_search.end(), intern) != to_search.end()){
                  to_search.erase(
                    std::remove(to_search.begin(), to_search.end(), intern),
                    to_search.end());
                }
              }
              for ( auto outp : outparts ) {
                  if ( std::find(searched.begin(), searched.end(), outp) == searched.end()
                    && std::find(to_search.begin(), to_search.end(), outp) == to_search.end() ) {
                    to_search.push_back(outp);
                  }
              }
          }
 
          // Iterate all fat vertices, and remove any with 0 out particles, as these are actually
          // just stable particles
          fat_vertices.erase(
            std::remove_if(
                fat_vertices.begin(),
                fat_vertices.end(),
                [](const FatVertex& fv) {
                    return fv.outparts.empty();
                }
            ),
            fat_vertices.end()
        );
 
          return fat_vertices;
        }

get_valid_children_by_pt()

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

(

const xAOD::TruthParticle *

part

)

Definition at line 42 of file FatVertex.cxx.

                                                                                                    {
            std::vector<const xAOD::TruthParticle*> children;
            if ( !part->hasDecayVtx() || !part->decayVtx() ) return children;
            for ( auto child : part->decayVtx()->particles_out() ) {
              if ( child ) children.push_back(child);
            }
            std::sort(children.begin(), children.end(),
                [](const xAOD::TruthParticle* a, const xAOD::TruthParticle* b) { return a->pt() > b->pt(); });
            return children;
        }

has_valid_child()

bool ParticleJetTools::FatVertex::has_valid_child

(

const xAOD::TruthParticle *

part

)

Definition at line 33 of file FatVertex.cxx.

                                                            {
            if ( part->nChildren() == 0 ) { return false; }
            if ( !part->hasDecayVtx() || !part->decayVtx() ) { return false; }
            for ( auto child : part->decayVtx()->particles_out() ) {
              if ( child ) return true;
            }
            return false;
        }

num_valid_children()

int ParticleJetTools::FatVertex::num_valid_children

(

const xAOD::TruthParticle *

part

)

Definition at line 23 of file FatVertex.cxx.

                                                              {
            if ( part->nChildren() == 0 ) { return 0; }
            if ( !part->hasDecayVtx() || !part->decayVtx() ) { return 0; }
            int num_valid = 0;
            for ( auto child : part->decayVtx()->particles_out() ) {
              if ( child ) num_valid++;
            }
            return num_valid;
        }

sum_4vec()

TLorentzVector ParticleJetTools::FatVertex::sum_4vec

(

const std::vector< const xAOD::TruthParticle * > &

parts

)

Definition at line 14 of file FatVertex.cxx.

                                                                                  {
          TLorentzVector sum;
          for ( auto part : parts ) {
            if ( !part ) continue;
            sum += part->p4();
          }
          return sum;
        }

vertex_distance()

float ParticleJetTools::FatVertex::vertex_distance	(	const xAOD::TruthVertex *	v1,
		const xAOD::TruthVertex *	v2 )

Definition at line 53 of file FatVertex.cxx.

                                                                                    {
            if ( !v1 || !v2 ) return NAN;
            return std::sqrt(
                std::pow(v1->x() - v2->x(), 2) + std::pow(v1->y() - v2->y(), 2) +
                std::pow(v1->z() - v2->z(), 2)
            );
        }

vertex_distance_xy()

float ParticleJetTools::FatVertex::vertex_distance_xy	(	const xAOD::TruthVertex *	v1,
		const xAOD::TruthVertex *	v2 )

Definition at line 61 of file FatVertex.cxx.

                                                                                      {
            if ( !v1 || !v2 ) return NAN;
            return std::sqrt(
                std::pow(v1->x() - v2->x(), 2) + std::pow(v1->y() - v2->y(), 2)
            );
        }