SingleLongTrackProducer Class Reference

Inheritance diagram for SingleLongTrackProducer:

Public Member Functions
	SingleLongTrackProducer (const edm::ParameterSet &)
	~SingleLongTrackProducer () override=default
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
const bool	debug
const double	matchInDr
const double	maxDxy
const double	maxDz
const double	maxEta
const int	minNumberOfLayers
const double	minPt
const edm::EDGetTokenT< std::vector< reco::Muon > >	muonsToken
const bool	onlyValidHits
const edm::EDGetTokenT< reco::VertexCollection >	PrimVtxToken
const edm::EDGetTokenT< std::vector< reco::Track > >	tracksToken

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 16 of file SingleLongTrackProducer.cc.

Constructor & Destructor Documentation

SingleLongTrackProducer()

SingleLongTrackProducer::SingleLongTrackProducer ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 40 of file SingleLongTrackProducer.cc.

References edm::ParameterSet::getParameter().

    : tracksToken{consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("allTracks"))},
      muonsToken{consumes<std::vector<reco::Muon>>(iConfig.getParameter<edm::InputTag>("matchMuons"))},
      PrimVtxToken{consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("PrimaryVertex"))},
      minNumberOfLayers{iConfig.getParameter<int>("minNumberOfLayers")},
      matchInDr{iConfig.getParameter<double>("requiredDr")},
      onlyValidHits{iConfig.getParameter<bool>("onlyValidHits")},
      debug{iConfig.getParameter<bool>("debug")},
      minPt{iConfig.getParameter<double>("minPt")},
      maxEta{iConfig.getParameter<double>("maxEta")},
      maxDxy{iConfig.getParameter<double>("maxDxy")},
      maxDz{iConfig.getParameter<double>("maxDz")} {
  produces<reco::TrackCollection>("").setBranchAlias("");
}

~SingleLongTrackProducer()

SingleLongTrackProducer::~SingleLongTrackProducer ( )

overridedefault

Member Function Documentation

fillDescriptions()

void SingleLongTrackProducer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 227 of file SingleLongTrackProducer.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

                                                                                         {
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("allTracks", edm::InputTag("generalTracks"))->setComment("input track collection");
  desc.add<edm::InputTag>("matchMuons", edm::InputTag("earlyMuons"))->setComment("input muon collection for matching");
  desc.add<edm::InputTag>("PrimaryVertex", edm::InputTag("offlinePrimaryVertices"))
      ->setComment("input primary vertex collection");
  desc.add<int>("minNumberOfLayers", 10)->setComment("minimum number of layers");
  desc.add<double>("requiredDr", 0.01)->setComment("matching muons deltaR. If negative do not match");
  desc.add<bool>("onlyValidHits", true)->setComment("use only valid hits");
  desc.add<bool>("debug", false)->setComment("verbose?");
  desc.add<double>("minPt", 15.0)->setComment("minimum pT");
  desc.add<double>("maxEta", 2.2)->setComment("maximum pseudorapidity (absolute value)");
  desc.add<double>("maxDxy", 0.02)->setComment("maximum transverse impact parameter");
  desc.add<double>("maxDz", 0.5)->setComment("maximum longitudinal impact parameter");
  descriptions.addWithDefaultLabel(desc);
}

produce()

void SingleLongTrackProducer::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overrideprivate

Definition at line 55 of file SingleLongTrackProducer.cc.

References funct::abs(), DMR_cfg::cerr, debug, reco::deltaR2(), PVValHelper::dxy, PVValHelper::dz, MillePedeFileConverter_cfg::e, reco::HitPattern::getHitPattern(), goodTracks_cfi::goodTracks, h, hcalSimParameters_cfi::hb, iEvent, visualization-live-secondInstance_cfg::m, matchInDr, maxDxy, maxDz, maxEta, minNumberOfLayers, minPt, HerwigMaxPtPartonFilter_cfi::moduleLabel, eostools::move(), DiMuonV_cfg::muons, muonsToken, onlyValidHits, PrimVtxToken, rpcPointValidation_cfi::recHit, reco::Track::setExtra(), HLT_2023v12_cff::track, reco::HitPattern::TRACK_HITS, reco::HitPattern::trackerLayersWithMeasurement(), DiMuonV_cfg::tracks, tracksToken, reco::HitPattern::validHitFilter(), AlignmentTracksFromVertexSelector_cfi::vertices, and L1BJetProducer_cff::vtx.

                                                                                   {
  using namespace edm;

  // register output collection:
  std::unique_ptr<reco::TrackCollection> goodTracks(new reco::TrackCollection);

  // register input collections:
  const auto &tracks = iEvent.getHandle(tracksToken);
  if (!tracks.isValid()) {
    edm::LogError("SingleLongTrackProducer")
        << "Input track collection is not valid.\n Returning empty output track collection.";
    iEvent.put(std::move(goodTracks), "");
    return;
  }

  const auto &muons = iEvent.getHandle(muonsToken);
  if (!muons.isValid() && matchInDr > 0.) {
    edm::LogError("SingleLongTrackProducer")
        << "Input muon collection is not valid.\n Returning empty output track collection.";
    iEvent.put(std::move(goodTracks), "");
    return;
  }

  const auto &vertices = iEvent.getHandle(PrimVtxToken);
  if (!vertices.isValid()) {
    edm::LogError("SingleLongTrackProducer")
        << "Input vertex collection is not valid.\n Returning empty output track collection.";
    iEvent.put(std::move(goodTracks), "");
    return;
  }

  const reco::Vertex vtx = vertices->at(0);

  // Preselection of long quality tracks
  std::vector<reco::Track> selTracks;
  reco::Track bestTrack;
  unsigned int tMuon = 0;
  double fitProb = 100;

  for (const auto &track : *tracks) {
    const reco::HitPattern &hitpattern = track.hitPattern();
    double dR2min = 100.;
    double chiNdof = track.normalizedChi2();
    double dxy = std::abs(track.dxy(vtx.position()));
    double dz = std::abs(track.dz(vtx.position()));

    if (track.pt() < minPt)
      continue;

    if (std::abs(track.eta()) > maxEta)
      continue;

    if (hitpattern.trackerLayersWithMeasurement() < minNumberOfLayers)
      continue;

    // Long track needs to be close to a good muon (only if requested)
    if (matchInDr > 0.) {
      for (const auto &m : *muons) {
        if (m.isTrackerMuon()) {
          tMuon++;
          reco::Track matchedTrack = *(m.innerTrack());
          // match to general track in deltaR
          double dr2 = reco::deltaR2(track, matchedTrack);
          if (dr2 < dR2min)
            dR2min = dr2;
        }
      }
      // matchInDr here is defined positive
      if (dR2min >= matchInDr * matchInDr)
        continue;
    }
    // do vertex consistency:
    bool vertex_match = dxy < maxDxy && dz < maxDz;
    if (!(vertex_match))
      continue;
    if (track.validFraction() < 1.0)
      continue;
    // only save the track with the smallest chiNdof
    if (chiNdof < fitProb) {
      fitProb = chiNdof;
      bestTrack = track;
      bestTrack.setExtra(track.extra());
    }
    if (debug)
      edm::LogPrint("SingleLongTrackProducer") << " deltaR2 (general) track to matched Track: " << dR2min;
    if (debug)
      edm::LogPrint("SingleLongTrackProducer") << "chi2Ndof:" << chiNdof << " best Track: " << fitProb;
  }

  selTracks.push_back(bestTrack);

  if (debug)
    edm::LogPrint("SingleLongTrackProducer")
        << " number of Tracker Muons: " << tMuon << ", thereof " << selTracks.size() << " tracks passed preselection.";

  // check hits validity in preselected tracks
  bool hitIsNotValid{false};

  for (const auto &track : selTracks) {
    reco::HitPattern hitpattern = track.hitPattern();
    int deref{0};

    // this checks track recHits
    try {  // (Un)Comment this line with /* to (not) allow for events with not valid hits
      auto hb = track.recHitsBegin();

      for (unsigned int h = 0; h < track.recHitsSize(); h++) {
        auto recHit = *(hb + h);
        auto const &hit = *recHit;

        if (onlyValidHits && !hit.isValid()) {
          hitIsNotValid = true;
          continue;
        }
      }
    } catch (cms::Exception const &e) {
      deref += 1;
      if (debug)
        std::cerr << e.explainSelf() << std::endl;
    }

    if (hitIsNotValid == true)
      break;  // (Un)Comment this line with */ to (not) allow for events with not valid hits

    int deref2{0};

    // this checks track hitPattern hits
    try {
      auto hb = track.recHitsBegin();

      for (unsigned int h = 0; h < track.recHitsSize(); h++) {
        uint32_t pHit = hitpattern.getHitPattern(reco::HitPattern::TRACK_HITS, h);

        auto recHit = *(hb + h);
        auto const &hit = *recHit;

        if (onlyValidHits && !hit.isValid()) {
          if (debug)
            edm::LogPrint("SingleLongTrackProducer") << "hit not valid: " << h;
          continue;
        }

        // loop over the hits of the track.
        if (onlyValidHits && !(hitpattern.validHitFilter(pHit))) {
          if (debug)
            edm::LogPrint("SingleLongTrackProducer") << "hit not valid: " << h;
          continue;
        }
      }
      goodTracks->push_back(track);
    } catch (cms::Exception const &e) {
      deref2 += 1;
      if (debug)
        std::cerr << e.explainSelf() << std::endl;
    }

    if (debug)
      edm::LogPrint("SingleLongTrackProducer")
          << "found tracks with " << deref << "missing valid hits and " << deref2 << " missing hit pattern";
  }

  if (debug) {
    auto const &moduleType = moduleDescription().moduleName();
    auto const &moduleLabel = moduleDescription().moduleLabel();
    edm::LogPrint("SingleLongTrackProducer") << "[" << moduleType << "] (" << moduleLabel << ") "
                                             << " output track size: " << goodTracks.get()->size();
  }

  // save track collection in event:
  iEvent.put(std::move(goodTracks), "");
}

Member Data Documentation

debug

const bool SingleLongTrackProducer::debug

private

Definition at line 33 of file SingleLongTrackProducer.cc.

Referenced by produce().

matchInDr

const double SingleLongTrackProducer::matchInDr

private

Definition at line 31 of file SingleLongTrackProducer.cc.

Referenced by produce().

maxDxy

const double SingleLongTrackProducer::maxDxy

private

Definition at line 36 of file SingleLongTrackProducer.cc.

Referenced by produce().

maxDz

const double SingleLongTrackProducer::maxDz

private

Definition at line 37 of file SingleLongTrackProducer.cc.

Referenced by produce().

maxEta

const double SingleLongTrackProducer::maxEta

private

Definition at line 35 of file SingleLongTrackProducer.cc.

Referenced by produce().

minNumberOfLayers

const int SingleLongTrackProducer::minNumberOfLayers

private

Definition at line 30 of file SingleLongTrackProducer.cc.

Referenced by produce().

minPt

const double SingleLongTrackProducer::minPt

private

Definition at line 34 of file SingleLongTrackProducer.cc.

Referenced by produce().

muonsToken

const edm::EDGetTokenT<std::vector<reco::Muon> > SingleLongTrackProducer::muonsToken

private

Definition at line 27 of file SingleLongTrackProducer.cc.

Referenced by produce().

onlyValidHits

const bool SingleLongTrackProducer::onlyValidHits

private

Definition at line 32 of file SingleLongTrackProducer.cc.

Referenced by produce().

PrimVtxToken

const edm::EDGetTokenT<reco::VertexCollection> SingleLongTrackProducer::PrimVtxToken

private

Definition at line 28 of file SingleLongTrackProducer.cc.

Referenced by produce().

tracksToken

const edm::EDGetTokenT<std::vector<reco::Track> > SingleLongTrackProducer::tracksToken

private

Definition at line 26 of file SingleLongTrackProducer.cc.

Referenced by produce().