Inheritance diagram for MuonHLTSeedMVAClassifier:

Public Member Functions
	MuonHLTSeedMVAClassifier (const edm::ParameterSet &)

	~MuonHLTSeedMVAClassifier () 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 Types
typedef std::pair < std::unique_ptr< const SeedMvaEstimator > , std::unique_ptr< const SeedMvaEstimator > >	PairSeedMvaEstimator

Private Member Functions
double	getSeedMva (const PairSeedMvaEstimator &pairMvaEstimator, const TrajectorySeed &seed, const GlobalVector &global_p, const l1t::MuonBxCollection &l1Muons, const reco::RecoChargedCandidateCollection &l2Muons)

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

Private Attributes
const double	baseScore_

const bool	doSort_

const double	etaEdge_

const bool	isFromL1_

const edm::EDGetTokenT < l1t::MuonBxCollection >	l1MuonToken_

const edm::EDGetTokenT < reco::RecoChargedCandidateCollection >	l2MuonToken_

const int	minL1Qual_

const double	mvaCutB_

const double	mvaCutE_

PairSeedMvaEstimator	mvaEstimator_

const edm::FileInPath	mvaFileB_

const edm::FileInPath	mvaFileE_

const std::vector< double >	mvaScaleMeanB_

const std::vector< double >	mvaScaleMeanE_

const std::vector< double >	mvaScaleStdB_

const std::vector< double >	mvaScaleStdE_

const int	nSeedsMaxB_

const int	nSeedsMaxE_

const bool	rejectAll_

const edm::EDGetTokenT < TrajectorySeedCollection >	seedToken_

const edm::ESGetToken < TrackerGeometry, TrackerDigiGeometryRecord >	trackerGeometryToken_

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 41 of file MuonHLTSeedMVAClassifier.cc.

Member Typedef Documentation

typedef std::pair<std::unique_ptr<const SeedMvaEstimator>, std::unique_ptr<const SeedMvaEstimator> > MuonHLTSeedMVAClassifier::PairSeedMvaEstimator

private

Definition at line 58 of file MuonHLTSeedMVAClassifier.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 90 of file MuonHLTSeedMVAClassifier.cc.

References isFromL1_, minL1Qual_, mvaEstimator_, mvaFileB_, mvaFileE_, mvaScaleMeanB_, mvaScaleMeanE_, mvaScaleStdB_, mvaScaleStdE_, and rejectAll_.

     : seedToken_(consumes<TrajectorySeedCollection>(iConfig.getParameter<edm::InputTag>("src"))),
       l1MuonToken_(consumes<l1t::MuonBxCollection>(iConfig.getParameter<edm::InputTag>("L1Muon"))),
       l2MuonToken_(consumes<reco::RecoChargedCandidateCollection>(iConfig.getParameter<edm::InputTag>("L2Muon"))),
       trackerGeometryToken_(esConsumes<TrackerGeometry, TrackerDigiGeometryRecord>()),
 
       rejectAll_(iConfig.getParameter<bool>("rejectAll")),
       isFromL1_(iConfig.getParameter<bool>("isFromL1")),
 
       mvaFileB_(iConfig.getParameter<edm::FileInPath>(isFromL1_ ? "mvaFileBL1" : "mvaFileBL2")),
       mvaFileE_(iConfig.getParameter<edm::FileInPath>(isFromL1_ ? "mvaFileEL1" : "mvaFileEL2")),
 
       mvaScaleMeanB_(iConfig.getParameter<std::vector<double>>(isFromL1_ ? "mvaScaleMeanBL1" : "mvaScaleMeanBL2")),
       mvaScaleStdB_(iConfig.getParameter<std::vector<double>>(isFromL1_ ? "mvaScaleStdBL1" : "mvaScaleStdBL2")),
       mvaScaleMeanE_(iConfig.getParameter<std::vector<double>>(isFromL1_ ? "mvaScaleMeanEL1" : "mvaScaleMeanEL2")),
       mvaScaleStdE_(iConfig.getParameter<std::vector<double>>(isFromL1_ ? "mvaScaleStdEL1" : "mvaScaleStdEL2")),
 
       doSort_(iConfig.getParameter<bool>("doSort")),
       nSeedsMaxB_(iConfig.getParameter<int>("nSeedsMaxB")),
       nSeedsMaxE_(iConfig.getParameter<int>("nSeedsMaxE")),
 
       etaEdge_(iConfig.getParameter<double>("etaEdge")),
       mvaCutB_(iConfig.getParameter<double>("mvaCutB")),
       mvaCutE_(iConfig.getParameter<double>("mvaCutE")),
 
       minL1Qual_(iConfig.getParameter<int>("minL1Qual")),
       baseScore_(iConfig.getParameter<double>("baseScore")) {
   if (!rejectAll_) {
     mvaEstimator_ = std::make_pair(
         std::make_unique<SeedMvaEstimator>(mvaFileB_, mvaScaleMeanB_, mvaScaleStdB_, isFromL1_, minL1Qual_),
         std::make_unique<SeedMvaEstimator>(mvaFileE_, mvaScaleMeanE_, mvaScaleStdE_, isFromL1_, minL1Qual_));
   }
 
   produces<TrajectorySeedCollection>();
 }

MuonHLTSeedMVAClassifier::~MuonHLTSeedMVAClassifier ( )

overridedefault

Member Function Documentation

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

static

Definition at line 241 of file MuonHLTSeedMVAClassifier.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, and HLT_FULL_cff::InputTag.

                                                                                           {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("src", edm::InputTag("hltIter2IterL3MuonPixelSeeds", ""));
   desc.add<edm::InputTag>("L1Muon", edm::InputTag("hltGtStage2Digis", "Muon"));
   desc.add<edm::InputTag>("L2Muon", edm::InputTag("hltL2MuonCandidates", ""));
 
   desc.add<bool>("rejectAll", false);
   desc.add<bool>("isFromL1", false);
 
   desc.add<edm::FileInPath>("mvaFileBL1",
                             edm::FileInPath("RecoMuon/TrackerSeedGenerator/data/xgb_Run3_Iter2FromL1Seeds_barrel.xml"));
   desc.add<edm::FileInPath>("mvaFileEL1",
                             edm::FileInPath("RecoMuon/TrackerSeedGenerator/data/xgb_Run3_Iter2FromL1Seeds_endcap.xml"));
   desc.add<edm::FileInPath>("mvaFileBL2",
                             edm::FileInPath("RecoMuon/TrackerSeedGenerator/data/xgb_Run3_Iter2Seeds_barrel.xml"));
   desc.add<edm::FileInPath>("mvaFileEL2",
                             edm::FileInPath("RecoMuon/TrackerSeedGenerator/data/xgb_Run3_Iter2Seeds_endcap.xml"));
   desc.add<std::vector<double>>("mvaScaleMeanBL1", {0., 0., 0., 0., 0., 0., 0., 0.});
   desc.add<std::vector<double>>("mvaScaleStdBL1", {1., 1., 1., 1., 1., 1., 1., 1.});
   desc.add<std::vector<double>>("mvaScaleMeanEL1", {0., 0., 0., 0., 0., 0., 0., 0.});
   desc.add<std::vector<double>>("mvaScaleStdEL1", {1., 1., 1., 1., 1., 1., 1., 1.});
   desc.add<std::vector<double>>("mvaScaleMeanBL2", {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.});
   desc.add<std::vector<double>>("mvaScaleStdBL2", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
   desc.add<std::vector<double>>("mvaScaleMeanEL2", {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.});
   desc.add<std::vector<double>>("mvaScaleStdEL2", {1., 1., 1., 1., 1., 1., 1., 1., 1., 1.});
 
   desc.add<bool>("doSort", false);
   desc.add<int>("nSeedsMaxB", 1e6);
   desc.add<int>("nSeedsMaxE", 1e6);
 
   desc.add<double>("etaEdge", 1.2);
   desc.add<double>("mvaCutB", -1.);
   desc.add<double>("mvaCutE", -1.);
 
   desc.add<int>("minL1Qual", 7);
   desc.add<double>("baseScore", 0.5);
 
   descriptions.add("MuonHLTSeedMVAClassifier", desc);
 }

double MuonHLTSeedMVAClassifier::getSeedMva	(	const PairSeedMvaEstimator &	pairMvaEstimator,
		const TrajectorySeed &	seed,
		const GlobalVector &	global_p,
		const l1t::MuonBxCollection &	l1Muons,
		const reco::RecoChargedCandidateCollection &	l2Muons
	)

private

Definition at line 225 of file MuonHLTSeedMVAClassifier.cc.

References funct::abs(), baseScore_, PV3DBase< T, PVType, FrameType >::eta(), etaEdge_, and beam_dqm_sourceclient-live_cfg::mva.

Referenced by produce().

                                                                                                {
   double mva = 0.;
   if (std::abs(global_p.eta()) < etaEdge_) {
     mva = pairMvaEstimator.first->computeMva(seed, global_p, l1Muons, l2Muons);
   } else {
     mva = pairMvaEstimator.second->computeMva(seed, global_p, l1Muons, l2Muons);
   }
 
   return (mva + baseScore_);
 }

void MuonHLTSeedMVAClassifier::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iEventSetup
	)

overrideprivate

Definition at line 127 of file MuonHLTSeedMVAClassifier.cc.

References funct::abs(), doSort_, PV3DBase< T, PVType, FrameType >::eta(), etaEdge_, funct::exp(), edm::Event::get(), edm::EventSetup::getData(), getSeedMva(), mps_fire::i, TrackerGeometry::idToDet(), l1MuonToken_, l2MuonToken_, eostools::move(), beam_dqm_sourceclient-live_cfg::mva, mvaCutB_, mvaCutE_, mvaEstimator_, nSeedsMaxB_, nSeedsMaxE_, edm::Event::put(), rejectAll_, mps_fire::result, fileCollector::seed, DetachedQuadStep_cff::seeds, seedToken_, sortByMvaScore(), GeomDet::toGlobal(), and trackerGeometryToken_.

                                                                                          {
   auto result = std::make_unique<TrajectorySeedCollection>();
 
   if (rejectAll_) {
     iEvent.put(std::move(result));
     return;
   }
 
   if (doSort_ && nSeedsMaxB_ <= 0 && nSeedsMaxE_ <= 0) {
     iEvent.put(std::move(result));
     return;
   }
 
   if (!doSort_ && mvaCutB_ > 1. && mvaCutE_ > 1.) {
     iEvent.put(std::move(result));
     return;
   }
 
   const TrajectorySeedCollection& seeds = iEvent.get(seedToken_);
   const l1t::MuonBxCollection& l1Muons = iEvent.get(l1MuonToken_);
   const reco::RecoChargedCandidateCollection& l2Muons = iEvent.get(l2MuonToken_);
   const TrackerGeometry& trkGeom = iEventSetup.getData(trackerGeometryToken_);
 
   std::vector<std::pair<unsigned, double>> pairSeedIdxMvaScoreB = {};
   std::vector<std::pair<unsigned, double>> pairSeedIdxMvaScoreE = {};
   for (auto& seed : seeds) {
     const GlobalVector global_p =
         trkGeom.idToDet(seed.startingState().detId())->surface().toGlobal(seed.startingState().parameters().momentum());
 
     bool isB = (std::abs(global_p.eta()) < etaEdge_);
 
     if (doSort_) {
       if (isB) {
         if (nSeedsMaxB_ <= 0) {
           continue;
         }
       } else {
         if (nSeedsMaxE_ <= 0) {
           continue;
         }
       }
     } else {
       if (isB) {
         if (mvaCutB_ > 1.0) {
           continue;
         } else if (mvaCutB_ <= 0.) {
           result->emplace_back(seed);
           continue;
         }
       } else {
         if (mvaCutE_ > 1.0) {
           continue;
         } else if (mvaCutE_ <= 0.) {
           result->emplace_back(seed);
           continue;
         }
       }
     }
 
     double mva = getSeedMva(mvaEstimator_, seed, global_p, l1Muons, l2Muons);
 
     double score = 1. / (1. + std::exp(-1. * mva));
     bool passMva = isB ? score > mvaCutB_ : score > mvaCutE_;
     if (!passMva)
       continue;
 
     if (doSort_) {
       if (isB)
         pairSeedIdxMvaScoreB.push_back(std::make_pair(&seed - &seeds.at(0), score));
       else
         pairSeedIdxMvaScoreE.push_back(std::make_pair(&seed - &seeds.at(0), score));
     } else {
       result->emplace_back(seed);
     }
   }
 
   if (doSort_) {
     std::sort(pairSeedIdxMvaScoreB.begin(), pairSeedIdxMvaScoreB.end(), sortByMvaScore);
     std::sort(pairSeedIdxMvaScoreE.begin(), pairSeedIdxMvaScoreE.end(), sortByMvaScore);
 
     for (auto i = 0U; i < pairSeedIdxMvaScoreB.size(); ++i) {
       if ((int)i == nSeedsMaxB_)
         break;
       const auto& seed(seeds.at(pairSeedIdxMvaScoreB.at(i).first));
       result->emplace_back(seed);
     }
 
     for (auto i = 0U; i < pairSeedIdxMvaScoreE.size(); ++i) {
       if ((int)i == nSeedsMaxE_)
         break;
       const auto& seed(seeds.at(pairSeedIdxMvaScoreE.at(i).first));
       result->emplace_back(seed);
     }
   }
 
   iEvent.put(std::move(result));
 }