CMS 3D CMS Logo

/data/refman/pasoursint/CMSSW_5_2_9/src/DQM/Physics/src/SusyDQM.h

Go to the documentation of this file.
00001 #ifndef SusyDQM_H
00002 #define SusyDQM_H
00003 
00004 #include <string>
00005 #include <vector>
00006 
00007 #include "FWCore/Framework/interface/EDAnalyzer.h"
00008 #include "FWCore/Framework/interface/Event.h"
00009 #include "FWCore/Framework/interface/Frameworkfwd.h"
00010 #include "FWCore/Utilities/interface/InputTag.h"
00011 #include "FWCore/ParameterSet/interface/ParameterSet.h"
00012 #include "FWCore/Framework/interface/MakerMacros.h"
00013 #include "FWCore/ServiceRegistry/interface/Service.h"
00014 #include "FWCore/Utilities/interface/EDMException.h"
00015 
00016 #include "DQMServices/Core/interface/DQMStore.h"
00017 #include "DQMServices/Core/interface/MonitorElement.h"
00018 
00019 #include "DataFormats/Common/interface/Handle.h"
00020 #include "DataFormats/TrackReco/interface/Track.h"
00021 #include "DataFormats/VertexReco/interface/Vertex.h"
00022 #include "DataFormats/VertexReco/interface/VertexFwd.h"
00023 #include "DataFormats/MuonReco/interface/Muon.h"
00024 #include "DataFormats/MuonReco/interface/MuonFwd.h"
00025 #include "DataFormats/MuonReco/interface/MuonEnergy.h"
00026 #include "DataFormats/MuonReco/interface/MuonIsolation.h"
00027 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
00028 #include "DataFormats/EgammaCandidates/interface/Electron.h"
00029 #include "DataFormats/EgammaCandidates/interface/ElectronFwd.h"
00030 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
00031 #include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
00032 #include "DataFormats/JetReco/interface/GenJetCollection.h"
00033 #include "DataFormats/JetReco/interface/CaloJetCollection.h"
00034 #include "DataFormats/METReco/interface/CaloMETCollection.h"
00035 #include "DataFormats/METReco/interface/CaloMET.h"
00036 #include "DataFormats/Math/interface/deltaR.h"
00037 #include "DataFormats/Math/interface/deltaPhi.h"
00038 #include "DataFormats/Math/interface/LorentzVector.h"
00039 
00040 class TH1F;
00041 class TH2F;
00042 
00043 class PtGreater {
00044    public:
00045       template<typename T> bool operator ()(const T& i, const T& j) {
00046          return (i.pt() > j.pt());
00047       }
00048 };
00049 
00050 template<typename Mu, typename Ele, typename Jet, typename Met>
00051 class SusyDQM: public edm::EDAnalyzer {
00052 
00053    public:
00054 
00055       explicit SusyDQM(const edm::ParameterSet&);
00056       ~SusyDQM();
00057 
00058    protected:
00059 
00060       void beginRun(const edm::Run&);
00061       void endRun(const edm::Run&);
00062 
00063    private:
00064 
00065       void initialize();
00066       virtual void beginJob();
00067       virtual void analyze(const edm::Event&, const edm::EventSetup&);
00068       virtual bool goodSusyElectron(const Ele*);
00069       virtual bool goodSusyMuon(const Mu*);
00070       virtual void endJob();
00071 
00072       edm::ParameterSet parameters_;
00073       DQMStore * dbe_;
00074 
00075       std::string moduleName_;
00076 
00077       edm::InputTag muons_;
00078       edm::InputTag electrons_;
00079       edm::InputTag jets_;
00080       edm::InputTag met_;
00081       edm::InputTag vertex_;
00082 
00083       double elec_eta_cut_;
00084       double elec_mva_cut_;
00085       double elec_d0_cut_;
00086 
00087       double muon_eta_cut_;
00088       double muon_nHits_cut_;
00089       double muon_nChi2_cut_;
00090       double muon_d0_cut_;
00091 
00092       double RAL_muon_pt_cut_;
00093       double RAL_muon_iso_cut_;
00094 
00095       double RAL_elec_pt_cut_;
00096       double RAL_elec_iso_cut_;
00097 
00098       double RAL_jet_pt_cut_;
00099       double RAL_jet_eta_cut_;
00100       double RAL_jet_min_emf_cut_;
00101       double RAL_jet_max_emf_cut_;
00102       double RAL_jet_sum_pt_cut_;
00103 
00104       double RAL_met_cut_;
00105 
00106       math::XYZPoint bs;
00107 
00108       MonitorElement * hRAL_N_muons_;
00109       MonitorElement * hRAL_pt_muons_;
00110       MonitorElement * hRAL_eta_muons_;
00111       MonitorElement * hRAL_phi_muons_;
00112       MonitorElement * hRAL_Iso_muons_;
00113 
00114       MonitorElement * hRAL_N_elecs_;
00115       MonitorElement * hRAL_pt_elecs_;
00116       MonitorElement * hRAL_eta_elecs_;
00117       MonitorElement * hRAL_phi_elecs_;
00118       MonitorElement * hRAL_Iso_elecs_;
00119 
00120       MonitorElement * hRAL_Sum_pt_jets_;
00121       MonitorElement * hRAL_Met_;
00122 
00123       MonitorElement * hRAL_dR_emu_;
00124 
00125       MonitorElement * hRAL_mass_OS_mumu_;
00126       MonitorElement * hRAL_mass_OS_ee_;
00127       MonitorElement * hRAL_mass_OS_emu_;
00128       MonitorElement * hRAL_mass_SS_mumu_;
00129       MonitorElement * hRAL_mass_SS_ee_;
00130       MonitorElement * hRAL_mass_SS_emu_;
00131 
00132       MonitorElement * hRAL_Muon_monitor_;
00133       MonitorElement * hRAL_Electron_monitor_;
00134       MonitorElement * hRAL_OSee_monitor_;
00135       MonitorElement * hRAL_OSemu_monitor_;
00136       MonitorElement * hRAL_OSmumu_monitor_;
00137       MonitorElement * hRAL_SSee_monitor_;
00138       MonitorElement * hRAL_SSemu_monitor_;
00139       MonitorElement * hRAL_SSmumu_monitor_;
00140       MonitorElement * hRAL_TriMuon_monitor_;
00141 
00142 };
00143 
00144 template<typename Mu, typename Ele, typename Jet, typename Met>
00145 SusyDQM<Mu, Ele, Jet, Met>::SusyDQM(const edm::ParameterSet& pset) {
00146 
00147    parameters_ = pset;
00148    initialize();
00149 
00150    moduleName_ = pset.getUntrackedParameter<std::string> ("moduleName");
00151 
00152    muons_ = pset.getParameter<edm::InputTag> ("muonCollection");
00153    electrons_ = pset.getParameter<edm::InputTag> ("electronCollection");
00154    jets_ = pset.getParameter<edm::InputTag> ("jetCollection");
00155    met_ = pset.getParameter<edm::InputTag> ("metCollection");
00156    vertex_ = pset.getParameter<edm::InputTag> ("vertexCollection");
00157 
00158    muon_eta_cut_ = pset.getParameter<double> ("muon_eta_cut");
00159    muon_nHits_cut_ = pset.getParameter<double> ("muon_nHits_cut");
00160    muon_nChi2_cut_ = pset.getParameter<double> ("muon_nChi2_cut");
00161    muon_d0_cut_ = pset.getParameter<double> ("muon_d0_cut");
00162 
00163    elec_eta_cut_ = pset.getParameter<double> ("elec_eta_cut");
00164    elec_mva_cut_ = pset.getParameter<double> ("elec_mva_cut");
00165    elec_d0_cut_ = pset.getParameter<double> ("elec_d0_cut");
00166 
00167    RAL_muon_pt_cut_ = pset.getParameter<double> ("RAL_muon_pt_cut");
00168    RAL_muon_iso_cut_ = pset.getParameter<double> ("RAL_muon_iso_cut");
00169 
00170    RAL_elec_pt_cut_ = pset.getParameter<double> ("RAL_elec_pt_cut");
00171    RAL_elec_iso_cut_ = pset.getParameter<double> ("RAL_elec_iso_cut");
00172 
00173    RAL_jet_pt_cut_ = pset.getParameter<double> ("RAL_jet_pt_cut");
00174    RAL_jet_sum_pt_cut_ = pset.getParameter<double> ("RAL_jet_sum_pt_cut");
00175    RAL_jet_eta_cut_ = pset.getParameter<double> ("RAL_jet_eta_cut");
00176    RAL_jet_min_emf_cut_ = pset.getParameter<double> ("RAL_jet_min_emf_cut");
00177    RAL_jet_max_emf_cut_ = pset.getParameter<double> ("RAL_jet_max_emf_cut");
00178 
00179    RAL_met_cut_ = pset.getParameter<double> ("RAL_met_cut");
00180 
00181    dbe_ = edm::Service<DQMStore>().operator->();
00182 
00183    hRAL_N_muons_ = 0;
00184    hRAL_pt_muons_ = 0;
00185    hRAL_eta_muons_ = 0;
00186    hRAL_phi_muons_ = 0;
00187    hRAL_Iso_muons_ = 0;
00188    hRAL_N_elecs_ = 0;
00189    hRAL_pt_elecs_ = 0;
00190    hRAL_eta_elecs_ = 0;
00191    hRAL_phi_elecs_ = 0;
00192    hRAL_Iso_elecs_ = 0;
00193    hRAL_Sum_pt_jets_ = 0;
00194    hRAL_Met_ = 0;
00195    hRAL_dR_emu_ = 0;
00196    hRAL_mass_OS_mumu_ = 0;
00197    hRAL_mass_OS_ee_ = 0;
00198    hRAL_mass_OS_emu_ = 0;
00199    hRAL_mass_SS_mumu_ = 0;
00200    hRAL_mass_SS_ee_ = 0;
00201    hRAL_mass_SS_emu_ = 0;
00202    hRAL_Muon_monitor_ = 0;
00203    hRAL_Electron_monitor_ = 0;
00204    hRAL_OSee_monitor_ = 0;
00205    hRAL_OSemu_monitor_ = 0;
00206    hRAL_OSmumu_monitor_ = 0;
00207    hRAL_SSee_monitor_ = 0;
00208    hRAL_SSemu_monitor_ = 0;
00209    hRAL_SSmumu_monitor_ = 0;
00210    hRAL_TriMuon_monitor_ = 0;
00211 
00212 }
00213 
00214 template<typename Mu, typename Ele, typename Jet, typename Met>
00215 SusyDQM<Mu, Ele, Jet, Met>::~SusyDQM() {
00216 
00217 }
00218 
00219 template<typename Mu, typename Ele, typename Jet, typename Met>
00220 void SusyDQM<Mu, Ele, Jet, Met>::initialize() {
00221 
00222 }
00223 
00224 template<typename Mu, typename Ele, typename Jet, typename Met>
00225 void SusyDQM<Mu, Ele, Jet, Met>::beginJob() {
00226 
00227    dbe_->setCurrentFolder(moduleName_);
00228 
00229    hRAL_N_muons_ = dbe_->book1D("RAL_N_muons", "RAL_N_muons", 10, 0., 10.);
00230    hRAL_pt_muons_ = dbe_->book1D("RAL_pt_muons", "RAL_pt_muons", 50, 0., 300.);
00231    hRAL_eta_muons_ = dbe_->book1D("RAL_eta_muons", "RAL_eta_muons", 50, -2.5, 2.5);
00232    hRAL_phi_muons_ = dbe_->book1D("RAL_phi_muons", "RAL_phi_muons", 50, -4., 4.);
00233    hRAL_Iso_muons_ = dbe_->book1D("RAL_Iso_muons", "RAL_Iso_muons", 50, 0., 25.);
00234 
00235    hRAL_N_elecs_ = dbe_->book1D("RAL_N_elecs", "RAL_N_elecs", 10, 0., 10.);
00236    hRAL_pt_elecs_ = dbe_->book1D("RAL_pt_elecs", "RAL_pt_elecs", 50, 0., 300.);
00237    hRAL_eta_elecs_ = dbe_->book1D("RAL_eta_elecs", "RAL_eta_elecs", 50, -2.5, 2.5);
00238    hRAL_phi_elecs_ = dbe_->book1D("RAL_phi_elecs", "RAL_phi_elecs", 50, -4., 4.);
00239    hRAL_Iso_elecs_ = dbe_->book1D("RAL_Iso_elecs", "RAL_Iso_elecs", 50, 0., 25.);
00240 
00241    hRAL_Sum_pt_jets_ = dbe_->book1D("RAL_Sum_pt_jets", "RAL_Sum_pt_jets", 50, 0., 2000.);
00242    hRAL_Met_ = dbe_->book1D("RAL_Met", "RAL_Met", 50, 0., 1000.);
00243 
00244    hRAL_dR_emu_ = dbe_->book1D("RAL_deltaR_emu", "RAL_deltaR_emu", 50, 0., 10.);
00245 
00246    hRAL_mass_OS_mumu_ = dbe_->book1D("RAL_mass_OS_mumu", "RAL_mass_OS_mumu", 50, 0., 300.);
00247    hRAL_mass_OS_ee_ = dbe_->book1D("RAL_mass_OS_ee", "RAL_mass_OS_ee", 50, 0., 300.);
00248    hRAL_mass_OS_emu_ = dbe_->book1D("RAL_mass_OS_emu", "RAL_mass_OS_emu", 50, 0., 300.);
00249    hRAL_mass_SS_mumu_ = dbe_->book1D("RAL_mass_SS_mumu", "RAL_mass_SS_mumu", 50, 0., 300.);
00250    hRAL_mass_SS_ee_ = dbe_->book1D("RAL_mass_SS_ee", "RAL_mass_SS_ee", 50, 0., 300.);
00251    hRAL_mass_SS_emu_ = dbe_->book1D("RAL_mass_SS_emu", "RAL_mass_SS_emu", 50, 0., 300.);
00252 
00253    hRAL_Muon_monitor_ = dbe_->book2D("RAL_Single_Muon_Selection", "RAL_Single_Muon_Selection", 50, 0., 1000., 50, 0.,
00254          1000.);
00255    hRAL_Electron_monitor_ = dbe_->book2D("RAL_Single_Electron_Selection", "RAL_Single_Electron_Selection", 50, 0.,
00256          1000., 50, 0., 1000.);
00257    hRAL_OSee_monitor_ = dbe_->book2D("RAL_OS_Electron_Selection", "RAL_OS_Electron_Selection", 50, 0., 1000., 50, 0.,
00258          1000.);
00259    hRAL_OSemu_monitor_ = dbe_->book2D("RAL_OS_ElectronMuon_Selection", "RAL_OS_ElectronMuon_Selection", 50, 0., 1000.,
00260          50, 0., 1000.);
00261    hRAL_OSmumu_monitor_ = dbe_->book2D("RAL_OS_Muon_Selection", "RAL_OS_Muon_Selection", 50, 0., 1000., 50, 0., 1000.);
00262    hRAL_SSee_monitor_ = dbe_->book2D("RAL_SS_Electron_Selection", "RAL_SS_Electron_Selection", 50, 0., 1000., 50, 0.,
00263          1000.);
00264    hRAL_SSemu_monitor_ = dbe_->book2D("RAL_SS_ElectronMuon_Selection", "RAL_SS_ElectronMuon_Selection", 50, 0., 1000.,
00265          50, 0., 1000.);
00266    hRAL_SSmumu_monitor_ = dbe_->book2D("RAL_SS_Muon_Selection", "RAL_SS_Muon_Selection", 50, 0., 1000., 50, 0., 1000.);
00267    hRAL_TriMuon_monitor_ = dbe_->book2D("RAL_Tri_Muon_Selection", "RAL_Tri_Muon_Selection", 50, 0., 1000., 50, 0.,
00268          1000.);
00269 
00270 }
00271 
00272 template<typename Mu, typename Ele, typename Jet, typename Met>
00273 void SusyDQM<Mu, Ele, Jet, Met>::beginRun(const edm::Run& run) {
00274 
00275 }
00276 
00277 template<typename Mu, typename Ele, typename Jet, typename Met>
00278 bool SusyDQM<Mu, Ele, Jet, Met>::goodSusyElectron(const Ele* ele) {
00279    //   if (ele->pt() < elec_pt_cut_)
00280    //      return false;
00281    if (fabs(ele->eta()) > elec_eta_cut_)
00282       return false;
00283    //   if (ele->mva() < elec_mva_cut_)
00284    //      return false;
00285    if (fabs(ele->gsfTrack()->dxy(bs)) > elec_d0_cut_)
00286       return false;
00287    return true;
00288 }
00289 
00290 template<typename Mu, typename Ele, typename Jet, typename Met>
00291 bool SusyDQM<Mu, Ele, Jet, Met>::goodSusyMuon(const Mu* mu) {
00292    //   if (mu->pt() < muon_pt_cut_)
00293    //      return false;
00294    if (fabs(mu->eta()) > muon_eta_cut_)
00295       return false;
00296    if (!mu->isGlobalMuon())
00297       return false;
00298    if (mu->innerTrack()->numberOfValidHits() < muon_nHits_cut_)
00299       return false;
00300    if (mu->globalTrack()->normalizedChi2() > muon_nChi2_cut_)
00301       return false;
00302    if (fabs(mu->innerTrack()->dxy(bs)) > muon_d0_cut_)
00303       return false;
00304    return true;
00305 }
00306 
00307 template<typename Mu, typename Ele, typename Jet, typename Met>
00308 void SusyDQM<Mu, Ele, Jet, Met>::analyze(const edm::Event& evt, const edm::EventSetup& iSetup) {
00309 
00310    edm::Handle<std::vector<Mu> > muons;
00311    bool isFound = evt.getByLabel(muons_, muons);
00312    if (!isFound)
00313       return;
00314 
00315    edm::Handle<std::vector<Ele> > elecs;
00316    isFound = evt.getByLabel(electrons_, elecs);
00317    if (!isFound)
00318       return;
00319 
00320    //edm::Handle<std::vector<Jet> > jets;
00321    //evt.getByLabel(jets_, jets);
00322 
00324    edm::Handle<std::vector<Jet> > cJets;
00325    isFound = evt.getByLabel(jets_, cJets);
00326    if (!isFound)
00327       return;
00328    std::vector<Jet> jets = *cJets;
00329    std::sort(jets.begin(), jets.end(), PtGreater());
00330 
00331    edm::Handle<std::vector<Met> > mets;
00332    isFound = evt.getByLabel(met_, mets);
00333    if (!isFound)
00334       return;
00335 
00336    edm::Handle<reco::VertexCollection> vertices;
00337    isFound = evt.getByLabel(vertex_, vertices);
00338    if (!isFound)
00339       return;
00340 
00342    // Leptonic DQM histos
00344 
00345    float sumPt = 0.;
00346    for (typename std::vector<Jet>::const_iterator jet_i = jets.begin(); jet_i != jets.end(); ++jet_i) {
00347       if (jet_i->pt() < RAL_jet_pt_cut_)
00348          continue;
00349       if (fabs(jet_i->eta()) > RAL_jet_eta_cut_)
00350          continue;
00351       if (fabs(jet_i->eta()) > RAL_jet_eta_cut_)
00352          continue;
00353       if (jet_i->emEnergyFraction() < RAL_jet_min_emf_cut_)
00354          continue;
00355       if (jet_i->emEnergyFraction() > RAL_jet_max_emf_cut_)
00356          continue;
00357       sumPt += jet_i->pt();
00358    }
00359 
00360    hRAL_Sum_pt_jets_->Fill(sumPt);
00361 
00362    float MET = 0.;
00363    for (typename std::vector<Met>::const_iterator met_i = mets->begin(); met_i != mets->end(); ++met_i) {
00364       MET = met_i->pt();
00365       break;
00366    }
00367 
00368    hRAL_Met_->Fill(MET);
00369 
00370    int nMuons = 0;
00371    int nSSmumu = 0;
00372    int nOSmumu = 0;
00373    int nSSemu = 0;
00374    int nOSemu = 0;
00375    float inv = 0.;
00376    float dR = 0.;
00377 
00378    for (typename std::vector<Mu>::const_iterator mu_i = muons->begin(); mu_i != muons->end(); ++mu_i) {
00379       if (!(goodSusyMuon(&(*mu_i)) && mu_i->pt() > RAL_muon_pt_cut_))
00380          continue;
00381       ++nMuons;
00382 
00383       hRAL_pt_muons_->Fill(mu_i->pt());
00384       hRAL_eta_muons_->Fill(mu_i->eta());
00385       hRAL_phi_muons_->Fill(mu_i->phi());
00386 
00387       reco::MuonIsolation muIso = mu_i->isolationR03();
00388       hRAL_Iso_muons_->Fill(muIso.emEt + muIso.hadEt + muIso.sumPt);
00389 
00390       //Muon muon pairs
00391       for (typename std::vector<Mu>::const_iterator mu_j = muons->begin(); mu_j != muons->end(); ++mu_j) {
00392          if (mu_i >= mu_j)
00393             continue;
00394          if (!(goodSusyMuon(&(*mu_j)) && mu_j->pt() > RAL_muon_pt_cut_))
00395             continue;
00396 
00397          inv = (mu_i->p4() + mu_j->p4()).M();
00398          if (mu_i->charge() * mu_j->charge() > 0) {
00399             ++nSSmumu;
00400             hRAL_mass_SS_mumu_->Fill(inv);
00401          }
00402          if (mu_i->charge() * mu_j->charge() < 0) {
00403             ++nOSmumu;
00404             hRAL_mass_OS_mumu_->Fill(inv);
00405          }
00406       }
00407 
00408       //Electron muon pairs
00409       for (typename std::vector<Ele>::const_iterator ele_j = elecs->begin(); ele_j != elecs->end(); ++ele_j) {
00410          if (!(goodSusyElectron(&(*ele_j)) && ele_j->pt() > RAL_elec_pt_cut_))
00411             continue;
00412          inv = (mu_i->p4() + ele_j->p4()).M();
00413          dR = deltaR(*mu_i, *ele_j);
00414          hRAL_dR_emu_->Fill(dR);
00415          if (mu_i->charge() * ele_j->charge() > 0) {
00416             ++nSSemu;
00417             hRAL_mass_SS_emu_->Fill(inv);
00418          }
00419          if (mu_i->charge() * ele_j->charge() < 0) {
00420             ++nOSemu;
00421             hRAL_mass_OS_emu_->Fill(inv);
00422          }
00423       }
00424    }
00425 
00426    hRAL_N_muons_->Fill(nMuons);
00427 
00428    int nElectrons = 0;
00429    int nSSee = 0;
00430    int nOSee = 0;
00431    for (typename std::vector<Ele>::const_iterator ele_i = elecs->begin(); ele_i != elecs->end(); ++ele_i) {
00432       if (!(goodSusyElectron(&(*ele_i)) && ele_i->pt() > RAL_elec_pt_cut_))
00433          continue;
00434       nElectrons++;
00435 
00436       hRAL_pt_elecs_->Fill(ele_i->pt());
00437       hRAL_eta_elecs_->Fill(ele_i->eta());
00438       hRAL_phi_elecs_->Fill(ele_i->phi());
00439 
00440       hRAL_Iso_elecs_->Fill(ele_i->dr03TkSumPt() + ele_i->dr03EcalRecHitSumEt() + ele_i->dr03HcalTowerSumEt());
00441 
00442       //Electron electron pairs
00443       for (typename std::vector<Ele>::const_iterator ele_j = elecs->begin(); ele_j != elecs->end(); ++ele_j) {
00444          if (ele_i >= ele_j)
00445             continue;
00446          if (!(goodSusyElectron(&(*ele_j)) && ele_j->pt() > RAL_elec_pt_cut_))
00447             continue;
00448 
00449          inv = (ele_i->p4() + ele_j->p4()).M();
00450          if (ele_i->charge() * ele_j->charge() > 0) {
00451             ++nSSee;
00452             hRAL_mass_SS_ee_->Fill(inv);
00453          }
00454          if (ele_i->charge() * ele_j->charge() < 0) {
00455             ++nOSee;
00456             hRAL_mass_OS_ee_->Fill(inv);
00457          }
00458       }
00459    }
00460 
00461    hRAL_N_elecs_->Fill(nElectrons);
00462 
00463    if (MET > RAL_met_cut_ && sumPt > RAL_jet_sum_pt_cut_) {
00464       if (nMuons >= 1) {
00465          hRAL_Muon_monitor_->Fill(sumPt, MET);
00466       }
00467       if (nElectrons >= 1) {
00468          hRAL_Electron_monitor_->Fill(sumPt, MET);
00469       }
00470       if (nOSee >= 1) {
00471          hRAL_OSee_monitor_->Fill(sumPt, MET);
00472       }
00473       if (nOSemu >= 1) {
00474          hRAL_OSemu_monitor_->Fill(sumPt, MET);
00475       }
00476       if (nOSmumu >= 1) {
00477          hRAL_OSmumu_monitor_->Fill(sumPt, MET);
00478       }
00479       if (nSSee >= 1) {
00480          hRAL_SSee_monitor_->Fill(sumPt, MET);
00481       }
00482       if (nSSemu >= 1) {
00483          hRAL_SSemu_monitor_->Fill(sumPt, MET);
00484       }
00485       if (nSSmumu >= 1) {
00486          hRAL_SSmumu_monitor_->Fill(sumPt, MET);
00487       }
00488    }
00489    if (nMuons >= 3) {
00490       hRAL_TriMuon_monitor_->Fill(sumPt, MET);
00491    }
00492 
00493 }
00494 
00495 template<typename Mu, typename Ele, typename Jet, typename Met>
00496 void SusyDQM<Mu, Ele, Jet, Met>::endRun(const edm::Run& run) {
00497 
00498 }
00499 
00500 template<typename Mu, typename Ele, typename Jet, typename Met>
00501 void SusyDQM<Mu, Ele, Jet, Met>::endJob() {
00502 
00503 }
00504 
00505 #endif
00506 
00507 typedef SusyDQM<reco::Muon, reco::GsfElectron, reco::CaloJet, reco::CaloMET> RecoSusyDQM;
00508 //typedef SusyDQM< pat::Muon, pat::Electron, pat::Jet, pat::MET > PatSusyDQM;