Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2022-03-31 23:46:04

0001 #include "FWCore/Framework/interface/Frameworkfwd.h"
0002 #include "FWCore/Framework/interface/MakerMacros.h"
0003 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0004 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0005 #include "DQMServices/Core/interface/DQMStore.h"
0006 #include "DQMServices/Core/interface/DQMEDAnalyzer.h"
0007 #include "DQMOffline/Trigger/plugins/TriggerDQMBase.h"
0008 #include "CommonTools/TriggerUtils/interface/GenericTriggerEventFlag.h"
0009 #include "CommonTools/Utils/interface/StringCutObjectSelector.h"
0010 #include "DataFormats/METReco/interface/CaloMET.h"
0011 #include "DataFormats/METReco/interface/CaloMETCollection.h"
0012 #include "DataFormats/MuonReco/interface/Muon.h"
0013 #include "DataFormats/MuonReco/interface/MuonFwd.h"
0014 #include "DataFormats/MuonReco/interface/MuonSelectors.h"
0015 #include "DataFormats/JetReco/interface/PFJet.h"
0016 #include "DataFormats/JetReco/interface/PFJetCollection.h"
0017 #include "DataFormats/HLTReco/interface/TriggerObject.h"
0018 #include "DataFormats/HLTReco/interface/TriggerEvent.h"
0019 #include "DataFormats/VertexReco/interface/Vertex.h"
0020 #include "DataFormats/VertexReco/interface/VertexFwd.h"
0021 #include "DataFormats/Math/interface/deltaR.h"
0022 
0023 class METplusTrackMonitor : public DQMEDAnalyzer, public TriggerDQMBase {
0024 public:
0025   typedef dqm::reco::MonitorElement MonitorElement;
0026   typedef dqm::reco::DQMStore DQMStore;
0027 
0028   METplusTrackMonitor(const edm::ParameterSet&);
0029   ~METplusTrackMonitor() noexcept(true) override {}
0030   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0031 
0032 protected:
0033   void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override;
0034   void analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) override;
0035 
0036 private:
0037   bool getHLTObj(const edm::Handle<trigger::TriggerEvent>& trigSummary,
0038                  const edm::InputTag& filterTag,
0039                  trigger::TriggerObject& obj) const;
0040 
0041   const std::string folderName_;
0042 
0043   const bool requireValidHLTPaths_;
0044   bool hltPathsAreValid_;
0045 
0046   edm::EDGetTokenT<reco::CaloMETCollection> metToken_;
0047   edm::EDGetTokenT<reco::MuonCollection> muonToken_;
0048   edm::EDGetTokenT<reco::PFJetCollection> jetToken_;
0049   edm::EDGetTokenT<reco::VertexCollection> vtxToken_;
0050   edm::EDGetTokenT<trigger::TriggerEvent> theTrigSummary_;
0051 
0052   edm::InputTag hltMetTag_;
0053   edm::InputTag trackLegFilterTag_;
0054 
0055   std::vector<double> met_variable_binning_;
0056   std::vector<double> muonPt_variable_binning_;
0057 
0058   MEbinning met_binning_;
0059   MEbinning ls_binning_;
0060   MEbinning pt_binning_;
0061   MEbinning eta_binning_;
0062   MEbinning phi_binning_;
0063 
0064   ObjME metME_variableBinning_;
0065   ObjME metVsLS_;
0066   ObjME metPhiME_;
0067   ObjME deltaphimetj1ME_;
0068   ObjME metVsHltMet_;
0069 
0070   ObjME muonPtME_variableBinning_;
0071   ObjME muonPtVsLS_;
0072   ObjME muonEtaME_;
0073   ObjME deltaphimetmuonME_;
0074   ObjME muonEtaVsPhi_;
0075 
0076   std::unique_ptr<GenericTriggerEventFlag> num_genTriggerEventFlag_;
0077   std::unique_ptr<GenericTriggerEventFlag> den_genTriggerEventFlag_;
0078 
0079   StringCutObjectSelector<reco::CaloMET, true> metSelection_;
0080   StringCutObjectSelector<reco::Muon, true> muonSelection_;
0081   StringCutObjectSelector<reco::PFJet, true> jetSelection_;
0082   StringCutObjectSelector<reco::Vertex, true> vtxSelection_;
0083 
0084   unsigned nmuons_;
0085   unsigned njets_;
0086 
0087   double leadJetEtaCut_;
0088 
0089   bool requireLeadMatched_;
0090   double maxMatchDeltaR_;
0091 };
0092 
0093 METplusTrackMonitor::METplusTrackMonitor(const edm::ParameterSet& iConfig)
0094     : folderName_(iConfig.getParameter<std::string>("FolderName")),
0095       requireValidHLTPaths_(iConfig.getParameter<bool>("requireValidHLTPaths")),
0096       hltPathsAreValid_(false),
0097       metToken_(consumes<reco::CaloMETCollection>(iConfig.getParameter<edm::InputTag>("met"))),
0098       muonToken_(consumes<reco::MuonCollection>(iConfig.getParameter<edm::InputTag>("muons"))),
0099       jetToken_(consumes<reco::PFJetCollection>(iConfig.getParameter<edm::InputTag>("jets"))),
0100       vtxToken_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertices"))),
0101       theTrigSummary_(consumes<trigger::TriggerEvent>(iConfig.getParameter<edm::InputTag>("trigSummary"))),
0102       hltMetTag_(iConfig.getParameter<edm::InputTag>("hltMetFilter")),
0103       trackLegFilterTag_(iConfig.getParameter<edm::InputTag>("trackLegFilter")),
0104       met_variable_binning_(
0105           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("metBinning")),
0106       muonPt_variable_binning_(
0107           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("ptBinning")),
0108       met_binning_(getHistoPSet(
0109           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("metPSet"))),
0110       ls_binning_(
0111           getHistoPSet(iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("lsPSet"))),
0112       pt_binning_(
0113           getHistoPSet(iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("ptPSet"))),
0114       eta_binning_(getHistoPSet(
0115           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("etaPSet"))),
0116       phi_binning_(getHistoPSet(
0117           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("phiPSet"))),
0118       num_genTriggerEventFlag_(new GenericTriggerEventFlag(
0119           iConfig.getParameter<edm::ParameterSet>("numGenericTriggerEventPSet"), consumesCollector(), *this)),
0120       den_genTriggerEventFlag_(new GenericTriggerEventFlag(
0121           iConfig.getParameter<edm::ParameterSet>("denGenericTriggerEventPSet"), consumesCollector(), *this)),
0122       metSelection_(iConfig.getParameter<std::string>("metSelection")),
0123       muonSelection_(iConfig.getParameter<std::string>("muonSelection")),
0124       jetSelection_(iConfig.getParameter<std::string>("jetSelection")),
0125       vtxSelection_(iConfig.getParameter<std::string>("vtxSelection")),
0126       nmuons_(iConfig.getParameter<unsigned>("nmuons")),
0127       njets_(iConfig.getParameter<unsigned>("njets")),
0128       leadJetEtaCut_(iConfig.getParameter<double>("leadJetEtaCut")),
0129       requireLeadMatched_(iConfig.getParameter<bool>("requireLeadMatched")),
0130       maxMatchDeltaR_(iConfig.getParameter<double>("maxMatchDeltaR")) {}
0131 
0132 void METplusTrackMonitor::bookHistograms(DQMStore::IBooker& ibooker,
0133                                          edm::Run const& iRun,
0134                                          edm::EventSetup const& iSetup) {
0135   // Initialize the GenericTriggerEventFlag
0136   if (num_genTriggerEventFlag_ && num_genTriggerEventFlag_->on()) {
0137     num_genTriggerEventFlag_->initRun(iRun, iSetup);
0138   }
0139   if (den_genTriggerEventFlag_ && den_genTriggerEventFlag_->on()) {
0140     den_genTriggerEventFlag_->initRun(iRun, iSetup);
0141   }
0142 
0143   // check if every HLT path specified in numerator and denominator has a valid match in the HLT Menu
0144   hltPathsAreValid_ = (num_genTriggerEventFlag_ && den_genTriggerEventFlag_ && num_genTriggerEventFlag_->on() &&
0145                        den_genTriggerEventFlag_->on() && num_genTriggerEventFlag_->allHLTPathsAreValid() &&
0146                        den_genTriggerEventFlag_->allHLTPathsAreValid());
0147 
0148   // if valid HLT paths are required,
0149   // create DQM outputs only if all paths are valid
0150   if (requireValidHLTPaths_ and (not hltPathsAreValid_)) {
0151     return;
0152   }
0153 
0154   std::string histname, histtitle;
0155 
0156   std::string currentFolder = folderName_;
0157   ibooker.setCurrentFolder(currentFolder);
0158 
0159   // MET leg histograms
0160   histname = "met_variable";
0161   histtitle = "CaloMET";
0162   bookME(ibooker, metME_variableBinning_, histname, histtitle, met_variable_binning_);
0163   setMETitle(metME_variableBinning_, "CaloMET [GeV]", "events / [GeV]");
0164 
0165   histname = "metVsLS";
0166   histtitle = "CaloMET vs LS";
0167   bookME(ibooker,
0168          metVsLS_,
0169          histname,
0170          histtitle,
0171          ls_binning_.nbins,
0172          ls_binning_.xmin,
0173          ls_binning_.xmax,
0174          met_binning_.xmin,
0175          met_binning_.xmax);
0176   setMETitle(metVsLS_, "LS", "CaloMET [GeV]");
0177 
0178   histname = "metPhi";
0179   histtitle = "CaloMET phi";
0180   bookME(ibooker, metPhiME_, histname, histtitle, phi_binning_.nbins, phi_binning_.xmin, phi_binning_.xmax);
0181   setMETitle(metPhiME_, "CaloMET #phi", "events / 0.2 rad");
0182 
0183   histname = "deltaphi_metjet1";
0184   histtitle = "dPhi(CaloMET, jet1)";
0185   bookME(ibooker, deltaphimetj1ME_, histname, histtitle, phi_binning_.nbins, 0, phi_binning_.xmax);
0186   setMETitle(deltaphimetj1ME_, "#Delta#phi (CaloMET, j1)", "events / 0.1 rad");
0187 
0188   histname = "metVsHltMet";
0189   histtitle = "CaloMET vs hltMet";
0190   bookME(ibooker,
0191          metVsHltMet_,
0192          histname,
0193          histtitle,
0194          met_binning_.nbins,
0195          met_binning_.xmin,
0196          met_binning_.xmax,
0197          met_binning_.nbins,
0198          met_binning_.xmin,
0199          met_binning_.xmax);
0200   setMETitle(metVsHltMet_, "hltMet (online) [GeV]", "CaloMET (offline) [GeV]");
0201 
0202   // Track leg histograms
0203 
0204   histname = "muonPt_variable";
0205   histtitle = "Muon PT";
0206   bookME(ibooker, muonPtME_variableBinning_, histname, histtitle, muonPt_variable_binning_);
0207   setMETitle(muonPtME_variableBinning_, "Muon p_{T} [GeV]", "events / [GeV]");
0208 
0209   histname = "muonEta";
0210   histtitle = "Muon eta";
0211   bookME(ibooker, muonEtaME_, histname, histtitle, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax);
0212   setMETitle(muonEtaME_, "Muon #eta", "events / 0.2");
0213 
0214   histname = "deltaphi_muonmet";
0215   histtitle = "dPhi(Muon, CaloMET)";
0216   bookME(ibooker, deltaphimetmuonME_, histname, histtitle, phi_binning_.nbins, 0, phi_binning_.xmax);
0217   setMETitle(deltaphimetmuonME_, "#Delta#phi (Muon, CaloMET)", "events / 0.1 rad");
0218 
0219   histname = "muonEtaVsPhi";
0220   histtitle = "Muon eta vs phi";
0221   bookME(ibooker,
0222          muonEtaVsPhi_,
0223          histname,
0224          histtitle,
0225          phi_binning_.nbins,
0226          phi_binning_.xmin,
0227          phi_binning_.xmax,
0228          eta_binning_.nbins,
0229          eta_binning_.xmin,
0230          eta_binning_.xmax);
0231   setMETitle(muonEtaVsPhi_, "Muon #phi", "Muon #eta");
0232 
0233   histname = "muonPtVsLS";
0234   histtitle = "Muon PT vs LS";
0235   bookME(ibooker,
0236          muonPtVsLS_,
0237          histname,
0238          histtitle,
0239          ls_binning_.nbins,
0240          ls_binning_.xmin,
0241          ls_binning_.xmax,
0242          pt_binning_.xmin,
0243          pt_binning_.xmax);
0244   setMETitle(muonPtVsLS_, "LS", "Muon p_{T} [GeV]");
0245 }
0246 
0247 void METplusTrackMonitor::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) {
0248   // if valid HLT paths are required,
0249   // analyze event only if all paths are valid
0250   if (requireValidHLTPaths_ and (not hltPathsAreValid_)) {
0251     return;
0252   }
0253 
0254   // Filter out events if Trigger Filtering is requested
0255   if (den_genTriggerEventFlag_->on() && !den_genTriggerEventFlag_->accept(iEvent, iSetup))
0256     return;
0257 
0258   edm::Handle<reco::CaloMETCollection> metHandle;
0259   iEvent.getByToken(metToken_, metHandle);
0260   reco::CaloMET caloMet = metHandle->front();
0261   if (!metSelection_(caloMet))
0262     return;
0263 
0264   float met = caloMet.pt();
0265   float metPhi = caloMet.phi();
0266 
0267   edm::Handle<reco::PFJetCollection> jetsHandle;
0268   iEvent.getByToken(jetToken_, jetsHandle);
0269   if (jetsHandle->size() < njets_)
0270     return;
0271   std::vector<reco::PFJet> jets;
0272   for (auto const& j : *jetsHandle) {
0273     if (jetSelection_(j))
0274       jets.push_back(j);
0275   }
0276   if (jets.size() < njets_)
0277     return;
0278   if (njets_ > 0 && !(jets.empty()) && fabs(jets[0].eta()) > leadJetEtaCut_)
0279     return;
0280   float deltaphi_metjet1 = !(jets.empty()) ? fabs(deltaPhi(caloMet.phi(), jets[0].phi())) : 10.0;
0281 
0282   edm::Handle<reco::VertexCollection> primaryVertices;
0283   iEvent.getByToken(vtxToken_, primaryVertices);
0284   if (primaryVertices->empty())
0285     return;
0286   const reco::Vertex* pv = nullptr;
0287   for (auto const& v : *primaryVertices) {
0288     if (!vtxSelection_(v))
0289       continue;
0290     pv = &v;
0291     break;
0292   }
0293   if (pv == nullptr)
0294     return;
0295 
0296   edm::Handle<reco::MuonCollection> muonHandle;
0297   iEvent.getByToken(muonToken_, muonHandle);
0298   if (muonHandle->size() < nmuons_)
0299     return;
0300   std::vector<reco::Muon> muons;
0301   for (auto const& m : *muonHandle) {
0302     bool passTightID =
0303         muon::isTightMuon(m, *pv) &&
0304         m.innerTrack()->hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::MISSING_INNER_HITS) == 0 &&
0305         m.innerTrack()->hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS) == 0;
0306     if (muonSelection_(m) && passTightID)
0307       muons.push_back(m);
0308   }
0309   if (muons.size() < nmuons_)
0310     return;
0311 
0312   // Filling MET leg histograms (denominator)
0313   metME_variableBinning_.denominator->Fill(met);
0314   metPhiME_.denominator->Fill(metPhi);
0315   deltaphimetj1ME_.denominator->Fill(deltaphi_metjet1);
0316 
0317   int ls = iEvent.id().luminosityBlock();
0318   metVsLS_.denominator->Fill(ls, met);
0319 
0320   // Apply the selection for the MET leg numerator
0321   edm::Handle<trigger::TriggerEvent> triggerSummary;
0322   iEvent.getByToken(theTrigSummary_, triggerSummary);
0323   if (!triggerSummary.isValid()) {
0324     edm::LogError("METplusTrackMonitor") << "Invalid collection: TriggerSummary"
0325                                          << "\n";
0326     return;
0327   }
0328 
0329   trigger::TriggerObject hltMet;
0330   bool passesHltMetFilter = getHLTObj(triggerSummary, hltMetTag_, hltMet);
0331 
0332   if (!passesHltMetFilter)
0333     return;
0334 
0335   // Filling MET leg histograms (numerator)
0336   metME_variableBinning_.numerator->Fill(met);
0337   metPhiME_.numerator->Fill(metPhi);
0338   deltaphimetj1ME_.numerator->Fill(deltaphi_metjet1);
0339   metVsLS_.numerator->Fill(ls, met);
0340   metVsHltMet_.numerator->Fill(hltMet.pt(), met);
0341 
0342   // Filling track leg histograms (denominator)
0343   double leadMuonPt = !(muons.empty()) ? muons[0].pt() : -1.0;
0344   double leadMuonEta = !(muons.empty()) ? muons[0].eta() : 10.0;
0345   double leadMuonPhi = !(muons.empty()) ? muons[0].phi() : 10.0;
0346   float deltaphi_metmuon = !(muons.empty()) ? fabs(deltaPhi(caloMet.phi(), muons[0].phi())) : 10.0;
0347 
0348   muonPtME_variableBinning_.denominator->Fill(leadMuonPt);
0349   muonPtVsLS_.denominator->Fill(ls, leadMuonPt);
0350   muonEtaME_.denominator->Fill(leadMuonEta);
0351   deltaphimetmuonME_.denominator->Fill(deltaphi_metmuon);
0352   muonEtaVsPhi_.denominator->Fill(leadMuonPhi, leadMuonEta);
0353 
0354   // Apply the selection for the track leg numerator
0355   trigger::TriggerObject isoTrk;
0356   bool passesTrackLegFilter = getHLTObj(triggerSummary, trackLegFilterTag_, isoTrk);
0357 
0358   // require track leg filter
0359   if (!passesTrackLegFilter)
0360     return;
0361 
0362   // if requested, require lead selected muon is matched to the track leg filter object
0363   if (requireLeadMatched_ && !(muons.empty()) && deltaR(muons[0], isoTrk) < maxMatchDeltaR_)
0364     return;
0365 
0366   // require the full HLT path is fired
0367   if (num_genTriggerEventFlag_->on() && !num_genTriggerEventFlag_->accept(iEvent, iSetup))
0368     return;
0369 
0370   // Filling track leg histograms (denominator)
0371   muonPtME_variableBinning_.numerator->Fill(leadMuonPt);
0372   muonPtVsLS_.numerator->Fill(ls, leadMuonPt);
0373   muonEtaME_.numerator->Fill(leadMuonEta);
0374   deltaphimetmuonME_.numerator->Fill(deltaphi_metmuon);
0375   muonEtaVsPhi_.numerator->Fill(leadMuonPhi, leadMuonEta);
0376 }
0377 
0378 bool METplusTrackMonitor::getHLTObj(const edm::Handle<trigger::TriggerEvent>& trigSummary,
0379                                     const edm::InputTag& filterTag,
0380                                     trigger::TriggerObject& obj) const {
0381   double leadingPt = -1.0;
0382 
0383   size_t filterIndex = trigSummary->filterIndex(filterTag);
0384   trigger::TriggerObjectCollection triggerObjects = trigSummary->getObjects();
0385 
0386   if (!(filterIndex >= trigSummary->sizeFilters())) {
0387     const trigger::Keys& keys = trigSummary->filterKeys(filterIndex);
0388     for (unsigned short key : keys) {
0389       trigger::TriggerObject foundObject = triggerObjects[key];
0390       if (foundObject.pt() > leadingPt) {
0391         obj = foundObject;
0392         leadingPt = obj.pt();
0393       }
0394     }
0395   }
0396 
0397   return (leadingPt > 0.0);
0398 }
0399 
0400 void METplusTrackMonitor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0401   edm::ParameterSetDescription desc;
0402   desc.add<std::string>("FolderName", "HLT/MET");
0403   desc.add<bool>("requireValidHLTPaths", true);
0404 
0405   desc.add<edm::InputTag>("met", edm::InputTag("caloMet"));
0406   desc.add<edm::InputTag>("jets", edm::InputTag("ak4PFJetsCHS"));
0407   desc.add<edm::InputTag>("electrons", edm::InputTag("gedGsfElectrons"));
0408   desc.add<edm::InputTag>("muons", edm::InputTag("muons"));
0409   desc.add<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
0410   desc.add<edm::InputTag>("trigSummary", edm::InputTag("hltTriggerSummaryAOD"));
0411   desc.add<edm::InputTag>("hltMetFilter", edm::InputTag("hltMET105", "", "HLT"));
0412   desc.add<edm::InputTag>("trackLegFilter", edm::InputTag("hltTrk50Filter", "", "HLT"));
0413 
0414   desc.add<std::string>("metSelection", "pt > 0");
0415   desc.add<std::string>("jetSelection", "pt > 0");
0416   desc.add<std::string>("muonSelection", "pt > 0");
0417   desc.add<std::string>("vtxSelection", "!isFake");
0418   desc.add<unsigned>("njets", 0);
0419   desc.add<unsigned>("nmuons", 0);
0420   desc.add<double>("leadJetEtaCut", 2.4);
0421   desc.add<bool>("requireLeadMatched", true);
0422   desc.add<double>("maxMatchDeltaR", 0.1);
0423 
0424   edm::ParameterSetDescription genericTriggerEventPSet;
0425   GenericTriggerEventFlag::fillPSetDescription(genericTriggerEventPSet);
0426   desc.add<edm::ParameterSetDescription>("numGenericTriggerEventPSet", genericTriggerEventPSet);
0427   desc.add<edm::ParameterSetDescription>("denGenericTriggerEventPSet", genericTriggerEventPSet);
0428 
0429   edm::ParameterSetDescription histoPSet;
0430   edm::ParameterSetDescription metPSet;
0431   edm::ParameterSetDescription phiPSet;
0432   edm::ParameterSetDescription ptPSet;
0433   edm::ParameterSetDescription etaPSet;
0434 
0435   fillHistoPSetDescription(metPSet);
0436   fillHistoPSetDescription(phiPSet);
0437   fillHistoPSetDescription(ptPSet);
0438   fillHistoPSetDescription(etaPSet);
0439 
0440   histoPSet.add<edm::ParameterSetDescription>("metPSet", metPSet);
0441   histoPSet.add<edm::ParameterSetDescription>("phiPSet", phiPSet);
0442   histoPSet.add<edm::ParameterSetDescription>("ptPSet", ptPSet);
0443   histoPSet.add<edm::ParameterSetDescription>("etaPSet", etaPSet);
0444 
0445   std::vector<double> bins = {0.,   20.,  40.,  60.,  80.,  90.,  100., 110., 120., 130., 140., 150., 160.,
0446                               170., 180., 190., 200., 220., 240., 260., 280., 300., 350., 400., 450., 1000.};
0447 
0448   histoPSet.add<std::vector<double> >("metBinning", bins);
0449   histoPSet.add<std::vector<double> >("ptBinning", bins);
0450 
0451   edm::ParameterSetDescription lsPSet;
0452   fillHistoLSPSetDescription(lsPSet);
0453   histoPSet.add<edm::ParameterSetDescription>("lsPSet", lsPSet);
0454 
0455   desc.add<edm::ParameterSetDescription>("histoPSet", histoPSet);
0456 
0457   descriptions.add("metPlusTrackMonitoring", desc);
0458 }
0459 
0460 DEFINE_FWK_MODULE(METplusTrackMonitor);