#include <MuonTestSummary.h>

Inheritance diagram for MuonTestSummary:

Public Member Functions
	MuonTestSummary (const edm::ParameterSet &ps)
	Constructor. More...

	~MuonTestSummary () override
	Destructor. More...

Public Member Functions inherited from DQMEDHarvester
void	accumulate (edm::Event const &ev, edm::EventSetup const &es) final

void	beginJob () override

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &) final

void	beginRun (edm::Run const &run, edm::EventSetup const &) override

virtual void	dqmAnalyze (DQMStore::IBooker &, DQMStore::IGetter &, edm::Event const &, edm::EventSetup const &)

	DQMEDHarvester (edm::ParameterSet const &iConfig)

	DQMEDHarvester ()

virtual void	dqmEndLuminosityBlock (DQMStore::IBooker &, DQMStore::IGetter &, edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	dqmEndRun (DQMStore::IBooker &, DQMStore::IGetter &, edm::Run const &, edm::EventSetup const &)

void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final

void	endLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &es) final

void	endProcessBlockProduce (edm::ProcessBlock &) final

void	endRun (edm::Run const &, edm::EventSetup const &) override

void	endRunProduce (edm::Run &run, edm::EventSetup const &es) final

	~DQMEDHarvester () override=default

Public Member Functions inherited from edm::one::EDProducer< edm::EndLuminosityBlockProducer, edm::EndRunProducer, edm::EndProcessBlockProducer, edm::one::WatchLuminosityBlocks, edm::one::WatchRuns, edm::one::SharedResources, edm::Accumulator >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

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

bool	wantsGlobalLuminosityBlocks () const noexcept final

bool	wantsGlobalRuns () const noexcept final

bool	wantsInputProcessBlocks () const noexcept final

bool	wantsProcessBlocks () const noexcept final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const noexcept

bool	wantsStreamRuns () const noexcept

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	doEnergyTests (DQMStore::IGetter &, std::string nameHisto, std::string muonType, int bin)

void	doKinematicsTests (DQMStore::IGetter &, std::string, int)
	test operations More...

void	doMultiplicityTests (DQMStore::IGetter &)

void	doMuonIDTests (DQMStore::IGetter &)

void	doResidualsTests (DQMStore::IGetter &, std::string, std::string, int)

void	dqmEndJob (DQMStore::IBooker &, DQMStore::IGetter &) override

void	GaussFit (std::string type, std::string parameter, MonitorElement *Histo, float &mean, float &mean_err, float &sigma, float &sigma_err)

void	ResidualCheck (DQMStore::IGetter &, std::string muType, const std::vector< std::string > &resHistos, int &numPlot, double &Mean, double &Mean_err, double &Sigma, double &Sigma_err)

Protected Member Functions inherited from edm::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

template<Transition Tr = Transition::Event>
auto	produces () noexcept

ProducesCollector	producesCollector ()

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Private Attributes
double	chi2Fraction

double	chi2Spread

MonitorElement *	chi2TestSummaryMap

MonitorElement *	energySummaryMap

double	etaExpected

double	expMultiplicityGlb_max

double	expMultiplicityGlb_min

double	expMultiplicitySta_max

double	expMultiplicitySta_min

double	expMultiplicityTk_max

double	expMultiplicityTk_min

double	expPeakEcalS9_max

double	expPeakEcalS9_min

double	expPeakHadS9_max

double	expPeakHadS9_min

MonitorElement *	kinematicsSummaryMap

MonitorElement *	KolmogorovTestSummaryMap

double	matchesFractionCsc_max

double	matchesFractionCsc_min

double	matchesFractionDt_max

double	matchesFractionDt_min

std::string	metname

MonitorElement *	multiplicitySummaryMap

MonitorElement *	muonIdSummaryMap

double	numMatchedExpected_max

double	numMatchedExpected_min

double	phiExpected

double	pullEtaSpread

double	pullOneOvPSpread

double	pullPhiSpread

double	resChargeLimit_glbSta

double	resChargeLimit_tkGlb

double	resChargeLimit_tkSta

double	resEtaSpread_glbSta

double	resEtaSpread_tkGlb

MonitorElement *	residualsSummaryMap

double	resOneOvPSpread_glbSta

double	resOneOvPSpread_tkGlb

double	resPhiSpread_glbSta

double	resPhiSpread_tkGlb

double	resSegmTrack_mean_max

double	resSegmTrack_mean_min

double	resSegmTrack_rms_max

double	resSegmTrack_rms_min

double	sigmaResSegmTrackExp

MonitorElement *	summaryCertification

MonitorElement *	summaryCertificationMap

MonitorElement *	summaryReport

MonitorElement *	summaryReportMap

std::vector< MonitorElement * >	theCertificationContents

std::vector< MonitorElement * >	theSummaryContents

Additional Inherited Members
Public Types inherited from DQMEDHarvester
typedef dqm::harvesting::DQMStore	DQMStore

typedef dqm::harvesting::MonitorElement	MonitorElement

Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
template<typename T >
using	BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >

using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Attributes inherited from DQMEDHarvester
DQMStore *	dqmstore_

edm::GetterOfProducts< DQMToken >	jobmegetter_

edm::EDPutTokenT< DQMToken >	jobToken_

edm::GetterOfProducts< DQMToken >	lumimegetter_

edm::EDPutTokenT< DQMToken >	lumiToken_

edm::GetterOfProducts< DQMToken >	runmegetter_

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

DQM Client for global summary

Author
G. Mila - INFN Torino updates: G. Hesketh - CERN

Definition at line 27 of file MuonTestSummary.h.

Constructor & Destructor Documentation

◆ MuonTestSummary()

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

Constructor.

Definition at line 25 of file MuonTestSummary.cc.

                                                           {
   // parameter initialization for kinematics test
   etaExpected = ps.getParameter<double>("etaExpected");
   phiExpected = ps.getParameter<double>("phiExpected");
   chi2Fraction = ps.getParameter<double>("chi2Fraction");
   chi2Spread = ps.getParameter<double>("chi2Spread");
   resEtaSpread_tkGlb = ps.getParameter<double>("resEtaSpread_tkGlb");
   resEtaSpread_glbSta = ps.getParameter<double>("resEtaSpread_glbSta");
   resPhiSpread_tkGlb = ps.getParameter<double>("resPhiSpread_tkGlb");
   resPhiSpread_glbSta = ps.getParameter<double>("resPhiSpread_glbSta");
   resOneOvPSpread_tkGlb = ps.getParameter<double>("resOneOvPSpread_tkGlb");
   resOneOvPSpread_glbSta = ps.getParameter<double>("resOneOvPSpread_glbSta");
   pullEtaSpread = ps.getParameter<double>("pullEtaSpread");
   pullPhiSpread = ps.getParameter<double>("pullPhiSpread");
   pullOneOvPSpread = ps.getParameter<double>("pullOneOvPSpread");
   resChargeLimit_tkGlb = ps.getParameter<double>("resChargeLimit_tkGlb");
   resChargeLimit_glbSta = ps.getParameter<double>("resChargeLimit_glbSta");
   resChargeLimit_tkSta = ps.getParameter<double>("resChargeLimit_tkSta");
   numMatchedExpected_min = ps.getParameter<double>("numMatchedExpected_min");
   numMatchedExpected_max = ps.getParameter<double>("numMatchedExpected_max");
   matchesFractionDt_min = ps.getParameter<double>("matchesFractionDt_min");
   matchesFractionDt_max = ps.getParameter<double>("matchesFractionDt_max");
   matchesFractionCsc_min = ps.getParameter<double>("matchesFractionCsc_min");
   matchesFractionCsc_max = ps.getParameter<double>("matchesFractionCsc_max");
   resSegmTrack_rms_min = ps.getParameter<double>("resSegmTrack_rms_min");
   resSegmTrack_rms_max = ps.getParameter<double>("resSegmTrack_rms_max");
   resSegmTrack_mean_min = ps.getParameter<double>("resSegmTrack_mean_min");
   resSegmTrack_mean_max = ps.getParameter<double>("resSegmTrack_mean_max");
   expPeakEcalS9_min = ps.getParameter<double>("expPeakEcalS9_min");
   expPeakEcalS9_max = ps.getParameter<double>("expPeakEcalS9_max");
   expPeakHadS9_min = ps.getParameter<double>("expPeakHadS9_min");
   expPeakHadS9_max = ps.getParameter<double>("expPeakHadS9_max");
   expMultiplicityGlb_max = ps.getParameter<double>("expMultiplicityGlb_max");
   expMultiplicityTk_max = ps.getParameter<double>("expMultiplicityTk_max");
   expMultiplicitySta_max = ps.getParameter<double>("expMultiplicitySta_max");
   expMultiplicityGlb_min = ps.getParameter<double>("expMultiplicityGlb_min");
   expMultiplicityTk_min = ps.getParameter<double>("expMultiplicityTk_min");
   expMultiplicitySta_min = ps.getParameter<double>("expMultiplicitySta_min");
 }

◆ ~MuonTestSummary()

MuonTestSummary::~MuonTestSummary ( )

override

Destructor.

Definition at line 65 of file MuonTestSummary.cc.

65 {}

Member Function Documentation

◆ doEnergyTests()

void MuonTestSummary::doEnergyTests	(	DQMStore::IGetter &	,
		std::string	nameHisto,
		std::string	muonType,
		int	bin
	)

protected

Definition at line 1003 of file MuonTestSummary.cc.

References plotT0FromHistos::binNumber(), muonTestSummary_cfi::expPeakEcalS9_max, muonTestSummary_cfi::expPeakEcalS9_min, muonTestSummary_cfi::expPeakHadS9_max, muonTestSummary_cfi::expPeakHadS9_min, dqm::implementation::IGetter::get(), dqm::impl::MonitorElement::getEntries(), dqm::legacy::MonitorElement::getTH1F(), LogTrace, metname, and castor_dqm_sourceclient_file_cfg::path.

                                                                                                              {
   // num matches test
   string path = "Muons/MuonEnergyDepositAnalyzer/" + histname + muonType;
   MonitorElement *energyHisto = igetter.get(path);
   Double_t hPeak = -1, hFWHM = -1;
   if (energyHisto) {
     TH1F *energyHisto_root = energyHisto->getTH1F();
 
     // Setting fit range and start values
     Double_t fitRange[2];
     Double_t startValues[4], parlimitslo[4], parlimitshi[4], fitPar[4], fitParErr[4];
 
     if (energyHisto->getEntries() > 20) {
       if (histname == "ecalS9PointingMuDepositedEnergy_") {
         fitRange[0] = 0.04;
         fitRange[1] = 3.0;
 
         startValues[0] = 0.036;
         startValues[1] = 0.193;
         startValues[2] = 110.0;
         startValues[3] = 0.06;
         parlimitslo[0] = 0.0;
         parlimitslo[1] = 0.;
         parlimitslo[2] = 1.0;
         parlimitslo[3] = 0.;
         parlimitshi[0] = 0.05;
         parlimitshi[1] = 0.5;
         parlimitshi[2] = 80000.0;
         parlimitshi[3] = 0.1;
 
         Double_t chisqr;
         Int_t ndf;
         TF1 *fit = langaufit(
             energyHisto_root, fitRange, startValues, parlimitslo, parlimitshi, fitPar, fitParErr, &chisqr, &ndf);
         if (fit) {
           langaupro(fitPar, hPeak, hFWHM);
           LogTrace(metname) << "hPeak from langau fit: " << hPeak << " for: " << histname + muonType << endl;
           LogTrace(metname) << "hFWHM from langau fit: " << hFWHM << " for: " << histname + muonType << endl;
         }
       }
 
       if (histname == "hadS9PointingMuDepositedEnergy_") {
         fitRange[0] = 0.0;
         fitRange[1] = 7.0;
 
         startValues[0] = 2.0;
         startValues[1] = 2.4;
         startValues[2] = 110.0;
         startValues[3] = 4.0;
         parlimitslo[0] = 0.0;
         parlimitslo[1] = 0.;
         parlimitslo[2] = 1.0;
         parlimitslo[3] = 0.;
         parlimitshi[0] = 4.0;
         parlimitshi[1] = 4.0;
         parlimitshi[2] = 80000.0;
         parlimitshi[3] = 8.0;
 
         Double_t chisqr;
         Int_t ndf;
         TF1 *fit = langaufit(
             energyHisto_root, fitRange, startValues, parlimitslo, parlimitshi, fitPar, fitParErr, &chisqr, &ndf);
         if (fit) {
           langaupro(fitPar, hPeak, hFWHM);
           LogTrace(metname) << "hPeak from langau fit: " << hPeak << " for: " << histname + muonType << endl;
           LogTrace(metname) << "hFWHM from langau fit: " << hFWHM << " for: " << histname + muonType << endl;
         }
       }
     } else {
       LogTrace(metname) << "[MuonTestSummary]: Test of  Energy for " << histname + muonType
                         << " not performed because # entries < 20 ";
     }
   }
 
   if (histname == "ecalS9PointingMuDepositedEnergy_" && hPeak > expPeakEcalS9_min && hPeak < expPeakEcalS9_max)
     energySummaryMap->setBinContent(binNumber, 1, 1);
   if (histname == "ecalS9PointingMuDepositedEnergy_" && (hPeak != -1) &&
       !(hPeak > expPeakEcalS9_min && hPeak < expPeakEcalS9_max))
     energySummaryMap->setBinContent(binNumber, 1, 0);
 
   if (histname == "hadS9PointingMuDepositedEnergy_" && hPeak > expPeakHadS9_min && hPeak < expPeakHadS9_max)
     energySummaryMap->setBinContent(binNumber, 2, 1);
   if (histname == "hadS9PointingMuDepositedEnergy_" && (hPeak != -1) &&
       !(hPeak > expPeakHadS9_min && hPeak < expPeakHadS9_max))
     energySummaryMap->setBinContent(binNumber, 2, 0);
 
   //missing test on ho distributions
 }

◆ doKinematicsTests()

void MuonTestSummary::doKinematicsTests	(	DQMStore::IGetter &	,
		std::string	,
		int
	)

protected

test operations

Definition at line 448 of file MuonTestSummary.cc.

References newFWLiteAna::bin, muonTestSummary_cfi::chi2Fraction, muonTestSummary_cfi::chi2Spread, muonTestSummary_cfi::etaExpected, HLT_2024v14_cff::fraction, dqm::implementation::IGetter::get(), dqm::legacy::MonitorElement::getTH1F(), createfilelist::int, LogTrace, cms::cuda::allocator::maxBin, metname, castor_dqm_sourceclient_file_cfg::path, muonTestSummary_cfi::phiExpected, and mathSSE::sqrt().

                                                                                           {
   // chi2 test
   string path = "Muons/MuonRecoAnalyzer/" + muonType + "chi2OverDf";
   MonitorElement *chi2Histo = igetter.get(path);
 
   if (chi2Histo) {
     TH1F *chi2Histo_root = chi2Histo->getTH1F();
     if (chi2Histo_root->GetEntries() > 20) {
       //Standard QT based on fraction of events below and above a cut
       LogTrace(metname) << "chi2 kin test based on fraction for " << muonType << endl;
       int maxBin = chi2Histo_root->GetMaximumBin();
       if (chi2Histo_root->Integral(maxBin + 1, chi2Histo_root->GetNbinsX()) != 0) {
         double fraction = double(chi2Histo_root->Integral(1, maxBin)) /
                           double(chi2Histo_root->Integral(maxBin + 1, chi2Histo_root->GetNbinsX()));
         LogTrace(metname) << "chi2 fraction for " << muonType << " : " << fraction << " must be within "
                           << chi2Fraction - chi2Spread << "," << chi2Fraction + chi2Spread << endl;
         if (fraction > (chi2Fraction - chi2Spread) && fraction < (chi2Fraction + chi2Spread))
           kinematicsSummaryMap->setBinContent(bin, 1, 1);
         else
           kinematicsSummaryMap->setBinContent(bin, 1, 0);
       }
     } else {
       LogTrace(metname) << "[MuonTestSummary]: Test of Chi2 Kin not performed for " << muonType
                         << " because # entries < 20 ";
     }
   }
 
   // pseudorapidity test
   path = "Muons/MuonRecoAnalyzer/" + muonType + "eta";
   MonitorElement *etaHisto = igetter.get(path);
 
   if (etaHisto) {
     TH1F *etaHisto_root = etaHisto->getTH1F();
     if (etaHisto_root->GetEntries() > 20) {
       //Standard QT based on fraction of events below and above a cut
       LogTrace(metname) << "eta kin test based on fraction for " << muonType << endl;
       double binSize =
           (etaHisto_root->GetXaxis()->GetXmax() - etaHisto_root->GetXaxis()->GetXmin()) / etaHisto_root->GetNbinsX();
       int binZero = int((0 - etaHisto_root->GetXaxis()->GetXmin()) / binSize);
       if (etaHisto_root->Integral(1, binZero - 1) != 0 &&
           etaHisto_root->Integral(binZero, etaHisto_root->GetNbinsX()) != 0) {
         double symmetryFactor = double(etaHisto_root->Integral(1, binZero - 1)) /
                                 double(etaHisto_root->Integral(binZero, etaHisto_root->GetNbinsX()));
         double errSymmetryFactor =
             symmetryFactor * sqrt(1.0 / double(etaHisto_root->Integral(1, binZero - 1)) +
                                   1.0 / double(etaHisto_root->Integral(binZero, etaHisto_root->GetNbinsX())));
         LogTrace(metname) << "eta symmetryFactor for " << muonType << " : " << symmetryFactor
                           << " (expected :" << etaExpected << ")" << endl;
         LogTrace(metname) << "eta errSymmetryFactor for " << muonType << " : " << errSymmetryFactor << endl;
         double tParameter;
         if ((symmetryFactor - etaExpected) > 0)
           tParameter = double(symmetryFactor - etaExpected) / errSymmetryFactor;
         else
           tParameter = double(-symmetryFactor + etaExpected) / errSymmetryFactor;
         LogTrace(metname) << "eta tParameter for " << muonType << " : " << tParameter << " (expected < 1.95)" << endl;
         if (tParameter < 1.95)  //2sigma rejection
           kinematicsSummaryMap->setBinContent(bin, 2, 1);
         else
           kinematicsSummaryMap->setBinContent(bin, 2, 0);
       }
 
     } else {
       LogTrace(metname) << "[MuonTestSummary]: Test of Eta Kin not performed for " << muonType
                         << " because # entries < 20 ";
     }
   }
 
   // phi test
   path = "Muons/MuonRecoAnalyzer/" + muonType + "phi";
   MonitorElement *phiHisto = igetter.get(path);
 
   if (phiHisto) {
     TH1F *phiHisto_root = phiHisto->getTH1F();
     if (phiHisto_root->GetEntries() > 20) {
       //Standard QT based on fraction of events below and above a cut
       LogTrace(metname) << "phi kin test based on fraction for " << muonType << endl;
       double binSize =
           (phiHisto_root->GetXaxis()->GetXmax() - phiHisto_root->GetXaxis()->GetXmin()) / phiHisto_root->GetNbinsX();
       int binZero = int((0 - phiHisto_root->GetXaxis()->GetXmin()) / binSize);
       if (phiHisto_root->Integral(binZero + 1, phiHisto_root->GetNbinsX()) != 0 &&
           phiHisto_root->Integral(1, binZero) != 0) {
         double symmetryFactor = double(phiHisto_root->Integral(binZero + 1, phiHisto_root->GetNbinsX())) /
                                 double(phiHisto_root->Integral(1, binZero));
         double errSymmetryFactor =
             symmetryFactor * sqrt(1.0 / double(phiHisto_root->Integral(binZero + 1, phiHisto_root->GetNbinsX())) +
                                   1.0 / double(phiHisto_root->Integral(1, binZero)));
         LogTrace(metname) << "phi symmetryFactor for " << muonType << " : " << symmetryFactor
                           << "(phi expected :" << phiExpected << ")" << endl;
         LogTrace(metname) << "phi errSymmetryFactor for " << muonType << " : " << errSymmetryFactor << endl;
         double tParameter;
         if ((symmetryFactor - phiExpected) > 0)
           tParameter = double(symmetryFactor - phiExpected) / errSymmetryFactor;
         else
           tParameter = double(-symmetryFactor + phiExpected) / errSymmetryFactor;
         LogTrace(metname) << "phi tParameter for " << muonType << " : " << tParameter << " (expected < 1.95)" << endl;
         if (tParameter < 1.95)  //2sigma rejection
           kinematicsSummaryMap->setBinContent(bin, 3, 1);
         else
           kinematicsSummaryMap->setBinContent(bin, 3, 0);
       }
 
     } else {
       LogTrace(metname) << "[MuonTestSummary]: Test of Phi Kin not performed for " << muonType
                         << " because # entries < 20 ";
     }
   }
 }

◆ doMultiplicityTests()

void MuonTestSummary::doMultiplicityTests ( DQMStore::IGetter & igetter )

protected

Definition at line 1091 of file MuonTestSummary.cc.

References muonTestSummary_cfi::expMultiplicityGlb_max, muonTestSummary_cfi::expMultiplicityGlb_min, muonTestSummary_cfi::expMultiplicitySta_max, muonTestSummary_cfi::expMultiplicitySta_min, muonTestSummary_cfi::expMultiplicityTk_max, muonTestSummary_cfi::expMultiplicityTk_min, dqm::implementation::IGetter::get(), dqm::impl::MonitorElement::getBinContent(), dqm::impl::MonitorElement::getEntries(), LogTrace, and metname.

                                                                   {
   MonitorElement *multiplicityHisto = igetter.get("Muons/MuonRecoAnalyzer/muReco");
 
   if (multiplicityHisto) {
     if (multiplicityHisto->getEntries() > 20) {
       double multiplicity_GLB = double(multiplicityHisto->getBinContent(1) + multiplicityHisto->getBinContent(2)) /
                                 double(multiplicityHisto->getEntries());
       LogTrace(metname) << "multiplicity_GLB: " << multiplicity_GLB << " ExpMultiplicityGlb_min "
                         << expMultiplicityGlb_min << " ExpMultiplicityGlb_max " << expMultiplicityGlb_max << endl;
       double multiplicity_TK = double(multiplicityHisto->getBinContent(3) + multiplicityHisto->getBinContent(4)) /
                                double(multiplicityHisto->getEntries());
       LogTrace(metname) << "multiplicity_TK: " << multiplicity_TK << " ExpMultiplicityTk_min " << expMultiplicityTk_min
                         << " ExpMultiplicityTk_max " << expMultiplicityTk_max << endl;
       double multiplicity_STA = double(multiplicityHisto->getBinContent(3) + multiplicityHisto->getBinContent(5)) /
                                 double(multiplicityHisto->getEntries());
       LogTrace(metname) << "multiplicity_STA: " << multiplicity_STA << " ExpMultiplicitySta_min "
                         << expMultiplicitySta_min << " ExpMultiplicitySta_max " << expMultiplicitySta_max << endl;
 
       if (multiplicity_GLB > expMultiplicityGlb_min && multiplicity_GLB < expMultiplicityGlb_max)
         multiplicitySummaryMap->setBinContent(1, 1);
       else
         multiplicitySummaryMap->setBinContent(1, 0);
 
       if (multiplicity_TK > expMultiplicityTk_min && multiplicity_TK < expMultiplicityTk_max)
         multiplicitySummaryMap->setBinContent(2, 1);
       else
         multiplicitySummaryMap->setBinContent(2, 0);
 
       if (multiplicity_STA > expMultiplicitySta_min && multiplicity_STA < expMultiplicitySta_max)
         multiplicitySummaryMap->setBinContent(3, 1);
       else
         multiplicitySummaryMap->setBinContent(3, 0);
     } else {
       LogTrace(metname) << "[MuonTestSummary]: Test of  Multiplicity not performed because # entries < 20 ";
     }
   }
 }

◆ doMuonIDTests()

void MuonTestSummary::doMuonIDTests ( DQMStore::IGetter & igetter )

protected

Definition at line 729 of file MuonTestSummary.cc.

                                                             {
   vector<string> muType;
   muType.push_back("GlobalMuons");
   muType.push_back("TrackerMuons");
 
   for (int i = 0; i <= 1; i++) {
     // num matches test
     string path = "Muons/MuonIdDQM/" + muType[i] + "/hNumMatches";
     MonitorElement *matchesHisto = igetter.get(path);
 
     if (matchesHisto) {
       TH1F *matchesHisto_root = matchesHisto->getTH1F();
       if (matchesHisto_root->GetMaximumBin() >= numMatchedExpected_min &&
           matchesHisto_root->GetMaximumBin() <= numMatchedExpected_max)
         muonIdSummaryMap->setBinContent(i + 1, 1, 1);
       else
         muonIdSummaryMap->setBinContent(i + 1, 1, 0);
     }
 
     // num of 0 associated segments
     double numOneSegm_dt = 0;
     int numHistos_dt = 0;
     int numHistos_csc = 0;
     MonitorElement *DT1Histo = igetter.get("Muons/MuonIdDQM/" + muType[i] + "/hDT1NumSegments");
     if (DT1Histo) {
       numHistos_dt++;
       if (DT1Histo->getEntries() != 0)
         numOneSegm_dt += double(DT1Histo->getBinContent(2)) / double(DT1Histo->getEntries());
     }
     MonitorElement *DT2Histo = igetter.get("Muons/MuonIdDQM/" + muType[i] + "/hDT2NumSegments");
     if (DT2Histo) {
       numHistos_dt++;
       if (DT2Histo->getEntries() != 0)
         numOneSegm_dt += double(DT2Histo->getBinContent(2)) / double(DT2Histo->getEntries());
     }
     MonitorElement *DT3Histo = igetter.get("Muons/MuonIdDQM/" + muType[i] + "/hDT3NumSegments");
     if (DT3Histo) {
       numHistos_dt++;
       if (DT3Histo->getEntries() != 0)
         numOneSegm_dt += double(DT3Histo->getBinContent(2)) / double(DT3Histo->getEntries());
     }
     MonitorElement *DT4Histo = igetter.get("Muons/MuonIdDQM/" + muType[i] + "/hDT4NumSegments");
     if (DT4Histo) {
       numHistos_dt++;
       if (DT4Histo->getEntries() != 0)
         numOneSegm_dt += double(DT4Histo->getBinContent(2)) / double(DT4Histo->getEntries());
     }
     double fraction_dt = 0;
     if (numOneSegm_dt != 0) {
       fraction_dt = numOneSegm_dt / double(numHistos_dt);
       LogTrace(metname) << "fraction_dt: " << fraction_dt << " for " << muType[i] << endl;
     }
 
     double numOneSegm_csc = 0;
     MonitorElement *CSC1Histo = igetter.get("Muons/MuonIdDQM/" + muType[i] + "/hCSC1NumSegments");
     if (CSC1Histo) {
       numHistos_csc++;
       if (CSC1Histo->getEntries() != 0)
         numOneSegm_csc += double(CSC1Histo->getBinContent(2)) / double(CSC1Histo->getEntries());
     }
     MonitorElement *CSC2Histo = igetter.get("Muons/MuonIdDQM/" + muType[i] + "/hCSC2NumSegments");
     if (CSC2Histo) {
       numHistos_csc++;
       if (CSC2Histo->getEntries() != 0)
         numOneSegm_csc += double(CSC2Histo->getBinContent(2)) / double(CSC2Histo->getEntries());
     }
     MonitorElement *CSC3Histo = igetter.get("Muons/MuonIdDQM/" + muType[i] + "/hCSC3NumSegments");
     if (CSC3Histo) {
       numHistos_csc++;
       if (CSC3Histo->getEntries() != 0)
         numOneSegm_csc += double(CSC3Histo->getBinContent(2)) / double(CSC3Histo->getEntries());
     }
     MonitorElement *CSC4Histo = igetter.get("Muons/MuonIdDQM/" + muType[i] + "/hCSC4NumSegments");
     if (CSC4Histo) {
       numHistos_csc++;
       if (CSC4Histo->getEntries() != 0)
         numOneSegm_csc += double(CSC4Histo->getBinContent(2)) / double(CSC4Histo->getEntries());
     }
     double fraction_csc = 0;
     if (numOneSegm_csc != 0) {
       fraction_csc = numOneSegm_csc / double(numHistos_csc);
       LogTrace(metname) << "fraction_csc: " << fraction_csc << " for " << muType[i] << endl;
     }
 
     //--GH modified
 
     if (fraction_dt > matchesFractionDt_min && fraction_dt < matchesFractionDt_max)
       muonIdSummaryMap->setBinContent(2 * i + 1, 1, 1);
     else
       muonIdSummaryMap->setBinContent(2 * i + 1, 1, 0);
 
     if (fraction_csc > matchesFractionCsc_min && fraction_csc < matchesFractionCsc_max)
       muonIdSummaryMap->setBinContent(2 * i + 2, 1, 1);
     else
       muonIdSummaryMap->setBinContent(2 * i + 2, 1, 0);
 
     //--GH modified
 
     // residuals test
     vector<string> DTXresHistos, DTYresHistos, CSCXresHistos, CSCYresHistos;
     DTXresHistos.push_back("hDT1Pullx");
     DTXresHistos.push_back("hDT2Pullx");
     DTXresHistos.push_back("hDT3Pullx");
     DTXresHistos.push_back("hDT4Pullx");
 
     DTYresHistos.push_back("hDT1Pully");
     DTYresHistos.push_back("hDT2Pully");
     DTYresHistos.push_back("hDT3Pully");
 
     CSCXresHistos.push_back("hCSC1Pullx");
     CSCXresHistos.push_back("hCSC2Pullx");
     CSCXresHistos.push_back("hCSC3Pullx");
     CSCXresHistos.push_back("hCSC4Pullx");
 
     CSCYresHistos.push_back("hCSC1Pully");
     CSCYresHistos.push_back("hCSC2Pully");
     CSCYresHistos.push_back("hCSC3Pully");
     CSCYresHistos.push_back("hCSC4Pully");
 
     int numPlot_dtX, numPlot_dtY, numPlot_cscX, numPlot_cscY;
     double dtSigmaX, dtSigmaY, cscSigmaX, cscSigmaY;
     double dtSigmaX_err, dtSigmaY_err, cscSigmaX_err, cscSigmaY_err;
     double dtMeanX, dtMeanY, cscMeanX, cscMeanY;
     double dtMeanX_err, dtMeanY_err, cscMeanX_err, cscMeanY_err;
     MuonTestSummary::ResidualCheck(
         igetter, muType[i], DTXresHistos, numPlot_dtX, dtMeanX, dtMeanX_err, dtSigmaX, dtSigmaX_err);
     MuonTestSummary::ResidualCheck(
         igetter, muType[i], DTYresHistos, numPlot_dtY, dtMeanY, dtMeanY_err, dtSigmaY, dtSigmaY_err);
     MuonTestSummary::ResidualCheck(
         igetter, muType[i], CSCXresHistos, numPlot_cscX, cscMeanX, cscMeanX_err, cscSigmaX, cscSigmaX_err);
     MuonTestSummary::ResidualCheck(
         igetter, muType[i], CSCYresHistos, numPlot_cscY, cscMeanY, cscMeanY_err, cscSigmaY, cscSigmaY_err);
 
     LogTrace(metname) << "DT mean must be between: " << resSegmTrack_mean_min << " and " << resSegmTrack_mean_max
                       << endl;
     LogTrace(metname) << "DT rms must be between: " << resSegmTrack_rms_min << " and " << resSegmTrack_rms_max << endl;
     LogTrace(metname) << "DT X residual " << muType[i] << " mean: " << dtMeanX << " +- " << dtMeanX_err
                       << ", sigma: " << dtSigmaX << " +- " << dtSigmaX_err << endl;
     LogTrace(metname) << "DT Y residual " << muType[i] << " mean: " << dtMeanY << " +- " << dtMeanY_err
                       << ", sigma: " << dtSigmaY << " +- " << dtSigmaY_err << endl;
     LogTrace(metname) << "CSC X residual " << muType[i] << " mean: " << cscMeanX << " +- " << cscMeanX_err
                       << ", sigma: " << cscSigmaX << " +- " << cscSigmaX_err << endl;
     LogTrace(metname) << "CSC Y residual " << muType[i] << " mean: " << cscMeanY << " +- " << cscMeanY_err
                       << ", sigma: " << cscSigmaY << " +- " << cscSigmaY_err << endl;
 
     //require the mean and rms to be within nsig sigma of preferred range;
     const int nsig = 2;
     if (numPlot_dtX > 0) {
       if (dtMeanX + nsig * dtMeanX_err > resSegmTrack_mean_min && dtMeanX - nsig * dtMeanX_err < resSegmTrack_mean_max)
         muonIdSummaryMap->setBinContent(2 * i + 1, 2, 1);
       else
         muonIdSummaryMap->setBinContent(2 * i + 1, 2, 0);
 
       if (dtSigmaX + nsig * dtSigmaX_err > resSegmTrack_rms_min &&
           dtSigmaX - nsig * dtSigmaX_err < resSegmTrack_rms_max)
         muonIdSummaryMap->setBinContent(2 * i + 1, 3, 1);
       else
         muonIdSummaryMap->setBinContent(2 * i + 1, 3, 0);
     }
     if (numPlot_dtY > 0) {
       if (dtMeanY + nsig * dtMeanY_err > resSegmTrack_mean_min && dtMeanY - nsig * dtMeanY_err < resSegmTrack_mean_max)
         muonIdSummaryMap->setBinContent(2 * i + 1, 4, 1);
       else
         muonIdSummaryMap->setBinContent(2 * i + 1, 4, 0);
 
       if (dtSigmaY + nsig * dtSigmaY_err > resSegmTrack_rms_min &&
           dtSigmaY - nsig * dtSigmaX_err < resSegmTrack_rms_max)
         muonIdSummaryMap->setBinContent(2 * i + 1, 5, 1);
       else
         muonIdSummaryMap->setBinContent(2 * i + 1, 5, 0);
     }
 
     if (numPlot_cscX > 0) {
       if (cscMeanX + nsig * cscMeanX_err > resSegmTrack_mean_min &&
           cscMeanX - nsig * cscMeanX_err < resSegmTrack_mean_max)
         muonIdSummaryMap->setBinContent(2 * i + 2, 2, 1);
       else
         muonIdSummaryMap->setBinContent(2 * i + 2, 2, 0);
 
       if (cscSigmaX + nsig * cscSigmaX_err > resSegmTrack_rms_min &&
           cscSigmaX - nsig * cscSigmaX_err < resSegmTrack_rms_max)
         muonIdSummaryMap->setBinContent(2 * i + 2, 3, 1);
       else
         muonIdSummaryMap->setBinContent(2 * i + 2, 3, 0);
     }
     if (numPlot_cscY > 0) {
       if (cscMeanY + nsig * cscMeanY_err > resSegmTrack_mean_min &&
           cscMeanY - nsig * cscMeanY_err < resSegmTrack_mean_max)
         muonIdSummaryMap->setBinContent(2 * i + 2, 4, 1);
       else
         muonIdSummaryMap->setBinContent(2 * i + 2, 4, 0);
 
       if (cscSigmaY + nsig * cscSigmaY_err > resSegmTrack_rms_min &&
           cscSigmaY - nsig * cscSigmaY_err < resSegmTrack_rms_max)
         muonIdSummaryMap->setBinContent(2 * i + 2, 5, 1);
       else
         muonIdSummaryMap->setBinContent(2 * i + 2, 5, 0);
     }
 
     //---- end of modification
   }
 }

◆ doResidualsTests()

void MuonTestSummary::doResidualsTests	(	DQMStore::IGetter &	,
		std::string	,
		std::string	,
		int
	)

protected

Definition at line 594 of file MuonTestSummary.cc.

                                                                                                        {
   // residuals test
   if (type != "GlbMuon") {
     string path = "Muons/MuonRecoAnalyzer/Res_" + type + "_" + parameter;
     MonitorElement *residualsHisto = igetter.get(path);
 
     float mean = -1;
     float mean_err = -1;
     float sigma = -1;
     float sigma_err = -1;
 
     if (residualsHisto) {
       LogTrace(metname) << "[MuonTestSummary]: Starting Gaussian fit for Test of  Res_" << type << "_" << parameter
                         << endl;
       GaussFit(type, parameter, residualsHisto, mean, mean_err, sigma, sigma_err);
 
       if (sigma != -1 && parameter == "eta" && type == "TkGlb") {
         if (sigma - sigma_err < resEtaSpread_tkGlb)
           residualsSummaryMap->setBinContent(bin, 1, 1);
         else
           residualsSummaryMap->setBinContent(bin, 1, 0);
       }
       if (sigma != -1 && parameter == "eta" && (type == "GlbSta" || type == "TkSta")) {
         if (sigma - sigma_err < resEtaSpread_glbSta)
           residualsSummaryMap->setBinContent(bin, 1, 1);
         else
           residualsSummaryMap->setBinContent(bin, 1, 0);
       }
       if (sigma != -1 && parameter == "phi" && type == "TkGlb") {
         if (sigma - sigma_err < resPhiSpread_tkGlb)
           residualsSummaryMap->setBinContent(bin, 2, 1);
         else
           residualsSummaryMap->setBinContent(bin, 2, 0);
       }
       if (sigma != -1 && parameter == "phi" && (type == "GlbSta" || type == "TkSta")) {
         if (sigma - sigma_err < resPhiSpread_glbSta)
           residualsSummaryMap->setBinContent(bin, 2, 1);
         else
           residualsSummaryMap->setBinContent(bin, 2, 0);
       }
       if (sigma != -1 && parameter == "oneOverp" && type == "TkGlb") {
         if (sigma - sigma_err < resOneOvPSpread_tkGlb)
           residualsSummaryMap->setBinContent(bin, 3, 1);
         else
           residualsSummaryMap->setBinContent(bin, 3, 0);
       }
       if (sigma != -1 && parameter == "oneOverp" && (type == "GlbSta" || type == "TkSta")) {
         if (sigma - sigma_err < resOneOvPSpread_glbSta)
           residualsSummaryMap->setBinContent(bin, 3, 1);
         else
           residualsSummaryMap->setBinContent(bin, 3, 0);
       }
     }
 
     //--GH modified
     if (type == "TkSta") {
       //look at the pull:
       string path = "Muons/MuonRecoAnalyzer/Pull_" + type + "_" + parameter;
       MonitorElement *pullHisto = igetter.get(path);
 
       if (pullHisto) {
         LogTrace(metname) << "[MuonTestSummary]: Starting Gaussian fit for Test of  Pull_" << type << "_" << parameter
                           << endl;
         GaussFit(type, parameter, pullHisto, mean, mean_err, sigma, sigma_err);
 
         if (sigma != -1 && parameter == "eta") {
           if (sigma - sigma_err < pullEtaSpread)
             residualsSummaryMap->setBinContent(4, 1, 1);
           else
             residualsSummaryMap->setBinContent(4, 1, 0);
         }
         if (sigma != -1 && parameter == "phi") {
           if (sigma - sigma_err < pullPhiSpread)
             residualsSummaryMap->setBinContent(4, 2, 1);
           else
             residualsSummaryMap->setBinContent(4, 2, 0);
         }
         if (sigma != -1 && parameter == "oneOverp") {
           if (sigma - sigma_err < pullOneOvPSpread)
             residualsSummaryMap->setBinContent(4, 3, 1);
           else
             residualsSummaryMap->setBinContent(4, 3, 0);
         }
 
       }  //have pull histo
     }    //TkSta muons
   }
 
   //this part for Global Muons:
   else {
     string path = "Muons/MuonRecoAnalyzer/" + type + "_" + parameter;
     MonitorElement *residualsHisto = igetter.get(path);
 
     if (residualsHisto) {
       LogTrace(metname) << "[MuonTestSummary]: Test of  Charge Comparison " << type << "_" << parameter << endl;
       if ((residualsHisto->getBinContent(3) + residualsHisto->getBinContent(4)) != 0) {
         LogTrace(metname) << "Charge comparison TkGlb: "
                           << residualsHisto->getBinContent(4) /
                                  double(residualsHisto->getBinContent(3) + residualsHisto->getBinContent(4))
                           << endl;
         if (residualsHisto->getBinContent(4) /
                 double(residualsHisto->getBinContent(3) + residualsHisto->getBinContent(4)) <
             resChargeLimit_tkGlb)
           residualsSummaryMap->setBinContent(1, 4, 1);
         else
           residualsSummaryMap->setBinContent(1, 4, 0);
       }
       if ((residualsHisto->getBinContent(1) + residualsHisto->getBinContent(2)) != 0) {
         LogTrace(metname) << "charge comparison GlbSta: "
                           << residualsHisto->getBinContent(2) /
                                  double(residualsHisto->getBinContent(1) + residualsHisto->getBinContent(2))
                           << endl;
         if (residualsHisto->getBinContent(2) /
                 double(residualsHisto->getBinContent(1) + residualsHisto->getBinContent(2)) <
             resChargeLimit_glbSta)
           residualsSummaryMap->setBinContent(2, 4, 1);
         else
           residualsSummaryMap->setBinContent(2, 4, 0);
       }
       if (residualsHisto->getBinContent(5) + residualsHisto->getBinContent(6) != 0) {
         LogTrace(metname) << "charge comparison TkSta: "
                           << residualsHisto->getBinContent(6) /
                                  double(residualsHisto->getBinContent(5) + residualsHisto->getBinContent(6))
                           << endl;
         if (residualsHisto->getBinContent(6) /
                 double(residualsHisto->getBinContent(5) + residualsHisto->getBinContent(6)) <
             resChargeLimit_tkSta)
           residualsSummaryMap->setBinContent(3, 4, 1);
         else
           residualsSummaryMap->setBinContent(3, 4, 0);
       }
     }
   }
 }

◆ dqmEndJob()

void MuonTestSummary::dqmEndJob	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter
	)

overrideprotectedvirtual

DO OTHER OPERATIONS WITH HISTOGRAMS

Implements DQMEDHarvester.

Definition at line 67 of file MuonTestSummary.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::IBooker::bookFloat(), dqm::implementation::NavigatorBase::cd(), dqm::impl::MonitorElement::Fill(), mps_fire::i, dqmiolumiharvest::j, dqm::impl::MonitorElement::setAxisTitle(), dqm::implementation::NavigatorBase::setCurrentFolder(), photonAnalyzer_cfi::xBin, and photonAnalyzer_cfi::yBin.

                                                                                   {
   // BOOKING NEW HISTOGRAMS
   ibooker.cd();
   ibooker.setCurrentFolder("Muons/TestSummary");
 
   // kinematics test report
   kinematicsSummaryMap = ibooker.book2D("kinematicsSummaryMap", "Kinematics test summary", 5, 1, 6, 3, 1, 4);
   kinematicsSummaryMap->setAxisTitle("track monitored", 1);
   kinematicsSummaryMap->setBinLabel(1, "GLB", 1);
   kinematicsSummaryMap->setBinLabel(2, "TKfromGLB", 1);
   kinematicsSummaryMap->setBinLabel(3, "STAfromGLB", 1);
   kinematicsSummaryMap->setBinLabel(4, "TK", 1);
   kinematicsSummaryMap->setBinLabel(5, "STA", 1);
   kinematicsSummaryMap->setAxisTitle("parameter tested", 2);
   kinematicsSummaryMap->setBinLabel(1, "#chi^{2}", 2);
   kinematicsSummaryMap->setBinLabel(2, "#eta", 2);
   kinematicsSummaryMap->setBinLabel(3, "#phi", 2);
 
   //chi2 kinematics quality test report
   chi2TestSummaryMap = ibooker.book2D("chi2TestSummaryMap", "#chi2 quality test summary", 5, 1, 6, 5, 1, 6);
   chi2TestSummaryMap->setAxisTitle("track monitored", 1);
   chi2TestSummaryMap->setBinLabel(1, "GLB", 1);
   chi2TestSummaryMap->setBinLabel(2, "TKfromGLB", 1);
   chi2TestSummaryMap->setBinLabel(3, "STAfromGLB", 1);
   chi2TestSummaryMap->setBinLabel(4, "TK", 1);
   chi2TestSummaryMap->setBinLabel(5, "STA", 1);
   chi2TestSummaryMap->setAxisTitle("parameter tested", 2);
   chi2TestSummaryMap->setBinLabel(1, "#chi^{2}", 2);
   chi2TestSummaryMap->setBinLabel(2, "#eta", 2);
   chi2TestSummaryMap->setBinLabel(3, "#phi", 2);
   chi2TestSummaryMap->setBinLabel(4, "#pt", 2);
   chi2TestSummaryMap->setBinLabel(5, "#q", 2);
 
   // residuals test report
   residualsSummaryMap = ibooker.book2D("residualsSummaryMap", "Residuals test summary", 4, 1, 5, 4, 1, 5);
   residualsSummaryMap->setAxisTitle("residuals", 1);
   residualsSummaryMap->setBinLabel(1, "TK-GLB", 1);
   residualsSummaryMap->setBinLabel(2, "GLB-STA", 1);
   residualsSummaryMap->setBinLabel(3, "TK-STA", 1);
   residualsSummaryMap->setBinLabel(4, "TK-STA Pull", 1);
   residualsSummaryMap->setAxisTitle("parameter tested", 2);
   residualsSummaryMap->setBinLabel(1, "#eta", 2);
   residualsSummaryMap->setBinLabel(2, "#phi", 2);
   residualsSummaryMap->setBinLabel(3, "1/p", 2);
   residualsSummaryMap->setBinLabel(4, "q", 2);
 
   // muonId test report
   muonIdSummaryMap = ibooker.book2D("muonIdSummaryMap", "muonId test summary", 4, 1, 5, 5, 1, 6);
   muonIdSummaryMap->setAxisTitle("muons", 1);
   muonIdSummaryMap->setBinLabel(1, "GLB DT", 1);
   muonIdSummaryMap->setBinLabel(2, "GLB CSC", 1);
   muonIdSummaryMap->setBinLabel(3, "TK DT", 1);
   muonIdSummaryMap->setBinLabel(4, "TK CSC", 1);
   muonIdSummaryMap->setAxisTitle("tests", 2);
   muonIdSummaryMap->setBinLabel(1, "#assSeg", 2);
   muonIdSummaryMap->setBinLabel(2, "x mean", 2);
   muonIdSummaryMap->setBinLabel(3, "x rms", 2);
   muonIdSummaryMap->setBinLabel(4, "y mean", 2);
   muonIdSummaryMap->setBinLabel(5, "y rms", 2);
 
   // energy test report
   energySummaryMap = ibooker.book2D("energySummaryMap", "Energy deposits test summary", 3, 1, 4, 3, 1, 4);
   energySummaryMap->setAxisTitle("muons", 1);
   energySummaryMap->setBinLabel(1, "GLB", 1);
   energySummaryMap->setBinLabel(2, "TK", 1);
   energySummaryMap->setBinLabel(3, "STA", 1);
   energySummaryMap->setAxisTitle("calorimeter tested", 2);
   energySummaryMap->setBinLabel(1, "ECAL", 2);
   energySummaryMap->setBinLabel(2, "HAD", 2);
   energySummaryMap->setBinLabel(3, "H0", 2);
 
   // multiplicity tests report
   multiplicitySummaryMap = ibooker.book1D("multiplicitySummaryMap", "muon multiplicity test summary", 3, 1, 4);
   multiplicitySummaryMap->setAxisTitle("muon");
   multiplicitySummaryMap->setBinLabel(1, "GLB");
   multiplicitySummaryMap->setBinLabel(2, "TK");
   multiplicitySummaryMap->setBinLabel(3, "STA");
 
   // summary test report
   ibooker.setCurrentFolder("Muons/EventInfo");
   summaryReport = ibooker.bookFloat("reportSummary");
 
   summaryReportMap = ibooker.book2D("reportSummaryMap", "Muon Report Summary Map", 3, 1, 4, 7, 1, 8);
   summaryReportMap->setAxisTitle("muons", 1);
   summaryReportMap->setBinLabel(1, "GLB", 1);
   summaryReportMap->setBinLabel(2, "TK", 1);
   summaryReportMap->setBinLabel(3, "STA", 1);
   summaryReportMap->setAxisTitle("test", 2);
   summaryReportMap->setBinLabel(1, "#chi^{2}/Df", 2);
   summaryReportMap->setBinLabel(2, "#eta", 2);
   summaryReportMap->setBinLabel(3, "#phi", 2);
   summaryReportMap->setBinLabel(4, "residuals", 2);
   summaryReportMap->setBinLabel(5, "muonId", 2);
   summaryReportMap->setBinLabel(6, "energyDeposits", 2);
   summaryReportMap->setBinLabel(7, "multiplicity", 2);
 
   ibooker.setCurrentFolder("Muons/EventInfo/reportSummaryContents");
   theSummaryContents.push_back(ibooker.bookFloat("kinematics_GLB"));
   theSummaryContents.push_back(ibooker.bookFloat("muonId_GLB"));
   theSummaryContents.push_back(ibooker.bookFloat("residuals_GLB"));
   theSummaryContents.push_back(ibooker.bookFloat("GLB"));
   theSummaryContents.push_back(ibooker.bookFloat("kinematics_TK"));
   theSummaryContents.push_back(ibooker.bookFloat("muonId_TK"));
   theSummaryContents.push_back(ibooker.bookFloat("residuals_TK"));
   theSummaryContents.push_back(ibooker.bookFloat("TK"));
   theSummaryContents.push_back(ibooker.bookFloat("kinematics_STA"));
   theSummaryContents.push_back(ibooker.bookFloat("residuals_STA"));
   theSummaryContents.push_back(ibooker.bookFloat("STA"));
   theSummaryContents.push_back(ibooker.bookFloat("energyDeposits"));
   theSummaryContents.push_back(ibooker.bookFloat("multiplicity"));
 
   // certification report
   ibooker.setCurrentFolder("Muons/EventInfo");
   summaryCertification = ibooker.bookFloat("CertificationSummary");
   summaryCertification->Fill(-1);
 
   summaryCertificationMap =
       ibooker.book2D("CertificationSummaryMap", "Muon Certification Summary Map", 9, 1, 10, 7, 1, 8);
   summaryCertificationMap->setAxisTitle("muons", 1);
   summaryCertificationMap->setBinLabel(1, "GLB_Tot", 1);
   summaryCertificationMap->setBinLabel(2, "TK_Tot", 1);
   summaryCertificationMap->setBinLabel(3, "STA_tot", 1);
   summaryCertificationMap->setBinLabel(4, "GLB_B", 1);
   summaryCertificationMap->setBinLabel(5, "TK_B", 1);
   summaryCertificationMap->setBinLabel(6, "STA_B", 1);
   summaryCertificationMap->setBinLabel(7, "GLB_EC", 1);
   summaryCertificationMap->setBinLabel(8, "TK_EC", 1);
   summaryCertificationMap->setBinLabel(9, "STA_EC", 1);
   summaryCertificationMap->setAxisTitle("test", 2);
   summaryCertificationMap->setBinLabel(1, "#chi^{2}/Df", 2);
   summaryCertificationMap->setBinLabel(2, "#eta", 2);
   summaryCertificationMap->setBinLabel(3, "#phi", 2);
   summaryCertificationMap->setBinLabel(4, "residuals", 2);
   summaryCertificationMap->setBinLabel(5, "muonId", 2);
   summaryCertificationMap->setBinLabel(6, "energyDeposits", 2);
   summaryCertificationMap->setBinLabel(7, "multiplicity", 2);
 
   ibooker.setCurrentFolder("Muons/EventInfo/CertificationContents");
   theCertificationContents.push_back(ibooker.bookFloat("GLB_Tot"));
   theCertificationContents.push_back(ibooker.bookFloat("STA_Tot"));
   theCertificationContents.push_back(ibooker.bookFloat("TK_Tot"));
   theCertificationContents.push_back(ibooker.bookFloat("GLB_B"));
   theCertificationContents.push_back(ibooker.bookFloat("STA_B"));
   theCertificationContents.push_back(ibooker.bookFloat("TK_B"));
   theCertificationContents.push_back(ibooker.bookFloat("GLB_EC"));
   theCertificationContents.push_back(ibooker.bookFloat("STA_EC"));
   theCertificationContents.push_back(ibooker.bookFloat("TK_EC"));
 
   for (unsigned int icert = 0; icert < theCertificationContents.size(); icert++) {
     theCertificationContents[icert]->Fill(-1);
   }
 
   // initialisation of histo bins
   for (int xBin = 1; xBin <= 5; xBin++) {
     for (int yBin = 1; yBin <= 3; yBin++) {
       kinematicsSummaryMap->Fill(xBin, yBin, 1);
     }
     for (int yBin = 1; yBin <= 5; yBin++) {
       chi2TestSummaryMap->Fill(xBin, yBin, 1);
     }
   }
   for (int xBin = 1; xBin <= residualsSummaryMap->getNbinsX(); xBin++) {
     for (int yBin = 1; yBin <= residualsSummaryMap->getNbinsY(); yBin++) {
       residualsSummaryMap->Fill(xBin, yBin, 1);
     }
   }
   residualsSummaryMap->setBinContent(4, 4, 1);  //not used for now
 
   for (int xBin = 1; xBin <= muonIdSummaryMap->getNbinsX(); xBin++) {
     for (int yBin = 1; yBin <= muonIdSummaryMap->getNbinsY(); yBin++) {
       muonIdSummaryMap->Fill(xBin, yBin, 1);
     }
   }
   for (int xBin = 1; xBin <= 3; xBin++) {
     for (int yBin = 1; yBin <= 3; yBin++) {
       energySummaryMap->Fill(xBin, yBin, 1);
     }
   }
   for (int xBin = 1; xBin <= 3; xBin++) {
     multiplicitySummaryMap->Fill(xBin, 1);
   }
   for (int xBin = 1; xBin <= 3; xBin++) {
     for (int yBin = 1; yBin <= 7; yBin++) {
       summaryReportMap->Fill(xBin, yBin, 1);
     }
   }
   for (int xBin = 1; xBin <= 9; xBin++) {
     for (int yBin = 1; yBin <= 7; yBin++) {
       summaryCertificationMap->Fill(xBin, yBin, 1);
     }
   }
 
   // fill the kinematics report summary
   doKinematicsTests(igetter, "GlbMuon_Glb_", 1);
   doKinematicsTests(igetter, "GlbMuon_Tk_", 2);
   doKinematicsTests(igetter, "GlbMuon_Sta_", 3);
   doKinematicsTests(igetter, "TkMuon_", 4);
   doKinematicsTests(igetter, "StaMuon_", 5);
 
   // fill the residuals report summary
   doResidualsTests(igetter, "TkGlb", "eta", 1);
   doResidualsTests(igetter, "GlbSta", "eta", 2);
   doResidualsTests(igetter, "TkSta", "eta", 3);
   doResidualsTests(igetter, "TkGlb", "phi", 1);
   doResidualsTests(igetter, "GlbSta", "phi", 2);
   doResidualsTests(igetter, "TkSta", "phi", 3);
   doResidualsTests(igetter, "TkGlb", "oneOverp", 1);
   doResidualsTests(igetter, "GlbSta", "oneOverp", 2);
   doResidualsTests(igetter, "TkSta", "oneOverp", 3);
   doResidualsTests(igetter, "GlbMuon", "qComparison", -1);
 
   // fill the muonID report summary
   doMuonIDTests(igetter);
 
   // fill the energy report summary
   doEnergyTests(igetter, "ecalS9PointingMuDepositedEnergy_", "Glb_muons", 1);
   doEnergyTests(igetter, "hadS9PointingMuDepositedEnergy_", "Glb_muons", 1);
   doEnergyTests(igetter, "hoS9PointingMuDepositedEnergy_", "Glb_muons", 1);
   doEnergyTests(igetter, "ecalS9PointingMuDepositedEnergy_", "Tk_muons", 2);
   doEnergyTests(igetter, "hadS9PointingMuDepositedEnergy_", "Tk_muons", 2);
   doEnergyTests(igetter, "hoS9PointingMuDepositedEnergy_", "Tk_muons", 2);
   doEnergyTests(igetter, "ecalS9PointingMuDepositedEnergy_", "Sta_muons", 3);
   doEnergyTests(igetter, "hadS9PointingMuDepositedEnergy_", "Sta_muons", 3);
   doEnergyTests(igetter, "hoS9PointingMuDepositedEnergy_", "Sta_muons", 3);
 
   // fill the multiplicity test summary
   doMultiplicityTests(igetter);
 
   // fill the final report summary
 
   //-- modified GH
   double residualsSummary = 0;
   //put the TRK-STA resid & pulls in the first bin ("GLB")
   //then the GLB-TRK and GLB-STA residuals in the 2nd and 3rd
   for (int i = 3; i <= residualsSummaryMap->getNbinsX(); i++)
     for (int j = 1; j <= residualsSummaryMap->getNbinsY(); j++)
       residualsSummary += residualsSummaryMap->getBinContent(i, j);
   residualsSummary /= 2 * residualsSummaryMap->getNbinsY();
   summaryReportMap->setBinContent(1, 4, residualsSummary);
 
   residualsSummary = 0;
   for (int i = 1; i <= 1; i++)
     for (int j = 1; j <= residualsSummaryMap->getNbinsY(); j++)
       residualsSummary += residualsSummaryMap->getBinContent(i, j);
   residualsSummary /= 1 * residualsSummaryMap->getNbinsY();
   summaryReportMap->setBinContent(2, 4, residualsSummary);
 
   residualsSummary = 0;
   for (int i = 2; i <= 2; i++)
     for (int j = 1; j <= residualsSummaryMap->getNbinsY(); j++)
       residualsSummary += residualsSummaryMap->getBinContent(i, j);
   residualsSummary /= 1 * residualsSummaryMap->getNbinsY();
   summaryReportMap->setBinContent(3, 4, residualsSummary);
 
   //--
 
   //-- modified GH
   float idtest = 0;
   for (int i = 1; i <= 2; i++)
     for (int j = 1; j <= 5; j++) {
       if (j == 3 || j == 5)
         continue;  //ignore pull widths for now
       idtest += muonIdSummaryMap->getBinContent(i, j);
     }
   //  idtest/=10.;
   idtest /= 6.;
   summaryReportMap->setBinContent(1, 5, idtest);
   idtest = 0;
   for (int i = 3; i <= 4; i++)
     for (int j = 1; j <= 5; j++) {
       if (j == 3 || j == 5)
         continue;  //ignore pull widths for now
       idtest += muonIdSummaryMap->getBinContent(i, j);
     }
   //  idtest/=10.;
   idtest /= 6.;
   summaryReportMap->setBinContent(2, 5, idtest);
   summaryReportMap->setBinContent(3, 5, -1.0 / 6.0);
   //--
 
   summaryReportMap->setBinContent(
       1, 6, double(energySummaryMap->getBinContent(1, 1) + energySummaryMap->getBinContent(1, 2)) / 2.0);
   summaryReportMap->setBinContent(
       2, 6, double(energySummaryMap->getBinContent(2, 1) + energySummaryMap->getBinContent(2, 2)) / 2.0);
   summaryReportMap->setBinContent(
       3, 6, double(energySummaryMap->getBinContent(3, 1) + energySummaryMap->getBinContent(3, 2)) / 2.0);
   summaryReportMap->setBinContent(1, 7, multiplicitySummaryMap->getBinContent(1));
   summaryReportMap->setBinContent(2, 7, multiplicitySummaryMap->getBinContent(2));
   summaryReportMap->setBinContent(3, 7, multiplicitySummaryMap->getBinContent(3));
 
   double kinematics_GLB = double(summaryReportMap->getBinContent(1, 1) + summaryReportMap->getBinContent(1, 2) +
                                  summaryReportMap->getBinContent(1, 3)) /
                           3.0;
   theSummaryContents[0]->Fill(kinematics_GLB);
   double muonId_GLB = double(summaryReportMap->getBinContent(1, 5));
   theSummaryContents[1]->Fill(muonId_GLB);
   double residuals_GLB = double(summaryReportMap->getBinContent(1, 4));
   theSummaryContents[2]->Fill(residuals_GLB);
   double GLB = (kinematics_GLB + muonId_GLB + residuals_GLB) / 3.0;
   theSummaryContents[3]->Fill(GLB);
 
   double kinematics_TK = double(summaryReportMap->getBinContent(2, 1) + summaryReportMap->getBinContent(2, 2) +
                                 summaryReportMap->getBinContent(2, 3)) /
                          3.0;
   theSummaryContents[4]->Fill(kinematics_TK);
   double muonId_TK = double(summaryReportMap->getBinContent(2, 5));
   theSummaryContents[5]->Fill(muonId_TK);
   double residuals_TK = double(summaryReportMap->getBinContent(2, 4));
   theSummaryContents[6]->Fill(residuals_TK);
   double TK = double(kinematics_TK + muonId_TK + residuals_TK) / 3.0;
   theSummaryContents[7]->Fill(TK);
 
   double kinematics_STA = double(summaryReportMap->getBinContent(3, 1) + summaryReportMap->getBinContent(3, 2) +
                                  summaryReportMap->getBinContent(3, 3)) /
                           3.0;
   theSummaryContents[8]->Fill(kinematics_STA);
   double residuals_STA = double(summaryReportMap->getBinContent(3, 4));
   theSummaryContents[9]->Fill(residuals_STA);
   double STA = double(kinematics_STA + residuals_STA) / 2.0;
   theSummaryContents[10]->Fill(STA);
   double energyDeposits = double(summaryReportMap->getBinContent(1, 6) + summaryReportMap->getBinContent(2, 6) +
                                  summaryReportMap->getBinContent(3, 6)) /
                           3.0;
   theSummaryContents[11]->Fill(energyDeposits);
   double multiplicity = double(summaryReportMap->getBinContent(1, 7) + summaryReportMap->getBinContent(2, 7) +
                                summaryReportMap->getBinContent(3, 7)) /
                         3.0;
   theSummaryContents[12]->Fill(multiplicity);
 
   summaryReport->Fill((GLB + TK + STA + energyDeposits + multiplicity) / 5.0);
 
   //global barrel:
   float muonIDsummary = 0;
   //  for(int i=2; i<=5; i++)
   //     muonIDsummary += muonIdSummaryMap->getBinContent(2, i);
   //  summaryCertificationMap->setBinContent(4, 5, muonIDsummary/4.);
   //for now, just report the mean:
   muonIDsummary += muonIdSummaryMap->getBinContent(1, 2);
   muonIDsummary += muonIdSummaryMap->getBinContent(1, 4);
   summaryCertificationMap->setBinContent(4, 5, muonIDsummary / 2.);
 
   //global EC:
   muonIDsummary = 0;
   //  for(int i=2; i<=5; i++)
   //  muonIDsummary += muonIdSummaryMap->getBinContent(2, i);
   // summaryCertificationMap->setBinContent(7, 5, muonIDsummary/4.);
   muonIDsummary += muonIdSummaryMap->getBinContent(2, 2);
   muonIDsummary += muonIdSummaryMap->getBinContent(2, 4);
   summaryCertificationMap->setBinContent(7, 5, muonIDsummary / 2.);
 
   //tracker barrel:
   muonIDsummary = 0;
   //  for(int i=2; i<=5; i++)
   //    muonIDsummary += muonIdSummaryMap->getBinContent(3, i);
   //  summaryCertificationMap->setBinContent(5, 5, muonIDsummary/4.);
   muonIDsummary += muonIdSummaryMap->getBinContent(3, 2);
   muonIDsummary += muonIdSummaryMap->getBinContent(3, 4);
   summaryCertificationMap->setBinContent(5, 5, muonIDsummary / 2.);
 
   //tracker EC:
   muonIDsummary = 0;
   //  for(int i=2; i<=5; i++)
   //    muonIDsummary += muonIdSummaryMap->getBinContent(4, i);
   //  summaryCertificationMap->setBinContent(8, 5, muonIDsummary/4.);
   muonIDsummary += muonIdSummaryMap->getBinContent(4, 2);
   muonIDsummary += muonIdSummaryMap->getBinContent(4, 4);
   summaryCertificationMap->setBinContent(8, 5, muonIDsummary / 2.);
 
   double muonId_GLB_B = double(summaryCertificationMap->getBinContent(4, 5));
   theCertificationContents[3]->Fill(muonId_GLB_B);
   double muonId_GLB_EC = double(summaryCertificationMap->getBinContent(7, 5));
   theCertificationContents[6]->Fill(muonId_GLB_EC);
 
   double muonId_TK_B = double(summaryCertificationMap->getBinContent(5, 5));
   theCertificationContents[5]->Fill(muonId_TK_B);
   double muonId_TK_EC = double(summaryCertificationMap->getBinContent(8, 5));
   theCertificationContents[8]->Fill(muonId_TK_EC);
 }

◆ GaussFit()

void MuonTestSummary::GaussFit	(	std::string	type,
		std::string	parameter,
		MonitorElement *	Histo,
		float &	mean,
		float &	mean_err,
		float &	sigma,
		float &	sigma_err
	)

protected

Definition at line 556 of file MuonTestSummary.cc.

References dqm::impl::MonitorElement::getMean(), dqm::impl::MonitorElement::getRMS(), dqm::legacy::MonitorElement::getTH1F(), LogTrace, SiStripPI::mean, and metname.

                                                                                                                         {
   // Gaussian Fit
   float statMean = Histo->getMean(1);
   float statSigma = Histo->getRMS(1);
   TH1F *histo_root = Histo->getTH1F();
   if (histo_root->GetEntries() > 20) {
     TF1 *gfit = new TF1("Gaussian", "gaus", (statMean - (2 * statSigma)), (statMean + (2 * statSigma)));
     try {
       histo_root->Fit(gfit, "Q0");
     } catch (cms::Exception &iException) {
       edm::LogError(metname) << "[MuonTestSummary]: Exception when fitting Res_" << type << "_" << parameter;
       mean = 1;
       mean_err = 1;
       sigma = 1;
       sigma_err = 1;
       return;
     }
     if (gfit) {
       mean = gfit->GetParameter(1);
       mean_err = gfit->GetParErrors()[2];
       sigma = gfit->GetParameter(2);
       sigma_err = gfit->GetParErrors()[2];
       LogTrace(metname) << "Gaussian fit mean: " << mean << " +- " << mean_err << " for " << type << "_" << parameter
                         << endl;
       LogTrace(metname) << "Gaussina fit sigma: " << sigma << " +- " << sigma_err << " for " << type << "_" << parameter
                         << endl;
     }
   } else {
     LogTrace(metname) << "[MuonTestSummary]: Test of  Res_" << type << "_" << parameter
                       << " not performed because # entries < 20 ";
     //auto-pass if not enough events.
     mean = 1;
     mean_err = 1;
     sigma = 1;
     sigma_err = 1;
   }
 }

◆ ResidualCheck()

void MuonTestSummary::ResidualCheck	(	DQMStore::IGetter &	igetter,
		std::string	muType,
		const std::vector< std::string > &	resHistos,
		int &	numPlot,
		double &	Mean,
		double &	Mean_err,
		double &	Sigma,
		double &	Sigma_err
	)

protected

Definition at line 932 of file MuonTestSummary.cc.

References dqm::implementation::IGetter::get(), dqm::legacy::MonitorElement::getTH1F(), LogTrace, Mean, SiStripPI::mean, metname, Skims_PA_cff::name, mathSSE::sqrt(), and parallelization::uint.

Referenced by doMuonIDTests().

                                                        {
   numPlot = 0;
   Mean = 0;
   Mean_err = 0;
   Sigma = 0;
   Sigma_err = 0;
   for (uint name = 0; name < resHistos.size(); name++) {
     MonitorElement *resHisto = igetter.get("Muons/MuonIdDQM/" + muType + "/" + resHistos[name]);
 
     if (resHisto) {
       TH1F *resHisto_root = resHisto->getTH1F();
       if (resHisto_root->GetEntries() < 20) {
         LogTrace(metname) << "[MuonTestSummary]: Test of " << muType << " for " << resHistos[name]
                           << " not performed because # entries < 20 ";
         continue;
       }
 
       //we also want to check if the peak is away from zero.
       //so, try fitting in 3 sigma around the histogram mean.
       //alternatively, could use the maximum bin (less sensitive to 1-sided tails).
       //  float mean = resHisto_root->GetMean();
       float mean = resHisto_root->GetBinLowEdge(resHisto_root->GetMaximumBin());
       TF1 *gfit = new TF1("Gaussian", "gaus", mean - 3, mean + 3);
 
       try {
         resHisto_root->Fit(gfit, "Q0");
       } catch (cms::Exception &iException) {
         edm::LogError(metname) << "[MuonTestSummary]: Exception when fitting " << resHistos[name];
         continue;
       }
       if (gfit) {
         double mean = gfit->GetParameter(1);
         double mean_err = gfit->GetParError(1);
         double sigma = gfit->GetParameter(2);
         double sigma_err = gfit->GetParError(2);
         LogTrace(metname) << "meanRes: " << mean << " +- " << mean_err << " for " << resHistos[name] << endl;
         LogTrace(metname) << "sigmaRes: " << sigma << " +- " << sigma_err << " for " << resHistos[name] << endl;
 
         Mean += mean;
         Mean_err += mean_err * mean_err;
         Sigma += sigma;
         Sigma_err += sigma_err * sigma_err;
         numPlot++;
       }  //if gfit? why would we not have gfit?
 
     }  //histogram exists...
   }    // loop over residuals histos
 
   if (numPlot == 0) {  //eg no stats
     Mean_err = 1;
     Mean = 1;
     Sigma_err = 1;
     Sigma = 1;
   } else {
     Mean_err = sqrt(Mean_err);
     Mean_err /= numPlot;
     Mean /= numPlot;
 
     Sigma_err = sqrt(Sigma_err);
     Sigma_err /= numPlot;
     Sigma /= numPlot;
   }
   return;
 }

Member Data Documentation

◆ chi2Fraction

double MuonTestSummary::chi2Fraction

private

Definition at line 68 of file MuonTestSummary.h.

◆ chi2Spread

double MuonTestSummary::chi2Spread

private

Definition at line 69 of file MuonTestSummary.h.

◆ chi2TestSummaryMap

MonitorElement* MuonTestSummary::chi2TestSummaryMap

private

Definition at line 107 of file MuonTestSummary.h.

◆ energySummaryMap

MonitorElement* MuonTestSummary::energySummaryMap

private

Definition at line 112 of file MuonTestSummary.h.

◆ etaExpected

double MuonTestSummary::etaExpected

private

Definition at line 66 of file MuonTestSummary.h.

◆ expMultiplicityGlb_max

double MuonTestSummary::expMultiplicityGlb_max

private

Definition at line 100 of file MuonTestSummary.h.

◆ expMultiplicityGlb_min

double MuonTestSummary::expMultiplicityGlb_min

private

Definition at line 97 of file MuonTestSummary.h.

◆ expMultiplicitySta_max

double MuonTestSummary::expMultiplicitySta_max

private

Definition at line 102 of file MuonTestSummary.h.

◆ expMultiplicitySta_min

double MuonTestSummary::expMultiplicitySta_min

private

Definition at line 99 of file MuonTestSummary.h.

◆ expMultiplicityTk_max

double MuonTestSummary::expMultiplicityTk_max

private

Definition at line 101 of file MuonTestSummary.h.

◆ expMultiplicityTk_min

double MuonTestSummary::expMultiplicityTk_min

private

Definition at line 98 of file MuonTestSummary.h.

◆ expPeakEcalS9_max

double MuonTestSummary::expPeakEcalS9_max

private

Definition at line 94 of file MuonTestSummary.h.

◆ expPeakEcalS9_min

double MuonTestSummary::expPeakEcalS9_min

private

Definition at line 93 of file MuonTestSummary.h.

◆ expPeakHadS9_max

double MuonTestSummary::expPeakHadS9_max

private

Definition at line 96 of file MuonTestSummary.h.

◆ expPeakHadS9_min

double MuonTestSummary::expPeakHadS9_min

private

Definition at line 95 of file MuonTestSummary.h.

◆ kinematicsSummaryMap

MonitorElement* MuonTestSummary::kinematicsSummaryMap

private

Definition at line 109 of file MuonTestSummary.h.

◆ KolmogorovTestSummaryMap

MonitorElement* MuonTestSummary::KolmogorovTestSummaryMap

private

Definition at line 106 of file MuonTestSummary.h.

◆ matchesFractionCsc_max

double MuonTestSummary::matchesFractionCsc_max

private

Definition at line 87 of file MuonTestSummary.h.

◆ matchesFractionCsc_min

double MuonTestSummary::matchesFractionCsc_min

private

Definition at line 86 of file MuonTestSummary.h.

◆ matchesFractionDt_max

double MuonTestSummary::matchesFractionDt_max

private

Definition at line 85 of file MuonTestSummary.h.

◆ matchesFractionDt_min

double MuonTestSummary::matchesFractionDt_min

private

Definition at line 84 of file MuonTestSummary.h.

◆ metname

std::string MuonTestSummary::metname

private

Definition at line 63 of file MuonTestSummary.h.

◆ multiplicitySummaryMap

MonitorElement* MuonTestSummary::multiplicitySummaryMap

private

Definition at line 113 of file MuonTestSummary.h.

◆ muonIdSummaryMap

MonitorElement* MuonTestSummary::muonIdSummaryMap

private

Definition at line 111 of file MuonTestSummary.h.

◆ numMatchedExpected_max

double MuonTestSummary::numMatchedExpected_max

private

Definition at line 83 of file MuonTestSummary.h.

◆ numMatchedExpected_min

double MuonTestSummary::numMatchedExpected_min

private

Definition at line 82 of file MuonTestSummary.h.

◆ phiExpected

double MuonTestSummary::phiExpected

private

Definition at line 67 of file MuonTestSummary.h.

◆ pullEtaSpread

double MuonTestSummary::pullEtaSpread

private

Definition at line 76 of file MuonTestSummary.h.

◆ pullOneOvPSpread

double MuonTestSummary::pullOneOvPSpread

private

Definition at line 78 of file MuonTestSummary.h.

◆ pullPhiSpread

double MuonTestSummary::pullPhiSpread

private

Definition at line 77 of file MuonTestSummary.h.

◆ resChargeLimit_glbSta

double MuonTestSummary::resChargeLimit_glbSta

private

Definition at line 80 of file MuonTestSummary.h.

◆ resChargeLimit_tkGlb

double MuonTestSummary::resChargeLimit_tkGlb

private

Definition at line 79 of file MuonTestSummary.h.

◆ resChargeLimit_tkSta

double MuonTestSummary::resChargeLimit_tkSta

private

Definition at line 81 of file MuonTestSummary.h.

◆ resEtaSpread_glbSta

double MuonTestSummary::resEtaSpread_glbSta

private

Definition at line 71 of file MuonTestSummary.h.

◆ resEtaSpread_tkGlb

double MuonTestSummary::resEtaSpread_tkGlb

private

Definition at line 70 of file MuonTestSummary.h.

◆ residualsSummaryMap

MonitorElement* MuonTestSummary::residualsSummaryMap

private

Definition at line 110 of file MuonTestSummary.h.

◆ resOneOvPSpread_glbSta

double MuonTestSummary::resOneOvPSpread_glbSta

private

Definition at line 75 of file MuonTestSummary.h.

◆ resOneOvPSpread_tkGlb

double MuonTestSummary::resOneOvPSpread_tkGlb

private

Definition at line 74 of file MuonTestSummary.h.

◆ resPhiSpread_glbSta

double MuonTestSummary::resPhiSpread_glbSta

private

Definition at line 73 of file MuonTestSummary.h.

◆ resPhiSpread_tkGlb

double MuonTestSummary::resPhiSpread_tkGlb

private

Definition at line 72 of file MuonTestSummary.h.

◆ resSegmTrack_mean_max

double MuonTestSummary::resSegmTrack_mean_max

private

Definition at line 91 of file MuonTestSummary.h.

◆ resSegmTrack_mean_min

double MuonTestSummary::resSegmTrack_mean_min

private

Definition at line 90 of file MuonTestSummary.h.

◆ resSegmTrack_rms_max

double MuonTestSummary::resSegmTrack_rms_max

private

Definition at line 89 of file MuonTestSummary.h.

◆ resSegmTrack_rms_min

double MuonTestSummary::resSegmTrack_rms_min

private

Definition at line 88 of file MuonTestSummary.h.

◆ sigmaResSegmTrackExp

double MuonTestSummary::sigmaResSegmTrackExp

private

Definition at line 92 of file MuonTestSummary.h.

◆ summaryCertification

MonitorElement* MuonTestSummary::summaryCertification

private

Definition at line 117 of file MuonTestSummary.h.

◆ summaryCertificationMap

MonitorElement* MuonTestSummary::summaryCertificationMap

private

Definition at line 118 of file MuonTestSummary.h.

◆ summaryReport

MonitorElement* MuonTestSummary::summaryReport

private

Definition at line 114 of file MuonTestSummary.h.

◆ summaryReportMap

MonitorElement* MuonTestSummary::summaryReportMap

private

Definition at line 115 of file MuonTestSummary.h.

◆ theCertificationContents

std::vector<MonitorElement *> MuonTestSummary::theCertificationContents

private

Definition at line 119 of file MuonTestSummary.h.

◆ theSummaryContents

std::vector<MonitorElement *> MuonTestSummary::theSummaryContents

private

Definition at line 116 of file MuonTestSummary.h.

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ MuonTestSummary()

◆ ~MuonTestSummary()

Member Function Documentation

◆ doEnergyTests()

◆ doKinematicsTests()

◆ doMultiplicityTests()

◆ doMuonIDTests()

◆ doResidualsTests()

◆ dqmEndJob()

◆ GaussFit()

◆ ResidualCheck()

Member Data Documentation

◆ chi2Fraction

◆ chi2Spread

◆ chi2TestSummaryMap

◆ energySummaryMap

◆ etaExpected

◆ expMultiplicityGlb_max

◆ expMultiplicityGlb_min

◆ expMultiplicitySta_max

◆ expMultiplicitySta_min

◆ expMultiplicityTk_max

◆ expMultiplicityTk_min

◆ expPeakEcalS9_max

◆ expPeakEcalS9_min

◆ expPeakHadS9_max

◆ expPeakHadS9_min

◆ kinematicsSummaryMap

◆ KolmogorovTestSummaryMap

◆ matchesFractionCsc_max

◆ matchesFractionCsc_min

◆ matchesFractionDt_max

◆ matchesFractionDt_min

◆ metname

◆ multiplicitySummaryMap

◆ muonIdSummaryMap

◆ numMatchedExpected_max

◆ numMatchedExpected_min

◆ phiExpected

◆ pullEtaSpread

◆ pullOneOvPSpread

◆ pullPhiSpread

◆ resChargeLimit_glbSta

◆ resChargeLimit_tkGlb

◆ resChargeLimit_tkSta

◆ resEtaSpread_glbSta

◆ resEtaSpread_tkGlb

◆ residualsSummaryMap

◆ resOneOvPSpread_glbSta

◆ resOneOvPSpread_tkGlb

◆ resPhiSpread_glbSta

◆ resPhiSpread_tkGlb

◆ resSegmTrack_mean_max

◆ resSegmTrack_mean_min

◆ resSegmTrack_rms_max

◆ resSegmTrack_rms_min

◆ sigmaResSegmTrackExp

◆ summaryCertification

◆ summaryCertificationMap

◆ summaryReport

◆ summaryReportMap

◆ theCertificationContents

◆ theSummaryContents