Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-02-14 13:11:02

0001 #ifndef SusyDQM_H
0002 #define SusyDQM_H
0003 
0004 #include <string>
0005 #include <vector>
0006 
0007 #include "FWCore/Framework/interface/Event.h"
0008 #include "FWCore/Framework/interface/Frameworkfwd.h"
0009 #include "FWCore/Utilities/interface/InputTag.h"
0010 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0011 #include "FWCore/Framework/interface/MakerMacros.h"
0012 #include "FWCore/ServiceRegistry/interface/Service.h"
0013 #include "FWCore/Utilities/interface/EDMException.h"
0014 
0015 #include "DQMServices/Core/interface/DQMEDAnalyzer.h"
0016 #include "DQMServices/Core/interface/DQMStore.h"
0017 
0018 #include "DataFormats/Common/interface/Handle.h"
0019 #include "DataFormats/TrackReco/interface/Track.h"
0020 #include "DataFormats/VertexReco/interface/Vertex.h"
0021 #include "DataFormats/VertexReco/interface/VertexFwd.h"
0022 #include "DataFormats/MuonReco/interface/Muon.h"
0023 #include "DataFormats/MuonReco/interface/MuonFwd.h"
0024 #include "DataFormats/MuonReco/interface/MuonEnergy.h"
0025 #include "DataFormats/MuonReco/interface/MuonIsolation.h"
0026 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
0027 #include "DataFormats/EgammaCandidates/interface/Electron.h"
0028 #include "DataFormats/EgammaCandidates/interface/ElectronFwd.h"
0029 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
0030 #include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
0031 #include "DataFormats/JetReco/interface/GenJetCollection.h"
0032 #include "DataFormats/JetReco/interface/CaloJetCollection.h"
0033 #include "DataFormats/METReco/interface/CaloMETCollection.h"
0034 #include "DataFormats/METReco/interface/CaloMET.h"
0035 #include "DataFormats/Math/interface/deltaR.h"
0036 #include "DataFormats/Math/interface/deltaPhi.h"
0037 #include "DataFormats/Math/interface/LorentzVector.h"
0038 
0039 class TH1F;
0040 class TH2F;
0041 
0042 class PtGreater {
0043 public:
0044   template <typename T>
0045   bool operator()(const T& i, const T& j) {
0046     return (i.pt() > j.pt());
0047   }
0048 };
0049 
0050 template <typename Mu, typename Ele, typename Jet, typename Met>
0051 class SusyDQM : public DQMEDAnalyzer {
0052 public:
0053   explicit SusyDQM(const edm::ParameterSet&);
0054   ~SusyDQM() override;
0055 
0056 protected:
0057   void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override;
0058 
0059 private:
0060   void analyze(const edm::Event&, const edm::EventSetup&) override;
0061   virtual bool goodSusyElectron(const Ele*);
0062   virtual bool goodSusyMuon(const Mu*);
0063 
0064   edm::ParameterSet parameters_;
0065 
0066   std::string moduleName_;
0067 
0068   edm::EDGetTokenT<std::vector<reco::Muon> > muons_;
0069   edm::EDGetTokenT<std::vector<reco::GsfElectron> > electrons_;
0070   edm::EDGetTokenT<std::vector<reco::CaloJet> > jets_;
0071   edm::EDGetTokenT<std::vector<reco::CaloMET> > met_;
0072   edm::EDGetTokenT<reco::VertexCollection> vertex_;
0073 
0074   double elec_eta_cut_;
0075   double elec_mva_cut_;
0076   double elec_d0_cut_;
0077 
0078   double muon_eta_cut_;
0079   double muon_nHits_cut_;
0080   double muon_nChi2_cut_;
0081   double muon_d0_cut_;
0082 
0083   double RAL_muon_pt_cut_;
0084   double RAL_muon_iso_cut_;
0085 
0086   double RAL_elec_pt_cut_;
0087   double RAL_elec_iso_cut_;
0088 
0089   double RAL_jet_pt_cut_;
0090   double RAL_jet_eta_cut_;
0091   double RAL_jet_min_emf_cut_;
0092   double RAL_jet_max_emf_cut_;
0093   double RAL_jet_sum_pt_cut_;
0094 
0095   double RAL_met_cut_;
0096 
0097   math::XYZPoint bs;
0098 
0099   MonitorElement* hRAL_N_muons_;
0100   MonitorElement* hRAL_pt_muons_;
0101   MonitorElement* hRAL_eta_muons_;
0102   MonitorElement* hRAL_phi_muons_;
0103   MonitorElement* hRAL_Iso_muons_;
0104 
0105   MonitorElement* hRAL_N_elecs_;
0106   MonitorElement* hRAL_pt_elecs_;
0107   MonitorElement* hRAL_eta_elecs_;
0108   MonitorElement* hRAL_phi_elecs_;
0109   MonitorElement* hRAL_Iso_elecs_;
0110 
0111   MonitorElement* hRAL_Sum_pt_jets_;
0112   MonitorElement* hRAL_Met_;
0113 
0114   MonitorElement* hRAL_dR_emu_;
0115 
0116   MonitorElement* hRAL_mass_OS_mumu_;
0117   MonitorElement* hRAL_mass_OS_ee_;
0118   MonitorElement* hRAL_mass_OS_emu_;
0119   MonitorElement* hRAL_mass_SS_mumu_;
0120   MonitorElement* hRAL_mass_SS_ee_;
0121   MonitorElement* hRAL_mass_SS_emu_;
0122 
0123   MonitorElement* hRAL_Muon_monitor_;
0124   MonitorElement* hRAL_Electron_monitor_;
0125   MonitorElement* hRAL_OSee_monitor_;
0126   MonitorElement* hRAL_OSemu_monitor_;
0127   MonitorElement* hRAL_OSmumu_monitor_;
0128   MonitorElement* hRAL_SSee_monitor_;
0129   MonitorElement* hRAL_SSemu_monitor_;
0130   MonitorElement* hRAL_SSmumu_monitor_;
0131   MonitorElement* hRAL_TriMuon_monitor_;
0132 };
0133 
0134 template <typename Mu, typename Ele, typename Jet, typename Met>
0135 SusyDQM<Mu, Ele, Jet, Met>::SusyDQM(const edm::ParameterSet& pset) {
0136   parameters_ = pset;
0137   moduleName_ = pset.getUntrackedParameter<std::string>("moduleName");
0138 
0139   muons_ = consumes<std::vector<reco::Muon> >(pset.getParameter<edm::InputTag>("muonCollection"));
0140   electrons_ = consumes<std::vector<reco::GsfElectron> >(pset.getParameter<edm::InputTag>("electronCollection"));
0141   jets_ = consumes<std::vector<reco::CaloJet> >(pset.getParameter<edm::InputTag>("jetCollection"));
0142   met_ = consumes<std::vector<reco::CaloMET> >(pset.getParameter<edm::InputTag>("metCollection"));
0143   vertex_ = consumes<reco::VertexCollection>(pset.getParameter<edm::InputTag>("vertexCollection"));
0144 
0145   muon_eta_cut_ = pset.getParameter<double>("muon_eta_cut");
0146   muon_nHits_cut_ = pset.getParameter<double>("muon_nHits_cut");
0147   muon_nChi2_cut_ = pset.getParameter<double>("muon_nChi2_cut");
0148   muon_d0_cut_ = pset.getParameter<double>("muon_d0_cut");
0149 
0150   elec_eta_cut_ = pset.getParameter<double>("elec_eta_cut");
0151   elec_mva_cut_ = pset.getParameter<double>("elec_mva_cut");
0152   elec_d0_cut_ = pset.getParameter<double>("elec_d0_cut");
0153 
0154   RAL_muon_pt_cut_ = pset.getParameter<double>("RAL_muon_pt_cut");
0155   RAL_muon_iso_cut_ = pset.getParameter<double>("RAL_muon_iso_cut");
0156 
0157   RAL_elec_pt_cut_ = pset.getParameter<double>("RAL_elec_pt_cut");
0158   RAL_elec_iso_cut_ = pset.getParameter<double>("RAL_elec_iso_cut");
0159 
0160   RAL_jet_pt_cut_ = pset.getParameter<double>("RAL_jet_pt_cut");
0161   RAL_jet_sum_pt_cut_ = pset.getParameter<double>("RAL_jet_sum_pt_cut");
0162   RAL_jet_eta_cut_ = pset.getParameter<double>("RAL_jet_eta_cut");
0163   RAL_jet_min_emf_cut_ = pset.getParameter<double>("RAL_jet_min_emf_cut");
0164   RAL_jet_max_emf_cut_ = pset.getParameter<double>("RAL_jet_max_emf_cut");
0165 
0166   RAL_met_cut_ = pset.getParameter<double>("RAL_met_cut");
0167 
0168   hRAL_N_muons_ = nullptr;
0169   hRAL_pt_muons_ = nullptr;
0170   hRAL_eta_muons_ = nullptr;
0171   hRAL_phi_muons_ = nullptr;
0172   hRAL_Iso_muons_ = nullptr;
0173   hRAL_N_elecs_ = nullptr;
0174   hRAL_pt_elecs_ = nullptr;
0175   hRAL_eta_elecs_ = nullptr;
0176   hRAL_phi_elecs_ = nullptr;
0177   hRAL_Iso_elecs_ = nullptr;
0178   hRAL_Sum_pt_jets_ = nullptr;
0179   hRAL_Met_ = nullptr;
0180   hRAL_dR_emu_ = nullptr;
0181   hRAL_mass_OS_mumu_ = nullptr;
0182   hRAL_mass_OS_ee_ = nullptr;
0183   hRAL_mass_OS_emu_ = nullptr;
0184   hRAL_mass_SS_mumu_ = nullptr;
0185   hRAL_mass_SS_ee_ = nullptr;
0186   hRAL_mass_SS_emu_ = nullptr;
0187   hRAL_Muon_monitor_ = nullptr;
0188   hRAL_Electron_monitor_ = nullptr;
0189   hRAL_OSee_monitor_ = nullptr;
0190   hRAL_OSemu_monitor_ = nullptr;
0191   hRAL_OSmumu_monitor_ = nullptr;
0192   hRAL_SSee_monitor_ = nullptr;
0193   hRAL_SSemu_monitor_ = nullptr;
0194   hRAL_SSmumu_monitor_ = nullptr;
0195   hRAL_TriMuon_monitor_ = nullptr;
0196 }
0197 
0198 template <typename Mu, typename Ele, typename Jet, typename Met>
0199 SusyDQM<Mu, Ele, Jet, Met>::~SusyDQM() {}
0200 
0201 template <typename Mu, typename Ele, typename Jet, typename Met>
0202 void SusyDQM<Mu, Ele, Jet, Met>::bookHistograms(DQMStore::IBooker& iBooker, edm::Run const&, edm::EventSetup const&) {
0203   iBooker.setCurrentFolder(moduleName_);
0204 
0205   hRAL_N_muons_ = iBooker.book1D("RAL_N_muons", "RAL_N_muons", 10, 0., 10.);
0206   hRAL_pt_muons_ = iBooker.book1D("RAL_pt_muons", "RAL_pt_muons", 50, 0., 300.);
0207   hRAL_eta_muons_ = iBooker.book1D("RAL_eta_muons", "RAL_eta_muons", 50, -2.5, 2.5);
0208   hRAL_phi_muons_ = iBooker.book1D("RAL_phi_muons", "RAL_phi_muons", 50, -4., 4.);
0209   hRAL_Iso_muons_ = iBooker.book1D("RAL_Iso_muons", "RAL_Iso_muons", 50, 0., 25.);
0210 
0211   hRAL_N_elecs_ = iBooker.book1D("RAL_N_elecs", "RAL_N_elecs", 10, 0., 10.);
0212   hRAL_pt_elecs_ = iBooker.book1D("RAL_pt_elecs", "RAL_pt_elecs", 50, 0., 300.);
0213   hRAL_eta_elecs_ = iBooker.book1D("RAL_eta_elecs", "RAL_eta_elecs", 50, -2.5, 2.5);
0214   hRAL_phi_elecs_ = iBooker.book1D("RAL_phi_elecs", "RAL_phi_elecs", 50, -4., 4.);
0215   hRAL_Iso_elecs_ = iBooker.book1D("RAL_Iso_elecs", "RAL_Iso_elecs", 50, 0., 25.);
0216 
0217   hRAL_Sum_pt_jets_ = iBooker.book1D("RAL_Sum_pt_jets", "RAL_Sum_pt_jets", 50, 0., 2000.);
0218   hRAL_Met_ = iBooker.book1D("RAL_Met", "RAL_Met", 50, 0., 1000.);
0219 
0220   hRAL_dR_emu_ = iBooker.book1D("RAL_deltaR_emu", "RAL_deltaR_emu", 50, 0., 10.);
0221 
0222   hRAL_mass_OS_mumu_ = iBooker.book1D("RAL_mass_OS_mumu", "RAL_mass_OS_mumu", 50, 0., 300.);
0223   hRAL_mass_OS_ee_ = iBooker.book1D("RAL_mass_OS_ee", "RAL_mass_OS_ee", 50, 0., 300.);
0224   hRAL_mass_OS_emu_ = iBooker.book1D("RAL_mass_OS_emu", "RAL_mass_OS_emu", 50, 0., 300.);
0225   hRAL_mass_SS_mumu_ = iBooker.book1D("RAL_mass_SS_mumu", "RAL_mass_SS_mumu", 50, 0., 300.);
0226   hRAL_mass_SS_ee_ = iBooker.book1D("RAL_mass_SS_ee", "RAL_mass_SS_ee", 50, 0., 300.);
0227   hRAL_mass_SS_emu_ = iBooker.book1D("RAL_mass_SS_emu", "RAL_mass_SS_emu", 50, 0., 300.);
0228 
0229   hRAL_Muon_monitor_ =
0230       iBooker.book2D("RAL_Single_Muon_Selection", "RAL_Single_Muon_Selection", 50, 0., 1000., 50, 0., 1000.);
0231   hRAL_Electron_monitor_ =
0232       iBooker.book2D("RAL_Single_Electron_Selection", "RAL_Single_Electron_Selection", 50, 0., 1000., 50, 0., 1000.);
0233   hRAL_OSee_monitor_ =
0234       iBooker.book2D("RAL_OS_Electron_Selection", "RAL_OS_Electron_Selection", 50, 0., 1000., 50, 0., 1000.);
0235   hRAL_OSemu_monitor_ =
0236       iBooker.book2D("RAL_OS_ElectronMuon_Selection", "RAL_OS_ElectronMuon_Selection", 50, 0., 1000., 50, 0., 1000.);
0237   hRAL_OSmumu_monitor_ = iBooker.book2D("RAL_OS_Muon_Selection", "RAL_OS_Muon_Selection", 50, 0., 1000., 50, 0., 1000.);
0238   hRAL_SSee_monitor_ =
0239       iBooker.book2D("RAL_SS_Electron_Selection", "RAL_SS_Electron_Selection", 50, 0., 1000., 50, 0., 1000.);
0240   hRAL_SSemu_monitor_ =
0241       iBooker.book2D("RAL_SS_ElectronMuon_Selection", "RAL_SS_ElectronMuon_Selection", 50, 0., 1000., 50, 0., 1000.);
0242   hRAL_SSmumu_monitor_ = iBooker.book2D("RAL_SS_Muon_Selection", "RAL_SS_Muon_Selection", 50, 0., 1000., 50, 0., 1000.);
0243   hRAL_TriMuon_monitor_ =
0244       iBooker.book2D("RAL_Tri_Muon_Selection", "RAL_Tri_Muon_Selection", 50, 0., 1000., 50, 0., 1000.);
0245 }
0246 
0247 template <typename Mu, typename Ele, typename Jet, typename Met>
0248 bool SusyDQM<Mu, Ele, Jet, Met>::goodSusyElectron(const Ele* ele) {
0249   //   if (ele->pt() < elec_pt_cut_)
0250   //      return false;
0251   if (fabs(ele->eta()) > elec_eta_cut_)
0252     return false;
0253   //   if (ele->mva() < elec_mva_cut_)
0254   //      return false;
0255   if (fabs(ele->gsfTrack()->dxy(bs)) > elec_d0_cut_)
0256     return false;
0257   return true;
0258 }
0259 
0260 template <typename Mu, typename Ele, typename Jet, typename Met>
0261 bool SusyDQM<Mu, Ele, Jet, Met>::goodSusyMuon(const Mu* mu) {
0262   //   if (mu->pt() < muon_pt_cut_)
0263   //      return false;
0264   if (fabs(mu->eta()) > muon_eta_cut_)
0265     return false;
0266   if (!mu->isGlobalMuon())
0267     return false;
0268   if (mu->innerTrack()->numberOfValidHits() < muon_nHits_cut_)
0269     return false;
0270   if (mu->globalTrack()->normalizedChi2() > muon_nChi2_cut_)
0271     return false;
0272   if (fabs(mu->innerTrack()->dxy(bs)) > muon_d0_cut_)
0273     return false;
0274   return true;
0275 }
0276 
0277 template <typename Mu, typename Ele, typename Jet, typename Met>
0278 void SusyDQM<Mu, Ele, Jet, Met>::analyze(const edm::Event& evt, const edm::EventSetup& iSetup) {
0279   edm::Handle<std::vector<Mu> > muons;
0280   bool isFound = evt.getByToken(muons_, muons);
0281   if (!isFound)
0282     return;
0283 
0284   edm::Handle<std::vector<Ele> > elecs;
0285   isFound = evt.getByToken(electrons_, elecs);
0286   if (!isFound)
0287     return;
0288 
0289   //// sorted jets
0290   edm::Handle<std::vector<Jet> > cJets;
0291   isFound = evt.getByToken(jets_, cJets);
0292   if (!isFound)
0293     return;
0294   std::vector<Jet> jets = *cJets;
0295   std::sort(jets.begin(), jets.end(), PtGreater());
0296 
0297   edm::Handle<std::vector<Met> > mets;
0298   isFound = evt.getByToken(met_, mets);
0299   if (!isFound)
0300     return;
0301 
0302   edm::Handle<reco::VertexCollection> vertices;
0303   isFound = evt.getByToken(vertex_, vertices);
0304   if (!isFound)
0305     return;
0306 
0307   //////////////////////////////
0308   // Leptonic DQM histos
0309   //////////////////////////////
0310 
0311   float sumPt = 0.;
0312   for (typename std::vector<Jet>::const_iterator jet_i = jets.begin(); jet_i != jets.end(); ++jet_i) {
0313     if (jet_i->pt() < RAL_jet_pt_cut_)
0314       continue;
0315     if (fabs(jet_i->eta()) > RAL_jet_eta_cut_)
0316       continue;
0317     if (fabs(jet_i->eta()) > RAL_jet_eta_cut_)
0318       continue;
0319     if (jet_i->emEnergyFraction() < RAL_jet_min_emf_cut_)
0320       continue;
0321     if (jet_i->emEnergyFraction() > RAL_jet_max_emf_cut_)
0322       continue;
0323     sumPt += jet_i->pt();
0324   }
0325 
0326   hRAL_Sum_pt_jets_->Fill(sumPt);
0327 
0328   float MET = 0.;
0329   for (typename std::vector<Met>::const_iterator met_i = mets->begin(); met_i != mets->end(); ++met_i) {
0330     MET = met_i->pt();
0331     break;
0332   }
0333 
0334   hRAL_Met_->Fill(MET);
0335 
0336   int nMuons = 0;
0337   int nSSmumu = 0;
0338   int nOSmumu = 0;
0339   int nSSemu = 0;
0340   int nOSemu = 0;
0341   float inv = 0.;
0342   float dR = 0.;
0343 
0344   for (typename std::vector<Mu>::const_iterator mu_i = muons->begin(); mu_i != muons->end(); ++mu_i) {
0345     if (!(goodSusyMuon(&(*mu_i)) && mu_i->pt() > RAL_muon_pt_cut_))
0346       continue;
0347     ++nMuons;
0348 
0349     hRAL_pt_muons_->Fill(mu_i->pt());
0350     hRAL_eta_muons_->Fill(mu_i->eta());
0351     hRAL_phi_muons_->Fill(mu_i->phi());
0352 
0353     reco::MuonIsolation muIso = mu_i->isolationR03();
0354     hRAL_Iso_muons_->Fill(muIso.emEt + muIso.hadEt + muIso.sumPt);
0355 
0356     // Muon muon pairs
0357     for (typename std::vector<Mu>::const_iterator mu_j = muons->begin(); mu_j != muons->end(); ++mu_j) {
0358       if (mu_i >= mu_j)
0359         continue;
0360       if (!(goodSusyMuon(&(*mu_j)) && mu_j->pt() > RAL_muon_pt_cut_))
0361         continue;
0362 
0363       inv = (mu_i->p4() + mu_j->p4()).M();
0364       if (mu_i->charge() * mu_j->charge() > 0) {
0365         ++nSSmumu;
0366         hRAL_mass_SS_mumu_->Fill(inv);
0367       }
0368       if (mu_i->charge() * mu_j->charge() < 0) {
0369         ++nOSmumu;
0370         hRAL_mass_OS_mumu_->Fill(inv);
0371       }
0372     }
0373 
0374     // Electron muon pairs
0375     for (typename std::vector<Ele>::const_iterator ele_j = elecs->begin(); ele_j != elecs->end(); ++ele_j) {
0376       if (!(goodSusyElectron(&(*ele_j)) && ele_j->pt() > RAL_elec_pt_cut_))
0377         continue;
0378       inv = (mu_i->p4() + ele_j->p4()).M();
0379       dR = deltaR(*mu_i, *ele_j);
0380       hRAL_dR_emu_->Fill(dR);
0381       if (mu_i->charge() * ele_j->charge() > 0) {
0382         ++nSSemu;
0383         hRAL_mass_SS_emu_->Fill(inv);
0384       }
0385       if (mu_i->charge() * ele_j->charge() < 0) {
0386         ++nOSemu;
0387         hRAL_mass_OS_emu_->Fill(inv);
0388       }
0389     }
0390   }
0391 
0392   hRAL_N_muons_->Fill(nMuons);
0393 
0394   int nElectrons = 0;
0395   int nSSee = 0;
0396   int nOSee = 0;
0397   for (typename std::vector<Ele>::const_iterator ele_i = elecs->begin(); ele_i != elecs->end(); ++ele_i) {
0398     if (!(goodSusyElectron(&(*ele_i)) && ele_i->pt() > RAL_elec_pt_cut_))
0399       continue;
0400     nElectrons++;
0401 
0402     hRAL_pt_elecs_->Fill(ele_i->pt());
0403     hRAL_eta_elecs_->Fill(ele_i->eta());
0404     hRAL_phi_elecs_->Fill(ele_i->phi());
0405 
0406     hRAL_Iso_elecs_->Fill(ele_i->dr03TkSumPt() + ele_i->dr03EcalRecHitSumEt() + ele_i->dr03HcalTowerSumEt());
0407 
0408     // Electron electron pairs
0409     for (typename std::vector<Ele>::const_iterator ele_j = elecs->begin(); ele_j != elecs->end(); ++ele_j) {
0410       if (ele_i >= ele_j)
0411         continue;
0412       if (!(goodSusyElectron(&(*ele_j)) && ele_j->pt() > RAL_elec_pt_cut_))
0413         continue;
0414 
0415       inv = (ele_i->p4() + ele_j->p4()).M();
0416       if (ele_i->charge() * ele_j->charge() > 0) {
0417         ++nSSee;
0418         hRAL_mass_SS_ee_->Fill(inv);
0419       }
0420       if (ele_i->charge() * ele_j->charge() < 0) {
0421         ++nOSee;
0422         hRAL_mass_OS_ee_->Fill(inv);
0423       }
0424     }
0425   }
0426 
0427   hRAL_N_elecs_->Fill(nElectrons);
0428 
0429   if (MET > RAL_met_cut_ && sumPt > RAL_jet_sum_pt_cut_) {
0430     if (nMuons >= 1) {
0431       hRAL_Muon_monitor_->Fill(sumPt, MET);
0432     }
0433     if (nElectrons >= 1) {
0434       hRAL_Electron_monitor_->Fill(sumPt, MET);
0435     }
0436     if (nOSee >= 1) {
0437       hRAL_OSee_monitor_->Fill(sumPt, MET);
0438     }
0439     if (nOSemu >= 1) {
0440       hRAL_OSemu_monitor_->Fill(sumPt, MET);
0441     }
0442     if (nOSmumu >= 1) {
0443       hRAL_OSmumu_monitor_->Fill(sumPt, MET);
0444     }
0445     if (nSSee >= 1) {
0446       hRAL_SSee_monitor_->Fill(sumPt, MET);
0447     }
0448     if (nSSemu >= 1) {
0449       hRAL_SSemu_monitor_->Fill(sumPt, MET);
0450     }
0451     if (nSSmumu >= 1) {
0452       hRAL_SSmumu_monitor_->Fill(sumPt, MET);
0453     }
0454   }
0455   if (nMuons >= 3) {
0456     hRAL_TriMuon_monitor_->Fill(sumPt, MET);
0457   }
0458 }
0459 
0460 #endif
0461 
0462 typedef SusyDQM<reco::Muon, reco::GsfElectron, reco::CaloJet, reco::CaloMET> RecoSusyDQM;