Inheritance diagram for L2MuonProducer:

Public Member Functions
	L2MuonProducer (const edm::ParameterSet &)
	constructor with config More...

void	produce (edm::Event &, const edm::EventSetup &) override
	reconstruct muons More...

	~L2MuonProducer () override
	destructor More...

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 Attributes
edm::EDGetTokenT< edm::View< TrajectorySeed > >	seedsToken

edm::InputTag	theSeedCollectionLabel

std::unique_ptr< MuonServiceProxy >	theService
	the event setup proxy, it takes care the services update More...

std::unique_ptr< MuonTrackFinder >	theTrackFinder
	the track finder More...

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

L2 muon reconstructor: reconstructs muons using DT, CSC and RPC information,
starting from internal seeds (L2 muon track segments).

Author: R.Bellan - INFN TO

modified by A. Sharma to add fillDescription function

Definition at line 45 of file L2MuonProducer.cc.

Constructor & Destructor Documentation

◆ L2MuonProducer()

L2MuonProducer::L2MuonProducer ( const edm::ParameterSet & parameterSet )

constructor with config

Definition at line 71 of file L2MuonProducer.cc.

References edm::ParameterSet::getParameter(), LogTrace, eostools::move(), edm::parameterSet(), seedsToken, theSeedCollectionLabel, theService, and theTrackFinder.

                                                                   {
   LogTrace("Muon|RecoMuon|L2MuonProducer") << "constructor called" << endl;
 
   // Parameter set for the Builder
   edm::ParameterSet trajectoryBuilderParameters =
       parameterSet.getParameter<edm::ParameterSet>("L2TrajBuilderParameters");
 
   // MuonSeed Collection Label
   theSeedCollectionLabel = parameterSet.getParameter<edm::InputTag>("InputObjects");
   seedsToken = consumes<edm::View<TrajectorySeed>>(theSeedCollectionLabel);
   // service parameters
   edm::ParameterSet serviceParameters = parameterSet.getParameter<edm::ParameterSet>("ServiceParameters");
 
   // TrackLoader parameters
   edm::ParameterSet trackLoaderParameters = parameterSet.getParameter<edm::ParameterSet>("TrackLoaderParameters");
 
   // the services
   theService = std::make_unique<MuonServiceProxy>(serviceParameters, consumesCollector());
 
   std::unique_ptr<MuonTrajectoryBuilder> trajectoryBuilder = nullptr;
   // instantiate the concrete trajectory builder in the Track Finder
 
   edm::ConsumesCollector iC = consumesCollector();
   string typeOfBuilder = parameterSet.getParameter<string>("MuonTrajectoryBuilder");
   if (typeOfBuilder == "StandAloneMuonTrajectoryBuilder" || typeOfBuilder.empty())
     trajectoryBuilder =
         std::make_unique<StandAloneMuonTrajectoryBuilder>(trajectoryBuilderParameters, theService.get(), iC);
   else if (typeOfBuilder == "Exhaustive")
     trajectoryBuilder =
         std::make_unique<ExhaustiveMuonTrajectoryBuilder>(trajectoryBuilderParameters, theService.get(), iC);
   else {
     edm::LogWarning("Muon|RecoMuon|StandAloneMuonProducer")
         << "No Trajectory builder associated with " << typeOfBuilder
         << ". Falling down to the default (StandAloneMuonTrajectoryBuilder)";
     trajectoryBuilder =
         std::make_unique<StandAloneMuonTrajectoryBuilder>(trajectoryBuilderParameters, theService.get(), iC);
   }
   theTrackFinder =
       std::make_unique<MuonTrackFinder>(std::move(trajectoryBuilder),
                                         std::make_unique<MuonTrackLoader>(trackLoaderParameters, iC, theService.get()),
                                         std::make_unique<MuonTrajectoryCleaner>(true),
                                         iC);
 
   produces<TrackingRecHitCollection>();
   produces<reco::TrackExtraCollection>();
   // TrackCollection refers to TrackingRechit and TrackExtra
   // collections, need to declare its production after them to work
   // around a rare race condition in framework scheduling
   produces<reco::TrackCollection>();
   produces<reco::TrackCollection>("UpdatedAtVtx");
   produces<reco::TrackToTrackMap>();
 
   produces<std::vector<Trajectory>>();
   produces<TrajTrackAssociationCollection>();
 
   produces<edm::AssociationMap<edm::OneToMany<std::vector<L2MuonTrajectorySeed>, std::vector<L2MuonTrajectorySeed>>>>();
 }

◆ ~L2MuonProducer()

L2MuonProducer::~L2MuonProducer ( )

override

destructor

Definition at line 130 of file L2MuonProducer.cc.

References LogTrace.

                                 {
   LogTrace("Muon|RecoMuon|L2eMuonProducer") << "L2MuonProducer destructor called" << endl;
 }

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 158 of file L2MuonProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), submitPVResolutionJobs::desc, HLT_2022v14_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                 {
   edm::ParameterSetDescription desc;
   {
     edm::ParameterSetDescription psd0;
     psd0.addUntracked<std::vector<std::string>>("Propagators",
                                                 {
                                                     "hltESPFastSteppingHelixPropagatorAny"
                                                     "hltESPFastSteppingHelixPropagatorOpposite",
                                                 });
     psd0.add<bool>("RPCLayers", true);
     psd0.addUntracked<bool>("UseMuonNavigation", true);
     desc.add<edm::ParameterSetDescription>("ServiceParameters", psd0);
   }
 
   desc.add<edm::InputTag>("InputObjects", edm::InputTag("hltL2MuonSeeds"));
   {
     edm::ParameterSetDescription psd0;
     psd0.add<std::string>("Fitter", "hltESPKFFittingSmootherForL2Muon");
     psd0.add<std::string>("MuonRecHitBuilder", "hltESPMuonTransientTrackingRecHitBuilder");
     psd0.add<unsigned int>("NMinRecHits", 2);
     psd0.add<bool>("UseSubRecHits", false);
     psd0.add<std::string>("Propagator", "hltESPFastSteppingHelixPropagatorAny");
     psd0.add<double>("RescaleError", 100.0);
     desc.add<edm::ParameterSetDescription>("SeedTransformerParameters", psd0);
   }
 
   {
     edm::ParameterSetDescription psd0;
     psd0.add<bool>("DoRefit", false);
     psd0.add<std::string>("SeedPropagator", "hltESPFastSteppingHelixPropagatorAny");
     {
       edm::ParameterSetDescription psd1;
       psd1.add<double>("NumberOfSigma", 3.0);
       psd1.add<std::string>("FitDirection", "insideOut");
       psd1.add<edm::InputTag>("DTRecSegmentLabel", edm::InputTag("hltDt4DSegments"));
       psd1.add<double>("MaxChi2", 1000.0);
       {
         edm::ParameterSetDescription psd2;
         psd2.add<double>("MaxChi2", 25.0);
         psd2.add<double>("RescaleErrorFactor", 100.0);
         psd2.add<int>("Granularity", 0);
         psd2.add<bool>("ExcludeRPCFromFit", false);
         psd2.add<bool>("UseInvalidHits", true);
         psd2.add<bool>("RescaleError", false);
         psd1.add<edm::ParameterSetDescription>("MuonTrajectoryUpdatorParameters", psd2);
       }
       psd1.add<bool>("EnableRPCMeasurement", true);
       psd1.add<edm::InputTag>("CSCRecSegmentLabel", edm::InputTag("hltCscSegments"));
       psd1.add<bool>("EnableDTMeasurement", true);
       psd1.add<edm::InputTag>("RPCRecSegmentLabel", edm::InputTag("hltRpcRecHits"));
       psd1.add<std::string>("Propagator", "hltESPFastSteppingHelixPropagatorAny");
       psd1.add<bool>("EnableGEMMeasurement", false);
       psd1.add<edm::InputTag>("GEMRecSegmentLabel", edm::InputTag("gemRecHits"));
       psd1.add<bool>("EnableME0Measurement", false);
       psd1.add<edm::InputTag>("ME0RecSegmentLabel", edm::InputTag("me0Segments"));
       psd1.add<bool>("EnableCSCMeasurement", true);
       psd0.add<edm::ParameterSetDescription>("FilterParameters", psd1);
     }
     psd0.add<std::string>("NavigationType", "Standard");
     {
       edm::ParameterSetDescription psd1;
       psd1.add<std::string>("Fitter", "hltESPKFFittingSmootherForL2Muon");
       psd1.add<std::string>("MuonRecHitBuilder", "hltESPMuonTransientTrackingRecHitBuilder");
       psd1.add<unsigned int>("NMinRecHits", 2);
       psd1.add<bool>("UseSubRecHits", false);
       psd1.add<std::string>("Propagator", "hltESPFastSteppingHelixPropagatorAny");
       psd1.add<double>("RescaleError", 100.0);
       psd0.add<edm::ParameterSetDescription>("SeedTransformerParameters", psd1);
     }
     psd0.add<bool>("DoBackwardFilter", true);
     psd0.add<std::string>("SeedPosition", "in");
     {
       edm::ParameterSetDescription psd1;
       psd1.add<double>("NumberOfSigma", 3.0);
       psd1.add<edm::InputTag>("CSCRecSegmentLabel", edm::InputTag("hltCscSegments"));
       psd1.add<std::string>("FitDirection", "outsideIn");
       psd1.add<edm::InputTag>("DTRecSegmentLabel", edm::InputTag("hltDt4DSegments"));
       psd1.add<double>("MaxChi2", 100.0);
       {
         edm::ParameterSetDescription psd2;
         psd2.add<double>("MaxChi2", 25.0);
         psd2.add<double>("RescaleErrorFactor", 100.0);
         psd2.add<int>("Granularity", 0);
         psd2.add<bool>("ExcludeRPCFromFit", false);
         psd2.add<bool>("UseInvalidHits", true);
         psd2.add<bool>("RescaleError", false);
         psd1.add<edm::ParameterSetDescription>("MuonTrajectoryUpdatorParameters", psd2);
       }
       psd1.add<bool>("EnableRPCMeasurement", true);
       psd1.add<std::string>("BWSeedType", "fromGenerator");
       psd1.add<bool>("EnableDTMeasurement", true);
       psd1.add<edm::InputTag>("RPCRecSegmentLabel", edm::InputTag("hltRpcRecHits"));
       psd1.add<std::string>("Propagator", "hltESPFastSteppingHelixPropagatorAny");
       psd1.add<bool>("EnableGEMMeasurement", false);
       psd1.add<edm::InputTag>("GEMRecSegmentLabel", edm::InputTag("gemRecHits"));
       psd1.add<bool>("EnableME0Measurement", false);
       psd1.add<edm::InputTag>("ME0RecSegmentLabel", edm::InputTag("me0Segments"));
       psd1.add<bool>("EnableCSCMeasurement", true);
       psd0.add<edm::ParameterSetDescription>("BWFilterParameters", psd1);
     }
     psd0.add<bool>("DoSeedRefit", false);
     desc.add<edm::ParameterSetDescription>("L2TrajBuilderParameters", psd0);
   }
   desc.add<bool>("DoSeedRefit", false);
   {
     edm::ParameterSetDescription psd0;
     psd0.add<std::string>("Smoother", "hltESPKFTrajectorySmootherForMuonTrackLoader");
     psd0.add<bool>("DoSmoothing", false);
     psd0.add<edm::InputTag>("beamSpot", edm::InputTag("hltOnlineBeamSpot"));
     {
       edm::ParameterSetDescription psd1;
       psd1.add<double>("MaxChi2", 1000000.0);
       psd1.add<std::vector<double>>("BeamSpotPosition",
                                     {
                                         0.0,
                                         0.0,
                                         0.0,
                                     });
       psd1.add<std::string>("Propagator", "hltESPFastSteppingHelixPropagatorOpposite");
       psd1.add<std::vector<double>>("BeamSpotPositionErrors",
                                     {
                                         0.1,
                                         0.1,
                                         5.3,
                                     });
       psd0.add<edm::ParameterSetDescription>("MuonUpdatorAtVertexParameters", psd1);
     }
     psd0.add<bool>("VertexConstraint", true);
     psd0.add<std::string>("TTRHBuilder", "hltESPTTRHBWithTrackAngle");
     desc.add<edm::ParameterSetDescription>("TrackLoaderParameters", psd0);
   }
   desc.add<std::string>("MuonTrajectoryBuilder", "Exhaustive");
   descriptions.add("L2MuonProducer", desc);
 }

◆ produce()

void L2MuonProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

override

reconstruct muons

Definition at line 135 of file L2MuonProducer.cc.

References options_cfi::eventSetup, edm::InputTag::label(), LogTrace, metname, DetachedQuadStep_cff::seeds, seedsToken, AlCaHLTBitMon_QueryRunRegistry::string, theSeedCollectionLabel, theService, and theTrackFinder.

                                                                              {
   const std::string metname = "Muon|RecoMuon|L2MuonProducer";
 
   LogTrace(metname) << endl << endl << endl;
   LogTrace(metname) << "L2 Muon Reconstruction Started" << endl;
 
   // Take the seeds container
   LogTrace(metname) << "Taking the seeds: " << theSeedCollectionLabel.label() << endl;
   edm::Handle<edm::View<TrajectorySeed>> seeds;
   event.getByToken(seedsToken, seeds);
 
   // Update the services
   theService->update(eventSetup);
 
   // Reconstruct
   LogTrace(metname) << "Track Reconstruction" << endl;
   theTrackFinder->reconstruct(seeds, event, eventSetup);
 
   LogTrace(metname) << "edm::Event loaded"
                     << "================================" << endl
                     << endl;
 }