DiMuonHistograms Class Reference

#include <DiMuonHistograms.h>

Inheritance diagram for DiMuonHistograms:

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
	DiMuonHistograms (const edm::ParameterSet &pset)
	~DiMuonHistograms () override
Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final
void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer ()
void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	endRun (edm::Run const &run, edm::EventSetup const &setup) final
virtual bool	getCanSaveByLumi ()
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	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

Private Attributes
int	etaBBin
int	etaBin
double	etaBMax
double	etaBMin
double	EtaCutMax
double	EtaCutMin
int	etaEBin
double	etaECMax
double	etaECMin
std::string	EtaName [3]
int	etaOvlpBin
std::vector< MonitorElement * >	GlbGlbMuon_HM
std::vector< MonitorElement * >	GlbGlbMuon_LM
double	HighMassMax
double	HighMassMin
std::vector< MonitorElement * >	LooseLooseMuon
std::vector< MonitorElement * >	LooseLooseMuonBadFrac
double	LowMassMax
double	LowMassMin
std::vector< MonitorElement * >	MediumMediumMuon
std::vector< MonitorElement * >	MediumMediumMuonBadFrac
std::string	metname
int	nGlbGlb
int	nLooseLoose
int	nMediumMedium
int	nTightTight
edm::ParameterSet	parameters
std::vector< MonitorElement * >	SoftSoftMuon
std::vector< MonitorElement * >	SoftSoftMuonBadFrac
std::vector< MonitorElement * >	StaTrkMuon_HM
std::vector< MonitorElement * >	StaTrkMuon_LM
MonitorElement *	test
edm::EDGetTokenT< reco::BeamSpot >	theBeamSpotLabel_
std::string	theFolder
edm::EDGetTokenT< edm::View< reco::Muon > >	theMuonCollectionLabel_
MuonServiceProxy *	theService
edm::EDGetTokenT< reco::VertexCollection >	theVertexLabel_
std::vector< MonitorElement * >	TightTightMuon
std::vector< MonitorElement * >	TightTightMuonBadFrac
std::vector< MonitorElement * >	TrkTrkMuon_HM
std::vector< MonitorElement * >	TrkTrkMuon_LM

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore
typedef dqm::reco::MonitorElement	MonitorElement
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
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
Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)
static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)
Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const
Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_
unsigned int	streamId_

Detailed Description

Class DiMuonHistograms

DQM monitoring for dimuon mass

Author: S.Folgueras, U. Oviedo

Definition at line 31 of file DiMuonHistograms.h.

Constructor & Destructor Documentation

DiMuonHistograms()

DiMuonHistograms::DiMuonHistograms

(

const edm::ParameterSet &

pset

)

Definition at line 31 of file DiMuonHistograms.cc.

References DQMOfflineHeavyIons_cff::etaBBin, muonRecoAnalyzer_cfi::etaBin, diMuonHistograms_cfi::etaBMax, diMuonHistograms_cfi::etaBMin, DQMOfflineHeavyIons_cff::etaEBin, diMuonHistograms_cfi::etaECMax, diMuonHistograms_cfi::etaECMin, DQMOfflineHeavyIons_cff::HighMassMax, DQMOfflineHeavyIons_cff::HighMassMin, DQMOfflineHeavyIons_cff::LowMassMax, and DQMOfflineHeavyIons_cff::LowMassMin.

                                                              {
  // initialise parameters:
  parameters = pSet;

  // counter
  nTightTight = 0;
  nMediumMedium = 0;
  nLooseLoose = 0;
  nGlbGlb = 0;

  // declare consumes:
  theMuonCollectionLabel_ = consumes<edm::View<reco::Muon> >(parameters.getParameter<edm::InputTag>("MuonCollection"));
  theVertexLabel_ = consumes<reco::VertexCollection>(parameters.getParameter<edm::InputTag>("VertexLabel"));

  theBeamSpotLabel_ = mayConsume<reco::BeamSpot>(parameters.getParameter<edm::InputTag>("BeamSpotLabel"));

  etaBin = parameters.getParameter<int>("etaBin");
  etaBBin = parameters.getParameter<int>("etaBBin");
  etaEBin = parameters.getParameter<int>("etaEBin");

  etaBMin = parameters.getParameter<double>("etaBMin");
  etaBMax = parameters.getParameter<double>("etaBMax");
  etaECMin = parameters.getParameter<double>("etaECMin");
  etaECMax = parameters.getParameter<double>("etaECMax");

  LowMassMin = parameters.getParameter<double>("LowMassMin");
  LowMassMax = parameters.getParameter<double>("LowMassMax");
  HighMassMin = parameters.getParameter<double>("HighMassMin");
  HighMassMax = parameters.getParameter<double>("HighMassMax");

  theFolder = parameters.getParameter<string>("folder");
}

~DiMuonHistograms()

DiMuonHistograms::~DiMuonHistograms ( )

override

Definition at line 64 of file DiMuonHistograms.cc.

{}

Member Function Documentation

analyze()

void DiMuonHistograms::analyze ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 142 of file DiMuonHistograms.cc.

References cms::cuda::bs, ALCARECOTkAlJpsiMuMu_cff::charge, relativeConstraints::error, diMuonHistograms_cfi::etaBMax, diMuonHistograms_cfi::etaBMin, diMuonHistograms_cfi::etaECMax, diMuonHistograms_cfi::etaECMin, DQMOfflineHeavyIons_cff::HighMassMin, iEvent, muon::isLooseMuon(), muon::isMediumMuon(), muon::isSoftMuon(), muon::isTightMuon(), LogTrace, DQMOfflineHeavyIons_cff::LowMassMax, metname, PDWG_BPHSkim_cff::muons, position, bphysicsOniaDQM_cfi::vertex, and L1BJetProducer_cff::vtx.

                                                                                  {
  LogTrace(metname) << "[DiMuonHistograms] Analyze the mu in different eta regions";
  edm::Handle<edm::View<reco::Muon> > muons;
  iEvent.getByToken(theMuonCollectionLabel_, muons);

  // =================================================================================
  // Look for the Primary Vertex (and use the BeamSpot instead, if you can't find it):
  reco::Vertex::Point posVtx;
  reco::Vertex::Error errVtx;
  unsigned int theIndexOfThePrimaryVertex = 999.;

  edm::Handle<reco::VertexCollection> vertex;
  iEvent.getByToken(theVertexLabel_, vertex);
  if (vertex.isValid()) {
    for (unsigned int ind = 0; ind < vertex->size(); ++ind) {
      if ((*vertex)[ind].isValid() && !((*vertex)[ind].isFake())) {
        theIndexOfThePrimaryVertex = ind;
        break;
      }
    }
  }

  if (theIndexOfThePrimaryVertex < 100) {
    posVtx = ((*vertex)[theIndexOfThePrimaryVertex]).position();
    errVtx = ((*vertex)[theIndexOfThePrimaryVertex]).error();
  } else {
    LogInfo("RecoMuonValidator") << "reco::PrimaryVertex not found, use BeamSpot position instead\n";

    edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
    iEvent.getByToken(theBeamSpotLabel_, recoBeamSpotHandle);
    reco::BeamSpot bs = *recoBeamSpotHandle;

    posVtx = bs.position();
    errVtx(0, 0) = bs.BeamWidthX();
    errVtx(1, 1) = bs.BeamWidthY();
    errVtx(2, 2) = bs.sigmaZ();
  }

  const reco::Vertex vtx(posVtx, errVtx);

  if (!muons.isValid())
    return;

  // Loop on muon collection
  TLorentzVector Mu1, Mu2;
  float charge = 99.;
  float InvMass = -99.;

  //Eta regions
  double EtaCutMin[] = {0, etaBMin, etaECMin};
  double EtaCutMax[] = {2.4, etaBMax, etaECMax};

  for (edm::View<reco::Muon>::const_iterator muon1 = muons->begin(); muon1 != muons->end(); ++muon1) {
    LogTrace(metname) << "[DiMuonHistograms] loop over 1st muon" << endl;

    // Loop on second muons to fill invariant mass plots
    for (edm::View<reco::Muon>::const_iterator muon2 = muon1; muon2 != muons->end(); ++muon2) {
      LogTrace(metname) << "[DiMuonHistograms] loop over 2nd muon" << endl;
      if (muon1 == muon2)
        continue;

      // Global-Global Muon
      if (muon1->isGlobalMuon() && muon2->isGlobalMuon()) {
        LogTrace(metname) << "[DiMuonHistograms] Glb-Glb pair" << endl;
        reco::TrackRef recoCombinedGlbTrack1 = muon1->combinedMuon();
        reco::TrackRef recoCombinedGlbTrack2 = muon2->combinedMuon();
        Mu1.SetPxPyPzE(recoCombinedGlbTrack1->px(),
                       recoCombinedGlbTrack1->py(),
                       recoCombinedGlbTrack1->pz(),
                       recoCombinedGlbTrack1->p());
        Mu2.SetPxPyPzE(recoCombinedGlbTrack2->px(),
                       recoCombinedGlbTrack2->py(),
                       recoCombinedGlbTrack2->pz(),
                       recoCombinedGlbTrack2->p());

        charge = recoCombinedGlbTrack1->charge() * recoCombinedGlbTrack2->charge();
        if (charge < 0) {
          InvMass = (Mu1 + Mu2).M();
          for (unsigned int iEtaRegion = 0; iEtaRegion < 3; iEtaRegion++) {
            if (fabs(recoCombinedGlbTrack1->eta()) > EtaCutMin[iEtaRegion] &&
                fabs(recoCombinedGlbTrack1->eta()) < EtaCutMax[iEtaRegion] &&
                fabs(recoCombinedGlbTrack2->eta()) > EtaCutMin[iEtaRegion] &&
                fabs(recoCombinedGlbTrack2->eta()) < EtaCutMax[iEtaRegion]) {
              if (InvMass < LowMassMax)
                GlbGlbMuon_LM[iEtaRegion]->Fill(InvMass);
              if (InvMass > HighMassMin)
                GlbGlbMuon_HM[iEtaRegion]->Fill(InvMass);
            }
          }
        }
        // Also Tight-Tight Muon Selection
        if (muon::isTightMuon(*muon1, vtx) && muon::isTightMuon(*muon2, vtx)) {
          test->Fill(InvMass);
          LogTrace(metname) << "[DiMuonHistograms] Tight-Tight pair" << endl;
          if (charge < 0) {
            for (unsigned int iEtaRegion = 0; iEtaRegion < 3; iEtaRegion++) {
              if (fabs(recoCombinedGlbTrack1->eta()) > EtaCutMin[iEtaRegion] &&
                  fabs(recoCombinedGlbTrack1->eta()) < EtaCutMax[iEtaRegion] &&
                  fabs(recoCombinedGlbTrack2->eta()) > EtaCutMin[iEtaRegion] &&
                  fabs(recoCombinedGlbTrack2->eta()) < EtaCutMax[iEtaRegion]) {
                if (InvMass > 55. && InvMass < 125.) {
                  TightTightMuon[iEtaRegion]->Fill(InvMass);
                  TightTightMuonBadFrac[iEtaRegion]->Fill(muon1->innerTrack()->lost() / muon1->innerTrack()->found());
                }
              }
            }
          }
        }
        // Also Medium-Medium Muon Selection
        if (muon::isMediumMuon(*muon1) && muon::isMediumMuon(*muon2)) {
          test->Fill(InvMass);
          LogTrace(metname) << "[DiMuonHistograms] Medium-Medium pair" << endl;
          if (charge < 0) {
            for (unsigned int iEtaRegion = 0; iEtaRegion < 3; iEtaRegion++) {
              if (fabs(recoCombinedGlbTrack1->eta()) > EtaCutMin[iEtaRegion] &&
                  fabs(recoCombinedGlbTrack1->eta()) < EtaCutMax[iEtaRegion] &&
                  fabs(recoCombinedGlbTrack2->eta()) > EtaCutMin[iEtaRegion] &&
                  fabs(recoCombinedGlbTrack2->eta()) < EtaCutMax[iEtaRegion]) {
                if (InvMass > 55. && InvMass < 125.) {
                  MediumMediumMuon[iEtaRegion]->Fill(InvMass);
                  MediumMediumMuonBadFrac[iEtaRegion]->Fill(muon1->innerTrack()->lost() / muon1->innerTrack()->found());
                }
              }
            }
          }
        }
        // Also Loose-Loose Muon Selection
        if (muon::isLooseMuon(*muon1) && muon::isLooseMuon(*muon2)) {
          test->Fill(InvMass);
          LogTrace(metname) << "[DiMuonHistograms] Loose-Loose pair" << endl;
          if (charge < 0) {
            for (unsigned int iEtaRegion = 0; iEtaRegion < 3; iEtaRegion++) {
              if (fabs(recoCombinedGlbTrack1->eta()) > EtaCutMin[iEtaRegion] &&
                  fabs(recoCombinedGlbTrack1->eta()) < EtaCutMax[iEtaRegion] &&
                  fabs(recoCombinedGlbTrack2->eta()) > EtaCutMin[iEtaRegion] &&
                  fabs(recoCombinedGlbTrack2->eta()) < EtaCutMax[iEtaRegion]) {
                if (InvMass > 55. && InvMass < 125.) {
                  LooseLooseMuon[iEtaRegion]->Fill(InvMass);
                  LooseLooseMuonBadFrac[iEtaRegion]->Fill(muon1->innerTrack()->lost() / muon1->innerTrack()->found());
                }
              }
            }
          }
        }
      }

      // Now check for STA-TRK
      if (muon2->isStandAloneMuon() && muon1->isTrackerMuon()) {
        LogTrace(metname) << "[DiMuonHistograms] STA-Trk pair" << endl;
        reco::TrackRef recoStaTrack = muon2->standAloneMuon();
        reco::TrackRef recoTrack = muon1->track();
        Mu2.SetPxPyPzE(recoStaTrack->px(), recoStaTrack->py(), recoStaTrack->pz(), recoStaTrack->p());
        Mu1.SetPxPyPzE(recoTrack->px(), recoTrack->py(), recoTrack->pz(), recoTrack->p());

        charge = recoStaTrack->charge() * recoTrack->charge();
        if (charge < 0) {
          InvMass = (Mu1 + Mu2).M();
          for (unsigned int iEtaRegion = 0; iEtaRegion < 3; iEtaRegion++) {
            if (fabs(recoStaTrack->eta()) > EtaCutMin[iEtaRegion] &&
                fabs(recoStaTrack->eta()) < EtaCutMax[iEtaRegion] && fabs(recoTrack->eta()) > EtaCutMin[iEtaRegion] &&
                fabs(recoTrack->eta()) < EtaCutMax[iEtaRegion]) {
              if (InvMass < LowMassMax)
                StaTrkMuon_LM[iEtaRegion]->Fill(InvMass);
              if (InvMass > HighMassMin)
                StaTrkMuon_HM[iEtaRegion]->Fill(InvMass);
            }
          }
        }
      }
      if (muon1->isStandAloneMuon() && muon2->isTrackerMuon()) {
        LogTrace(metname) << "[DiMuonHistograms] STA-Trk pair" << endl;
        reco::TrackRef recoStaTrack = muon1->standAloneMuon();
        reco::TrackRef recoTrack = muon2->track();
        Mu1.SetPxPyPzE(recoStaTrack->px(), recoStaTrack->py(), recoStaTrack->pz(), recoStaTrack->p());
        Mu2.SetPxPyPzE(recoTrack->px(), recoTrack->py(), recoTrack->pz(), recoTrack->p());

        charge = recoStaTrack->charge() * recoTrack->charge();
        if (charge < 0) {
          InvMass = (Mu1 + Mu2).M();
          for (unsigned int iEtaRegion = 0; iEtaRegion < 3; iEtaRegion++) {
            if (fabs(recoStaTrack->eta()) > EtaCutMin[iEtaRegion] &&
                fabs(recoStaTrack->eta()) < EtaCutMax[iEtaRegion] && fabs(recoTrack->eta()) > EtaCutMin[iEtaRegion] &&
                fabs(recoTrack->eta()) < EtaCutMax[iEtaRegion]) {
              if (InvMass < LowMassMax)
                StaTrkMuon_LM[iEtaRegion]->Fill(InvMass);
              if (InvMass > HighMassMin)
                StaTrkMuon_HM[iEtaRegion]->Fill(InvMass);
            }
          }
        }
      }

      // TRK-TRK dimuon
      if (muon1->isTrackerMuon() && muon2->isTrackerMuon()) {
        LogTrace(metname) << "[DiMuonHistograms] Trk-Trk dimuon pair" << endl;
        reco::TrackRef recoTrack2 = muon2->track();
        reco::TrackRef recoTrack1 = muon1->track();
        Mu2.SetPxPyPzE(recoTrack2->px(), recoTrack2->py(), recoTrack2->pz(), recoTrack2->p());
        Mu1.SetPxPyPzE(recoTrack1->px(), recoTrack1->py(), recoTrack1->pz(), recoTrack1->p());

        charge = recoTrack1->charge() * recoTrack2->charge();
        if (charge < 0) {
          InvMass = (Mu1 + Mu2).M();
          for (unsigned int iEtaRegion = 0; iEtaRegion < 3; iEtaRegion++) {
            if (fabs(recoTrack1->eta()) > EtaCutMin[iEtaRegion] && fabs(recoTrack1->eta()) < EtaCutMax[iEtaRegion] &&
                fabs(recoTrack2->eta()) > EtaCutMin[iEtaRegion] && fabs(recoTrack2->eta()) < EtaCutMax[iEtaRegion]) {
              if (InvMass < LowMassMax)
                TrkTrkMuon_LM[iEtaRegion]->Fill(InvMass);
              if (InvMass > HighMassMin)
                TrkTrkMuon_HM[iEtaRegion]->Fill(InvMass);
            }
          }
        }

        LogTrace(metname) << "[DiMuonHistograms] Soft-Soft pair" << endl;

        if (muon::isSoftMuon(*muon1, vtx) && muon::isSoftMuon(*muon2, vtx)) {
          if (charge < 0) {
            InvMass = (Mu1 + Mu2).M();
            for (unsigned int iEtaRegion = 0; iEtaRegion < 3; iEtaRegion++) {
              if (fabs(recoTrack1->eta()) > EtaCutMin[iEtaRegion] && fabs(recoTrack1->eta()) < EtaCutMax[iEtaRegion] &&
                  fabs(recoTrack2->eta()) > EtaCutMin[iEtaRegion] && fabs(recoTrack2->eta()) < EtaCutMax[iEtaRegion]) {
                SoftSoftMuon[iEtaRegion]->Fill(InvMass);
                SoftSoftMuonBadFrac[iEtaRegion]->Fill(muon1->innerTrack()->lost() / muon1->innerTrack()->found());
              }
            }
          }
        }
      }
    }  //muon2
  }    //Muon1
}

bookHistograms()

void DiMuonHistograms::bookHistograms ( DQMStore::IBooker &  ibooker, edm::Run const &  , edm::EventSetup const &    )

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 66 of file DiMuonHistograms.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::NavigatorBase::cd(), DQMOfflineHeavyIons_cff::etaBBin, muonRecoAnalyzer_cfi::etaBin, DQMOfflineHeavyIons_cff::etaEBin, DQMOfflineHeavyIons_cff::HighMassMax, DQMOfflineHeavyIons_cff::HighMassMin, DQMOfflineHeavyIons_cff::LowMassMax, DQMOfflineHeavyIons_cff::LowMassMin, PFElectronDQMAnalyzer_cfi::nBin, and dqm::implementation::NavigatorBase::setCurrentFolder().

                                                              {
  ibooker.cd();
  ibooker.setCurrentFolder(theFolder);

  int nBin[3] = {etaBin, etaBBin, etaEBin};
  EtaName[0] = "";
  EtaName[1] = "_Barrel";
  EtaName[2] = "_EndCap";
  test = ibooker.book1D("test", "InvMass_{Tight,Tight}", 100, 0., 200.);
  for (unsigned int iEtaRegion = 0; iEtaRegion < 3; iEtaRegion++) {
    GlbGlbMuon_LM.push_back(ibooker.book1D("GlbGlbMuon_LM" + EtaName[iEtaRegion],
                                           "InvMass_{GLB,GLB}" + EtaName[iEtaRegion],
                                           nBin[iEtaRegion],
                                           LowMassMin,
                                           LowMassMax));
    TrkTrkMuon_LM.push_back(ibooker.book1D("TrkTrkMuon_LM" + EtaName[iEtaRegion],
                                           "InvMass_{TRK,TRK}" + EtaName[iEtaRegion],
                                           nBin[iEtaRegion],
                                           LowMassMin,
                                           LowMassMax));
    StaTrkMuon_LM.push_back(ibooker.book1D("StaTrkMuon_LM" + EtaName[iEtaRegion],
                                           "InvMass_{STA,TRK}" + EtaName[iEtaRegion],
                                           nBin[iEtaRegion],
                                           LowMassMin,
                                           LowMassMax));

    GlbGlbMuon_HM.push_back(ibooker.book1D("GlbGlbMuon_HM" + EtaName[iEtaRegion],
                                           "InvMass_{GLB,GLB}" + EtaName[iEtaRegion],
                                           nBin[iEtaRegion],
                                           HighMassMin,
                                           HighMassMax));
    TrkTrkMuon_HM.push_back(ibooker.book1D("TrkTrkMuon_HM" + EtaName[iEtaRegion],
                                           "InvMass_{TRK,TRK}" + EtaName[iEtaRegion],
                                           nBin[iEtaRegion],
                                           HighMassMin,
                                           HighMassMax));
    StaTrkMuon_HM.push_back(ibooker.book1D("StaTrkMuon_HM" + EtaName[iEtaRegion],
                                           "InvMass_{STA,TRK}" + EtaName[iEtaRegion],
                                           nBin[iEtaRegion],
                                           HighMassMin,
                                           HighMassMax));

    // arround the Z peak
    TightTightMuon.push_back(ibooker.book1D("TightTightMuon" + EtaName[iEtaRegion],
                                            "InvMass_{Tight,Tight}" + EtaName[iEtaRegion],
                                            nBin[iEtaRegion],
                                            LowMassMin,
                                            LowMassMax));
    MediumMediumMuon.push_back(ibooker.book1D("MediumMediumMuon" + EtaName[iEtaRegion],
                                              "InvMass_{Medium,Medium}" + EtaName[iEtaRegion],
                                              nBin[iEtaRegion],
                                              LowMassMin,
                                              LowMassMax));
    LooseLooseMuon.push_back(ibooker.book1D("LooseLooseMuon" + EtaName[iEtaRegion],
                                            "InvMass_{Loose,Loose}" + EtaName[iEtaRegion],
                                            nBin[iEtaRegion],
                                            LowMassMin,
                                            LowMassMax));
    //Fraction of bad hits in the tracker track to the total
    TightTightMuonBadFrac.push_back(ibooker.book1D(
        "TightTightMuonBadFrac" + EtaName[iEtaRegion], "BadFrac_{Tight,Tight}" + EtaName[iEtaRegion], 10, 0, 0.4));
    MediumMediumMuonBadFrac.push_back(ibooker.book1D(
        "MediumMediumMuonBadFrac" + EtaName[iEtaRegion], "BadFrac_{Medium,Medium}" + EtaName[iEtaRegion], 10, 0, 0.4));
    LooseLooseMuonBadFrac.push_back(ibooker.book1D(
        "LooseLooseMuonBadFrac" + EtaName[iEtaRegion], "BadFrac_{Loose,Loose}" + EtaName[iEtaRegion], 10, 0, 0.4));

    // low-mass resonances
    SoftSoftMuon.push_back(ibooker.book1D(
        "SoftSoftMuon" + EtaName[iEtaRegion], "InvMass_{Soft,Soft}" + EtaName[iEtaRegion], nBin[iEtaRegion], 0.0, 55.0));
    SoftSoftMuonBadFrac.push_back(ibooker.book1D(
        "SoftSoftMuonBadFrac" + EtaName[iEtaRegion], "BadFrac_{Soft,Soft}" + EtaName[iEtaRegion], 10, 0, 0.4));
  }
}

Member Data Documentation

etaBBin

int DiMuonHistograms::etaBBin

private

Definition at line 52 of file DiMuonHistograms.h.

etaBin

int DiMuonHistograms::etaBin

private

Definition at line 51 of file DiMuonHistograms.h.

etaBMax

double DiMuonHistograms::etaBMax

private

Definition at line 62 of file DiMuonHistograms.h.

etaBMin

double DiMuonHistograms::etaBMin

private

Definition at line 61 of file DiMuonHistograms.h.

EtaCutMax

double DiMuonHistograms::EtaCutMax

private

Definition at line 60 of file DiMuonHistograms.h.

EtaCutMin

double DiMuonHistograms::EtaCutMin

private

Definition at line 59 of file DiMuonHistograms.h.

etaEBin

int DiMuonHistograms::etaEBin

private

Definition at line 53 of file DiMuonHistograms.h.

etaECMax

double DiMuonHistograms::etaECMax

private

Definition at line 64 of file DiMuonHistograms.h.

etaECMin

double DiMuonHistograms::etaECMin

private

Definition at line 63 of file DiMuonHistograms.h.

EtaName

std::string DiMuonHistograms::EtaName[3]

private

Definition at line 57 of file DiMuonHistograms.h.

etaOvlpBin

int DiMuonHistograms::etaOvlpBin

private

Definition at line 54 of file DiMuonHistograms.h.

GlbGlbMuon_HM

std::vector<MonitorElement*> DiMuonHistograms::GlbGlbMuon_HM

private

Definition at line 73 of file DiMuonHistograms.h.

GlbGlbMuon_LM

std::vector<MonitorElement*> DiMuonHistograms::GlbGlbMuon_LM

private

Definition at line 72 of file DiMuonHistograms.h.

HighMassMax

double DiMuonHistograms::HighMassMax

private

Definition at line 70 of file DiMuonHistograms.h.

HighMassMin

double DiMuonHistograms::HighMassMin

private

Definition at line 69 of file DiMuonHistograms.h.

LooseLooseMuon

std::vector<MonitorElement*> DiMuonHistograms::LooseLooseMuon

private

Definition at line 79 of file DiMuonHistograms.h.

LooseLooseMuonBadFrac

std::vector<MonitorElement*> DiMuonHistograms::LooseLooseMuonBadFrac

private

Definition at line 83 of file DiMuonHistograms.h.

LowMassMax

double DiMuonHistograms::LowMassMax

private

Definition at line 68 of file DiMuonHistograms.h.

LowMassMin

double DiMuonHistograms::LowMassMin

private

Definition at line 67 of file DiMuonHistograms.h.

MediumMediumMuon

std::vector<MonitorElement*> DiMuonHistograms::MediumMediumMuon

private

Definition at line 80 of file DiMuonHistograms.h.

MediumMediumMuonBadFrac

std::vector<MonitorElement*> DiMuonHistograms::MediumMediumMuonBadFrac

private

Definition at line 84 of file DiMuonHistograms.h.

metname

std::string DiMuonHistograms::metname

private

Definition at line 48 of file DiMuonHistograms.h.

nGlbGlb

int DiMuonHistograms::nGlbGlb

private

Definition at line 100 of file DiMuonHistograms.h.

nLooseLoose

int DiMuonHistograms::nLooseLoose

private

Definition at line 99 of file DiMuonHistograms.h.

nMediumMedium

int DiMuonHistograms::nMediumMedium

private

Definition at line 98 of file DiMuonHistograms.h.

nTightTight

int DiMuonHistograms::nTightTight

private

Definition at line 97 of file DiMuonHistograms.h.

parameters

edm::ParameterSet DiMuonHistograms::parameters

private

Definition at line 45 of file DiMuonHistograms.h.

SoftSoftMuon

std::vector<MonitorElement*> DiMuonHistograms::SoftSoftMuon

private

Definition at line 82 of file DiMuonHistograms.h.

SoftSoftMuonBadFrac

std::vector<MonitorElement*> DiMuonHistograms::SoftSoftMuonBadFrac

private

Definition at line 86 of file DiMuonHistograms.h.

StaTrkMuon_HM

std::vector<MonitorElement*> DiMuonHistograms::StaTrkMuon_HM

private

Definition at line 75 of file DiMuonHistograms.h.

StaTrkMuon_LM

std::vector<MonitorElement*> DiMuonHistograms::StaTrkMuon_LM

private

Definition at line 74 of file DiMuonHistograms.h.

test

MonitorElement* DiMuonHistograms::test

private

Definition at line 88 of file DiMuonHistograms.h.

Referenced by edmIntegrityCheck.IntegrityCheck::report(), and edmIntegrityCheck.IntegrityCheck::structured().

theBeamSpotLabel_

edm::EDGetTokenT<reco::BeamSpot> DiMuonHistograms::theBeamSpotLabel_

private

Definition at line 93 of file DiMuonHistograms.h.

theFolder

std::string DiMuonHistograms::theFolder

private

Definition at line 95 of file DiMuonHistograms.h.

theMuonCollectionLabel_

edm::EDGetTokenT<edm::View<reco::Muon> > DiMuonHistograms::theMuonCollectionLabel_

private

Definition at line 91 of file DiMuonHistograms.h.

theService

MuonServiceProxy* DiMuonHistograms::theService

private

Definition at line 44 of file DiMuonHistograms.h.

theVertexLabel_

edm::EDGetTokenT<reco::VertexCollection> DiMuonHistograms::theVertexLabel_

private

Definition at line 92 of file DiMuonHistograms.h.

TightTightMuon

std::vector<MonitorElement*> DiMuonHistograms::TightTightMuon

private

Definition at line 81 of file DiMuonHistograms.h.

TightTightMuonBadFrac

std::vector<MonitorElement*> DiMuonHistograms::TightTightMuonBadFrac

private

Definition at line 85 of file DiMuonHistograms.h.

TrkTrkMuon_HM

std::vector<MonitorElement*> DiMuonHistograms::TrkTrkMuon_HM

private

Definition at line 77 of file DiMuonHistograms.h.

TrkTrkMuon_LM

std::vector<MonitorElement*> DiMuonHistograms::TrkTrkMuon_LM

private

Definition at line 76 of file DiMuonHistograms.h.