ParticleJetTools Namespace Reference

Classes
class	IParticleLinker
struct	LabelDecorators
struct	LabelNames
struct	Particles

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)

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 109 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");
  }

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());
  }