Inheritance diagram for MuonHLTSeedMVAClassifier:

Public Member Functions
bool	checkMVAFileConsistency (const std::string &weightsFileFullPath, bool isFromL1) const

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

Member Typedef Documentation

◆ PairSeedMvaEstimator

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

private

Definition at line 62 of file MuonHLTSeedMVAClassifier.cc.

Constructor & Destructor Documentation

◆ MuonHLTSeedMVAClassifier()

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

explicit

Definition at line 126 of file MuonHLTSeedMVAClassifier.cc.

References checkMVAFileConsistency(), Exception, edm::FileInPath::fullPath(), 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>("mvaFileB")),
       mvaFileE_(iConfig.getParameter<edm::FileInPath>("mvaFileE")),
       mvaScaleMeanB_(iConfig.getParameter<std::vector<double>>("mvaScaleMeanB")),
       mvaScaleStdB_(iConfig.getParameter<std::vector<double>>("mvaScaleStdB")),
       mvaScaleMeanE_(iConfig.getParameter<std::vector<double>>("mvaScaleMeanE")),
       mvaScaleStdE_(iConfig.getParameter<std::vector<double>>("mvaScaleStdE")),
       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")) {
   const auto& mvaFileBPath = mvaFileB_.fullPath();
   const auto& mvaFileEPath = mvaFileE_.fullPath();
 
   if (!checkMVAFileConsistency(mvaFileBPath, isFromL1_) || !checkMVAFileConsistency(mvaFileEPath, isFromL1_)) {
     throw cms::Exception("ConfigurationError") << " MVA files appear to be not consistent with the value of isFromL1 "
                                                   "parameter.\n Please check your configuration.";
   }
 
   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::~MuonHLTSeedMVAClassifier ( )

overridedefault

Member Function Documentation

◆ checkMVAFileConsistency()

bool MuonHLTSeedMVAClassifier::checkMVAFileConsistency	(	const std::string &	weightsFileFullPath,
		bool	isFromL1
	)		const

Definition at line 94 of file MuonHLTSeedMVAClassifier.cc.

References MillePedeFileConverter_cfg::e, reco::details::hasEnding(), HLT_2024v14_cff::isFromL1, LogTrace, and dqmiodumpmetadata::n.

Referenced by MuonHLTSeedMVAClassifier().

                                                                                   {
   tinyxml2::XMLDocument xmlDoc;
   if (reco::details::hasEnding(weightsFileFullPath, ".xml")) {
     xmlDoc.LoadFile(weightsFileFullPath.c_str());
   } else {
     edm::LogError("MuonHLTSeedMVAClassifier") << "unsupported file extension, it should be a .xml file!";
     return false;
   }
   tinyxml2::XMLElement* root = xmlDoc.FirstChildElement("MethodSetup");
   if (root == nullptr) {
     edm::LogError("MuonHLTSeedMVAClassifier") << "could not retrieve the MethodSetup node from XML file!";
     return false;
   }
 
   const auto& vars = root->FirstChildElement("Variables");
   size_t n = 0;
   if (vars != nullptr) {
     for (tinyxml2::XMLElement* e = vars->FirstChildElement("Variable"); e != nullptr;
          e = e->NextSiblingElement("Variable")) {
       ++n;
     }
   } else {
     edm::LogError("MuonHLTSeedMVAClassifier") << "could not retrieve the Variables node from XML file!";
     return false;
   }
 
   LogTrace("MuonHLTSeedMVAClassifier") << "MVA file:" << weightsFileFullPath.c_str() << " n Var:" << n;
   bool condition = (isFromL1 && (n == inputIndexes::kLastL1)) || (!isFromL1 && (n == inputIndexes::kLastL2));
   return condition;
 }

◆ fillDescriptions()

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

static

Definition at line 279 of file MuonHLTSeedMVAClassifier.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and ProducerED_cfi::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>("mvaFileB",
                             edm::FileInPath("RecoMuon/TrackerSeedGenerator/data/xgb_Run3_Iter2FromL1Seeds_barrel.xml"));
   desc.add<edm::FileInPath>("mvaFileE",
                             edm::FileInPath("RecoMuon/TrackerSeedGenerator/data/xgb_Run3_Iter2FromL1Seeds_endcap.xml"));
   desc.add<std::vector<double>>("mvaScaleMeanB", {0., 0., 0., 0., 0., 0., 0., 0.});
   desc.add<std::vector<double>>("mvaScaleStdB", {1., 1., 1., 1., 1., 1., 1., 1.});
   desc.add<std::vector<double>>("mvaScaleMeanE", {0., 0., 0., 0., 0., 0., 0., 0.});
   desc.add<std::vector<double>>("mvaScaleStdE", {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);
 }

◆ getSeedMva()

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

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

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_);
 }

◆ produce()

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

overrideprivate

Definition at line 165 of file MuonHLTSeedMVAClassifier.cc.

References funct::abs(), doSort_, PV3DBase< T, PVType, FrameType >::eta(), etaEdge_, JetChargeProducer_cfi::exp, edm::EventSetup::getData(), getSeedMva(), mps_fire::i, TrackerGeometry::idToDet(), iEvent, l1MuonToken_, l2MuonToken_, eostools::move(), beam_dqm_sourceclient-live_cfg::mva, mvaCutB_, mvaCutE_, mvaEstimator_, nSeedsMaxB_, nSeedsMaxE_, rejectAll_, mps_fire::result, offlineSlimmedPrimaryVertices_cfi::score, fileCollector::seed, HLT_2024v14_cff::seeds, seedToken_, jetUpdater_cfi::sort, sortByMvaScore(), GeomDet::toGlobal(), trackerGeometryToken_, and mitigatedMETSequence_cff::U.

                                                                                          {
   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));
 }