ParticleJetTools Namespace Reference

Namespaces
namespace	FatVertex

Classes
class	IParticleLinker
struct	IRCSafeLabelDecorators
struct	IRCSafeLabelNames
class	JetTruthVertexSummaryDecoratorAlg
struct	LabelDecorators
struct	LabelNames
struct	Particles
struct	Tag_PseudoJets
class	TruthVertexDecoratorAlg

Functions
Amg::Vector3D	p3 (const xAOD::TruthVertex *p)
Amg::Vector3D	p3 (const xAOD::Jet &j)
Amg::Vector3D	signalProcessP3 (const xAOD::TruthEventContainer &)
void	setJetLabels (const xAOD::Jet &jet, const Particles &particles, const LabelNames &names)
void	setJetLabels (const xAOD::Jet &jet, const Particles &particles, const LabelDecorators &decs)
float	partPt (const xAOD::TruthParticle *part)
float	partLxy (const xAOD::TruthParticle *part, const Amg::Vector3D &origin)
float	partDR (const xAOD::TruthParticle *part, const xAOD::Jet &jet)
int	partPdgId (const xAOD::TruthParticle *part)
float	positionDPhi (const xAOD::TruthParticle *part, const xAOD::Jet &jet, const Amg::Vector3D &origin)
float	positionDEta (const xAOD::TruthParticle *part, const xAOD::Jet &jet, const Amg::Vector3D &origin)
void	childrenRemoved (const std::vector< const xAOD::TruthParticle * > &parents, std::vector< const xAOD::TruthParticle * > &children)
template<typename T>
void	declareProperties (T &tool, LabelNames *n)
bool	isChild (const xAOD::TruthParticle *p, const xAOD::TruthParticle *c)
const xAOD::TruthParticle *	get_initial_particle (const xAOD::TruthParticle *part)
std::vector< const xAOD::TruthParticle * >	get_all_initial_particles (const std::vector< const xAOD::TruthParticle * > &truth_particles)
std::vector< const xAOD::TruthVertex * >	get_matched_primary_vertices (const xAOD::TruthVertex *pv, const std::vector< const xAOD::TruthVertex * > &truth_vertices, float selection_distance=0.001, SG::ConstAccessor< int > acc_uid=SG::ConstAccessor< int >("barcode"))
	Get the matched primary vertex for a given truth vertex.

Function Documentation

childrenRemoved()

void ParticleJetTools::childrenRemoved	(	const std::vector< const xAOD::TruthParticle * > &	parents,
		std::vector< const xAOD::TruthParticle * > &	children )

Definition at line 63 of file ParticleJetLabelCommon.cxx.

      {
 
    if ( &parents == &children ) {
      // Same vector provided for both inputs. Extra care needed in
      // this case...
      const std::vector<const xAOD::TruthParticle*> copyParents = parents;
      childrenRemoved(copyParents, children);
      return;
    }
    // We can now safely assume that parents will not be modified
    // during this loop.
    for ( const xAOD::TruthParticle* p : parents ) {
      if (!p) continue;
      children.erase(std::remove_if(children.begin(),
                                    children.end(),
                                    [p](const xAOD::TruthParticle* c) { return (c && isChild(p, c)); }),
                     children.end());
      // auto erased = std::erase_if(children, [p](const xAOD::TruthParticle* c) { return (c && isChild(p, c)); }); // C++20
    }
    return;
  }

declareProperties()

template<typename T>

void ParticleJetTools::declareProperties	(	T &	tool,
		LabelNames *	n )

Definition at line 144 of file ParticleJetLabelCommon.h.

                                                 {
    tool.declareProperty("LabelName", n->singleint="", "Jet label attribute to be added.");
    tool.declareProperty("DoubleLabelName", n->doubleint="", "Jet label attribute to be added (with the possibility of up to 2 matched hadrons).");
    tool.declareProperty("LabelPtName", n->pt="", "Attribute for labelling particle pt");
    tool.declareProperty("LabelLxyName", n->Lxy="", "Attribute for Lxy of labelling particle");
    tool.declareProperty("LabelDRName", n->dr="", "Attribute for dR(part, jet) for labelling particle");
    tool.declareProperty("LabelPdgIdName", n->pdgId="", "Attribute for pdgID of labelling particle");
    tool.declareProperty("LabelPositionDPhiName", n->positionDPhi="", "Attribute for the position dPhi of the labeling particle ");
    tool.declareProperty("LabelPositionDEtaName", n->positionDEta="", "Attribute for the position dEta of the labeling particle ");
    tool.declareProperty("LabelBarcodeName", n->uniqueID="", "Attribute for uniqueID of labeling particle");
    tool.declareProperty("ChildLxyName", n->childLxy="", "Attribute for the labeling particle child Lxy");
    tool.declareProperty("ChildPtName", n->childPt="", "Attribute for the labeling particle child Pt");
    tool.declareProperty("ChildPdgIdName", n->childPdgId="", "Attribute for the labeling particle child pdg ID");
    tool.declareProperty("ChildPositionDPhiName", n->childPositionDPhi="", "Attribute for the position dPhi of the labeling particle child");
    tool.declareProperty("ChildPositionDEtaName", n->childPositionDEta="", "Attribute for the position dEta of the labeling particle child");
    // ATLASRECTS-8290: this is for backward compatability, remove eventually
    tool.declareProperty("useBarcode", n->useBarcode=false, "use barcode instead of uid");
  }

get_all_initial_particles()

std::vector< const xAOD::TruthParticle * > ParticleJetTools::get_all_initial_particles

(

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

truth_particles

)

Definition at line 40 of file TruthVertexDecoratorAlg.cxx.

  {
  std::unordered_set<const xAOD::TruthParticle*> pv_parts;
 
  for ( const auto& part : truth_particles ) {
    auto initial_part = get_initial_particle(part);
    if ( initial_part ) {
      pv_parts.insert(initial_part);
    }
  }
 
  std::vector<const xAOD::TruthParticle*> initial_particles;
  initial_particles.reserve(pv_parts.size());
  for ( const auto& part : pv_parts ) {
    initial_particles.push_back(part);
  }
  return initial_particles;
 
}

get_initial_particle()

const xAOD::TruthParticle * ParticleJetTools::get_initial_particle ( const xAOD::TruthParticle * part )

inline

Definition at line 13 of file TruthVertexDecoratorAlg.cxx.

  {
  const xAOD::TruthParticle* parent = part;
  for ( int i = 0; i < 1000; i++ ) {
    const xAOD::TruthParticle* next_parent = nullptr;
 
    if(parent->nParents() > 1){
      float cur_pt = -1.0;
      for (size_t j = 0; j < parent->nParents(); j++) {
        const xAOD::TruthParticle* p = parent->parent(j);
        if ( !p ) continue;
        if ( p->pt() > cur_pt ) {
          cur_pt = p->pt();
          next_parent = p;
        }
      }
    }else{
      next_parent = parent->parent(0);
    }
    if ( !next_parent ) break;
    if ( !next_parent->hasDecayVtx() || !next_parent->decayVtx() ) break;
    parent = next_parent;
  }
  return parent;
}

get_matched_primary_vertices()

std::vector< const xAOD::TruthVertex * > ParticleJetTools::get_matched_primary_vertices	(	const xAOD::TruthVertex *	pv,
		const std::vector< const xAOD::TruthVertex * > &	truth_vertices,
		float	selection_distance = 0.001,
		SG::ConstAccessor< int >	acc_uid = SG::ConstAccessor<int>("barcode") )

Get the matched primary vertex for a given truth vertex.

The TruthPrimaryVertices container does NOT contain particle links, so we match by position to find the corresponding vertex in TruthVertices.

Definition at line 66 of file TruthVertexDecoratorAlg.cxx.

  {
  std::vector<const xAOD::TruthVertex*> matched_vertices;
 
  float closest_distance = 1e9;
  const xAOD::TruthVertex* closest_vertex = nullptr;
  for( const auto& vert : truth_vertices ) {
    if ( !vert ) continue;
    float r = FatVertex::vertex_distance(pv, vert);
    if(r < selection_distance){
      matched_vertices.push_back(vert);
      if (r < closest_distance) {
        closest_distance = r;
        closest_vertex = vert;
      }else if (r == closest_distance) {
        // If we have two vertices at the same distance, we'll take the one with the lowest
        // barcode as it *should* be the case that this is the actual PV.
        if ( std::abs(acc_uid(*vert)) < std::abs(acc_uid(*closest_vertex)) ) {
          closest_vertex = vert;
        }
      }
    }
  }
  // Set it such that the first vertex is the closest vertex
  if ( !matched_vertices.empty() && closest_vertex ) {
    // remove the closest vertex from the matched vertices
    matched_vertices.erase(
        std::remove(matched_vertices.begin(), matched_vertices.end(), closest_vertex),
        matched_vertices.end()
    );
    // Insert into the front of the vector
    matched_vertices.insert(matched_vertices.begin(), closest_vertex);
 
  }
  return matched_vertices;
 
}

isChild()

bool ParticleJetTools::isChild ( const xAOD::TruthParticle * p, const xAOD::TruthParticle * c )

inline

Definition at line 34 of file ParticleJetLabelCommon.cxx.

                                                                               {
 
    if ( HepMC::is_same_particle(p,c) ) { return false; }
 
    for (size_t iC = 0; iC < p->nChildren(); iC++) {
      const xAOD::TruthParticle* cc = p->child(iC);
      if (!cc) { continue; }
 
      if ( HepMC::is_same_particle(cc,c) ) { return true; }
 
      if (isChild(cc, c)) { return true; }
    }
 
    return false;
  }

p3() [1/2]

Amg::Vector3D ParticleJetTools::p3

(

const xAOD::Jet &

j

)

Definition at line 54 of file ParticleJetLabelCommon.cxx.

                                   {
    return {j.px(), j.py(), j.pz()};
  }

p3() [2/2]

Amg::Vector3D ParticleJetTools::p3

(

const xAOD::TruthVertex *

p

)

Definition at line 50 of file ParticleJetLabelCommon.cxx.

                                           {
    if (!p) return {NAN, NAN, NAN};
    return {p->x(), p->y(), p->z()};
  }

partDR()

float ParticleJetTools::partDR	(	const xAOD::TruthParticle *	part,
		const xAOD::Jet &	jet )

Definition at line 298 of file ParticleJetLabelCommon.cxx.

                                                                  {
    if (!part) return NAN;
    return part->p4().DeltaR(jet.p4());
  }

partLxy()

float ParticleJetTools::partLxy	(	const xAOD::TruthParticle *	part,
		const Amg::Vector3D &	origin )

Definition at line 293 of file ParticleJetLabelCommon.cxx.

                                                                          {
    if (!part) return NAN;
    if (const auto* vx = part->decayVtx() ) return (p3(vx) - origin).perp();
    return INFINITY;
  }

partPdgId()

int ParticleJetTools::partPdgId

(

const xAOD::TruthParticle *

part

)

Definition at line 302 of file ParticleJetLabelCommon.cxx.

                                               {
    if (!part) return 0;
    return part->pdgId();
  }

partPt()

float ParticleJetTools::partPt

(

const xAOD::TruthParticle *

part

)

Definition at line 289 of file ParticleJetLabelCommon.cxx.

                                              {
    if (!part) return NAN;
    return part->pt();
  }

positionDEta()

float ParticleJetTools::positionDEta	(	const xAOD::TruthParticle *	part,
		const xAOD::Jet &	jet,
		const Amg::Vector3D &	origin )

Definition at line 316 of file ParticleJetLabelCommon.cxx.

                                                {
    if (!part) return NAN;
    if (const auto* vx = part->decayVtx() ) {
      Amg::Vector3D displacement = p3(vx) - origin;
      return displacement.eta() - jet.eta();
    }
    return INFINITY;
  }

positionDPhi()

float ParticleJetTools::positionDPhi	(	const xAOD::TruthParticle *	part,
		const xAOD::Jet &	jet,
		const Amg::Vector3D &	origin )

Definition at line 306 of file ParticleJetLabelCommon.cxx.

                                                {
    if (!part) return NAN;
    if (const auto* vx = part->decayVtx() ) {
      Amg::Vector3D displacement = p3(vx) - origin;
      return p3(jet).deltaPhi(displacement);
    }
    return INFINITY;
  }

setJetLabels() [1/2]

void ParticleJetTools::setJetLabels	(	const xAOD::Jet &	jet,
		const Particles &	particles,
		const LabelDecorators &	decs )

Definition at line 164 of file ParticleJetLabelCommon.cxx.

                                                 {
 
    // we also want to save information about the maximum pt particle of the labeling partons
    auto getMaxPtPart = [](const auto& container) -> const xAOD::TruthParticle* {
      if (container.size() == 0) return nullptr;
      auto itr = std::max_element(container.begin(), container.end(),
                                  [](auto* p1, auto* p2) {
                                    return p1->pt() < p2->pt();
                                  });
      return *itr;
    };
 
    // set truth label for jets above pt threshold
    // hierarchy: b > c > tau > light
    int label = 0; // default: light
    const xAOD::TruthParticle* labelling_particle = nullptr;
    const xAOD::TruthParticle* child_particle = nullptr;
    if (particles.b.size()) {
      label = 5;
      labelling_particle = getMaxPtPart(particles.b);
      child_particle = getCharmChild(labelling_particle);
    } else if (particles.c.size()) {
      label = 4;
      labelling_particle = getMaxPtPart(particles.c);
    } else if (particles.tau.size()) {
      label = 15;
      labelling_particle = getMaxPtPart(particles.tau);
    }
 
    const Amg::Vector3D& origin = particles.origin;
 
    // decorate info about the labelling particle
    decs.singleint(jet) = label;
    if (label == 0) {
      decs.pt(jet) = NAN;
      decs.Lxy(jet) = NAN;
      decs.dr(jet) = NAN;
      decs.pdgId(jet) = 0;
      decs.positionDPhi(jet) = NAN;
      decs.positionDEta(jet) = NAN;
      decs.uniqueID(jet) = HepMC::INVALID_PARTICLE_ID;
      decs.childLxy(jet) = NAN;
      decs.childPt(jet) = NAN;
      decs.childPdgId(jet) = 0;
      decs.childPositionDPhi(jet) = NAN;
      decs.childPositionDEta(jet) = NAN;
    } else {
      decs.pt(jet) = partPt(labelling_particle);
      decs.Lxy(jet) = partLxy(labelling_particle, origin);
      decs.dr(jet) = partDR(labelling_particle, jet);
      decs.pdgId(jet) = partPdgId(labelling_particle);
      decs.positionDPhi(jet) = positionDPhi(labelling_particle, jet, origin);
      decs.positionDEta(jet) = positionDEta(labelling_particle, jet, origin);
      decs.uniqueID(jet) = labelling_particle ?
        // ATLASRECTS-8290: this should be replaced with ->uid()
        decs.acc_uid(*labelling_particle) : HepMC::INVALID_PARTICLE_ID;
      decs.childLxy(jet) = partLxy(child_particle, origin);
      decs.childPt(jet) = partPt(child_particle);
      decs.childPdgId(jet) = partPdgId(child_particle);
      decs.childPositionDPhi(jet) = positionDPhi(child_particle, jet, origin);
      decs.childPositionDEta(jet) = positionDEta(child_particle, jet, origin);
    }
 
    // extended flavour label
    int double_label = 0;
    if (particles.b.size()) {
      if (particles.b.size() >= 2)
        double_label = 55;
 
      else if (particles.c.size())
        double_label = 54;
 
      else
        double_label = 5;
 
    } else if (particles.c.size()) {
      if (particles.c.size() >= 2)
        double_label = 44;
 
      else
        double_label = 4;
 
    } else if (particles.tau.size()){
 
      bool hasElectrondecay = false;
      bool hasMuondecay = false;
      bool hasHadronicdecay = false;
      for (auto itau: particles.tau){
        for (size_t i = 0; i< itau->nChildren(); i++){ // tau children loop
          if (itau->child(i)->absPdgId() == 12 || itau->child(i)->absPdgId() == 14 || itau->child(i)->absPdgId() == 16) continue; 
          if (MC::isMuon(itau->child(i))) hasMuondecay = true;
          else if (MC::isElectron(itau->child(i))) hasElectrondecay = true;
          else hasHadronicdecay = true;
        }
      }
 
      if (particles.tau.size() >= 2){
        // check if we have at least one hadronic tau
        if (hasHadronicdecay){
          // check if we have also tau->mu decay 
          if (hasMuondecay) double_label = 151513;
          // check if we have also tau->el decay 
          else if (hasElectrondecay) double_label = 151511;
          // otherwise fully hadronic di-tau decay 
          else double_label = 1515;
    }
      } else { 
        // only consider hadronic tau decay
        if (hasHadronicdecay) double_label = 15;
      }
      
    }
 
    decs.doubleint(jet) = double_label;
 
  }

setJetLabels() [2/2]

void ParticleJetTools::setJetLabels	(	const xAOD::Jet &	jet,
		const Particles &	particles,
		const LabelNames &	names )

Definition at line 283 of file ParticleJetLabelCommon.cxx.

                                             {
    setJetLabels(jet, particles, LabelDecorators(names));
  }

signalProcessP3()

Amg::Vector3D ParticleJetTools::signalProcessP3

(

const xAOD::TruthEventContainer &

events

)

Definition at line 57 of file ParticleJetLabelCommon.cxx.

                                                                     {
    if (events.empty()) return {NAN, NAN, NAN};
    return p3(events.at(0)->signalProcessVertex());
  }