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
VertexClassifier const &	evaluate (reco::VertexBaseRef const &)
	Classify the RecoVertex in categories. More...

VertexClassifier const &	evaluate (TrackingVertexRef const &)
	Classify the TrackingVertex in categories. More...

VertexClassifier const &	evaluate (reco::VertexRef const &vertex)
	Classify the RecoVertex in categories. More...

VertexHistory const &	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_

edm::ESGetToken< ParticleDataTable, edm::DefaultRecord >	particleDataTableToken_

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.

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

     : VertexCategories(),
       tracer_(config, collector),
       hepMCLabel_(config.getUntrackedParameter<edm::InputTag>("hepMC")),
       particleDataTableToken_(collector.esConsumes()) {
   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");
 }

◆ ~VertexClassifier()

virtual VertexClassifier::~VertexClassifier ( )

inlinevirtual

Definition at line 26 of file VertexClassifier.h.

26 {}

Member Function Documentation

◆ evaluate() [1/3]

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

Classify the RecoVertex in categories.

Definition at line 48 of file VertexClassifier.cc.

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().

                                                                                   {
   // 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;
 }

◆ evaluate() [2/3]

VertexClassifier const & VertexClassifier::evaluate ( TrackingVertexRef const & vertex )

Classify the TrackingVertex in categories.

Definition at line 74 of file VertexClassifier.cc.

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().

                                                                                   {
   // 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;
 }

◆ evaluate() [3/3]

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

inline

Classify the RecoVertex in categories.

Definition at line 38 of file VertexClassifier.h.

References evaluate(), and bphysicsOniaDQM_cfi::vertex.

Referenced by evaluate().

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

bphysicsOniaDQM_cfi.vertex

vertex

Definition: bphysicsOniaDQM_cfi.py:7

edm::RefToBase< reco::Vertex >

VertexClassifier::evaluate

VertexClassifier const & evaluate(reco::VertexBaseRef const &)

Classify the RecoVertex in categories.

Definition: VertexClassifier.cc:48

◆ genPrimaryVertices()

void VertexClassifier::genPrimaryVertices ( )

private

Definition at line 382 of file VertexClassifier.cc.

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

Referenced by newEvent().

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

◆ history()

VertexHistory const& VertexClassifier::history ( ) const

inline

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

Definition at line 41 of file VertexClassifier.h.

References tracer_.

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

41 { return tracer_; }

VertexClassifier::tracer_

VertexHistory tracer_

Definition: VertexClassifier.h:44

◆ isCharged()

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

private

Definition at line 372 of file VertexClassifier.cc.

References AlCaHLTBitMon_ParallelJobs::p, and particleDataTable_.

Referenced by genPrimaryVertices().

                                                           {
   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;
   }
 }

◆ isFinalstateParticle()

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

private

Definition at line 368 of file VertexClassifier.cc.

References AlCaHLTBitMon_ParallelJobs::p.

Referenced by genPrimaryVertices().

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

◆ 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 34 of file VertexClassifier.cc.

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

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

                                                                                  {
   // 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
   particleDataTable_ = setup.getHandle(particleDataTableToken_);
 
   // Create the list of primary vertices associated to the event
   genPrimaryVertices();
 }

◆ processesAtGenerator()

void VertexClassifier::processesAtGenerator ( )

private

Get all the information related to decay process.

Definition at line 112 of file VertexClassifier.cc.

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().

                                             {
   // 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);
         }
       }
     }
   }
 }

◆ processesAtSimulation()

void VertexClassifier::processesAtSimulation ( )

private

Get information about conversion and other interactions.

Definition at line 160 of file VertexClassifier.cc.

Referenced by evaluate().

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

◆ 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 105 of file VertexClassifier.cc.

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

Referenced by evaluate().

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

◆ vertexInformation()

void VertexClassifier::vertexInformation ( )

private

Get geometrical information about the vertices.

Definition at line 257 of file VertexClassifier.cc.

References caloTruthCellsNtuples_cff::Clusters, bsc_activity_cfg::clusters, HLT_2022v15_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().

                                          {
   // 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;
 }

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 90 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().

◆ particleDataTableToken_

edm::ESGetToken<ParticleDataTable, edm::DefaultRecord> VertexClassifier::particleDataTableToken_

private

Definition at line 56 of file VertexClassifier.h.

Referenced by newEvent().

◆ 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().

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Categories

Constructor & Destructor Documentation

◆ VertexClassifier()

◆ ~VertexClassifier()

Member Function Documentation

◆ evaluate() [1/3]

◆ evaluate() [2/3]

◆ evaluate() [3/3]

◆ genPrimaryVertices()

◆ history()

◆ isCharged()

◆ isFinalstateParticle()

◆ newEvent()

◆ processesAtGenerator()

◆ processesAtSimulation()

◆ reconstructionInformation()

◆ simulationInformation()

◆ vertexInformation()

Member Data Documentation

◆ g4toCMSProcMap_

◆ genpvs_

◆ hepMCLabel_

◆ longLivedDecayLength_

◆ mcInformation_

◆ particleDataTable_

◆ particleDataTableToken_

◆ tracer_

◆ vertexClusteringDistance_