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
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_
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

typedef VertexCategories VertexClassifier::Categories

Type to the associate category.

Definition at line 21 of file VertexClassifier.h.

Constructor & Destructor Documentation

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

Constructor by ParameterSet.

Definition at line 18 of file VertexClassifier.cc.

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

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

virtual VertexClassifier::~VertexClassifier ( )

inlinevirtual

Definition at line 26 of file VertexClassifier.h.

References evaluate(), and newEvent().

{}

Member Function Documentation

VertexClassifier const & VertexClassifier::evaluate

(

reco::VertexBaseRef const &

vertex

)

Classify the RecoVertex in categories.

Definition at line 47 of file VertexClassifier.cc.

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

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

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

VertexClassifier const & VertexClassifier::evaluate

(

TrackingVertexRef const &

vertex

)

Classify the TrackingVertex in categories.

Definition at line 73 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(), 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;
}

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

inline

Classify the RecoVertex in categories.

Definition at line 38 of file VertexClassifier.h.

References evaluate().

Referenced by evaluate().

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

void VertexClassifier::genPrimaryVertices ( )

private

Definition at line 381 of file VertexClassifier.cc.

References funct::abs(), SoftLeptonByDistance_cfi::distance, spr::find(), genpvs_, edm::HepMCProduct::GetEvent(), training_settings::idx, isCharged(), isFinalstateParticle(), funct::m, mcInformation_, parents, funct::pow(), MetAnalyzer::pv(), 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());
}

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 VertexHistoryAnalyzer::analyze(), recoBSVTagInfoValidationAnalyzer::analyze(), and SVTagInfoValidationAnalyzer::analyze().

{ return tracer_; }

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

private

Definition at line 371 of file VertexClassifier.cc.

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

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

private

Definition at line 367 of file VertexClassifier.cc.

Referenced by genPrimaryVertices().

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

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.

References genPrimaryVertices(), edm::EventSetup::getData(), hepMCLabel_, mcInformation_, VertexHistory::newEvent(), particleDataTable_, and tracer_.

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

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

void VertexClassifier::processesAtGenerator ( )

private

Get all the information related to decay process.

Definition at line 111 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, source_particleGun_cfi::ParticleID, BPhysicsValidation_cfi::pdgid, VertexCategories::SigmaMinusDecay, VertexCategories::SigmaPlusDecay, tracer_, update, 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);
        }
      }
    }
  }
}

void VertexClassifier::processesAtSimulation ( )

private

Get information about conversion and other interactions.

Definition at line 159 of file VertexClassifier.cc.

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, source_particleGun_cfi::ParticleID, BPhysicsValidation_cfi::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().

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

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

private

Get reconstruction information.

void VertexClassifier::simulationInformation ( )

private

Get all the information related to the simulation details.

Definition at line 104 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();
}

void VertexClassifier::vertexInformation ( )

private

Get geometrical information about the vertices.

Definition at line 256 of file VertexClassifier.cc.

References fastPrimaryVertexProducer_cfi::clusters, hgcalValidationTPG_cfi::Clusters, SoftLeptonByDistance_cfi::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

const G4toCMSLegacyProcTypeMap VertexClassifier::g4toCMSProcMap_

private

Definition at line 46 of file VertexClassifier.h.

Referenced by processesAtSimulation().

std::vector<GeneratedPrimaryVertex> VertexClassifier::genpvs_

private

Definition at line 89 of file VertexClassifier.h.

Referenced by genPrimaryVertices(), and vertexInformation().

const edm::InputTag VertexClassifier::hepMCLabel_

private

Definition at line 48 of file VertexClassifier.h.

Referenced by newEvent(), and VertexClassifier().

double VertexClassifier::longLivedDecayLength_

private

Definition at line 50 of file VertexClassifier.h.

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

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

private

Definition at line 53 of file VertexClassifier.h.

Referenced by genPrimaryVertices(), and newEvent().

edm::ESHandle<ParticleDataTable> VertexClassifier::particleDataTable_

private

Definition at line 55 of file VertexClassifier.h.

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

VertexHistory VertexClassifier::tracer_

private

Definition at line 44 of file VertexClassifier.h.

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

double VertexClassifier::vertexClusteringDistance_

private

Definition at line 51 of file VertexClassifier.h.

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