VertexClassifier Class Reference

Get track history and classify it in function of their . More...

#include <VertexClassifier.h>

Inheritance diagram for VertexClassifier:

Classes
struct	GeneratedPrimaryVertex
	Auxiliary class holding simulated primary vertices. More...

Public Types
typedef VertexCategories	Categories
	Type to the associate category. More...
Public Types inherited from VertexCategories
enum	Category {   Fake = 0, Reconstructed = Fake, SignalEvent, BWeakDecay,   CWeakDecay, TauDecay, KsDecay, LambdaDecay,   JpsiDecay, XiDecay, OmegaDecay, SigmaPlusDecay,   SigmaMinusDecay, LongLivedDecay, KnownProcess, UndefinedProcess,   UnknownProcess, PrimaryProcess, HadronicProcess, DecayProcess,   ComptonProcess, AnnihilationProcess, EIoniProcess, HIoniProcess,   MuIoniProcess, PhotonProcess, MuPairProdProcess, ConversionsProcess,   EBremProcess, SynchrotronRadiationProcess, MuBremProcess, MuNuclProcess,   PrimaryVertex, SecondaryVertex, TertiaryVertex, TierciaryVertex = TertiaryVertex,   Unknown }
	Categories available to vertexes. More...
typedef std::vector< bool >	Flags
	Main types associated to the class. More...

Public Member Functions
const VertexClassifier &	evaluate (reco::VertexBaseRef const &)
	Classify the RecoVertex in categories. More...
const VertexClassifier &	evaluate (reco::VertexRef const &vertex)
	Classify the RecoVertex in categories. More...
const VertexClassifier &	evaluate (TrackingVertexRef const &)
	Classify the TrackingVertex in categories. More...
const VertexHistory &	history () const
	Returns a reference to the vertex history used in the classification. More...
virtual void	newEvent (edm::Event const &, edm::EventSetup const &)
	Pre-process event information (for accessing reconstraction information) More...
	VertexClassifier (edm::ParameterSet const &pset, edm::ConsumesCollector &&)
	Constructor by ParameterSet. More...
virtual	~VertexClassifier ()
Public Member Functions inherited from VertexCategories
const Flags &	flags () const
	Returns flags with the category descriptions. More...
bool	is (Category category) const
	Returns track flag for a given category. More...
	VertexCategories ()
	Void constructor. More...

Private Member Functions
void	genPrimaryVertices ()
bool	isCharged (const HepMC::GenParticle *)
bool	isFinalstateParticle (const HepMC::GenParticle *)
void	processesAtGenerator ()
	Get all the information related to decay process. More...
void	processesAtSimulation ()
	Get information about conversion and other interactions. More...
void	reconstructionInformation (reco::TrackBaseRef const &)
	Get reconstruction information. More...
void	simulationInformation ()
	Get all the information related to the simulation details. More...
void	vertexInformation ()
	Get geometrical information about the vertices. More...

Private Attributes
const G4toCMSLegacyProcTypeMap	g4toCMSProcMap_
std::vector< GeneratedPrimaryVertex >	genpvs_
const edm::InputTag	hepMCLabel_
double	longLivedDecayLength_
edm::Handle< edm::HepMCProduct >	mcInformation_
edm::ESHandle< ParticleDataTable >	particleDataTable_
VertexHistory	tracer_
double	vertexClusteringDistance_

Additional Inherited Members
Static Public Attributes inherited from VertexCategories
static const char *const	Names []
	Name of the different categories. More...
Protected Member Functions inherited from VertexCategories
void	reset ()
	Reset the categories flags. More...
void	unknownVertex ()
Protected Attributes inherited from VertexCategories
Flags	flags_
	Flag containers. More...

Detailed Description

Get track history and classify it in function of their .

Definition at line 18 of file VertexClassifier.h.

Member Typedef Documentation

Categories

typedef VertexCategories VertexClassifier::Categories

Type to the associate category.

Definition at line 21 of file VertexClassifier.h.

Constructor & Destructor Documentation

VertexClassifier()

VertexClassifier::VertexClassifier	(	edm::ParameterSet const &	pset,
		edm::ConsumesCollector &&	collector
	)

Constructor by ParameterSet.

Definition at line 18 of file VertexClassifier.cc.

    : VertexCategories(),
      tracer_(config, std::move(collector)),
      hepMCLabel_(config.getUntrackedParameter<edm::InputTag>("hepMC")) {
  collector.consumes<edm::HepMCProduct>(hepMCLabel_);
  // Set the history depth after hadronization
  tracer_.depth(-2);
 
  // Set the minimum decay length for detecting long decays
  longLivedDecayLength_ = config.getUntrackedParameter<double>("longLivedDecayLength");
 
  // Set the distance for clustering vertices
  vertexClusteringDistance_ = config.getUntrackedParameter<double>("vertexClusteringDistance");
}

References HistoryBase::depth(), hepMCLabel_, longLivedDecayLength_, tracer_, and vertexClusteringDistance_.

~VertexClassifier()

virtual VertexClassifier::~VertexClassifier ( )

inlinevirtual

Definition at line 26 of file VertexClassifier.h.

{}

Member Function Documentation

evaluate() [1/3]

const VertexClassifier & VertexClassifier::evaluate

(

reco::VertexBaseRef const &

vertex

)

Classify the RecoVertex in categories.

Definition at line 47 of file VertexClassifier.cc.

                                                                                  {
  // Initializing the category vector
  reset();
 
  // Associate and evaluate the vertex history (check for fakes)
  if (tracer_.evaluate(vertex)) {
    // Get all the information related to the simulation details
    simulationInformation();
 
    // Get all the information related to decay process
    processesAtGenerator();
 
    // Get information about conversion and other interactions
    processesAtSimulation();
 
    // Get geometrical information about the vertices
    vertexInformation();
 
    // Check for unkown classification
    unknownVertex();
  } else
    flags_[Fake] = true;
 
  return *this;
}

References VertexHistory::evaluate(), VertexCategories::Fake, VertexCategories::flags_, processesAtGenerator(), processesAtSimulation(), VertexCategories::reset(), simulationInformation(), tracer_, VertexCategories::unknownVertex(), bphysicsOniaDQM_cfi::vertex, and vertexInformation().

Referenced by VertexHistoryAnalyzer::analyze(), and VertexClassifierByProxy< reco::SecondaryVertexTagInfoCollection >::evaluate().

evaluate() [2/3]

const VertexClassifier& VertexClassifier::evaluate ( reco::VertexRef const &  vertex )

inline

Classify the RecoVertex in categories.

Definition at line 38 of file VertexClassifier.h.

{ return evaluate(reco::VertexBaseRef(vertex)); }

References evaluate(), and bphysicsOniaDQM_cfi::vertex.

Referenced by evaluate().

evaluate() [3/3]

const VertexClassifier & VertexClassifier::evaluate

(

TrackingVertexRef const &

vertex

)

Classify the TrackingVertex in categories.

Definition at line 73 of file VertexClassifier.cc.

                                                                                  {
  // Initializing the category vector
  reset();
 
  // Trace the history for the given TP
  tracer_.evaluate(vertex);
 
  // Check for a reconstructed track
  if (tracer_.recoVertex().isNonnull())
    flags_[Reconstructed] = true;
  else
    flags_[Reconstructed] = false;
 
  // Get all the information related to the simulation details
  simulationInformation();
 
  // Get all the information related to decay process
  processesAtGenerator();
 
  // Get information about conversion and other interactions
  processesAtSimulation();
 
  // Get geometrical information about the vertices
  vertexInformation();
 
  // Check for unkown classification
  unknownVertex();
 
  return *this;
}

References VertexHistory::evaluate(), VertexCategories::flags_, edm::RefToBase< T >::isNonnull(), processesAtGenerator(), processesAtSimulation(), VertexCategories::Reconstructed, VertexHistory::recoVertex(), VertexCategories::reset(), simulationInformation(), tracer_, VertexCategories::unknownVertex(), bphysicsOniaDQM_cfi::vertex, and vertexInformation().

genPrimaryVertices()

void VertexClassifier::genPrimaryVertices ( )

private

Definition at line 381 of file VertexClassifier.cc.

                                          {
  genpvs_.clear();
 
  const HepMC::GenEvent *event = mcInformation_->GetEvent();
 
  if (event) {
    int idx = 0;
 
    // Loop over the different GenVertex
    for (HepMC::GenEvent::vertex_const_iterator ivertex = event->vertices_begin(); ivertex != event->vertices_end();
         ++ivertex) {
      bool hasParentVertex = false;
 
      // Loop over the parents looking to see if they are coming from a
      // production vertex
      for (HepMC::GenVertex::particle_iterator iparent = (*ivertex)->particles_begin(HepMC::parents);
           iparent != (*ivertex)->particles_end(HepMC::parents);
           ++iparent)
        if ((*iparent)->production_vertex()) {
          hasParentVertex = true;
          break;
        }
 
      // Reject those vertices with parent vertices
      if (hasParentVertex)
        continue;
 
      // Get the position of the vertex
      HepMC::FourVector pos = (*ivertex)->position();
 
      double const mm = 0.1;
 
      GeneratedPrimaryVertex pv(pos.x() * mm, pos.y() * mm, pos.z() * mm);
 
      std::vector<GeneratedPrimaryVertex>::iterator ientry = genpvs_.begin();
 
      // Search for a VERY close vertex in the list
      for (; ientry != genpvs_.end(); ++ientry) {
        double distance = sqrt(pow(pv.x - ientry->x, 2) + pow(pv.y - ientry->y, 2) + pow(pv.z - ientry->z, 2));
        if (distance < vertexClusteringDistance_)
          break;
      }
 
      // Check if there is not a VERY close vertex and added to the list
      if (ientry == genpvs_.end())
        ientry = genpvs_.insert(ientry, pv);
 
      // Add the vertex barcodes to the new or existent vertices
      ientry->genVertex.push_back((*ivertex)->barcode());
 
      // Collect final state descendants
      for (HepMC::GenVertex::particle_iterator idecendants = (*ivertex)->particles_begin(HepMC::descendants);
           idecendants != (*ivertex)->particles_end(HepMC::descendants);
           ++idecendants) {
        if (isFinalstateParticle(*idecendants))
          if (find(ientry->finalstateParticles.begin(), ientry->finalstateParticles.end(), (*idecendants)->barcode()) ==
              ientry->finalstateParticles.end()) {
            ientry->finalstateParticles.push_back((*idecendants)->barcode());
            HepMC::FourVector m = (*idecendants)->momentum();
 
            ientry->ptot.setPx(ientry->ptot.px() + m.px());
            ientry->ptot.setPy(ientry->ptot.py() + m.py());
            ientry->ptot.setPz(ientry->ptot.pz() + m.pz());
            ientry->ptot.setE(ientry->ptot.e() + m.e());
            ientry->ptsq += m.perp() * m.perp();
 
            if (m.perp() > 0.8 && std::abs(m.pseudoRapidity()) < 2.5 && isCharged(*idecendants))
              ientry->nGenTrk++;
          }
      }
      idx++;
    }
  }
 
  std::sort(genpvs_.begin(), genpvs_.end());
}

References funct::abs(), HLT_2018_cff::distance, spr::find(), genpvs_, edm::HepMCProduct::GetEvent(), charmTagsComputerCvsB_cfi::idx, isCharged(), isFinalstateParticle(), visualization-live-secondInstance_cfg::m, mcInformation_, parents, funct::pow(), MetAnalyzer::pv(), mathSSE::sqrt(), and vertexClusteringDistance_.

Referenced by newEvent().

history()

const VertexHistory& VertexClassifier::history ( ) const

inline

Returns a reference to the vertex history used in the classification.

Definition at line 41 of file VertexClassifier.h.

{ return tracer_; }

References tracer_.

Referenced by VertexHistoryAnalyzer::analyze(), SVTagInfoValidationAnalyzer::analyze(), and recoBSVTagInfoValidationAnalyzer::analyze().

isCharged()

bool VertexClassifier::isCharged ( const HepMC::GenParticle *  p )

private

Definition at line 371 of file VertexClassifier.cc.

                                                          {
  const ParticleData *part = particleDataTable_->particle(p->pdg_id());
  if (part)
    return part->charge() != 0;
  else {
    // the new/improved particle table doesn't know anti-particles
    return particleDataTable_->particle(-p->pdg_id()) != nullptr;
  }
}

References AlCaHLTBitMon_ParallelJobs::p, and particleDataTable_.

Referenced by genPrimaryVertices().

isFinalstateParticle()

bool VertexClassifier::isFinalstateParticle ( const HepMC::GenParticle *  p )

private

Definition at line 367 of file VertexClassifier.cc.

                                                                     {
  return !p->end_vertex() && p->status() == 1;
}

References AlCaHLTBitMon_ParallelJobs::p.

Referenced by genPrimaryVertices().

newEvent()

void VertexClassifier::newEvent ( edm::Event const &  event, edm::EventSetup const &  setup  )

virtual

Pre-process event information (for accessing reconstraction information)

Reimplemented in VertexClassifierByProxy< Collection >, and VertexClassifierByProxy< reco::SecondaryVertexTagInfoCollection >.

Definition at line 33 of file VertexClassifier.cc.

                                                                                 {
  // Get the new event information for the tracer
  tracer_.newEvent(event, setup);
 
  // Get hepmc of the event
  event.getByLabel(hepMCLabel_, mcInformation_);
 
  // Get the partivle data table
  setup.getData(particleDataTable_);
 
  // Create the list of primary vertices associated to the event
  genPrimaryVertices();
}

References genPrimaryVertices(), hepMCLabel_, mcInformation_, VertexHistory::newEvent(), particleDataTable_, singleTopDQM_cfi::setup, and tracer_.

Referenced by VertexHistoryAnalyzer::analyze(), and VertexClassifierByProxy< reco::SecondaryVertexTagInfoCollection >::newEvent().

processesAtGenerator()

void VertexClassifier::processesAtGenerator ( )

private

Get all the information related to decay process.

Definition at line 111 of file VertexClassifier.cc.

                                            {
  // Get the generated vetices from track history
  VertexHistory::GenVertexTrail const &genVertexTrail = tracer_.genVertexTrail();
 
  // Loop over the generated vertices
  for (VertexHistory::GenVertexTrail::const_iterator ivertex = genVertexTrail.begin(); ivertex != genVertexTrail.end();
       ++ivertex) {
    // Get the pointer to the vertex by removing the const-ness (no const methos
    // in HepMC::GenVertex)
    HepMC::GenVertex *vertex = const_cast<HepMC::GenVertex *>(*ivertex);
 
    // Loop over the sources looking for specific decays
    for (HepMC::GenVertex::particle_iterator iparent = vertex->particles_begin(HepMC::parents);
         iparent != vertex->particles_end(HepMC::parents);
         ++iparent) {
      // Collect the pdgid of the parent
      int pdgid = std::abs((*iparent)->pdg_id());
      // Get particle type
      HepPDT::ParticleID particleID(pdgid);
 
      // Check if the particle type is valid one
      if (particleID.isValid()) {
        // Get particle data
        ParticleData const *particleData = particleDataTable_->particle(particleID);
        // Check if the particle exist in the table
        if (particleData) {
          // Check if their life time is bigger than longLivedDecayLength_
          if (particleData->lifetime() > longLivedDecayLength_) {
            // Check for B, C weak decays and long lived decays
            update(flags_[BWeakDecay], particleID.hasBottom());
            update(flags_[CWeakDecay], particleID.hasCharm());
            update(flags_[LongLivedDecay], true);
          }
          // Check Tau, Ks and Lambda decay
          update(flags_[TauDecay], pdgid == 15);
          update(flags_[KsDecay], pdgid == 310);
          update(flags_[LambdaDecay], pdgid == 3122);
          update(flags_[JpsiDecay], pdgid == 443);
          update(flags_[XiDecay], pdgid == 3312);
          update(flags_[OmegaDecay], pdgid == 3334);
          update(flags_[SigmaPlusDecay], pdgid == 3222);
          update(flags_[SigmaMinusDecay], pdgid == 3112);
        }
      }
    }
  }
}

References funct::abs(), VertexCategories::BWeakDecay, VertexCategories::CWeakDecay, VertexCategories::flags_, HistoryBase::genVertexTrail(), VertexCategories::JpsiDecay, VertexCategories::KsDecay, VertexCategories::LambdaDecay, VertexCategories::LongLivedDecay, longLivedDecayLength_, VertexCategories::OmegaDecay, parents, particleDataTable_, EgammaObjectsElectrons_cfi::particleID, LHEGenericFilter_cfi::ParticleID, EgammaValidation_cff::pdgid, VertexCategories::SigmaMinusDecay, VertexCategories::SigmaPlusDecay, tracer_, update, bphysicsOniaDQM_cfi::vertex, and VertexCategories::XiDecay.

Referenced by evaluate().

processesAtSimulation()

void VertexClassifier::processesAtSimulation ( )

private

Get information about conversion and other interactions.

Definition at line 159 of file VertexClassifier.cc.

                                             {
  VertexHistory::SimVertexTrail const &simVertexTrail = tracer_.simVertexTrail();
 
  for (VertexHistory::SimVertexTrail::const_iterator ivertex = simVertexTrail.begin(); ivertex != simVertexTrail.end();
       ++ivertex) {
    // pdgid of the real source parent vertex
    int pdgid = 0;
 
    // select the original source in case of combined vertices
    bool flag = false;
    TrackingVertex::tp_iterator itd, its;
 
    for (its = (*ivertex)->sourceTracks_begin(); its != (*ivertex)->sourceTracks_end(); ++its) {
      for (itd = (*ivertex)->daughterTracks_begin(); itd != (*ivertex)->daughterTracks_end(); ++itd)
        if (itd != its) {
          flag = true;
          break;
        }
      if (flag)
        break;
    }
    // Collect the pdgid of the original source track
    if (its != (*ivertex)->sourceTracks_end())
      pdgid = std::abs((*its)->pdgId());
    else
      pdgid = 0;
 
    // Geant4 process type is selected using first Geant4 vertex assigned to
    // the TrackingVertex
    unsigned int processG4 = 0;
 
    if ((*ivertex)->nG4Vertices() > 0) {
      processG4 = (*(*ivertex)->g4Vertices_begin()).processType();
    }
 
    unsigned int process = g4toCMSProcMap_.processId(processG4);
 
    // Flagging all the different processes
    update(flags_[KnownProcess], process != CMS::Undefined && process != CMS::Unknown && process != CMS::Primary);
 
    update(flags_[UndefinedProcess], process == CMS::Undefined);
    update(flags_[UnknownProcess], process == CMS::Unknown);
    update(flags_[PrimaryProcess], process == CMS::Primary);
    update(flags_[HadronicProcess], process == CMS::Hadronic);
    update(flags_[DecayProcess], process == CMS::Decay);
    update(flags_[ComptonProcess], process == CMS::Compton);
    update(flags_[AnnihilationProcess], process == CMS::Annihilation);
    update(flags_[EIoniProcess], process == CMS::EIoni);
    update(flags_[HIoniProcess], process == CMS::HIoni);
    update(flags_[MuIoniProcess], process == CMS::MuIoni);
    update(flags_[PhotonProcess], process == CMS::Photon);
    update(flags_[MuPairProdProcess], process == CMS::MuPairProd);
    update(flags_[ConversionsProcess], process == CMS::Conversions);
    update(flags_[EBremProcess], process == CMS::EBrem);
    update(flags_[SynchrotronRadiationProcess], process == CMS::SynchrotronRadiation);
    update(flags_[MuBremProcess], process == CMS::MuBrem);
    update(flags_[MuNuclProcess], process == CMS::MuNucl);
 
    // Loop over the simulated particles
    for (TrackingVertex::tp_iterator iparticle = (*ivertex)->daughterTracks_begin();
         iparticle != (*ivertex)->daughterTracks_end();
         ++iparticle) {
      if ((*iparticle)->numberOfTrackerLayers()) {
        // Special treatment for decays
        if (process == CMS::Decay) {
          // Get particle type
          HepPDT::ParticleID particleID(pdgid);
          // Check if the particle type is valid one
          if (particleID.isValid()) {
            // Get particle data
            ParticleData const *particleData = particleDataTable_->particle(particleID);
            // Check if the particle exist in the table
            if (particleData) {
              // Check if their life time is bigger than 1e-14
              if (particleDataTable_->particle(particleID)->lifetime() > longLivedDecayLength_) {
                // Check for B, C weak decays and long lived decays
                update(flags_[BWeakDecay], particleID.hasBottom());
                update(flags_[CWeakDecay], particleID.hasCharm());
                update(flags_[LongLivedDecay], true);
              }
              // Check Tau, Ks and Lambda decay
              update(flags_[TauDecay], pdgid == 15);
              update(flags_[KsDecay], pdgid == 310);
              update(flags_[LambdaDecay], pdgid == 3122);
              update(flags_[JpsiDecay], pdgid == 443);
              update(flags_[XiDecay], pdgid == 3312);
              update(flags_[OmegaDecay], pdgid == 3334);
              update(flags_[SigmaPlusDecay], pdgid == 3222);
              update(flags_[SigmaMinusDecay], pdgid == 3112);
            }
          }
        }
      }
    }
  }
}

References funct::abs(), CMS::Annihilation, VertexCategories::AnnihilationProcess, VertexCategories::BWeakDecay, CMS::Compton, VertexCategories::ComptonProcess, CMS::Conversions, VertexCategories::ConversionsProcess, VertexCategories::CWeakDecay, CMS::Decay, VertexCategories::DecayProcess, CMS::EBrem, VertexCategories::EBremProcess, CMS::EIoni, VertexCategories::EIoniProcess, RemoveAddSevLevel::flag, VertexCategories::flags_, g4toCMSProcMap_, CMS::Hadronic, VertexCategories::HadronicProcess, CMS::HIoni, VertexCategories::HIoniProcess, VertexCategories::JpsiDecay, VertexCategories::KnownProcess, VertexCategories::KsDecay, VertexCategories::LambdaDecay, VertexCategories::LongLivedDecay, longLivedDecayLength_, CMS::MuBrem, VertexCategories::MuBremProcess, CMS::MuIoni, VertexCategories::MuIoniProcess, CMS::MuNucl, VertexCategories::MuNuclProcess, CMS::MuPairProd, VertexCategories::MuPairProdProcess, VertexCategories::OmegaDecay, particleDataTable_, EgammaObjectsElectrons_cfi::particleID, LHEGenericFilter_cfi::ParticleID, EgammaValidation_cff::pdgid, CMS::Photon, VertexCategories::PhotonProcess, CMS::Primary, VertexCategories::PrimaryProcess, LaserDQM_cfg::process, G4toCMSLegacyProcTypeMap::processId(), VertexCategories::SigmaMinusDecay, VertexCategories::SigmaPlusDecay, HistoryBase::simVertexTrail(), CMS::SynchrotronRadiation, VertexCategories::SynchrotronRadiationProcess, tracer_, CMS::Undefined, VertexCategories::UndefinedProcess, CMS::Unknown, VertexCategories::UnknownProcess, update, and VertexCategories::XiDecay.

Referenced by evaluate().

reconstructionInformation()

void VertexClassifier::reconstructionInformation ( reco::TrackBaseRef const &  )

private

Get reconstruction information.

simulationInformation()

void VertexClassifier::simulationInformation ( )

private

Get all the information related to the simulation details.

Definition at line 104 of file VertexClassifier.cc.

                                             {
  // Get the event id for the initial TP.
  EncodedEventId eventId = tracer_.simVertex()->eventId();
  // Check for signal events
  flags_[SignalEvent] = !eventId.bunchCrossing() && !eventId.event();
}

References EncodedEventId::bunchCrossing(), EncodedEventId::event(), VertexCategories::flags_, VertexCategories::SignalEvent, HistoryBase::simVertex(), and tracer_.

Referenced by evaluate().

vertexInformation()

void VertexClassifier::vertexInformation ( )

private

Get geometrical information about the vertices.

Definition at line 256 of file VertexClassifier.cc.

                                         {
  // Helper class for clusterization
  typedef std::multimap<double, HepMC::ThreeVector> Clusters;
  typedef std::pair<double, HepMC::ThreeVector> ClusterPair;
 
  Clusters clusters;
 
  // Get the main primary vertex from the list
  GeneratedPrimaryVertex const &genpv = genpvs_.back();
 
  // Get the generated history of the tracks
  const VertexHistory::GenVertexTrail &genVertexTrail = tracer_.genVertexTrail();
 
  // Unit transformation from mm to cm
  double const mm = 0.1;
 
  // Loop over the generated vertexes
  for (VertexHistory::GenVertexTrail::const_iterator ivertex = genVertexTrail.begin(); ivertex != genVertexTrail.end();
       ++ivertex) {
    // Check vertex exist
    if (*ivertex) {
      // Measure the distance2 respecto the primary vertex
      HepMC::ThreeVector p = (*ivertex)->point3d();
      double distance =
          sqrt(pow(p.x() * mm - genpv.x, 2) + pow(p.y() * mm - genpv.y, 2) + pow(p.z() * mm - genpv.z, 2));
 
      // If there is not any clusters add the first vertex.
      if (clusters.empty()) {
        clusters.insert(ClusterPair(distance, HepMC::ThreeVector(p.x() * mm, p.y() * mm, p.z() * mm)));
        continue;
      }
 
      // Check if there is already a cluster in the given distance from primary
      // vertex
      Clusters::const_iterator icluster = clusters.lower_bound(distance - vertexClusteringDistance_);
 
      if (icluster == clusters.upper_bound(distance + vertexClusteringDistance_)) {
        clusters.insert(ClusterPair(distance, HepMC::ThreeVector(p.x() * mm, p.y() * mm, p.z() * mm)));
        continue;
      }
 
      bool cluster = false;
 
      // Looping over the vertex clusters of a given distance from primary
      // vertex
      for (; icluster != clusters.upper_bound(distance + vertexClusteringDistance_); ++icluster) {
        double difference = sqrt(pow(p.x() * mm - icluster->second.x(), 2) + pow(p.y() * mm - icluster->second.y(), 2) +
                                 pow(p.z() * mm - icluster->second.z(), 2));
 
        if (difference < vertexClusteringDistance_) {
          cluster = true;
          break;
        }
      }
 
      if (!cluster)
        clusters.insert(ClusterPair(distance, HepMC::ThreeVector(p.x() * mm, p.y() * mm, p.z() * mm)));
    }
  }
 
  const VertexHistory::SimVertexTrail &simVertexTrail = tracer_.simVertexTrail();
 
  // Loop over the generated particles
  for (VertexHistory::SimVertexTrail::const_reverse_iterator ivertex = simVertexTrail.rbegin();
       ivertex != simVertexTrail.rend();
       ++ivertex) {
    // Look for those with production vertex
    TrackingVertex::LorentzVector p = (*ivertex)->position();
 
    double distance = sqrt(pow(p.x() - genpv.x, 2) + pow(p.y() - genpv.y, 2) + pow(p.z() - genpv.z, 2));
 
    // If there is not any clusters add the first vertex.
    if (clusters.empty()) {
      clusters.insert(ClusterPair(distance, HepMC::ThreeVector(p.x(), p.y(), p.z())));
      continue;
    }
 
    // Check if there is already a cluster in the given distance from primary
    // vertex
    Clusters::const_iterator icluster = clusters.lower_bound(distance - vertexClusteringDistance_);
 
    if (icluster == clusters.upper_bound(distance + vertexClusteringDistance_)) {
      clusters.insert(ClusterPair(distance, HepMC::ThreeVector(p.x(), p.y(), p.z())));
      continue;
    }
 
    bool cluster = false;
 
    // Looping over the vertex clusters of a given distance from primary vertex
    for (; icluster != clusters.upper_bound(distance + vertexClusteringDistance_); ++icluster) {
      double difference = sqrt(pow(p.x() - icluster->second.x(), 2) + pow(p.y() - icluster->second.y(), 2) +
                               pow(p.z() - icluster->second.z(), 2));
 
      if (difference < vertexClusteringDistance_) {
        cluster = true;
        break;
      }
    }
 
    if (!cluster)
      clusters.insert(ClusterPair(distance, HepMC::ThreeVector(p.x(), p.y(), p.z())));
  }
 
  if (clusters.size() == 1)
    flags_[PrimaryVertex] = true;
  else if (clusters.size() == 2)
    flags_[SecondaryVertex] = true;
  else
    flags_[TertiaryVertex] = true;
}

References caloTruthCellsNtuples_cff::Clusters, bsc_activity_cfg::clusters, HLT_2018_cff::distance, VertexCategories::flags_, genpvs_, HistoryBase::genVertexTrail(), AlCaHLTBitMon_ParallelJobs::p, funct::pow(), VertexCategories::PrimaryVertex, VertexCategories::SecondaryVertex, HistoryBase::simVertexTrail(), mathSSE::sqrt(), VertexCategories::TertiaryVertex, tracer_, vertexClusteringDistance_, VertexClassifier::GeneratedPrimaryVertex::x, VertexClassifier::GeneratedPrimaryVertex::y, and VertexClassifier::GeneratedPrimaryVertex::z.

Referenced by evaluate().

Member Data Documentation

g4toCMSProcMap_

const G4toCMSLegacyProcTypeMap VertexClassifier::g4toCMSProcMap_

private

Definition at line 46 of file VertexClassifier.h.

Referenced by processesAtSimulation().

genpvs_

std::vector<GeneratedPrimaryVertex> VertexClassifier::genpvs_

private

Definition at line 89 of file VertexClassifier.h.

Referenced by genPrimaryVertices(), and vertexInformation().

hepMCLabel_

const edm::InputTag VertexClassifier::hepMCLabel_

private

Definition at line 48 of file VertexClassifier.h.

Referenced by newEvent(), and VertexClassifier().

longLivedDecayLength_

double VertexClassifier::longLivedDecayLength_

private

Definition at line 50 of file VertexClassifier.h.

Referenced by processesAtGenerator(), processesAtSimulation(), and VertexClassifier().

mcInformation_

edm::Handle<edm::HepMCProduct> VertexClassifier::mcInformation_

private

Definition at line 53 of file VertexClassifier.h.

Referenced by genPrimaryVertices(), and newEvent().

particleDataTable_

edm::ESHandle<ParticleDataTable> VertexClassifier::particleDataTable_

private

Definition at line 55 of file VertexClassifier.h.

Referenced by isCharged(), newEvent(), processesAtGenerator(), and processesAtSimulation().

tracer_

VertexHistory VertexClassifier::tracer_

private

Definition at line 44 of file VertexClassifier.h.

Referenced by evaluate(), history(), newEvent(), processesAtGenerator(), processesAtSimulation(), simulationInformation(), VertexClassifier(), and vertexInformation().

vertexClusteringDistance_

double VertexClassifier::vertexClusteringDistance_

private

Definition at line 51 of file VertexClassifier.h.

Referenced by genPrimaryVertices(), VertexClassifier(), and vertexInformation().