FastTSGFromL2Muon Class Reference

#include <FastTSGFromL2Muon.h>

Inheritance diagram for FastTSGFromL2Muon:

Public Member Functions
void	beginRun (edm::Run const &run, edm::EventSetup const &es) override
	FastTSGFromL2Muon (const edm::ParameterSet &cfg)
void	produce (edm::Event &ev, const edm::EventSetup &es) override
	~FastTSGFromL2Muon () override
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

Private Member Functions
bool	clean (reco::TrackRef muRef, RectangularEtaPhiTrackingRegion *region, const BasicTrajectorySeed *aSeed, const SimTrack &theSimTrack)

Private Attributes
edm::InputTag	theL2CollectionLabel
double	thePtCut
std::unique_ptr< MuonTrackingRegionBuilder >	theRegionBuilder
std::vector< edm::InputTag >	theSeedCollectionLabels
MuonServiceProxy *	theService
edm::InputTag	theSimTrackCollectionLabel

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 26 of file FastTSGFromL2Muon.h.

Constructor & Destructor Documentation

FastTSGFromL2Muon()

FastTSGFromL2Muon::FastTSGFromL2Muon

(

const edm::ParameterSet &

cfg

)

Definition at line 20 of file FastTSGFromL2Muon.cc.

References looper::cfg, theL2CollectionLabel, thePtCut, theRegionBuilder, theSeedCollectionLabels, and theSimTrackCollectionLabel.

                                                               {
  produces<L3MuonTrajectorySeedCollection>();

  edm::ParameterSet serviceParameters = cfg.getParameter<edm::ParameterSet>("ServiceParameters");

  thePtCut = cfg.getParameter<double>("PtCut");

  theL2CollectionLabel = cfg.getParameter<edm::InputTag>("MuonCollectionLabel");
  theSeedCollectionLabels = cfg.getParameter<std::vector<edm::InputTag> >("SeedCollectionLabels");
  theSimTrackCollectionLabel = cfg.getParameter<edm::InputTag>("SimTrackCollectionLabel");
  // useTFileService_ = cfg.getUntrackedParameter<bool>("UseTFileService",false);
  edm::ParameterSet regionBuilderPSet = cfg.getParameter<edm::ParameterSet>("MuonTrackingRegionBuilder");
  theRegionBuilder = std::make_unique<MuonTrackingRegionBuilder>(regionBuilderPSet, consumesCollector());
}

~FastTSGFromL2Muon()

FastTSGFromL2Muon::~FastTSGFromL2Muon ( )

override

Definition at line 35 of file FastTSGFromL2Muon.cc.

{}

Member Function Documentation

beginRun()

void FastTSGFromL2Muon::beginRun ( edm::Run const &  run, edm::EventSetup const &  es  )

override

Definition at line 37 of file FastTSGFromL2Muon.cc.

                                                                           {
  //region builder

  /*
  if(useTFileService_) {
    edm::Service<TFileService> fs;
    h_nSeedPerTrack = fs->make<TH1F>("nSeedPerTrack","nSeedPerTrack",76,-0.5,75.5);
    h_nGoodSeedPerTrack = fs->make<TH1F>("nGoodSeedPerTrack","nGoodSeedPerTrack",75,-0.5,75.5);
    h_nGoodSeedPerEvent = fs->make<TH1F>("nGoodSeedPerEvent","nGoodSeedPerEvent",75,-0.5,75.5);
  } else {
    h_nSeedPerTrack = 0;
    h_nGoodSeedPerEvent = 0;
    h_nGoodSeedPerTrack = 0;
  }
  */
}

clean()

bool FastTSGFromL2Muon::clean ( reco::TrackRef  muRef, RectangularEtaPhiTrackingRegion *  region, const BasicTrajectorySeed *  aSeed, const SimTrack &  theSimTrack  )

private

Definition at line 147 of file FastTSGFromL2Muon.cc.

References SiPixelRawToDigiRegional_cfi::deltaPhi, generateTowerEtThresholdLUT::etaRange, CoreSimTrack::momentum(), ptMin, HLT_2022v12_cff::region, TkTrackingRegionsMargin< T >::right(), and mathSSE::sqrt().

Referenced by produce().

                                                           {
  // Eta cleaner
  const PixelRecoRange<float>& etaRange = region->etaRange();
  double etaSeed = theSimTrack.momentum().Eta();
  double etaLimit = (fabs(fabs(etaRange.max()) - fabs(etaRange.mean())) < 0.05)
                        ? 0.05
                        : fabs(fabs(etaRange.max()) - fabs(etaRange.mean()));
  bool inEtaRange = etaSeed >= (etaRange.mean() - etaLimit) && etaSeed <= (etaRange.mean() + etaLimit);
  if (!inEtaRange)
    return false;

  // Phi cleaner
  const TkTrackingRegionsMargin<float>& phiMargin = region->phiMargin();
  double phiSeed = theSimTrack.momentum().Phi();
  double phiLimit = (phiMargin.right() < 0.05) ? 0.05 : phiMargin.right();
  bool inPhiRange = (fabs(deltaPhi(phiSeed, double(region->direction().phi()))) < phiLimit);
  if (!inPhiRange)
    return false;

  // pt cleaner
  double ptSeed = std::sqrt(theSimTrack.momentum().Perp2());
  double ptMin = (region->ptMin() > 3.5) ? 3.5 : region->ptMin();
  bool inPtRange = ptSeed >= ptMin && ptSeed <= 2 * (muRef->pt());
  return inPtRange;
}

produce()

void FastTSGFromL2Muon::produce ( edm::Event &  ev, const edm::EventSetup &  es  )

override

Definition at line 54 of file FastTSGFromL2Muon.cc.

References edm::Range< T >::begin(), clean(), runTheMatrix::const, makeMEIFBenchmarkPlots::ev, iseed, eostools::move(), TrajectorySeed::recHits(), HLT_2022v12_cff::region, mps_fire::result, seedmultiplicitymonitor_cfi::seedCollections, theL2CollectionLabel, thePtCut, theRegionBuilder, theSeedCollectionLabels, and theSimTrackCollectionLabel.

                                                                     {
  // Initialize the output product
  std::unique_ptr<L3MuonTrajectorySeedCollection> result(new L3MuonTrajectorySeedCollection());

  // Region builder
  theRegionBuilder->setEvent(ev, es);

  // Retrieve the Monte Carlo truth (SimTracks)
  edm::Handle<edm::SimTrackContainer> theSimTracks;
  ev.getByLabel(theSimTrackCollectionLabel, theSimTracks);

  // Retrieve L2 muon collection
  edm::Handle<reco::TrackCollection> l2muonH;
  ev.getByLabel(theL2CollectionLabel, l2muonH);

  // Retrieve Seed collection
  unsigned seedCollections = theSeedCollectionLabels.size();
  std::vector<edm::Handle<edm::View<TrajectorySeed> > > theSeeds;
  theSeeds.resize(seedCollections);
  unsigned seed_size = 0;
  for (unsigned iseed = 0; iseed < seedCollections; ++iseed) {
    ev.getByLabel(theSeedCollectionLabels[iseed], theSeeds[iseed]);
    seed_size += theSeeds[iseed]->size();
  }

  // Loop on L2 muons
  unsigned int imu = 0;
  unsigned int imuMax = l2muonH->size();
  // std::cout << "Found " << imuMax << " L2 muons" << std::endl;
  for (; imu != imuMax; ++imu) {
    // Make a ref to l2 muon
    reco::TrackRef muRef(l2muonH, imu);

    // Cut on muons with low momenta
    if (muRef->pt() < thePtCut || muRef->innerMomentum().Rho() < thePtCut || muRef->innerMomentum().R() < 2.5)
      continue;

    // Define the region of interest
    std::unique_ptr<RectangularEtaPhiTrackingRegion> region = theRegionBuilder->region(muRef);

    // Copy the collection of seeds (ahem, this is time consuming!)
    std::vector<TrajectorySeed> tkSeeds;
    std::set<unsigned> tkIds;
    tkSeeds.reserve(seed_size);
    for (unsigned iseed = 0; iseed < seedCollections; ++iseed) {
      edm::Handle<edm::View<TrajectorySeed> > aSeedCollection = theSeeds[iseed];
      unsigned nSeeds = aSeedCollection->size();
      for (unsigned seednr = 0; seednr < nSeeds; ++seednr) {
        // The seed
        const BasicTrajectorySeed* aSeed = &((*aSeedCollection)[seednr]);

        // The SimTrack id associated to the first hit of the Seed
        int simTrackId = static_cast<FastTrackerRecHit const&>(*aSeed->recHits().begin()).simTrackId(0);

        // Track already associated to a seed
        std::set<unsigned>::iterator tkId = tkIds.find(simTrackId);
        if (tkId != tkIds.end())
          continue;

        const SimTrack& theSimTrack = (*theSimTracks)[simTrackId];

        if (clean(muRef, region.get(), aSeed, theSimTrack))
          tkSeeds.push_back(*aSeed);
        tkIds.insert(simTrackId);

      }  // End loop on seeds

    }  // End loop on seed collections

    // A plot
    // if(h_nSeedPerTrack) h_nSeedPerTrack->Fill(tkSeeds.size());

    // Another plot
    // if(h_nGoodSeedPerTrack) h_nGoodSeedPerTrack->Fill(tkSeeds.size());

    // Now create the Muon Trajectory Seed
    unsigned int is = 0;
    unsigned int isMax = tkSeeds.size();
    for (; is != isMax; ++is) {
      result->push_back(L3MuonTrajectorySeed(tkSeeds[is], muRef));
    }  // End of tk seed loop

  }  // End of l2 muon loop

  // std::cout << "Found " << result->size() << " seeds for muons" << std::endl;

  // And yet another plot
  // if(h_nGoodSeedPerEvent) h_nGoodSeedPerEvent->Fill(result->size());

  //put in the event
  ev.put(std::move(result));
}

Member Data Documentation

theL2CollectionLabel

edm::InputTag FastTSGFromL2Muon::theL2CollectionLabel

private

Definition at line 41 of file FastTSGFromL2Muon.h.

Referenced by FastTSGFromL2Muon(), and produce().

thePtCut

double FastTSGFromL2Muon::thePtCut

private

Definition at line 47 of file FastTSGFromL2Muon.h.

Referenced by FastTSGFromL2Muon(), and produce().

theRegionBuilder

std::unique_ptr<MuonTrackingRegionBuilder> FastTSGFromL2Muon::theRegionBuilder

private

Definition at line 48 of file FastTSGFromL2Muon.h.

Referenced by FastTSGFromL2Muon(), and produce().

theSeedCollectionLabels

std::vector<edm::InputTag> FastTSGFromL2Muon::theSeedCollectionLabels

private

Definition at line 42 of file FastTSGFromL2Muon.h.

Referenced by FastTSGFromL2Muon(), and produce().

theService

MuonServiceProxy* FastTSGFromL2Muon::theService

private

Definition at line 46 of file FastTSGFromL2Muon.h.

theSimTrackCollectionLabel

edm::InputTag FastTSGFromL2Muon::theSimTrackCollectionLabel

private

Definition at line 40 of file FastTSGFromL2Muon.h.

Referenced by FastTSGFromL2Muon(), and produce().