TrackClassifier Class Reference

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

#include <TrackClassifier.h>

Inheritance diagram for TrackClassifier:

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

Public Types
typedef TrackCategories	Categories
	Type to the associate category. More...
Public Types inherited from TrackCategories
enum	Category {   Fake = 0, Reconstructed = Fake, Bad, BadInnerHits,   SharedInnerHits, SignalEvent, Bottom, Charm,   Light, Muon, TrackerSimHits, BWeakDecay,   CWeakDecay, ChargePionDecay, ChargeKaonDecay, 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, FromBWeakDecayMuon, FromCWeakDecayMuon,   DecayOnFlightMuon, FromChargePionMuon, FromChargeKaonMuon, PrimaryVertex,   SecondaryVertex, TertiaryVertex, TierciaryVertex = TertiaryVertex, Unknown }
	Categories available to vertex. More...
typedef std::vector< bool >	Flags
	Main types associated to the class. More...

Public Member Functions
const TrackClassifier &	evaluate (reco::TrackBaseRef const &)
	Classify the RecoTrack in categories. More...
const TrackClassifier &	evaluate (reco::TrackRef const &track)
	Classify the RecoTrack in categories. More...
const TrackClassifier &	evaluate (TrackingParticleRef const &)
	Classify the TrackingParticle in categories. More...
const TrackHistory &	history () const
	Returns a reference to the track history used in the classification. More...
void	newEvent (edm::Event const &, edm::EventSetup const &)
	Pre-process event information (for accessing reconstraction information) More...
const TrackQuality &	quality () const
	Returns a reference to the track quality used in the classification. More...
	TrackClassifier (edm::ParameterSet const &, edm::ConsumesCollector &&)
	Constructor by ParameterSet. More...
Public Member Functions inherited from TrackCategories
const Flags &	flags () const
	Returns flags with the category descriptions. More...
bool	is (Category category) const
	Returns track flag for a given category. More...
	TrackCategories ()
	Void constructor. More...

Private Member Functions
void	genPrimaryVertices ()
void	hadronFlavor ()
	Get hadron flavor of the initial hadron. More...
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	qualityInformation (reco::TrackBaseRef const &)
	Classify all the tracks by their reconstruction quality. More...
void	reconstructionInformation (reco::TrackBaseRef const &)
void	simulationInformation ()
	Get all the information related to the simulation details. More...
void	vertexInformation ()
	Get geometrical information about the vertices. More...

Private Attributes
double	badPull_
edm::Handle< reco::BeamSpot >	beamSpot_
const edm::InputTag	beamSpotLabel_
const G4toCMSLegacyProcTypeMap	g4toCMSProcMap_
std::vector< GeneratedPrimaryVertex >	genpvs_
const edm::InputTag	hepMCLabel_
double	longLivedDecayLength_
edm::ESHandle< MagneticField >	magneticField_
edm::Handle< edm::HepMCProduct >	mcInformation_
unsigned int	minTrackerSimHits_
unsigned int	numberOfInnerLayers_
edm::ESHandle< ParticleDataTable >	particleDataTable_
TrackQuality	quality_
TrackHistory	tracer_
edm::ESHandle< TransientTrackBuilder >	transientTrackBuilder_
const TrackerTopology *	tTopo_
double	vertexClusteringSqDistance_

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

Detailed Description

Get track history and classify it in function of their .

Definition at line 29 of file TrackClassifier.h.

Member Typedef Documentation

Categories

typedef TrackCategories TrackClassifier::Categories

Type to the associate category.

Definition at line 32 of file TrackClassifier.h.

Constructor & Destructor Documentation

TrackClassifier()

TrackClassifier::TrackClassifier	(	edm::ParameterSet const &	config,
		edm::ConsumesCollector &&	collector
	)

Constructor by ParameterSet.

Definition at line 15 of file TrackClassifier.cc.

    : TrackCategories(),
      hepMCLabel_(config.getUntrackedParameter<edm::InputTag>("hepMC")),
      beamSpotLabel_(config.getUntrackedParameter<edm::InputTag>("beamSpot")),
      tracer_(config, std::move(collector)),
      quality_(config, collector) {
  collector.consumes<edm::HepMCProduct>(hepMCLabel_);
  collector.consumes<reco::BeamSpot>(beamSpotLabel_);
 
  // Set the history depth after hadronization
  tracer_.depth(-2);
 
  // Set the maximum d0pull for the bad category
  badPull_ = config.getUntrackedParameter<double>("badPull");
 
  // Set the minimum decay length for detecting long decays
  longLivedDecayLength_ = config.getUntrackedParameter<double>("longLivedDecayLength");
 
  // Set the distance for clustering vertices
  float vertexClusteringDistance = config.getUntrackedParameter<double>("vertexClusteringDistance");
  vertexClusteringSqDistance_ = vertexClusteringDistance * vertexClusteringDistance;
 
  // Set the number of innermost layers to check for bad hits
  numberOfInnerLayers_ = config.getUntrackedParameter<unsigned int>("numberOfInnerLayers");
 
  // Set the minimum number of simhits in the tracker
  minTrackerSimHits_ = config.getUntrackedParameter<unsigned int>("minTrackerSimHits");
}

References badPull_, beamSpotLabel_, HistoryBase::depth(), hepMCLabel_, longLivedDecayLength_, minTrackerSimHits_, numberOfInnerLayers_, tracer_, MuonClassifier_cff::vertexClusteringDistance, and vertexClusteringSqDistance_.

Member Function Documentation

evaluate() [1/3]

const TrackClassifier & TrackClassifier::evaluate

(

reco::TrackBaseRef const &

track

)

Classify the RecoTrack in categories.

Definition at line 75 of file TrackClassifier.cc.

                                                                              {
  // Initializing the category vector
  reset();
 
  // Associate and evaluate the track history (check for fakes)
  if (tracer_.evaluate(track)) {
    // Classify all the tracks by their association and reconstruction
    // information
    reconstructionInformation(track);
 
    // Get all the information related to the simulation details
    simulationInformation();
 
    // Analyse the track reconstruction quality
    qualityInformation(track);
 
    // Get hadron flavor of the initial hadron
    hadronFlavor();
 
    // 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
    unknownTrack();
  } else
    flags_[Fake] = true;
 
  return *this;
}

References TrackHistory::evaluate(), TrackCategories::Fake, TrackCategories::flags_, hadronFlavor(), processesAtGenerator(), processesAtSimulation(), qualityInformation(), reconstructionInformation(), TrackCategories::reset(), simulationInformation(), tracer_, HLT_FULL_cff::track, TrackCategories::unknownTrack(), and vertexInformation().

Referenced by TrackCategoriesAnalyzer::analyze(), TrackingParticleCategoriesAnalyzer::analyze(), TrackHistoryAnalyzer::analyze(), BDHadronTrackMonitoringAnalyzer::analyze(), QualityCutsAnalyzer::LoopOverJetTracksAssociation(), and JetVetoedTracksAssociationDRVertex::produce().

evaluate() [2/3]

const TrackClassifier& TrackClassifier::evaluate ( reco::TrackRef const &  track )

inline

Classify the RecoTrack in categories.

Definition at line 47 of file TrackClassifier.h.

{ return evaluate(reco::TrackBaseRef(track)); }

References evaluate(), and HLT_FULL_cff::track.

Referenced by evaluate().

evaluate() [3/3]

const TrackClassifier & TrackClassifier::evaluate

(

TrackingParticleRef const &

track

)

Classify the TrackingParticle in categories.

Definition at line 111 of file TrackClassifier.cc.

                                                                                 {
  // Initializing the category vector
  reset();
 
  // Trace the history for the given TP
  tracer_.evaluate(track);
 
  // Collect the associated reco track
  const reco::TrackBaseRef &recotrack = tracer_.recoTrack();
 
  // If there is a reco truck then evaluate the simulated history
  if (recotrack.isNonnull()) {
    flags_[Reconstructed] = true;
    // Classify all the tracks by their association and reconstruction
    // information
    reconstructionInformation(recotrack);
    // Analyse the track reconstruction quality
    qualityInformation(recotrack);
  } else
    flags_[Reconstructed] = false;
 
  // Get all the information related to the simulation details
  simulationInformation();
 
  // Get hadron flavor of the initial hadron
  hadronFlavor();
 
  // 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
  unknownTrack();
 
  return *this;
}

References TrackHistory::evaluate(), TrackCategories::flags_, hadronFlavor(), edm::RefToBase< T >::isNonnull(), processesAtGenerator(), processesAtSimulation(), qualityInformation(), TrackCategories::Reconstructed, reconstructionInformation(), TrackHistory::recoTrack(), TrackCategories::reset(), simulationInformation(), tracer_, HLT_FULL_cff::track, TrackCategories::unknownTrack(), and vertexInformation().

genPrimaryVertices()

void TrackClassifier::genPrimaryVertices ( )

private

Definition at line 501 of file TrackClassifier.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 distance2 = pow(pv.x - ientry->x, 2) + pow(pv.y - ientry->y, 2) + pow(pv.z - ientry->z, 2);
        if (distance2 < vertexClusteringSqDistance_)
          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(), spr::find(), genpvs_, edm::HepMCProduct::GetEvent(), heavyIonCSV_trainingSettings::idx, isCharged(), isFinalstateParticle(), visualization-live-secondInstance_cfg::m, mcInformation_, parents, funct::pow(), MetAnalyzer::pv(), jetUpdater_cfi::sort, and vertexClusteringSqDistance_.

Referenced by newEvent().

hadronFlavor()

void TrackClassifier::hadronFlavor ( )

private

Get hadron flavor of the initial hadron.

Definition at line 234 of file TrackClassifier.cc.

                                   {
  // Get the initial hadron from the recoGenParticleTrail
  const reco::GenParticle *particle = tracer_.recoGenParticle();
 
  // Check for the initial hadron
  if (particle) {
    HepPDT::ParticleID pid(particle->pdgId());
    flags_[Bottom] = pid.hasBottom();
    flags_[Charm] = pid.hasCharm();
    flags_[Light] = !pid.hasCharm() && !pid.hasBottom();
  }
}

References TrackCategories::Bottom, TrackCategories::Charm, TrackCategories::flags_, TrackCategories::Light, LHEGenericFilter_cfi::ParticleID, reco::LeafCandidate::pdgId(), HistoryBase::recoGenParticle(), and tracer_.

Referenced by evaluate().

history()

const TrackHistory& TrackClassifier::history ( ) const

inline

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

Definition at line 50 of file TrackClassifier.h.

{ return tracer_; }

References tracer_.

Referenced by TrackHistoryAnalyzer::analyze(), and BDHadronTrackMonitoringAnalyzer::analyze().

isCharged()

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

private

Definition at line 491 of file TrackClassifier.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 TrackClassifier::isFinalstateParticle ( const HepMC::GenParticle *  p )

private

Definition at line 489 of file TrackClassifier.cc.

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

References AlCaHLTBitMon_ParallelJobs::p.

Referenced by genPrimaryVertices().

newEvent()

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

Pre-process event information (for accessing reconstraction information)

Definition at line 44 of file TrackClassifier.cc.

                                                                                {
  // Get the new event information for the tracer
  tracer_.newEvent(event, setup);
 
  // Get the new event information for the track quality analyser
  quality_.newEvent(event, setup);
 
  // Get hepmc of the event
  event.getByLabel(hepMCLabel_, mcInformation_);
 
  // Magnetic field
  setup.get<IdealMagneticFieldRecord>().get(magneticField_);
 
  // Get the partivle data table
  setup.getData(particleDataTable_);
 
  // get the beam spot
  event.getByLabel(beamSpotLabel_, beamSpot_);
 
  // Transient track builder
  setup.get<TransientTrackRecord>().get("TransientTrackBuilder", transientTrackBuilder_);
 
  // Create the list of primary vertices associated to the event
  genPrimaryVertices();
 
  // Retrieve tracker topology from geometry
  edm::ESHandle<TrackerTopology> tTopoHand;
  setup.get<TrackerTopologyRcd>().get(tTopoHand);
  tTopo_ = tTopoHand.product();
}

References beamSpot_, beamSpotLabel_, genPrimaryVertices(), get, hepMCLabel_, magneticField_, mcInformation_, TrackHistory::newEvent(), TrackQuality::newEvent(), particleDataTable_, edm::ESHandle< T >::product(), quality_, singleTopDQM_cfi::setup, tracer_, transientTrackBuilder_, and tTopo_.

Referenced by TrackCategoriesAnalyzer::analyze(), TrackingParticleCategoriesAnalyzer::analyze(), TrackHistoryAnalyzer::analyze(), QualityCutsAnalyzer::analyze(), BDHadronTrackMonitoringAnalyzer::analyze(), and JetVetoedTracksAssociatorAtVertex::produce().

processesAtGenerator()

void TrackClassifier::processesAtGenerator ( )

private

Get all the information related to decay process.

Definition at line 247 of file TrackClassifier.cc.

                                           {
  // pdgid of the "in" particle to the production vertex
  int pdgid = 0;
 
  // Get the generated particles from track history (reco::GenParticle in the
  // recoGenParticleTrail)
  TrackHistory::RecoGenParticleTrail const &recoGenParticleTrail = tracer_.recoGenParticleTrail();
 
  // Loop over the generated particles (reco::GenParticle in the
  // recoGenParticleTrail)
  for (TrackHistory::RecoGenParticleTrail::const_iterator iparticle = recoGenParticleTrail.begin();
       iparticle != recoGenParticleTrail.end();
       ++iparticle) {
    pdgid = std::abs((*iparticle)->pdgId());
    // 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_)
          update(flags_[LongLivedDecay], true);
        // Check for B and C weak decays
        update(flags_[BWeakDecay], particleID.hasBottom());
        update(flags_[CWeakDecay], particleID.hasCharm());
        // Check for B and C pure leptonic decay
        std::set<int> daughterIds;
        size_t ndau = (*iparticle)->numberOfDaughters();
        for (size_t i = 0; i < ndau; ++i) {
          daughterIds.insert((*iparticle)->daughter(i)->pdgId());
        }
        update(flags_[FromBWeakDecayMuon], particleID.hasBottom() && (daughterIds.find(13) != daughterIds.end()));
        update(flags_[FromCWeakDecayMuon], particleID.hasCharm() && (daughterIds.find(13) != daughterIds.end()));
      }
      // Check Tau, Ks and Lambda decay
      update(flags_[ChargePionDecay], pdgid == 211);
      update(flags_[ChargeKaonDecay], pdgid == 321);
      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_[SigmaPlusDecay], pdgid == 3222);
      update(flags_[SigmaMinusDecay], pdgid == 3112);
    }
  }
  // Decays in flight
  update(flags_[FromChargePionMuon], flags_[Muon] && flags_[ChargePionDecay]);
  update(flags_[FromChargeKaonMuon], flags_[Muon] && flags_[ChargeKaonDecay]);
  update(flags_[DecayOnFlightMuon], (flags_[FromChargePionMuon] || flags_[FromChargeKaonMuon]));
}

References funct::abs(), TrackCategories::BWeakDecay, TrackCategories::ChargeKaonDecay, TrackCategories::ChargePionDecay, TrackCategories::CWeakDecay, TrackCategories::DecayOnFlightMuon, TrackCategories::flags_, TrackCategories::FromBWeakDecayMuon, TrackCategories::FromChargeKaonMuon, TrackCategories::FromChargePionMuon, TrackCategories::FromCWeakDecayMuon, mps_fire::i, TrackCategories::JpsiDecay, TrackCategories::KsDecay, TrackCategories::LambdaDecay, TrackCategories::LongLivedDecay, longLivedDecayLength_, particleDataTable_, EgammaObjectsElectrons_cfi::particleID, LHEGenericFilter_cfi::ParticleID, EgammaValidation_cff::pdgid, HistoryBase::recoGenParticleTrail(), TrackCategories::SigmaMinusDecay, TrackCategories::SigmaPlusDecay, tracer_, update, and TrackCategories::XiDecay.

Referenced by evaluate().

processesAtSimulation()

void TrackClassifier::processesAtSimulation ( )

private

Get information about conversion and other interactions.

Definition at line 303 of file TrackClassifier.cc.

                                            {
  TrackHistory::SimParticleTrail const &simParticleTrail = tracer_.simParticleTrail();
 
  // Loop over the simulated particles
  for (TrackHistory::SimParticleTrail::const_iterator iparticle = simParticleTrail.begin();
       iparticle != simParticleTrail.end();
       ++iparticle) {
    // pdgid of the real source parent vertex
    int pdgid = 0;
 
    // Get a reference to the TP's parent vertex
    TrackingVertexRef const &parentVertex = (*iparticle)->parentVertex();
 
    // Look for the original source track
    if (parentVertex.isNonnull()) {
      // select the original source in case of combined vertices
      bool flag = false;
      TrackingVertex::tp_iterator itd, its;
 
      for (its = parentVertex->sourceTracks_begin(); its != parentVertex->sourceTracks_end(); ++its) {
        for (itd = parentVertex->daughterTracks_begin(); itd != parentVertex->daughterTracks_end(); ++itd)
          if (itd != its) {
            flag = true;
            break;
          }
        if (flag)
          break;
      }
 
      // Collect the pdgid of the original source track
      if (its != parentVertex->sourceTracks_end())
        pdgid = std::abs((*its)->pdgId());
      else
        pdgid = 0;
    }
 
    unsigned int processG4 = 0;
 
    // Check existence of SimVerteces assigned
    if (parentVertex->nG4Vertices() > 0) {
      processG4 = (*(parentVertex->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);
 
    // 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);
      // Special treatment for decays
      if (process == CMS::Decay) {
        // 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_)
            update(flags_[LongLivedDecay], true);
 
          // Check for B and C weak decays
          update(flags_[BWeakDecay], particleID.hasBottom());
          update(flags_[CWeakDecay], particleID.hasCharm());
 
          // Check for B or C pure leptonic decays
          int daughtId = abs((*iparticle)->pdgId());
          update(flags_[FromBWeakDecayMuon], particleID.hasBottom() && daughtId == 13);
          update(flags_[FromCWeakDecayMuon], particleID.hasCharm() && daughtId == 13);
        }
        // Check decays
        update(flags_[ChargePionDecay], pdgid == 211);
        update(flags_[ChargeKaonDecay], pdgid == 321);
        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);
      }
    }
  }
  // Decays in flight
  update(flags_[FromChargePionMuon], flags_[Muon] && flags_[ChargePionDecay]);
  update(flags_[FromChargeKaonMuon], flags_[Muon] && flags_[ChargeKaonDecay]);
  update(flags_[DecayOnFlightMuon], flags_[FromChargePionMuon] || flags_[FromChargeKaonMuon]);
}

References funct::abs(), CMS::Annihilation, TrackCategories::AnnihilationProcess, TrackCategories::BWeakDecay, TrackCategories::ChargeKaonDecay, TrackCategories::ChargePionDecay, CMS::Compton, TrackCategories::ComptonProcess, CMS::Conversions, TrackCategories::ConversionsProcess, TrackCategories::CWeakDecay, CMS::Decay, TrackCategories::DecayOnFlightMuon, TrackCategories::DecayProcess, CMS::EBrem, TrackCategories::EBremProcess, CMS::EIoni, TrackCategories::EIoniProcess, RemoveAddSevLevel::flag, TrackCategories::flags_, TrackCategories::FromBWeakDecayMuon, TrackCategories::FromChargeKaonMuon, TrackCategories::FromChargePionMuon, TrackCategories::FromCWeakDecayMuon, g4toCMSProcMap_, CMS::Hadronic, TrackCategories::HadronicProcess, CMS::HIoni, TrackCategories::HIoniProcess, edm::Ref< C, T, F >::isNonnull(), TrackCategories::JpsiDecay, TrackCategories::KnownProcess, TrackCategories::KsDecay, TrackCategories::LambdaDecay, TrackCategories::LongLivedDecay, longLivedDecayLength_, CMS::MuBrem, TrackCategories::MuBremProcess, CMS::MuIoni, TrackCategories::MuIoniProcess, CMS::MuNucl, TrackCategories::MuNuclProcess, CMS::MuPairProd, TrackCategories::MuPairProdProcess, TrackCategories::OmegaDecay, particleDataTable_, EgammaObjectsElectrons_cfi::particleID, LHEGenericFilter_cfi::ParticleID, EgammaValidation_cff::pdgid, CMS::Photon, TrackCategories::PhotonProcess, CMS::Primary, TrackCategories::PrimaryProcess, LaserDQM_cfg::process, G4toCMSLegacyProcTypeMap::processId(), TrackCategories::SigmaMinusDecay, TrackCategories::SigmaPlusDecay, HistoryBase::simParticleTrail(), CMS::SynchrotronRadiation, TrackCategories::SynchrotronRadiationProcess, tracer_, CMS::Undefined, TrackCategories::UndefinedProcess, CMS::Unknown, TrackCategories::UnknownProcess, update, and TrackCategories::XiDecay.

Referenced by evaluate().

quality()

const TrackQuality& TrackClassifier::quality ( void  ) const

inline

Returns a reference to the track quality used in the classification.

Definition at line 53 of file TrackClassifier.h.

{ return quality_; }

References quality_.

qualityInformation()

void TrackClassifier::qualityInformation ( reco::TrackBaseRef const &  track )

private

Classify all the tracks by their reconstruction quality.

Definition at line 211 of file TrackClassifier.cc.

                                                                      {
  // run the hit-by-hit reconstruction quality analysis
  quality_.evaluate(tracer_.simParticleTrail(), track, tTopo_);
 
  unsigned int maxLayers = std::min(numberOfInnerLayers_, quality_.numberOfLayers());
 
  // check the innermost layers for bad hits
  for (unsigned int i = 0; i < maxLayers; i++) {
    const TrackQuality::Layer &layer = quality_.layer(i);
 
    // check all hits in that layer
    for (unsigned int j = 0; j < layer.hits.size(); j++) {
      const TrackQuality::Layer::Hit &hit = layer.hits[j];
 
      // In those cases the bad hit was used by track reconstruction
      if (hit.state == TrackQuality::Layer::Noise || hit.state == TrackQuality::Layer::Misassoc)
        flags_[BadInnerHits] = true;
      else if (hit.state == TrackQuality::Layer::Shared)
        flags_[SharedInnerHits] = true;
    }
  }
}

References TrackCategories::BadInnerHits, TrackQuality::evaluate(), TrackCategories::flags_, mps_fire::i, dqmiolumiharvest::j, TrackQuality::layer(), phase1PixelTopology::layer, histoParameters_cff::maxLayers, min(), TrackQuality::Layer::Misassoc, TrackQuality::Layer::Noise, numberOfInnerLayers_, TrackQuality::numberOfLayers(), quality_, TrackQuality::Layer::Shared, TrackCategories::SharedInnerHits, HistoryBase::simParticleTrail(), tracer_, HLT_FULL_cff::track, and tTopo_.

Referenced by evaluate().

reconstructionInformation()

void TrackClassifier::reconstructionInformation ( reco::TrackBaseRef const &  track )

private

Classify all the tracks by their association and reconstruction information

Definition at line 153 of file TrackClassifier.cc.

                                                                             {
  TrackingParticleRef tpr = tracer_.simParticle();
 
  // Compute tracking particle parameters at point of closest approach to the
  // beamline
 
  const SimTrack *assocTrack = &(*tpr->g4Track_begin());
 
  FreeTrajectoryState ftsAtProduction(
      GlobalPoint(tpr->vertex().x(), tpr->vertex().y(), tpr->vertex().z()),
      GlobalVector(assocTrack->momentum().x(), assocTrack->momentum().y(), assocTrack->momentum().z()),
      TrackCharge(track->charge()),
      magneticField_.product());
 
  try {
    TSCPBuilderNoMaterial tscpBuilder;
    TrajectoryStateClosestToPoint tsAtClosestApproach =
        tscpBuilder(ftsAtProduction, GlobalPoint(beamSpot_->x0(), beamSpot_->y0(), beamSpot_->z0()));
 
    GlobalVector v =
        tsAtClosestApproach.theState().position() - GlobalPoint(beamSpot_->x0(), beamSpot_->y0(), beamSpot_->z0());
    GlobalVector p = tsAtClosestApproach.theState().momentum();
 
    // Simulated dxy
    double dxySim = -v.x() * sin(p.phi()) + v.y() * cos(p.phi());
 
    // Simulated dz
    double dzSim = v.z() - (v.x() * p.x() + v.y() * p.y()) * p.z() / p.perp2();
 
    // Calculate the dxy pull
    double dxyPull =
        std::abs(track->dxy(reco::TrackBase::Point(beamSpot_->x0(), beamSpot_->y0(), beamSpot_->z0())) - dxySim) /
        track->dxyError();
 
    // Calculate the dx pull
    double dzPull =
        std::abs(track->dz(reco::TrackBase::Point(beamSpot_->x0(), beamSpot_->y0(), beamSpot_->z0())) - dzSim) /
        track->dzError();
 
    // Return true if d0Pull > badD0Pull sigmas
    flags_[Bad] = (dxyPull > badPull_ || dzPull > badPull_);
 
  } catch (cms::Exception const &) {
    flags_[Bad] = true;
  }
}

References funct::abs(), TrackCategories::Bad, badPull_, beamSpot_, funct::cos(), TrackCategories::flags_, magneticField_, CoreSimTrack::momentum(), FreeTrajectoryState::momentum(), AlCaHLTBitMon_ParallelJobs::p, FreeTrajectoryState::position(), edm::ESHandle< T >::product(), HistoryBase::simParticle(), funct::sin(), TrajectoryStateClosestToPoint::theState(), tracer_, HLT_FULL_cff::track, findQualityFiles::v, reco::BeamSpot::x0(), reco::BeamSpot::y0(), and reco::BeamSpot::z0().

Referenced by evaluate().

simulationInformation()

void TrackClassifier::simulationInformation ( )

private

Get all the information related to the simulation details.

Definition at line 200 of file TrackClassifier.cc.

                                            {
  // Get the event id for the initial TP.
  EncodedEventId eventId = tracer_.simParticle()->eventId();
  // Check for signal events
  flags_[SignalEvent] = !eventId.bunchCrossing() && !eventId.event();
  // Check for muons
  flags_[Muon] = (abs(tracer_.simParticle()->pdgId()) == 13);
  // Check for the number of psimhit in tracker
  flags_[TrackerSimHits] = tracer_.simParticle()->numberOfTrackerLayers() >= (int)minTrackerSimHits_;
}

References funct::abs(), EncodedEventId::bunchCrossing(), EncodedEventId::event(), TrackCategories::flags_, createfilelist::int, minTrackerSimHits_, TrackCategories::Muon, TrackCategories::SignalEvent, HistoryBase::simParticle(), tracer_, and TrackCategories::TrackerSimHits.

Referenced by evaluate().

vertexInformation()

void TrackClassifier::vertexInformation ( )

private

Get geometrical information about the vertices.

Definition at line 413 of file TrackClassifier.cc.

                                        {
  // Get the main primary vertex from the list
  GeneratedPrimaryVertex const &genpv = genpvs_.back();
 
  // Get the generated history of the tracks
  const TrackHistory::GenParticleTrail &genParticleTrail = tracer_.genParticleTrail();
 
  // Vertex counter
  int counter = 0;
 
  // Unit transformation from mm to cm
  double const mm = 0.1;
 
  double oldX = genpv.x;
  double oldY = genpv.y;
  double oldZ = genpv.z;
 
  // Loop over the generated particles
  for (TrackHistory::GenParticleTrail::const_reverse_iterator iparticle = genParticleTrail.rbegin();
       iparticle != genParticleTrail.rend();
       ++iparticle) {
    // Look for those with production vertex
    HepMC::GenVertex *parent = (*iparticle)->production_vertex();
    if (parent) {
      HepMC::ThreeVector p = parent->point3d();
 
      double distance2 = pow(p.x() * mm - genpv.x, 2) + pow(p.y() * mm - genpv.y, 2) + pow(p.z() * mm - genpv.z, 2);
      double difference2 = pow(p.x() * mm - oldX, 2) + pow(p.y() * mm - oldY, 2) + pow(p.z() * mm - oldZ, 2);
 
      // std::cout << "Distance2 : " << distance2 << " (" << p.x() * mm << ","
      // << p.y() * mm << "," << p.z() * mm << ")" << std::endl; std::cout <<
      // "Difference2 : " << difference2 << std::endl;
 
      if (difference2 > vertexClusteringSqDistance_) {
        if (distance2 > vertexClusteringSqDistance_)
          counter++;
        oldX = p.x() * mm;
        oldY = p.y() * mm;
        oldZ = p.z() * mm;
      }
    }
  }
 
  const TrackHistory::SimParticleTrail &simParticleTrail = tracer_.simParticleTrail();
 
  // Loop over the generated particles
  for (TrackHistory::SimParticleTrail::const_reverse_iterator iparticle = simParticleTrail.rbegin();
       iparticle != simParticleTrail.rend();
       ++iparticle) {
    // Look for those with production vertex
    TrackingParticle::Point p = (*iparticle)->vertex();
 
    double distance2 = pow(p.x() - genpv.x, 2) + pow(p.y() - genpv.y, 2) + pow(p.z() - genpv.z, 2);
    double difference2 = pow(p.x() - oldX, 2) + pow(p.y() - oldY, 2) + pow(p.z() - oldZ, 2);
 
    // std::cout << "Distance2 : " << distance2 << " (" << p.x() << "," << p.y()
    // << "," << p.z() << ")" << std::endl; std::cout << "Difference2 : " <<
    // difference2 << std::endl;
 
    if (difference2 > vertexClusteringSqDistance_) {
      if (distance2 > vertexClusteringSqDistance_)
        counter++;
      oldX = p.x();
      oldY = p.y();
      oldZ = p.z();
    }
  }
 
  if (!counter)
    flags_[PrimaryVertex] = true;
  else if (counter == 1)
    flags_[SecondaryVertex] = true;
  else
    flags_[TertiaryVertex] = true;
}

References TrackCategories::flags_, HistoryBase::genParticleTrail(), genpvs_, AlCaHLTBitMon_ParallelJobs::p, class-composition::parent, funct::pow(), TrackCategories::PrimaryVertex, TrackCategories::SecondaryVertex, HistoryBase::simParticleTrail(), TrackCategories::TertiaryVertex, tracer_, vertexClusteringSqDistance_, TrackClassifier::GeneratedPrimaryVertex::x, TrackClassifier::GeneratedPrimaryVertex::y, and TrackClassifier::GeneratedPrimaryVertex::z.

Referenced by evaluate().

Member Data Documentation

badPull_

double TrackClassifier::badPull_

private

Definition at line 59 of file TrackClassifier.h.

Referenced by reconstructionInformation(), and TrackClassifier().

beamSpot_

edm::Handle<reco::BeamSpot> TrackClassifier::beamSpot_

private

Definition at line 79 of file TrackClassifier.h.

Referenced by newEvent(), and reconstructionInformation().

beamSpotLabel_

const edm::InputTag TrackClassifier::beamSpotLabel_

private

Definition at line 57 of file TrackClassifier.h.

Referenced by newEvent(), and TrackClassifier().

g4toCMSProcMap_

const G4toCMSLegacyProcTypeMap TrackClassifier::g4toCMSProcMap_

private

Definition at line 69 of file TrackClassifier.h.

Referenced by processesAtSimulation().

genpvs_

std::vector<GeneratedPrimaryVertex> TrackClassifier::genpvs_

private

Definition at line 122 of file TrackClassifier.h.

Referenced by genPrimaryVertices(), and vertexInformation().

hepMCLabel_

const edm::InputTag TrackClassifier::hepMCLabel_

private

Definition at line 56 of file TrackClassifier.h.

Referenced by newEvent(), and TrackClassifier().

longLivedDecayLength_

double TrackClassifier::longLivedDecayLength_

private

Definition at line 60 of file TrackClassifier.h.

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

magneticField_

edm::ESHandle<MagneticField> TrackClassifier::magneticField_

private

Definition at line 71 of file TrackClassifier.h.

Referenced by newEvent(), and reconstructionInformation().

mcInformation_

edm::Handle<edm::HepMCProduct> TrackClassifier::mcInformation_

private

Definition at line 73 of file TrackClassifier.h.

Referenced by genPrimaryVertices(), and newEvent().

minTrackerSimHits_

unsigned int TrackClassifier::minTrackerSimHits_

private

Definition at line 63 of file TrackClassifier.h.

Referenced by simulationInformation(), and TrackClassifier().

numberOfInnerLayers_

unsigned int TrackClassifier::numberOfInnerLayers_

private

Definition at line 62 of file TrackClassifier.h.

Referenced by qualityInformation(), and TrackClassifier().

particleDataTable_

edm::ESHandle<ParticleDataTable> TrackClassifier::particleDataTable_

private

Definition at line 75 of file TrackClassifier.h.

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

quality_

TrackQuality TrackClassifier::quality_

private

Definition at line 67 of file TrackClassifier.h.

Referenced by newEvent(), quality(), and qualityInformation().

tracer_

TrackHistory TrackClassifier::tracer_

private

Definition at line 65 of file TrackClassifier.h.

Referenced by evaluate(), hadronFlavor(), history(), newEvent(), processesAtGenerator(), processesAtSimulation(), qualityInformation(), reconstructionInformation(), simulationInformation(), TrackClassifier(), and vertexInformation().

transientTrackBuilder_

edm::ESHandle<TransientTrackBuilder> TrackClassifier::transientTrackBuilder_

private

Definition at line 77 of file TrackClassifier.h.

Referenced by newEvent().

tTopo_

const TrackerTopology* TrackClassifier::tTopo_

private

Definition at line 81 of file TrackClassifier.h.

Referenced by newEvent(), and qualityInformation().

vertexClusteringSqDistance_

double TrackClassifier::vertexClusteringSqDistance_

private

Definition at line 61 of file TrackClassifier.h.

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