#include <B2GDQM.h>

Inheritance diagram for B2GDQM:

Public Member Functions
	B2GDQM (const edm::ParameterSet &ps)

virtual	~B2GDQM ()

Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final

virtual void	beginStream (edm::StreamID id) final

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDAnalyzer (void)

virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

Public Member Functions inherited from edm::stream::EDAnalyzerBase
	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Protected Member Functions
virtual void	analyze (edm::Event const &e, edm::EventSetup const &eSetup)

virtual void	analyzeAllHad (edm::Event const &e, edm::EventSetup const &eSetup)

virtual void	analyzeJets (edm::Event const &e, edm::EventSetup const &eSetup)

virtual void	analyzeSemiE (edm::Event const &e, edm::EventSetup const &eSetup)

virtual void	analyzeSemiMu (edm::Event const &e, edm::EventSetup const &eSetup)

Protected Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Private Member Functions
virtual void	bookHistograms (DQMStore::IBooker &bei, edm::Run const &, edm::EventSetup const &) override

Private Attributes
MonitorElement *	allHad_mass0

MonitorElement *	allHad_mass1

MonitorElement *	allHad_minMass0

MonitorElement *	allHad_minMass1

MonitorElement *	allHad_mttbar

MonitorElement *	allHad_phi0

MonitorElement *	allHad_phi1

MonitorElement *	allHad_pt0

MonitorElement *	allHad_pt1

MonitorElement *	allHad_y0

MonitorElement *	allHad_y1

double	allHadDeltaPhiCut_

double	allHadPtCut_

double	allHadRapidityCut_

std::vector< MonitorElement * >	boostedJet_massDrop

std::vector< MonitorElement * >	boostedJet_minMass

std::vector< MonitorElement * >	boostedJet_subjetM

std::vector< MonitorElement * >	boostedJet_subjetN

std::vector< MonitorElement * >	boostedJet_subjetPhi

std::vector< MonitorElement * >	boostedJet_subjetPt

std::vector< MonitorElement * >	boostedJet_subjetY

edm::InputTag	cmsTagLabel_

edm::EDGetTokenT< edm::View < reco::BasicJet > >	cmsTagToken_

std::shared_ptr < StringCutObjectSelector < reco::GsfElectron > >	elecSelect_

edm::InputTag	electronLabel_

edm::EDGetTokenT< edm::View < reco::GsfElectron > >	electronToken_

HLTConfigProvider	hltConfigProvider_

int	ievt

int	irun

bool	isValidHltConfig_

std::vector< edm::InputTag >	jetLabels_

std::vector< double >	jetPtMins_

std::vector< edm::EDGetTokenT < edm::View< reco::Jet > > >	jetTokens_

edm::InputTag	muonLabel_

std::shared_ptr < StringCutObjectSelector < reco::Muon > >	muonSelect_

edm::EDGetTokenT< edm::View < reco::Muon > >	muonToken_

int	nEvents_

int	nLumiSecs_

std::vector< MonitorElement * >	pfJet_cemf

std::vector< MonitorElement * >	pfJet_chef

std::vector< MonitorElement * >	pfJet_m

std::vector< MonitorElement * >	pfJet_nemf

std::vector< MonitorElement * >	pfJet_nhef

std::vector< MonitorElement * >	pfJet_phi

std::vector< MonitorElement * >	pfJet_pt

std::vector< MonitorElement * >	pfJet_y

std::string	PFJetCorService_

MonitorElement *	pfMet_phi

MonitorElement *	pfMet_pt

edm::InputTag	PFMETLabel_

edm::EDGetTokenT< std::vector < reco::PFMET > >	PFMETToken_

double	semiE_dphiHadCut_

double	semiE_dRMin_

MonitorElement *	semiE_eDRMin

MonitorElement *	semiE_eEta

MonitorElement *	semiE_ePhi

MonitorElement *	semiE_ePt

MonitorElement *	semiE_ePtRel

MonitorElement *	semiE_hadJetDR

MonitorElement *	semiE_hadJetMass

MonitorElement *	semiE_hadJetMinMass

MonitorElement *	semiE_hadJetPhi

MonitorElement *	semiE_hadJetPt

double	semiE_HadJetPtCut_

MonitorElement *	semiE_hadJetY

double	semiE_LepJetPtCut_

MonitorElement *	semiE_mttbar

double	semiE_ptRel_

double	semiMu_dphiHadCut_

double	semiMu_dRMin_

MonitorElement *	semiMu_hadJetDR

MonitorElement *	semiMu_hadJetMass

MonitorElement *	semiMu_hadJetMinMass

MonitorElement *	semiMu_hadJetPhi

MonitorElement *	semiMu_hadJetPt

double	semiMu_HadJetPtCut_

MonitorElement *	semiMu_hadJetY

double	semiMu_LepJetPtCut_

MonitorElement *	semiMu_mttbar

MonitorElement *	semiMu_muDRMin

MonitorElement *	semiMu_muEta

MonitorElement *	semiMu_muPhi

MonitorElement *	semiMu_muPt

MonitorElement *	semiMu_muPtRel

double	semiMu_ptRel_

edm::InputTag	theTriggerResultsCollection

edm::Handle< edm::TriggerResults >	triggerResults_

edm::EDGetTokenT < edm::TriggerResults >	triggerToken_

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr < dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr < dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Detailed Description

Definition at line 81 of file B2GDQM.h.

Constructor & Destructor Documentation

B2GDQM::B2GDQM ( const edm::ParameterSet & ps )

Definition at line 82 of file B2GDQM.cc.

References edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                         {
 
   edm::LogInfo("B2GDQM") << " Starting B2GDQM "
                          << "\n";
 
   typedef std::vector<edm::InputTag> vtag;
 
   // Get parameters from configuration file
   // Trigger
   theTriggerResultsCollection =
       ps.getParameter<InputTag>("triggerResultsCollection");
   triggerToken_ = consumes<edm::TriggerResults>(theTriggerResultsCollection);
 
   // Jets
   jetLabels_ = ps.getParameter<std::vector<edm::InputTag> >("jetLabels");
   for (std::vector<edm::InputTag>::const_iterator
            jetlabel = jetLabels_.begin(),
            jetlabelEnd = jetLabels_.end();
        jetlabel != jetlabelEnd; ++jetlabel) {
     jetTokens_.push_back(consumes<edm::View<reco::Jet> >(*jetlabel));
   }
   cmsTagLabel_ = ps.getParameter<edm::InputTag>("cmsTagLabel");
   cmsTagToken_ = consumes<edm::View<reco::BasicJet> >(cmsTagLabel_);
 
   muonToken_ = consumes<edm::View<reco::Muon> >(
       ps.getParameter<edm::InputTag>("muonSrc"));
   electronToken_ = consumes<edm::View<reco::GsfElectron> >(
       ps.getParameter<edm::InputTag>("electronSrc"));
 
   jetPtMins_ = ps.getParameter<std::vector<double> >("jetPtMins");
   allHadPtCut_ = ps.getParameter<double>("allHadPtCut");
   allHadRapidityCut_ = ps.getParameter<double>("allHadRapidityCut");
   allHadDeltaPhiCut_ = ps.getParameter<double>("allHadDeltaPhiCut");
 
   semiMu_HadJetPtCut_ = ps.getParameter<double>("semiMu_HadJetPtCut");
   semiMu_LepJetPtCut_ = ps.getParameter<double>("semiMu_LepJetPtCut");
   semiMu_dphiHadCut_ = ps.getParameter<double>("semiMu_dphiHadCut");
   semiMu_dRMin_ = ps.getParameter<double>("semiMu_dRMin");
   semiMu_ptRel_ = ps.getParameter<double>("semiMu_ptRel");
   muonSelect_ = std::shared_ptr<StringCutObjectSelector<reco::Muon> >(
       new StringCutObjectSelector<reco::Muon>(
           ps.getParameter<std::string>("muonSelect")));
 
   semiE_HadJetPtCut_ = ps.getParameter<double>("semiE_HadJetPtCut");
   semiE_dphiHadCut_ = ps.getParameter<double>("semiE_dphiHadCut");
   semiE_dRMin_ = ps.getParameter<double>("semiE_dRMin");
   semiE_ptRel_ = ps.getParameter<double>("semiE_ptRel");
   elecSelect_ = std::shared_ptr<StringCutObjectSelector<reco::GsfElectron> >(
       new StringCutObjectSelector<reco::GsfElectron>(
           ps.getParameter<std::string>("elecSelect")));
 
   PFJetCorService_ = ps.getParameter<std::string>("PFJetCorService");
 
   // MET
   PFMETLabel_ = ps.getParameter<InputTag>("pfMETCollection");
   PFMETToken_ = consumes<std::vector<reco::PFMET> >(PFMETLabel_);
 }

B2GDQM::~B2GDQM ( )

virtual

Definition at line 143 of file B2GDQM.cc.

                 {
   edm::LogInfo("B2GDQM") << " Deleting B2GDQM "
                          << "\n";
 }

Member Function Documentation

void B2GDQM::analyze	(	edm::Event const &	e,
		edm::EventSetup const &	eSetup
	)

protectedvirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 310 of file B2GDQM.cc.

                                                                         {
 
   analyzeJets(iEvent, iSetup);
   analyzeSemiMu(iEvent, iSetup);
   analyzeSemiE(iEvent, iSetup);
   analyzeAllHad(iEvent, iSetup);
 }

void B2GDQM::analyzeAllHad	(	edm::Event const &	e,
		edm::EventSetup const &	eSetup
	)

protectedvirtual

Definition at line 414 of file B2GDQM.cc.

References funct::abs(), reco::deltaPhi(), edm::Event::getByToken(), edm::Ptr< T >::isAvailable(), M_PI, and reco::CATopJetProperties::minMass.

                                                                            {
 
   edm::Handle<edm::View<reco::BasicJet> > jetCollection;
   bool validJets = iEvent.getByToken(cmsTagToken_, jetCollection);
   if (!validJets) return;
 
   // Require two back-to-back jets at high pt with |delta y| < 1.0
   if (jetCollection->size() < 2) return;
   edm::Ptr<reco::BasicJet> jet0 = jetCollection->ptrAt(0);
   edm::Ptr<reco::BasicJet> jet1 = jetCollection->ptrAt(1);
   if (jet0.isAvailable() == false || jet1.isAvailable() == false) return;
   if (jet0->pt() < allHadPtCut_ || jet1->pt() < allHadPtCut_) return;
   if (std::abs(jet0->rapidity() - jet1->rapidity()) > allHadRapidityCut_)
     return;
   if (std::abs(reco::deltaPhi(jet0->phi(), jet1->phi())) < M_PI * 0.5) return;
 
   CATopJetHelper helper(173., 80.4);
 
   allHad_pt0->Fill(jet0->pt());
   allHad_y0->Fill(jet0->rapidity());
   allHad_phi0->Fill(jet0->phi());
   allHad_mass0->Fill(jet0->mass());
   reco::CATopJetProperties properties0 = helper(*jet0);
   if (jet0->numberOfDaughters() > 2) {
     allHad_minMass0->Fill(properties0.minMass);
   } else {
     allHad_minMass0->Fill(-1.0);
   }
 
   allHad_pt1->Fill(jet1->pt());
   allHad_y1->Fill(jet1->rapidity());
   allHad_phi1->Fill(jet1->phi());
   allHad_mass1->Fill(jet1->mass());
   reco::CATopJetProperties properties1 = helper(*jet1);
   if (jet1->numberOfDaughters() > 2) {
     allHad_minMass1->Fill(properties1.minMass);
   } else {
     allHad_minMass1->Fill(-1.0);
   }
 
   auto p4cand = (jet0->p4() + jet1->p4());
   allHad_mttbar->Fill(p4cand.mass());
 }

void B2GDQM::analyzeJets	(	edm::Event const &	e,
		edm::EventSetup const &	eSetup
	)

protectedvirtual

Definition at line 318 of file B2GDQM.cc.

References edm::View< T >::begin(), reco::PFJet::chargedEmEnergyFraction(), reco::PFJet::chargedHadronEnergyFraction(), compareJSON::const, edm::View< T >::end(), edm::Event::getByToken(), icoll, metsig::jet, diffTwoXMLs::label, reco::Candidate::mass(), reco::CATopJetProperties::minMass, reco::PFJet::neutralEmEnergyFraction(), reco::PFJet::neutralHadronEnergyFraction(), HLT_FULL_cff::pfJetCollection, phi, reco::Candidate::phi(), EnergyCorrector::pt, reco::Candidate::pt(), and reco::Candidate::rapidity().

                                                                          {
 
   // Loop over the different types of jets,
   //   Loop over the jets in that collection,
   //     fill PF jet information as well as substructure
   //     information for boosted jets.
   // Utilizes the CMS top-tagging algorithm and the "mass drop" W-tagger.
   for (unsigned int icoll = 0; icoll < jetLabels_.size(); ++icoll) {
 
     edm::Handle<edm::View<reco::Jet> > pfJetCollection;
     bool ValidPFJets = iEvent.getByToken(jetTokens_[icoll], pfJetCollection);
     if (!ValidPFJets) continue;
     edm::View<reco::Jet> const& pfjets = *pfJetCollection;
 
     // Jet Correction
     int countJet = 0;
     // const JetCorrector* pfcorrector =
     // JetCorrector::getJetCorrector(PFJetCorService_,iSetup);
 
     for (edm::View<reco::Jet>::const_iterator jet = pfjets.begin(),
                                               jetEnd = pfjets.end();
          jet != jetEnd; ++jet) {
       if (jet->pt() < jetPtMins_[icoll]) continue;
       pfJet_pt[icoll]->Fill(jet->pt());
       pfJet_y[icoll]->Fill(jet->rapidity());
       pfJet_phi[icoll]->Fill(jet->phi());
       pfJet_m[icoll]->Fill(jet->mass());
 
       // Dynamic cast the base class (reco::Jet) to the derived class (PFJet)
       // to access the PFJet information
       reco::PFJet const* pfjet = dynamic_cast<reco::PFJet const*>(&*jet);
 
       if (pfjet != 0) {
         pfJet_chef[icoll]->Fill(pfjet->chargedHadronEnergyFraction());
         pfJet_nhef[icoll]->Fill(pfjet->neutralHadronEnergyFraction());
         pfJet_cemf[icoll]->Fill(pfjet->chargedEmEnergyFraction());
         pfJet_nemf[icoll]->Fill(pfjet->neutralEmEnergyFraction());
       }
 
       // Dynamic cast the base class (reco::Jet) to the derived class (BasicJet)
       // to access the substructure information
       reco::BasicJet const* basicjet =
           dynamic_cast<reco::BasicJet const*>(&*jet);
 
       if (basicjet != 0) {
         boostedJet_subjetN[icoll]->Fill(jet->numberOfDaughters());
 
         for (unsigned int ida = 0; ida < jet->numberOfDaughters(); ++ida) {
           reco::Candidate const* subjet = jet->daughter(ida);
           boostedJet_subjetPt[icoll]->Fill(subjet->pt());
           boostedJet_subjetY[icoll]->Fill(subjet->rapidity());
           boostedJet_subjetPhi[icoll]->Fill(subjet->phi());
           boostedJet_subjetM[icoll]->Fill(subjet->mass());
         }
         // Check the various tagging algorithms
 
         // For top-tagging, check the minimum mass pairing
         if (jetLabels_[icoll].label() == "cmsTopTagPFJetsCHS") {
           CATopJetHelper helper(173., 80.4);
           reco::CATopJetProperties properties = helper(*basicjet);
           if (jet->numberOfDaughters() > 2) {
             boostedJet_minMass[icoll]->Fill(properties.minMass);
           } else {
             boostedJet_minMass[icoll]->Fill(-1.0);
           }
 
           // For W-tagging, check the mass drop
         } else if ((jetLabels_[icoll].label() == "ak8PFJetsCHSPruned")||(jetLabels_[icoll].label() == "ak8PFJetsCHSSoftdrop")) {
           if (jet->numberOfDaughters() > 1) {
             reco::Candidate const* da0 = jet->daughter(0);
             reco::Candidate const* da1 = jet->daughter(1);
             if (da0->mass() > da1->mass()) {
               boostedJet_massDrop[icoll]->Fill(da0->mass() / jet->mass());
             } else {
               boostedJet_massDrop[icoll]->Fill(da1->mass() / jet->mass());
             }
           } else {
             boostedJet_massDrop[icoll]->Fill(-1.0);
           }
 
         }  // end if collection is AK8 PFJets CHS Pruned
 
       }  // end if basic jet != 0
       countJet++;
     }
   }
 
   // PFMETs
   edm::Handle<std::vector<reco::PFMET> > pfMETCollection;
   bool ValidPFMET = iEvent.getByToken(PFMETToken_, pfMETCollection);
   if (!ValidPFMET) return;
 
   pfMet_pt->Fill((*pfMETCollection)[0].pt());
   pfMet_phi->Fill((*pfMETCollection)[0].phi());
 }

void B2GDQM::analyzeSemiE	(	edm::Event const &	e,
		edm::EventSetup const &	eSetup
	)

protectedvirtual

Definition at line 535 of file B2GDQM.cc.

References funct::abs(), reco::deltaPhi(), reco::deltaR(), HLT_25ns14e33_v1_cff::dRMin, metsig::electron, reco::LeafCandidate::eta(), edm::Event::getByToken(), edm::Ptr< T >::isAvailable(), M_PI, reco::CATopJetProperties::minMass, reco::GsfElectron::p4(), reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), and contentValuesCheck::ss.

                                                                           {
 
   edm::Handle<edm::View<reco::GsfElectron> > electronCollection;
   bool validElectrons = iEvent.getByToken(electronToken_, electronCollection);
 
   if (!validElectrons) return;
   if (electronCollection->size() < 1) return;
   reco::GsfElectron const& electron = electronCollection->at(0);
   if (!(*elecSelect_)(electron)) return;
 
   edm::Handle<edm::View<reco::BasicJet> > jetCollection;
   bool validJets = iEvent.getByToken(cmsTagToken_, jetCollection);
   if (!validJets) return;
   if (jetCollection->size() < 2) return;
 
   double pt0 = -1.0;
   double dRMin = 999.0;
   edm::Ptr<reco::BasicJet> hadJet;  // highest pt jet with dphi(lep,jet) > pi/2
   edm::Ptr<reco::BasicJet> lepJet;  // closest jet to lepton with pt > ptMin
 
   for (auto ijet = jetCollection->begin(), ijetBegin = ijet,
             ijetEnd = jetCollection->end();
        ijet != ijetEnd; ++ijet) {
     // Hadronic jets
     if (std::abs(reco::deltaPhi(electron, *ijet)) > M_PI * 0.5) {
       if (ijet->pt() > pt0 && ijet->p() > semiE_HadJetPtCut_) {
         hadJet = jetCollection->ptrAt(ijet - ijetBegin);
         pt0 = hadJet->pt();
       }
     }
     // Leptonic jets
     else if (ijet->pt() > semiE_LepJetPtCut_) {
       auto idRMin = reco::deltaR(electron, *ijet);
       if (idRMin < dRMin) {
         lepJet = jetCollection->ptrAt(ijet - ijetBegin);
         dRMin = idRMin;
       }
     }
   }
   if (hadJet.isAvailable() == false || lepJet.isAvailable() == false) return;
 
   auto lepJetP4 = lepJet->p4();
   auto electronP4 = electron.p4();
 
   double tot = lepJetP4.mag2();
   double ss = electronP4.Dot(lepJet->p4());
   double per = electronP4.mag2();
   if (tot > 0.0) per -= ss * ss / tot;
   if (per < 0) per = 0;
   double ptRel = per;
   bool pass2D = dRMin > semiE_dRMin_ || ptRel > semiE_ptRel_;
 
   if (!pass2D) return;
 
   CATopJetHelper helper(173., 80.4);
 
   semiE_ePt->Fill(electron.pt());
   semiE_eEta->Fill(electron.eta());
   semiE_ePhi->Fill(electron.phi());
   semiE_eDRMin->Fill(dRMin);
   semiE_ePtRel->Fill(ptRel);
 
   semiE_hadJetDR->Fill(reco::deltaR(electron, *hadJet));
   semiE_mttbar->Fill(0.0);
 
   semiE_hadJetPt->Fill(hadJet->pt());
   semiE_hadJetY->Fill(hadJet->rapidity());
   semiE_hadJetPhi->Fill(hadJet->phi());
   semiE_hadJetMass->Fill(hadJet->mass());
   reco::CATopJetProperties properties0 = helper(*hadJet);
   if (hadJet->numberOfDaughters() > 2) {
     semiE_hadJetMinMass->Fill(properties0.minMass);
   } else {
     semiE_hadJetMinMass->Fill(-1.0);
   }
 }

void B2GDQM::analyzeSemiMu	(	edm::Event const &	e,
		edm::EventSetup const &	eSetup
	)

protectedvirtual

Definition at line 458 of file B2GDQM.cc.

References funct::abs(), reco::deltaPhi(), reco::deltaR(), HLT_25ns14e33_v1_cff::dRMin, reco::LeafCandidate::eta(), edm::Event::getByToken(), edm::Ptr< T >::isAvailable(), M_PI, reco::CATopJetProperties::minMass, metsig::muon, reco::LeafCandidate::p4(), reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), and contentValuesCheck::ss.

                                                                            {
 
   edm::Handle<edm::View<reco::Muon> > muonCollection;
   bool validMuons = iEvent.getByToken(muonToken_, muonCollection);
 
   if (!validMuons) return;
   if (muonCollection->size() < 1) return;
   reco::Muon const& muon = muonCollection->at(0);
   if (!(*muonSelect_)(muon)) return;
 
   edm::Handle<edm::View<reco::BasicJet> > jetCollection;
   bool validJets = iEvent.getByToken(cmsTagToken_, jetCollection);
   if (!validJets) return;
   if (jetCollection->size() < 2) return;
 
   double pt0 = -1.0;
   double dRMin = 999.0;
   edm::Ptr<reco::BasicJet> hadJet;  // highest pt jet with dphi(lep,jet) > pi/2
   edm::Ptr<reco::BasicJet> lepJet;  // closest jet to lepton with pt > ptMin
 
   for (auto ijet = jetCollection->begin(), ijetBegin = ijet,
             ijetEnd = jetCollection->end();
        ijet != ijetEnd; ++ijet) {
     // Hadronic jets
     if (std::abs(reco::deltaPhi(muon, *ijet)) > M_PI * 0.5) {
       if (ijet->pt() > pt0 && ijet->p() > semiMu_HadJetPtCut_) {
         hadJet = jetCollection->ptrAt(ijet - ijetBegin);
         pt0 = hadJet->pt();
       }
     }
     // Leptonic jets
     else if (ijet->pt() > semiMu_LepJetPtCut_) {
       auto idRMin = reco::deltaR(muon, *ijet);
       if (idRMin < dRMin) {
         lepJet = jetCollection->ptrAt(ijet - ijetBegin);
         dRMin = idRMin;
       }
     }
   }
   if (hadJet.isAvailable() == false || lepJet.isAvailable() == false) return;
 
   auto lepJetP4 = lepJet->p4();
   auto muonP4 = muon.p4();
 
   double tot = lepJetP4.mag2();
   double ss = muonP4.Dot(lepJet->p4());
   double per = muonP4.mag2();
   if (tot > 0.0) per -= ss * ss / tot;
   if (per < 0) per = 0;
   double ptRel = per;
   bool pass2D = dRMin > semiMu_dRMin_ || ptRel > semiMu_ptRel_;
 
   if (!pass2D) return;
 
   CATopJetHelper helper(173., 80.4);
 
   semiMu_muPt->Fill(muon.pt());
   semiMu_muEta->Fill(muon.eta());
   semiMu_muPhi->Fill(muon.phi());
   semiMu_muDRMin->Fill(dRMin);
   semiMu_muPtRel->Fill(ptRel);
 
   semiMu_hadJetDR->Fill(reco::deltaR(muon, *hadJet));
   semiMu_mttbar->Fill(0.0);
 
   semiMu_hadJetPt->Fill(hadJet->pt());
   semiMu_hadJetY->Fill(hadJet->rapidity());
   semiMu_hadJetPhi->Fill(hadJet->phi());
   semiMu_hadJetMass->Fill(hadJet->mass());
   reco::CATopJetProperties properties0 = helper(*hadJet);
   if (hadJet->numberOfDaughters() > 2) {
     semiMu_hadJetMinMass->Fill(properties0.minMass);
   } else {
     semiMu_hadJetMinMass->Fill(-1.0);
   }
 }

void B2GDQM::bookHistograms	(	DQMStore::IBooker &	bei,
		edm::Run const &	,
		edm::EventSetup const &
	)

overrideprivatevirtual

Implements DQMEDAnalyzer.

Definition at line 151 of file B2GDQM.cc.

References DQMStore::IBooker::book1D(), icoll, DQMStore::IBooker::setCurrentFolder(), and contentValuesCheck::ss.

                                                   {
 
   bei.setCurrentFolder("Physics/B2G");
 
   //--- Jets
 
   for (unsigned int icoll = 0; icoll < jetLabels_.size(); ++icoll) {
     std::stringstream ss;
     ss << "Physics/B2G/" << jetLabels_[icoll].label();
     bei.setCurrentFolder(ss.str().c_str());
     pfJet_pt.push_back(
         bei.book1D("pfJet_pt", "Pt of PFJet (GeV)", 50, 0.0, 1000));
     pfJet_y.push_back(
         bei.book1D("pfJet_y", "Rapidity of PFJet", 60, -6.0, 6.0));
     pfJet_phi.push_back(bei.book1D("pfJet_phi", "#phi of PFJet (radians)", 60,
                                    -3.14159, 3.14159));
     pfJet_m.push_back(
         bei.book1D("pfJet_m", "Mass of PFJet (GeV)", 50, 0.0, 500));
     pfJet_chef.push_back(
         bei.book1D("pfJet_pfchef", "PFJetID CHEF", 50, 0.0, 1.0));
     pfJet_nhef.push_back(
         bei.book1D("pfJet_pfnhef", "PFJetID NHEF", 50, 0.0, 1.0));
     pfJet_cemf.push_back(
         bei.book1D("pfJet_pfcemf", "PFJetID CEMF", 50, 0.0, 1.0));
     pfJet_nemf.push_back(
         bei.book1D("pfJet_pfnemf", "PFJetID NEMF", 50, 0.0, 1.0));
 
     boostedJet_subjetPt.push_back(
         bei.book1D("boostedJet_subjetPt", "Pt of subjets (GeV)", 50, 0.0, 500));
     boostedJet_subjetY.push_back(
         bei.book1D("boostedJet_subjetY", "Rapidity of subjets", 60, -6.0, 6.0));
     boostedJet_subjetPhi.push_back(bei.book1D("boostedJet_subjetPhi",
                                               "#phi of subjets (radians)", 60,
                                               -3.14159, 3.14159));
     boostedJet_subjetM.push_back(bei.book1D(
         "boostedJet_subjetM", "Mass of subjets (GeV)", 50, 0.0, 250.));
     boostedJet_subjetN.push_back(
         bei.book1D("boostedJet_subjetN", "Number of subjets", 10, 0, 10));
     boostedJet_massDrop.push_back(bei.book1D(
         "boostedJet_massDrop", "Mass drop for W-like jets", 50, 0.0, 1.0));
     boostedJet_minMass.push_back(
         bei.book1D("boostedJet_minMass",
                    "Minimum Mass Pairing for top-like jets", 50, 0.0, 250.0));
   }
 
   bei.setCurrentFolder("Physics/B2G/MET");
   pfMet_pt = bei.book1D("pfMet_pt", "Pf Missing p_{T}; GeV", 50, 0.0, 500);
   pfMet_phi = bei.book1D("pfMet_phi", "Pf Missing p_{T} #phi;#phi (radians)",
                          35, -3.5, 3.5);
 
   //--- Mu+Jets
   bei.setCurrentFolder("Physics/B2G/SemiMu");
   semiMu_muPt = bei.book1D(
       "semiMu_muPt", "Pt of Muon in #mu+Jets Channel (GeV)", 50, 0.0, 1000);
   semiMu_muEta = bei.book1D("semiMu_muEta", "#eta of Muon in #mu+Jets Channel",
                             60, -6.0, 6.0);
   semiMu_muPhi =
       bei.book1D("semiMu_muPhi", "#phi of Muon in #mu+Jets Channel (radians)",
                  60, -3.14159, 3.14159);
   semiMu_muDRMin =
       bei.book1D("semiMu_muDRMin",
                  "#Delta R(E,nearest jet) in #mu+Jets Channel", 50, 0, 10.0);
   semiMu_muPtRel = bei.book1D("semiMu_muPtRel",
                               "p_{T}^{REL} in #mu+Jets Channel", 60, 0, 300.);
   semiMu_hadJetDR =
       bei.book1D("semiMu_hadJetDR", "#Delta R(E,had jet) in #mu+Jets Channel",
                  50, 0, 10.0);
   semiMu_hadJetPt = bei.book1D(
       "semiMu_hadJetPt", "Pt of Leading Hadronic Jet in #mu+Jets Channel (GeV)",
       50, 0.0, 1000);
   semiMu_hadJetY = bei.book1D(
       "semiMu_hadJetY", "Rapidity of Leading Hadronic Jet in #mu+Jets Channel",
       60, -6.0, 6.0);
   semiMu_hadJetPhi =
       bei.book1D("semiMu_hadJetPhi",
                  "#phi of Leading Hadronic Jet in #mu+Jets Channel (radians)",
                  60, -3.14159, 3.14159);
   semiMu_hadJetMass = bei.book1D(
       "semiMu_hadJetMass",
       "Mass of Leading Hadronic Jet in #mu+Jets Channel (GeV)", 50, 0.0, 500);
   semiMu_hadJetMinMass = bei.book1D(
       "semiMu_hadJetminMass",
       "Minimum Mass Pairing for Leading Hadronic Jet in #mu+Jets Channel (GeV)",
       50, 0.0, 250.0);
   semiMu_mttbar = bei.book1D(
       "semiMu_mttbar", "Mass of #mu+Jets ttbar Candidate", 100, 0., 5000.);
 
   //--- E+Jets
   bei.setCurrentFolder("Physics/B2G/SemiE");
   semiE_ePt = bei.book1D("semiE_ePt", "Pt of Electron in e+Jets Channel (GeV)",
                          50, 0.0, 1000);
   semiE_eEta = bei.book1D("semiE_eEta", "#eta of Electron in e+Jets Channel",
                           60, -6.0, 6.0);
   semiE_ePhi =
       bei.book1D("semiE_ePhi", "#phi of Electron in e+Jets Channel (radians)",
                  60, -3.14159, 3.14159);
   semiE_eDRMin = bei.book1D(
       "semiE_eDRMin", "#Delta R(E,nearest jet) in e+Jets Channel", 50, 0, 10.0);
   semiE_ePtRel =
       bei.book1D("semiE_ePtRel", "p_{T}^{REL} in e+Jets Channel", 60, 0, 300.);
   semiE_hadJetDR = bei.book1D(
       "semiE_hadJetDR", "#Delta R(E,had jet) in e+Jets Channel", 50, 0, 10.0);
   semiE_hadJetPt = bei.book1D(
       "semiE_hadJetPt", "Pt of Leading Hadronic Jet in e+Jets Channel (GeV)",
       50, 0.0, 1000);
   semiE_hadJetY = bei.book1D(
       "semiE_hadJetY", "Rapidity of Leading Hadronic Jet in e+Jets Channel", 60,
       -6.0, 6.0);
   semiE_hadJetPhi =
       bei.book1D("semiE_hadJetPhi",
                  "#phi of Leading Hadronic Jet in e+Jets Channel (radians)", 60,
                  -3.14159, 3.14159);
   semiE_hadJetMass = bei.book1D(
       "semiE_hadJetMass",
       "Mass of Leading Hadronic Jet in e+Jets Channel (GeV)", 50, 0.0, 500);
   semiE_hadJetMinMass = bei.book1D(
       "semiE_hadJetminMass",
       "Minimum Mass Pairing for Leading Hadronic Jet in e+Jets Channel (GeV)",
       50, 0.0, 250.0);
   semiE_mttbar = bei.book1D("semiE_mttbar", "Mass of e+Jets ttbar Candidate",
                             100, 0., 5000.);
 
   //--- All-hadronic
   bei.setCurrentFolder("Physics/B2G/AllHad");
   allHad_pt0 = bei.book1D(
       "allHad_pt0", "Pt of Leading All-Hadronic PFJet (GeV)", 50, 0.0, 1000);
   allHad_y0 = bei.book1D("allHad_y0", "Rapidity of Leading All-Hadronic PFJet",
                          60, -6.0, 6.0);
   allHad_phi0 =
       bei.book1D("allHad_phi0", "#phi of Leading All-Hadronic PFJet (radians)",
                  60, -3.14159, 3.14159);
   allHad_mass0 = bei.book1D(
       "allHad_mass0", "Mass of Leading All-Hadronic PFJet (GeV)", 50, 0.0, 500);
   allHad_minMass0 =
       bei.book1D("allHad_minMass0",
                  "Minimum Mass Pairing for Leading All-Hadronic PFJet (GeV)",
                  50, 0.0, 250.0);
   allHad_pt1 = bei.book1D(
       "allHad_pt1", "Pt of Subleading All-Hadronic PFJet (GeV)", 50, 0.0, 1000);
   allHad_y1 = bei.book1D(
       "allHad_y1", "Rapidity of Subleading All-Hadronic PFJet", 60, -6.0, 6.0);
   allHad_phi1 = bei.book1D("allHad_phi1",
                            "#phi of Subleading All-Hadronic PFJet (radians)",
                            60, -3.14159, 3.14159);
   allHad_mass1 =
       bei.book1D("allHad_mass1", "Mass of Subleading All-Hadronic PFJet (GeV)",
                  50, 0.0, 500);
   allHad_minMass1 =
       bei.book1D("allHad_minMass1",
                  "Minimum Mass Pairing for Subleading All-Hadronic PFJet (GeV)",
                  50, 0.0, 250.0);
   allHad_mttbar = bei.book1D(
       "allHad_mttbar", "Mass of All-Hadronic ttbar Candidate", 100, 0., 5000.);
 }

Member Data Documentation

MonitorElement* B2GDQM::allHad_mass0

private

Definition at line 205 of file B2GDQM.h.

MonitorElement* B2GDQM::allHad_mass1

private

Definition at line 210 of file B2GDQM.h.

MonitorElement* B2GDQM::allHad_minMass0

private

Definition at line 206 of file B2GDQM.h.

MonitorElement* B2GDQM::allHad_minMass1

private

Definition at line 211 of file B2GDQM.h.

MonitorElement* B2GDQM::allHad_mttbar

private

Definition at line 212 of file B2GDQM.h.

MonitorElement* B2GDQM::allHad_phi0

private

Definition at line 204 of file B2GDQM.h.

MonitorElement* B2GDQM::allHad_phi1

private

Definition at line 209 of file B2GDQM.h.

MonitorElement* B2GDQM::allHad_pt0

private

Definition at line 202 of file B2GDQM.h.

MonitorElement* B2GDQM::allHad_pt1

private

Definition at line 207 of file B2GDQM.h.

MonitorElement* B2GDQM::allHad_y0

private

Definition at line 203 of file B2GDQM.h.

MonitorElement* B2GDQM::allHad_y1

private

Definition at line 208 of file B2GDQM.h.

double B2GDQM::allHadDeltaPhiCut_

private

Definition at line 134 of file B2GDQM.h.

double B2GDQM::allHadPtCut_

private

Definition at line 132 of file B2GDQM.h.

double B2GDQM::allHadRapidityCut_

private

Definition at line 133 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::boostedJet_massDrop

private

Definition at line 171 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::boostedJet_minMass

private

Definition at line 172 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::boostedJet_subjetM

private

Definition at line 169 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::boostedJet_subjetN

private

Definition at line 170 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::boostedJet_subjetPhi

private

Definition at line 168 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::boostedJet_subjetPt

private

Definition at line 166 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::boostedJet_subjetY

private

Definition at line 167 of file B2GDQM.h.

edm::InputTag B2GDQM::cmsTagLabel_

private

Definition at line 117 of file B2GDQM.h.

edm::EDGetTokenT<edm::View<reco::BasicJet> > B2GDQM::cmsTagToken_

private

Definition at line 118 of file B2GDQM.h.

std::shared_ptr<StringCutObjectSelector<reco::GsfElectron> > B2GDQM::elecSelect_

private

Definition at line 152 of file B2GDQM.h.

edm::InputTag B2GDQM::electronLabel_

private

Definition at line 123 of file B2GDQM.h.

edm::EDGetTokenT<edm::View<reco::GsfElectron> > B2GDQM::electronToken_

private

Definition at line 124 of file B2GDQM.h.

HLTConfigProvider B2GDQM::hltConfigProvider_

private

Definition at line 103 of file B2GDQM.h.

int B2GDQM::ievt

private

Definition at line 101 of file B2GDQM.h.

int B2GDQM::irun

private

Definition at line 101 of file B2GDQM.h.

bool B2GDQM::isValidHltConfig_

private

Definition at line 104 of file B2GDQM.h.

std::vector<edm::InputTag> B2GDQM::jetLabels_

private

Definition at line 112 of file B2GDQM.h.

std::vector<double> B2GDQM::jetPtMins_

private

Definition at line 130 of file B2GDQM.h.

std::vector<edm::EDGetTokenT<edm::View<reco::Jet> > > B2GDQM::jetTokens_

private

Definition at line 113 of file B2GDQM.h.

edm::InputTag B2GDQM::muonLabel_

private

Definition at line 120 of file B2GDQM.h.

std::shared_ptr<StringCutObjectSelector<reco::Muon> > B2GDQM::muonSelect_

private

Definition at line 142 of file B2GDQM.h.

edm::EDGetTokenT<edm::View<reco::Muon> > B2GDQM::muonToken_

private

Definition at line 121 of file B2GDQM.h.

int B2GDQM::nEvents_

private

Definition at line 101 of file B2GDQM.h.

int B2GDQM::nLumiSecs_

private

Definition at line 100 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::pfJet_cemf

private

Definition at line 164 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::pfJet_chef

private

Definition at line 162 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::pfJet_m

private

Definition at line 161 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::pfJet_nemf

private

Definition at line 165 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::pfJet_nhef

private

Definition at line 163 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::pfJet_phi

private

Definition at line 160 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::pfJet_pt

private

Definition at line 158 of file B2GDQM.h.

std::vector<MonitorElement*> B2GDQM::pfJet_y

private

Definition at line 159 of file B2GDQM.h.

std::string B2GDQM::PFJetCorService_

private

Definition at line 154 of file B2GDQM.h.

MonitorElement* B2GDQM::pfMet_phi

private

Definition at line 174 of file B2GDQM.h.

MonitorElement* B2GDQM::pfMet_pt

private

Definition at line 173 of file B2GDQM.h.

edm::InputTag B2GDQM::PFMETLabel_

private

Definition at line 114 of file B2GDQM.h.

edm::EDGetTokenT<std::vector<reco::PFMET> > B2GDQM::PFMETToken_

private

Definition at line 115 of file B2GDQM.h.

double B2GDQM::semiE_dphiHadCut_

private

Definition at line 146 of file B2GDQM.h.

double B2GDQM::semiE_dRMin_

private

Definition at line 148 of file B2GDQM.h.

MonitorElement* B2GDQM::semiE_eDRMin

private

Definition at line 192 of file B2GDQM.h.

MonitorElement* B2GDQM::semiE_eEta

private

Definition at line 190 of file B2GDQM.h.

MonitorElement* B2GDQM::semiE_ePhi

private

Definition at line 191 of file B2GDQM.h.

MonitorElement* B2GDQM::semiE_ePt

private

Definition at line 189 of file B2GDQM.h.

MonitorElement* B2GDQM::semiE_ePtRel

private

Definition at line 193 of file B2GDQM.h.

MonitorElement* B2GDQM::semiE_hadJetDR

private

Definition at line 194 of file B2GDQM.h.

MonitorElement* B2GDQM::semiE_hadJetMass

private

Definition at line 198 of file B2GDQM.h.

MonitorElement* B2GDQM::semiE_hadJetMinMass

private

Definition at line 199 of file B2GDQM.h.

MonitorElement* B2GDQM::semiE_hadJetPhi

private

Definition at line 197 of file B2GDQM.h.

MonitorElement* B2GDQM::semiE_hadJetPt

private

Definition at line 195 of file B2GDQM.h.

double B2GDQM::semiE_HadJetPtCut_

private

Definition at line 144 of file B2GDQM.h.

MonitorElement* B2GDQM::semiE_hadJetY

private

Definition at line 196 of file B2GDQM.h.

double B2GDQM::semiE_LepJetPtCut_

private

Definition at line 145 of file B2GDQM.h.

MonitorElement* B2GDQM::semiE_mttbar

private

Definition at line 200 of file B2GDQM.h.

double B2GDQM::semiE_ptRel_

private

Definition at line 150 of file B2GDQM.h.

double B2GDQM::semiMu_dphiHadCut_

private

Definition at line 138 of file B2GDQM.h.

double B2GDQM::semiMu_dRMin_

private

Definition at line 139 of file B2GDQM.h.

MonitorElement* B2GDQM::semiMu_hadJetDR

private

Definition at line 181 of file B2GDQM.h.

MonitorElement* B2GDQM::semiMu_hadJetMass

private

Definition at line 185 of file B2GDQM.h.

MonitorElement* B2GDQM::semiMu_hadJetMinMass

private

Definition at line 186 of file B2GDQM.h.

MonitorElement* B2GDQM::semiMu_hadJetPhi

private

Definition at line 184 of file B2GDQM.h.

MonitorElement* B2GDQM::semiMu_hadJetPt

private

Definition at line 182 of file B2GDQM.h.

double B2GDQM::semiMu_HadJetPtCut_

private

Definition at line 136 of file B2GDQM.h.

MonitorElement* B2GDQM::semiMu_hadJetY

private

Definition at line 183 of file B2GDQM.h.

double B2GDQM::semiMu_LepJetPtCut_

private

Definition at line 137 of file B2GDQM.h.

MonitorElement* B2GDQM::semiMu_mttbar

private

Definition at line 187 of file B2GDQM.h.

MonitorElement* B2GDQM::semiMu_muDRMin

private

Definition at line 179 of file B2GDQM.h.

MonitorElement* B2GDQM::semiMu_muEta

private

Definition at line 177 of file B2GDQM.h.

MonitorElement* B2GDQM::semiMu_muPhi

private

Definition at line 178 of file B2GDQM.h.

MonitorElement* B2GDQM::semiMu_muPt

private

Definition at line 176 of file B2GDQM.h.

MonitorElement* B2GDQM::semiMu_muPtRel

private

Definition at line 180 of file B2GDQM.h.

double B2GDQM::semiMu_ptRel_

private

Definition at line 140 of file B2GDQM.h.

edm::InputTag B2GDQM::theTriggerResultsCollection

private

Definition at line 107 of file B2GDQM.h.

edm::Handle<edm::TriggerResults> B2GDQM::triggerResults_

private

Definition at line 110 of file B2GDQM.h.

edm::EDGetTokenT<edm::TriggerResults> B2GDQM::triggerToken_

private

Definition at line 108 of file B2GDQM.h.

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation