#include <TopConfig.h>

Collaboration diagram for top::TopConfig:

Public Member Functions
	TopConfig ()
	m_tauJetID("SetMe"), m_tauJetIDBkg("SetMe"), m_tauEVetoID("SetMe"), m_tauVetoLArCrack(false), m_tauPtcut(20000.), More...

	TopConfig (const top::TopPersistentSettings *settings)

virtual	~TopConfig ()

	TopConfig (const TopConfig &rhs)=delete

	TopConfig (TopConfig &&rhs)=delete

TopConfig &	operator= (const TopConfig &rhs)=delete

top::TopPersistentSettings *	createPersistentSettings ()
	– top::TopPersistentSettings allows us to take a snapshot of top::TopConfig –/// – and save it to a mini-xAOD. More...

void	setConfigSettings (top::ConfigurationSettings *const &settings)

void	fixConfiguration ()

bool	makeAllCPTools () const

void	setGrlDir (const std::string &s)

const std::string &	grlDir () const

void	setGrlFile (const std::string &s)

const std::vector< std::string >	grlFile () const

void	setTDPPath (const std::string &s)

const std::string &	getTDPPath () const

void	setShoweringAlgorithm (SampleXsection::showering in)

SampleXsection::showering	getShoweringAlgorithm () const

bool	recomputeCPvars () const

bool	usePhotons () const

bool	useElectrons () const

bool	useFwdElectrons () const

bool	useMuons () const

bool	useSoftMuons () const

bool	useTaus () const

bool	useJets () const

bool	useLargeRJets () const

bool	useTrackJets () const

bool	useTracks () const

bool	useJetGhostTrack () const

bool	useRCJets () const

bool	useVarRCJets () const

bool	useParticleFlowJets () const

bool	useTruthParticles () const

bool	useTruthElectrons () const

bool	useTruthMuons () const

bool	useTruthPhotons () const

bool	useTruthJets () const

bool	useTruthLargeRJets () const

bool	useTruthTaus () const

bool	useTruthMET () const

bool	applyTTVACut () const

bool	useAntiMuons () const

bool	isMC () const

void	setIsMC (const bool value)

bool	isAFII () const

void	setIsAFII (const bool value)

bool	isDataOverlay () const

void	setIsDataOverlay (const bool value)

std::vector< std::string >	filterBranches () const

void	setFilterBranches (const std::vector< std::string > &value)

std::vector< std::string >	filterPartonLevelBranches () const

void	setFilterPartonLevelBranches (const std::vector< std::string > &value)

std::vector< std::string >	filterParticleLevelBranches () const

void	setFilterParticleLevelBranches (const std::vector< std::string > &value)

std::vector< std::string >	filterNominalLooseBranches () const

void	setFilterNominalLooseBranches (const std::vector< std::string > &value)

std::vector< std::string >	filterNominalBranches () const

void	setFilterNominalBranches (const std::vector< std::string > &value)

bool	isTruthDxAOD () const

void	setIsTruthDxAOD (const bool value)

std::string	getDerivationStream () const

void	setDerivationStream (const std::string &value)

unsigned int	getDSID () const

void	setDSID (unsigned int value)

bool	isSherpa22Vjets () const

void	setIsSherpa22Vjets (unsigned int dsid)

unsigned int	getMapIndex () const

void	setMapIndex (unsigned int value)

bool	doTightEvents () const

bool	doLooseEvents () const

bool	doTightSysts () const

bool	doLooseSysts () const

bool	doFakesMMWeightsIFF () const

std::string	FakesMMConfigIFF () const

bool	FakesMMIFFDebug () const

void	setFakesMMWeightsCalculationIFF ()

void	setFakesMMConfigIFF (const std::string &configIFF)

void	setFakesMMIFFDebug ()

void	setUseLooseObjectsInMETInLooseTree ()

bool	useLooseObjectsInMETInLooseTree () const

void	setUseLooseObjectsInMETInNominalTree ()

bool	useLooseObjectsInMETInNominalTree () const

void	setWriteMETBuiltWithLooseObjects ()

bool	writeMETBuiltWithLooseObjects ()

void	setOverlapRemovalOnLooseLeptonDef ()

bool	doOverlapRemovalOnLooseLeptonDef () const

std::string	overlapRemovalProcedure () const

float	overlapRemovalSlidingInnerDRel () const

float	overlapRemovalSlidingInnerDRmu () const

void	setLargeJetOverlapRemoval ()

bool	doLargeJetOverlapRemoval () const

void	setEleEleOverlapRemoval ()

bool	doEleEleOverlapRemoval () const

void	setApplyTightSFsInLooseTree ()

bool	applyTightSFsInLooseTree () const

bool	applyElectronInJetSubtraction () const

void	setApplyElectronInJetSubtraction ()

bool	doTruthBlockInfo () const

void	setTruthBlockInfo ()

bool	doTruthPDFInfo () const

void	setTruthPDFInfo ()

bool	doTruthPDFInfoInNominalTrees () const

void	setTruthPDFInfoInNominalTrees ()

bool	doMCGeneratorWeights () const

void	setMCGeneratorWeights ()

bool	doMCGeneratorWeightsInNominalTrees () const

void	setMCGeneratorWeightsInNominalTrees ()

const std::vector< std::string > &	nominalWeightNames () const

void	setNominalWeightName (const std::string &name)

void	setNominalWeightIndex (size_t index)

std::string	nominalWeightName () const

size_t	nominalWeightIndex () const

bool	forceNominalWeightFallbackIndex () const

bool	doTopPartonHistory () const

void	setTopPartonHistory ()

bool	isTopPartonHistoryRegisteredInNtuple () const

void	setTopPartonHistoryRegisteredInNtuple ()

bool	doTopPartonLevel () const

void	setTopPartonLevel (bool in)

bool	doTopParticleLevel () const

void	setTopParticleLevel (bool in)

bool	doParticleLevelOverlapRemovalMuJet () const

bool	doParticleLevelOverlapRemovalElJet () const

bool	doParticleLevelOverlapRemovalJetPhoton () const

bool	useParticleLevelOverlapRemovalWithRapidity () const

void	setParticleLevelOverlapRemovalMuJet (bool value)

void	setParticleLevelOverlapRemovalElJet (bool value)

void	setParticleLevelOverlapRemovalJetPhoton (bool value)

void	setParticleLevelOverlapRemovalWithRapidity (bool value)

bool	doKLFitter () const

void	setKLFitter ()

const std::string &	KLFitterTransferFunctionsPath () const

const std::string &	KLFitterOutput () const

const std::string &	KLFitterJetSelectionMode () const

const std::string &	KLFitterBTaggingMethod () const

const std::string &	KLFitterLH () const

bool	KLFitterTopMassFixed () const

bool	KLFitterSaveAllPermutations () const

bool	KLFitterFailOnLessThanXJets () const

bool	doPseudoTop () const

void	setPseudoTop ()

virtual void	allTriggers_Tight (std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)

virtual void	electronTriggers_Tight (std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)

virtual void	muonTriggers_Tight (std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)

virtual void	tauTriggers_Tight (std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)

virtual void	photonTriggers_Tight (std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)

virtual void	allTriggers_Loose (std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)

virtual void	electronTriggers_Loose (std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)

virtual void	muonTriggers_Loose (std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)

virtual void	tauTriggers_Loose (std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)

virtual void	photonTriggers_Loose (std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)

std::shared_ptr< std::vector< std::string > >	allSelectionNames () const

virtual const std::vector< std::pair< std::string, int > > &	allTriggers_Tight (const std::string &selection) const

virtual const std::vector< std::pair< std::string, int > > &	electronTriggers_Tight (const std::string &selection) const

virtual const std::vector< std::pair< std::string, int > > &	muonTriggers_Tight (const std::string &selection) const

virtual const std::vector< std::pair< std::string, int > > &	tauTriggers_Tight (const std::string &selection) const

virtual const std::vector< std::pair< std::string, int > > &	photonTriggers_Tight (const std::string &selection) const

virtual const std::vector< std::pair< std::string, int > > &	allTriggers_Loose (const std::string &selection) const

virtual const std::vector< std::pair< std::string, int > > &	electronTriggers_Loose (const std::string &selection) const

virtual const std::vector< std::pair< std::string, int > > &	muonTriggers_Loose (const std::string &selection) const

virtual const std::vector< std::pair< std::string, int > > &	tauTriggers_Loose (const std::string &selection) const

virtual const std::vector< std::pair< std::string, int > > &	photonTriggers_Loose (const std::string &selection) const

bool	triggerMatchingElementRelink () const

virtual void	sgKeyMCParticle (const std::string &s)

virtual void	sgKeyPhotons (const std::string &s)

virtual void	sgKeyElectrons (const std::string &s)

virtual void	sgKeyFwdElectrons (const std::string &s)

virtual void	sgKeyMuons (const std::string &s)

virtual void	sgKeySoftMuons (const std::string &s)

virtual void	sgKeyTaus (const std::string &s)

virtual void	sgKeyJets (const std::string &s)

virtual void	sgKeyLargeRJets (const std::string &s)

virtual void	sgKeyTrackJets (const std::string &s)

virtual void	sgKeyTracks (const std::string &s)

virtual void	sgKeyTruthElectrons (const std::string &s)

virtual void	sgKeyTruthMuons (const std::string &s)

virtual void	sgKeyTruthPhotons (const std::string &s)

virtual void	sgKeyTruthMET (const std::string &s)

virtual void	sgKeyTruthJets (const std::string &s)

virtual void	sgKeyTruthLargeRJets (const std::string &s)

virtual void	sgKeyTruthTaus (const std::string &s)

virtual void	sgKeyMissingEt (const std::string &s)

virtual void	sgKeyMissingEtLoose (const std::string &s)

float	jetResponseMatchingDeltaR () const

void	setJetResponseMatchingDeltaR (const float value)

const std::string &	sgKeyEventInfo () const

const std::string &	sgKeyPrimaryVertices () const

virtual const std::string &	sgKeyPhotons () const

virtual const std::string &	sgKeyElectrons () const

virtual const std::string &	sgKeyFwdElectrons () const

virtual const std::string &	sgKeyMuons () const

virtual const std::string &	sgKeySoftMuons () const

virtual const std::string &	sgKeyTaus () const

virtual const std::string &	sgKeyJets () const

virtual const std::string &	sgKeyLargeRJets () const

virtual const std::string &	sgKeyTrackJets () const

virtual const std::string &	sgKeyTracks () const

virtual const std::string &	sgKeyMissingEt () const

virtual const std::string &	sgKeyMissingEtLoose () const

const std::string &	sgKeyInDetTrackParticles () const

const std::string &	sgKeyTruthEvent () const

virtual const std::string &	sgKeyMCParticle () const

const std::string &	sgKeyTruthPhotons () const

const std::string &	sgKeyTruthElectrons () const

const std::string &	sgKeyTruthMuons () const

const std::string &	sgKeyTruthTaus () const

virtual const std::string &	sgKeyTruthJets () const

virtual const std::string &	sgKeyTruthLargeRJets () const

const std::string &	sgKeyTruthMET () const

const std::string &	sgKeyTopPartonHistory () const

const std::string &	sgKeyTopSystematicEvents () const

const std::string &	sgKeyTopSystematicEventsLoose () const

const std::string &	passEventSelectionDecoration () const

virtual void	decoKeyJetGhostTrack (const std::string &key)

virtual const std::string &	decoKeyJetGhostTrack () const

virtual void	runPeriodJetGhostTrack (const std::vector< std::uint32_t > &vect)

virtual void	runPeriodTrack (const std::vector< std::uint32_t > &vect)

virtual const std::string &	sgKeyPhotons (const std::size_t hash) const

virtual const std::string &	sgKeyElectrons (const std::size_t hash) const

virtual const std::string &	sgKeyFwdElectrons (const std::size_t hash) const

virtual const std::string &	sgKeyElectronsStandAlone (const std::size_t hash) const

virtual const std::string &	sgKeyFwdElectronsStandAlone (const std::size_t hash) const

virtual const std::string &	sgKeyMuons (const std::size_t hash) const

virtual const std::string &	sgKeySoftMuons (const std::size_t hash) const

virtual const std::string &	sgKeyTaus (const std::size_t hash) const

virtual const std::string &	sgKeyJets (const std::size_t hash, const bool useLooseLeptonJets) const

virtual const std::string &	sgKeyJetsStandAlone (const std::size_t hash) const

virtual const std::string &	sgKeyLargeRJets (const std::size_t hash) const

virtual const std::string &	sgKeyTrackJets (const std::size_t hash) const

virtual const std::string &	sgKeyTracks (const std::size_t hash) const

virtual const std::string &	sgKeyMissingEt (const std::size_t hash) const

virtual const std::string &	sgKeyMissingEtLoose (const std::size_t hash) const

const std::string &	sgKeyPhotonsTDS (const std::size_t hash) const

const std::string &	sgKeyPhotonsTDSAux (const std::size_t hash) const

const std::string &	sgKeyElectronsTDS (const std::size_t hash) const

const std::string &	sgKeyElectronsTDSAux (const std::size_t hash) const

const std::string &	sgKeyFwdElectronsTDS (const std::size_t hash) const

const std::string &	sgKeyFwdElectronsTDSAux (const std::size_t hash) const

const std::string &	sgKeyMuonsTDS (const std::size_t hash) const

const std::string &	sgKeyMuonsTDSAux (const std::size_t hash) const

const std::string &	sgKeySoftMuonsTDS (const std::size_t hash) const

const std::string &	sgKeySoftMuonsTDSAux (const std::size_t hash) const

const std::string &	sgKeyTausTDS (const std::size_t hash) const

const std::string &	sgKeyTausTDSAux (const std::size_t hash) const

const std::string &	sgKeyJetsTDS (const std::size_t hash, const bool useLooseLeptonJets) const

const std::string &	sgKeyJetsTDSAux (const std::size_t hash, const bool useLooseLeptonJets) const

const std::string &	sgKeyLargeRJetsTDS (const std::size_t hash) const

const std::string &	sgKeyLargeRJetsTDSAux (const std::size_t hash) const

const std::string &	sgKeyTrackJetsTDS (const std::size_t hash) const

const std::string &	sgKeyTrackJetsTDSAux (const std::size_t hash) const

const std::string &	sgKeyTracksTDS (const std::size_t hash) const

const std::string &	sgKeyTracksTDSAux (const std::size_t hash) const

const std::string &	sgKeyKLFitter (const std::size_t hash) const

const std::string &	sgKeyKLFitterLoose (const std::size_t hash) const

const std::string &	sgKeyPseudoTop (const std::size_t hash) const

const std::string &	sgKeyPseudoTop (const std::string) const

const std::string &	sgKeyPseudoTopLoose (const std::size_t hash) const

const std::string &	sgKeyPseudoTopLoose (const std::string) const

const std::string &	decoKeyJetGhostTrack (const std::size_t hash) const

const std::vector< std::string > &	systematicsJetGhostTrack () const

const std::vector< std::uint32_t > &	runPeriodsJetGhostTrack () const

const std::vector< std::uint32_t > &	runPeriodsTrack () const

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	systMapJetGhostTrack () const

virtual void	dumpBtagSystsInSystTrees (const bool &b)

virtual const bool &	dumpBtagSystsInSystTrees ()

virtual void	storePerJetBtagSFs (const bool &b)

virtual const bool &	storePerJetBtagSFs ()

virtual void	egammaSystematicModel (const std::string &s)

virtual void	electronEfficiencySystematicModel (const std::string &s)

virtual void	electronEfficiencySystematicModelEtaBinning (const std::string &s)

virtual void	electronEfficiencySystematicModelEtBinning (const std::string &s)

virtual void	electronEfficiencySystematicModelNToys (const int &s)

virtual void	electronEfficiencySystematicModelToySeed (const int &s)

virtual void	electronEfficiencySystematicModelRecoSize (const int &s)

virtual void	electronEfficiencySystematicModelIdSize (const int &s)

virtual void	electronEfficiencySystematicModelIsoSize (const int &s)

virtual void	electronID (const std::string &s)

virtual void	electronIDLoose (const std::string &s)

void	removeElectronVetoLArCrack ()

virtual void	electronVetoLArCrack (const bool b)

virtual void	electronPtcut (const float pt)

virtual void	electrond0Sigcut (const float d0sig)

virtual void	electrondeltaz0cut (const float delta_z0)

virtual void	electronIsolation (const std::string &iso)

virtual void	electronIsolationLoose (const std::string &iso)

void	electronIsolationSF (std::string const &iso)

void	electronIsolationSFLoose (std::string const &iso)

virtual void	useElectronChargeIDSelection (const std::string &s)

virtual void	useEgammaLeakageCorrection (const std::string &s)

virtual void	enablePromptLeptonImprovedVetoStudies (const std::string &s)

virtual const std::string &	egammaSystematicModel ()

virtual const std::string &	electronEfficiencySystematicModel ()

virtual const std::string &	electronEfficiencySystematicModelEtaBinning ()

virtual const std::string &	electronEfficiencySystematicModelEtBinning ()

virtual const int &	electronEfficiencySystematicModelNToys ()

virtual const int &	electronEfficiencySystematicModelToySeed ()

virtual const int &	electronEfficiencySystematicModelRecoSize ()

virtual const int &	electronEfficiencySystematicModelIdSize ()

virtual const int &	electronEfficiencySystematicModelIsoSize ()

virtual const std::string &	electronID () const

virtual const std::string &	electronIDLoose () const

virtual bool	electronVetoLArCrack () const

virtual float	electronPtcut () const

virtual float	electrond0Sigcut () const

virtual float	electrondeltaz0cut () const

virtual const std::string &	electronIsolation () const

virtual const std::string &	electronIsolationLoose () const

virtual const std::vector< std::string > &	electronIsolationWPs () const

std::string const &	electronIsolationSF () const

std::string const &	electronIsolationSFLoose () const

const std::string &	electronIDDecoration () const

const std::string &	electronIDLooseDecoration () const

bool	useElectronChargeIDSelection () const

bool	useEgammaLeakageCorrection () const

bool	enablePromptLeptonImprovedVetoStudies () const

std::string const &	elTrigEffConfig () const

void	elTrigEffConfig (const std::string &s)

virtual void	fwdElectronID (const std::string &s)

virtual void	fwdElectronIDLoose (const std::string &s)

virtual void	fwdElectronPtcut (const float pt)

virtual void	fwdElectronMinEtacut (const float eta)

virtual void	fwdElectronMaxEtacut (const float eta)

virtual void	fwdElectronBCIDCleaningMinRun (const int fwdElectronBCIDCleaningMinRun)

virtual void	fwdElectronBCIDCleaningMaxRun (const int fwdElectronBCIDCleaningMaxRun)

virtual const std::string &	fwdElectronID () const

virtual const std::string &	fwdElectronIDLoose () const

virtual float	fwdElectronPtcut () const

virtual float	fwdElectronMinEtacut () const

virtual float	fwdElectronMaxEtacut () const

virtual int	fwdElectronBCIDCleaningMinRun () const

virtual int	fwdElectronBCIDCleaningMaxRun () const

const std::string	electronIDSFFilePath () const

const std::string	electronIDSFFileLoosePath () const

bool	printEIDFileWarning () const

void	setPrintEIDFileWarning (bool flag)

virtual void	photonPtcut (const float pt)

virtual void	photonEtacut (const float eta)

virtual void	photonIdentification (const std::string &quality)

virtual void	photonIdentificationLoose (const std::string &quality)

virtual void	photonIsolation (const std::string &quality)

virtual void	photonIsolationLoose (const std::string &quality)

virtual void	muonPtcut (const float pt)

virtual void	muond0Sigcut (const float d0sig)

virtual void	muondeltaz0cut (const float delta_z0)

virtual void	muonEtacut (const float eta)

virtual void	muonQuality (const std::string &quality)

void	muonUseMVALowPt (const bool &UseMVALowPt)

void	muonUseLowPt (const bool &UseLowPt)

void	muonUse2stationMuonsHighPt (const bool &Use2stationMuonsHighPt)

void	muonUseMVALowPtLoose (const bool &UseMVALowPtLoose)

void	muonUseLowPtLoose (const bool &UseLowPtLoose)

void	muonUse2stationMuonsHighPtLoose (const bool &Use2stationMuonsHighPtLoose)

virtual void	muonQualityLoose (const std::string &quality)

virtual void	muonIsolation (const std::string &iso)

virtual void	muonIsolationLoose (const std::string &iso)

void	muonIsolationSF (std::string const &iso)

void	muonIsolationSFLoose (std::string const &iso)

void	muonMuonDoSmearing2stationHighPt (const bool &MuonDoSmearing2stationHighPt)

void	muonMuonDoExtraSmearingHighPt (const bool &MuonDoExtraSmearingHighPt)

virtual float	muonPtcut () const

virtual float	muonEtacut () const

virtual float	muond0Sigcut () const

virtual float	muondeltaz0cut () const

virtual const std::string &	muonQuality () const

virtual const std::string &	muonQualityLoose () const

virtual bool	muonUseMVALowPt () const

virtual bool	muonUseLowPt () const

virtual bool	muonUse2stationMuonsHighPt () const

virtual bool	muonUseMVALowPtLoose () const

virtual bool	muonUseLowPtLoose () const

virtual bool	muonUse2stationMuonsHighPtLoose () const

virtual const std::string &	muonIsolation () const

virtual const std::string &	muonIsolationLoose () const

virtual const std::vector< std::string > &	muonIsolationWPs () const

std::string const &	muonIsolationSF () const

std::string const &	muonIsolationSFLoose () const

std::string const &	muonCalibMode () const

std::string const &	muonSmearingSystematicModel () const

virtual bool	muonMuonDoSmearing2stationHighPt () const

virtual bool	muonMuonDoExtraSmearingHighPt () const

virtual void	muonBreakDownSystematics (const bool flag)

virtual bool	muonBreakDownSystematics ()

std::string const &	muonSFCustomInputFolder () const

void	muonSFCustomInputFolder (const std::string &s)

std::string const &	muonSFCustomInputFolderTrigger () const

void	muonSFCustomInputFolderTrigger (const std::string &s)

int	muonForceYear () const

void	muonForceYear (int s)

std::string const &	muonForcePeriod () const

void	muonForcePeriod (const std::string &s)

std::string const &	muonForceTrigger () const

void	muonForceTrigger (const std::string &s)

virtual void	softmuonPtcut (const float pt)

virtual void	softmuonEtacut (const float eta)

virtual void	softmuonQuality (const std::string &quality)

void	softmuonUseMVALowPt (const bool UseMVALowPtSoftMuon)

void	softmuonUseLowPt (const bool UseLowPtSoftMuon)

virtual void	softmuonDRJetcut (const float DRJet)

virtual void	softmuonDRJetcutUseRapidity (const bool in)

virtual void	softmuonAdditionalTruthInfo (bool in)

virtual void	softmuonAdditionalTruthInfoCheckPartonOrigin (bool in)

virtual void	softmuonAdditionalTruthInfoDoVerbose (bool in)

virtual float	softmuonPtcut () const

virtual float	softmuonEtacut () const

virtual const std::string &	softmuonQuality () const

virtual bool	softmuonUseMVALowPt () const

virtual bool	softmuonUseLowPt () const

virtual float	softmuonDRJetcut () const

virtual bool	softmuonDRJetcutUseRapidity () const

virtual bool	softmuonAdditionalTruthInfo () const

virtual bool	softmuonAdditionalTruthInfoCheckPartonOrigin () const

virtual bool	softmuonAdditionalTruthInfoDoVerbose () const

virtual void	jetPtcut (const float pt)

virtual void	jetEtacut (const float eta)

virtual void	jetPtGhostTracks (const float pt, const float small_jet_pt)

virtual void	jetEtaGhostTracks (const float eta)

virtual void	ghostTrackspT (const float pt)

virtual void	ghostTracksVertexAssociation (const std::string &vertexassociation)

virtual void	ghostTracksQuality (const std::string &ghostTracksQuality)

virtual float	jetPtcut () const

virtual float	jetEtacut () const

virtual float	ghostTrackspT () const

virtual const std::string &	ghostTracksVertexAssociation () const

virtual const std::string &	ghostTracksQuality () const

virtual float	jetPtGhostTracks () const

virtual float	jetEtaGhostTracks () const

virtual void	largeRJetPtcut (const float pt)

virtual void	largeRJetMasscut (const float m)

virtual void	largeRJetEtacut (const float eta)

virtual void	largeRJetUncertainties_NPModel (const std::string &largeR_config)

virtual void	largeRJetUncertainties_JMR_NPModel (const std::string &largeR_JMR_config)

virtual void	largeRJetUncertaintiesConfigDir (const std::string &largeRConfigDir)

virtual void	largeRJESJMSConfig (const std::string &largeR_config)

virtual float	largeRJetPtcut () const

virtual float	largeRJetMasscut () const

virtual float	largeRJetEtacut () const

virtual const std::map< std::string, std::string >	largeRJetSubstructureVariables () const

virtual const std::string &	largeRJetUncertainties_NPModel () const

virtual const std::string &	largeRJetUncertainties_JMR_NPModel () const

virtual const std::string &	largeRJetUncertaintiesConfigDir () const

virtual const std::string &	largeRJESJMSConfig () const

virtual void	trackJetPtcut (const float pt)

virtual void	trackJetEtacut (const float eta)

virtual float	trackJetPtcut () const

virtual float	trackJetEtacut () const

virtual void	trackPtcut (const float pt)

virtual void	trackEtacut (const float eta)

virtual void	trackQuality (const std::string &quality)

virtual const std::string &	trackQuality () const

virtual float	trackPtcut () const

virtual float	trackEtacut () const

virtual float	RCJetPtcut () const

virtual float	RCJetEtacut () const

virtual float	RCInputJetPtMin () const

virtual float	RCInputJetEtaMax () const

virtual float	RCJetTrimcut () const

virtual float	RCJetRadius () const

virtual bool	useRCJetSubstructure () const

virtual bool	useRCJetAdditionalSubstructure () const

virtual void	RCJetPtcut (const float pt)

virtual void	RCJetEtacut (const float eta)

virtual void	RCInputJetPtMin (const float pt)

virtual void	RCInputJetEtaMax (const float eta)

virtual void	RCJetTrimcut (const float trim)

virtual void	RCJetRadius (const float radius)

virtual void	useRCJetSubstructure (const bool use)

virtual void	useRCJetAdditionalSubstructure (const bool use)

virtual float	VarRCJetPtcut () const

virtual float	VarRCJetEtacut () const

virtual float	VarRCJetTrimcut () const

virtual float	VarRCJetMaxRadius () const

virtual const std::string &	VarRCJetRho () const

virtual const std::string &	VarRCJetMassScale () const

virtual bool	useVarRCJetSubstructure () const

virtual bool	useVarRCJetAdditionalSubstructure () const

virtual void	VarRCJetPtcut (const float pt)

virtual void	VarRCJetEtacut (const float eta)

virtual void	VarRCJetTrimcut (const float trim)

virtual void	VarRCJetMaxRadius (const float radius)

virtual void	VarRCJetRho (const std::string &rho)

virtual void	VarRCJetMassScale (const std::string &mass_scale)

virtual void	useVarRCJetSubstructure (const bool use)

virtual void	useVarRCJetAdditionalSubstructure (const bool use)

virtual void	jetUncertainties_NPModel (const std::string &s)

virtual void	jetUncertainties_QGFracFile (const std::string &s)

virtual void	jetUncertainties_QGHistPatterns (const std::string &s)

bool	doMultipleJES () const

virtual const std::string &	jetUncertainties_NPModel () const

virtual const std::string &	jetUncertainties_QGFracFile () const

virtual const std::vector< std::string > &	jetUncertainties_QGHistPatterns () const

virtual void	jetJERSmearingModel (const std::string &s)

virtual const std::string &	jetJERSmearingModel () const

virtual void	jetJMSOption (const std::string &s)

virtual const std::string &	jetJMSOption () const

virtual void	doLargeRPseudodataJER (const bool &b)

virtual bool	doLargeRPseudodataJER () const

virtual void	jetCalibSequence (const std::string &s)

virtual const std::string &	jetCalibSequence () const

virtual void	allowSmallRJMSforAFII (const bool setting)

virtual bool	allowSmallRJMSforAFII () const

virtual void	jetStoreTruthLabels (bool b)

virtual bool	jetStoreTruthLabels () const

virtual void	doJVTinMET (const bool &doJVT)

virtual bool	doJVTinMET () const

virtual void	saveFailJVTJets (const bool &doJVT)

virtual bool	saveFailJVTJets () const

const std::string &	getJVTWP () const

void	setJVTWP (const std::string &value)

virtual void	doForwardJVTinMET (const bool &dofJVT)

virtual bool	doForwardJVTinMET () const

virtual void	saveFailForwardJVTJets (const bool &dofJVT)

virtual bool	saveFailForwardJVTJets () const

const std::string &	getfJVTWP () const

void	setfJVTWP (const std::string &value)

virtual float	JSF () const

virtual float	bJSF () const

virtual void	METUncertaintiesConfigDir (const std::string &METConfigDir)

virtual const std::string &	METUncertaintiesConfigDir () const

virtual void	METSignificance (bool doMETSignificance)

virtual void	METSignifSoftTermParam (const std::string &METSignifSoftTermParam)

virtual const std::string &	METSignifSoftTermParam () const

virtual bool	METSignificance () const

const std::string &	getMETJetSelectionWP ()

void	setMETJetSelectionWP (const std::string &value)

virtual void	tauPtcut (const float pt)

virtual void	tauEtaRegions (const std::string &etaRegions)

virtual void	tauJetIDWP (const std::string &s)

virtual void	tauJetIDWPLoose (const std::string &s)

virtual void	tauEleIDWP (const std::string &s)

virtual void	tauEleIDWPLoose (const std::string &s)

virtual void	tauMuOLR (bool do_tau_ele_olr)

virtual void	tauMuOLRLoose (bool do_tau_ele_olr)

virtual void	tauJetConfigFile (const std::string &s)

virtual void	tauJetConfigFileLoose (const std::string &s)

virtual void	tauSubstructureSF (bool do_tau_substructure_sf)

virtual void	tauSubstructureSFLoose (bool do_tau_substructure_sf)

virtual float	tauPtcut () const

const std::string &	tauEtaRegions () const

const std::string &	tauJetIDWP () const

const std::string &	tauJetIDWPLoose () const

const std::string &	tauEleIDWP () const

const std::string &	tauEleIDWPLoose () const

virtual bool	tauMuOLR ()

virtual bool	tauMuOLRLoose ()

const std::string &	tauJetConfigFile ()

const std::string &	tauJetConfigFileLoose ()

virtual bool	tauSubstructureSF ()

virtual bool	tauSubstructureSFLoose ()

bool	applyTauMVATES ()

virtual float	photonPtcut () const

virtual float	photonEtacut () const

const std::string &	photonIdentification ()

const std::string &	photonIdentificationLoose ()

const std::string &	photonIsolation ()

const std::string &	photonIsolationLoose ()

const std::vector< std::string > &	photonIsolationWPs ()

virtual void	truth_electron_PtCut (const float pt)

virtual void	truth_electron_EtaCut (const float eta)

virtual float	truth_electron_PtCut () const

virtual float	truth_electron_EtaCut () const

virtual bool	truth_electron_NotFromHadron () const

virtual bool	truth_electron_TauIsHadron () const

virtual void	truth_muon_PtCut (const float pt)

virtual void	truth_muon_EtaCut (const float eta)

virtual float	truth_muon_PtCut () const

virtual float	truth_muon_EtaCut () const

virtual bool	truth_muon_NotFromHadron () const

virtual bool	truth_muon_TauIsHadron () const

virtual void	truth_softmuon_PtCut (const float pt)

virtual void	truth_softmuon_EtaCut (const float eta)

virtual float	truth_softmuon_PtCut () const

virtual float	truth_softmuon_EtaCut () const

virtual void	truth_photon_PtCut (const float pt)

virtual void	truth_photon_EtaCut (const float eta)

virtual void	truth_photon_Origin (const std::string &value)

virtual void	truth_photon_Isolation (const std::string &value)

virtual float	truth_photon_PtCut () const

virtual float	truth_photon_EtaCut () const

virtual const std::string &	truth_photon_Origin () const

virtual const std::string &	truth_photon_Isolation () const

virtual void	truth_jet_PtCut (const float pt)

virtual void	truth_jet_EtaCut (const float eta)

virtual float	truth_jet_PtCut () const

virtual float	truth_jet_EtaCut () const

virtual void	truth_jet_largeR_PtCut (const float pt)

virtual void	truth_jet_largeR_EtaCut (const float eta)

virtual float	truth_jet_largeR_PtCut () const

virtual float	truth_jet_largeR_EtaCut () const

virtual void	truth_tau_PtCut (const float pt)

virtual void	truth_tau_EtaCut (const float eta)

virtual float	truth_tau_PtCut () const

virtual float	truth_tau_EtaCut () const

void	setBTaggingSFSysts (std::string WP, const std::set< std::string > &btagging_SFs, bool isTrackJet=false)

virtual std::set< std::string >	btagging_namedSysts (std::string WP) const

virtual unsigned int	btagging_num_B_eigenvars (std::string WP) const

virtual unsigned int	btagging_num_C_eigenvars (std::string WP) const

virtual unsigned int	btagging_num_Light_eigenvars (std::string WP) const

virtual std::set< std::string >	trkjet_btagging_namedSysts (std::string WP) const

virtual unsigned int	trkjet_btagging_num_B_eigenvars (std::string WP) const

virtual unsigned int	trkjet_btagging_num_C_eigenvars (std::string WP) const

virtual unsigned int	trkjet_btagging_num_Light_eigenvars (std::string WP) const

const std::vector< std::pair< std::string, std::string > > &	boostedJetTaggers () const

const std::unordered_map< std::string, std::string > &	boostedTaggerSFnames () const

const std::unordered_map< std::string, std::vector< std::string > > &	boostedTaggersSFSysNames () const

void	setCalibBoostedJetTagger (const std::string &WP, const std::string &SFname)

void	setBoostedTaggersSFSysNames (const std::unordered_map< std::string, std::vector< std::string >> &sysNames)

const std::vector< std::pair< std::string, std::string > >	bTagAlgoWP () const

const std::vector< std::pair< std::string, std::string > >	bTagAlgoWP_trkJet () const

const std::vector< std::string >	bTagWP () const

const std::vector< std::string >	bTagWP_trkJet () const

const std::vector< std::pair< std::string, std::string > >	bTagAlgoWP_calib () const

const std::vector< std::pair< std::string, std::string > >	bTagAlgoWP_calib_trkJet () const

const std::vector< std::string >	bTagWP_calib () const

const std::vector< std::string >	bTagWP_calib_trkJet () const

const std::map< std::string, std::string >	bTagAlgos () const

const std::map< std::string, std::string >	bTagAlgos_trkJet () const

void	addBTagAlgo (const std::string &algorithm, const std::string &selectionToolName, bool trackJets=false)

void	parse_bTagWPs (const std::string &btagWPsettingString, std::vector< std::pair< std::string, std::string >> &btagAlgoWPlist, std::vector< std::string > &btagWPlist)

const std::string	bTagSystsExcludedFromEV () const

bool	printCDIpathWarning () const

void	setPrintCDIpathWarning (bool flag)

const std::string	bTaggingCDIPath () const

const std::string &	bTaggingCalibration_B () const

const std::string &	bTaggingCalibration_C () const

const std::string &	bTaggingCalibration_Light () const

bool	printEgammaCalibModelWarning () const

void	setPrintEgammaCalibModelWarning (bool flag)

const std::string &	egammaCalibration () const

virtual std::vector< std::string >	LHAPDFSets ()

virtual bool	doLHAPDF ()

virtual std::string	baseLHAPDF ()

virtual bool	doLHAPDFInNominalTrees ()

virtual bool	saveLHAPDFEvent ()

void	addLHAPDFResult (const std::string &pdf_name, std::vector< float > sum_of_weights)

std::unordered_map< std::string, std::vector< float > > &	getLHAPDFResults ()

bool	doPileupReweighting ()

bool	PileupUseGRLTool ()

const std::vector< std::string > &	PileupConfig ()

const std::vector< std::string > &	PileupLumiCalc ()

bool	PileupMuDependent ()

const std::vector< std::string > &	PileupConfig_FS ()

const std::vector< std::string > &	PileupConfig_AF ()

const std::vector< std::string > &	PileupActualMu_FS ()

const std::vector< std::string > &	PileupActualMu_AF ()

virtual float	PileupDataTolerance () const

const std::vector< int > &	PileupPeriodAssignments () const

const std::vector< double > &	PileUpCustomScaleFactors ()

unsigned int	forceRandomRunNumber () const

void	setForceRandomRunNumber (const unsigned int randomRunNumber)

bool	isRun3 () const

void	setIsRun3 (const bool isRun3)

bool	demandPriVtx () const

const std::string &	sumOfEventWeightsMetaData () const

virtual void	objectSelectionName (const std::string &s)

virtual const std::string &	objectSelectionName () const

virtual void	outputFormat (const std::string &s)

virtual const std::string &	outputFormat () const

virtual void	outputEvents (const std::string &s)

virtual const std::string &	outputEvents () const

bool	saveOnlySelectedEvents () const

bool	outputFileSetAutoFlushZero () const

int	outputFileNEventAutoFlush () const

int	outputFileBasketSizePrimitive () const

int	outputFileBasketSizeVector () const

virtual unsigned int	numberOfEventsToRun () const

virtual void	numberOfEventsToRun (const unsigned int &n_events)

virtual unsigned int	numberOfEventsToSkip () const

virtual void	numberOfEventsToSkip (const unsigned int &n_events)

virtual void	systematics (const std::string &s)

virtual const std::string &	systematics () const

bool	isSystNominal (const std::string &syst) const
	syst helper functions More...

bool	isSystAll (const std::string &syst) const

bool	getSystematicsList (const std::string &syst, std::set< std::string > &systList) const

bool	contains (const std::set< std::string > &systList, const std::string &name) const

virtual void	systematicsPhotons (const std::list< CP::SystematicSet > &syst)

virtual void	systematicsElectrons (const std::list< CP::SystematicSet > &syst)

virtual void	systematicsFwdElectrons (const std::list< CP::SystematicSet > &syst)

virtual void	systematicsMuons (const std::list< CP::SystematicSet > &syst)

virtual void	systematicsSoftMuons (const std::list< CP::SystematicSet > &syst)

virtual void	systematicsTaus (const std::list< CP::SystematicSet > &syst)

virtual void	systematicsJets (const std::list< CP::SystematicSet > &syst)

virtual void	systematicsLargeRJets (const std::list< CP::SystematicSet > &syst)

virtual void	systematicsTrackJets (const std::list< CP::SystematicSet > &syst)

virtual void	systematicsTracks (const std::list< CP::SystematicSet > &syst)

virtual void	systematicsMET (const std::list< CP::SystematicSet > &syst)

virtual void	systematicsJetGhostTrack (const std::list< CP::SystematicSet > &syst)

virtual void	jetSubstructureName (const std::string &s)

virtual const std::string &	jetSubstructureName () const

std::size_t	nominalHashValue () const

std::shared_ptr< std::unordered_set< std::size_t > >	systHashPhotons () const

std::shared_ptr< std::unordered_set< std::size_t > >	systHashElectrons () const

std::shared_ptr< std::unordered_set< std::size_t > >	systHashFwdElectrons () const

std::shared_ptr< std::unordered_set< std::size_t > >	systHashMuons () const

std::shared_ptr< std::unordered_set< std::size_t > >	systHashSoftMuons () const

std::shared_ptr< std::unordered_set< std::size_t > >	systHashTaus () const

std::shared_ptr< std::unordered_set< std::size_t > >	systHashJets () const

std::shared_ptr< std::unordered_set< std::size_t > >	systHashAll () const

std::shared_ptr< std::unordered_set< std::size_t > >	systHashElectronInJetSubtraction () const

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	systMapPhotons () const

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	systMapElectrons () const

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	systMapFwdElectrons () const

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	systMapMuons () const

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	systMapSoftMuons () const

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	systMapTaus () const

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	systMapJets () const

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	systMapLargeRJets () const

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	systSgKeyMapPhotons () const

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	systSgKeyMapElectrons () const

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	systSgKeyMapFwdElectrons () const

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	systSgKeyMapMuons () const

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	systSgKeyMapSoftMuons () const

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	systSgKeyMapTaus () const

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	systSgKeyMapJets (const bool useLooseLeptonJets) const

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	systSgKeyMapLargeRJets () const

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	systSgKeyMapTrackJets () const

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	systSgKeyMapTracks () const

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	systAllTTreeNames () const

const std::string &	systematicName (const std::size_t hash) const

unsigned int	ttreeIndex (const std::size_t hash) const

unsigned int	ttreeIndexLoose (const std::size_t hash) const

void	setReleaseSeries ()

int	getReleaseSeries () const

bool	saveBootstrapWeights () const

void	setSaveBootstrapWeights (const bool value)

int	getNumberOfBootstrapReplicas () const

void	setNumberOfBootstrapReplicas (const int value)

bool	useBadBatmanCleaning () const

void	setUseBadBatmanCleaning (const bool value)

unsigned int	badBatmanCleaningMin () const

void	setBadBatmanCleaningMin (const unsigned int value)

unsigned int	badBatmanCleaningMax () const

void	setBadBatmanCleaningMax (const unsigned int value)

bool	useEventLevelJetCleaningTool () const

void	setUseEventLevelJetCleaningTool (const bool value)

std::string	getYear (unsigned int runnumber, const bool isMC)

const std::string &	getYear ()

void	SetYear (const std::string &year)

void	SetTriggersToYear (const bool isMC)

virtual void	setNominalAvailable (const bool s)

bool	isNominalAvailable () const

void	setGlobalTriggerConfiguration (std::vector< std::string >, std::vector< std::string >, std::vector< std::string >, std::vector< std::string >, std::vector< std::string >, std::vector< std::string >)

bool	useGlobalTrigger () const

auto const &	getGlobalTriggers () const

auto const &	getGlobalTriggersLoose () const

bool	useGlobalTriggerConfiguration () const

std::vector< std::string >	getGlobalTriggerElectronSystematics () const

std::vector< std::string >	getGlobalTriggerMuonSystematics () const

std::vector< std::string >	getGlobalTriggerPhotonSystematics () const

std::vector< std::string >	getGlobalTriggerElectronTools () const

std::vector< std::string >	getGlobalTriggerMuonTools () const

std::vector< std::string >	getGlobalTriggerPhotonTools () const

const TreeFilter *	getTreeFilter () const

const std::unordered_map< std::string, std::string > &	GetMCMCTranslator () const

void	ReadIsAFII (top::ConfigurationSettings *const &settings)

Private Member Functions
void	ReadIsDataOverlay (top::ConfigurationSettings *const &settings)

float	readFloatOption (top::ConfigurationSettings *const &settings, std::string in) const

Private Attributes
bool	m_configFixed

bool	m_makeAllCPTools

std::string	m_grlDir

std::vector< std::string >	m_grlFile = {}

std::string	m_topDataPreparationPath

bool	m_usePhotons

bool	m_useElectrons

bool	m_useFwdElectrons

bool	m_useMuons

bool	m_useSoftMuons

bool	m_useAntiMuons

bool	m_useTaus

bool	m_useJets

bool	m_useLargeRJets

bool	m_useTrackJets

bool	m_useRCJets

bool	m_useVarRCJets

bool	m_useJetGhostTrack

bool	m_useTracks

bool	m_useParticleFlowJets = false

bool	m_useTruthParticles

bool	m_useTruthElectrons

bool	m_useTruthMuons

bool	m_useTruthPhotons

bool	m_useTruthJets

bool	m_useTruthLargeRJets

bool	m_useTruthTaus

bool	m_useTruthMET

bool	m_applyTTVACut

bool	m_demandPriVtx

std::string	m_jetSubstructureName

bool	m_recomputeCPvars

bool	m_isNominalAvailable

std::string	m_systematics

std::string	m_nominalSystName

std::string	m_allSystName

unsigned int	m_DSID

unsigned int	m_MapIndex

SampleXsection::showering	m_showeringAlgo

bool	m_is_sherpa_22_vjets = false

bool	m_isMC

bool	m_isAFII

bool	m_isDataOverlay

std::vector< std::string >	m_filterBranches

std::vector< std::string >	m_filterPartonLevelBranches

std::vector< std::string >	m_filterParticleLevelBranches

std::vector< std::string >	m_filterNominalLooseBranches

std::vector< std::string >	m_filterNominalBranches

std::string	m_generators

bool	m_isTruthDxAOD = false

std::string	m_derivationStream

bool	m_doFakesMMWeightsIFF

std::string	m_FakesMMConfigIFF

bool	m_doFakesMMIFFDebug

bool	m_useLooseObjectsInMETInLooseTree

bool	m_useLooseObjectsInMETInNominalTree

bool	m_writeMETBuiltWithLooseObjects

bool	m_doOverlapRemovalOnLooseLeptonDef

std::string	m_overlap_removal_procedure = "recommended"

float	m_overlapRemovalSlidingInnerDRel = 0.2

float	m_overlapRemovalSlidingInnerDRmu = 0.2

bool	m_doLargeJetOverlapRemoval

bool	m_doEleEleOverlapRemoval

bool	m_doTightEvents

bool	m_doLooseEvents

bool	m_doTightSysts

bool	m_doLooseSysts

bool	m_applyTightSFsInLooseTree

bool	m_applyElectronInJetSubtraction

bool	m_doTruthBlockInfo

bool	m_doTruthPDFInfo

bool	m_doTruthPDFInfoInNominalTrees

bool	m_doMCGeneratorWeights

bool	m_doMCGeneratorWeightsInNominalTrees

std::vector< std::string >	m_nominalWeightNames

std::string	m_nominalWeightName

size_t	m_nominalWeightIndex

bool	m_forceWeightIndex

bool	m_doTopPartonHistory

bool	m_isTopPartonHistoryRegisteredInNtuple

bool	m_doTopPartonLevel

bool	m_doTopParticleLevel

bool	m_doParticleLevelOverlapRemovalMuJet

bool	m_doParticleLevelOverlapRemovalElJet

bool	m_doParticleLevelOverlapRemovalJetPhoton

bool	m_useParticleLevelOverlapRemovalWithRapidity

bool	m_doKLFitter

std::string	m_KLFitterTransferFunctionsPath

std::string	m_KLFitterOutput

std::string	m_KLFitterJetSelectionMode

std::string	m_KLFitterBTaggingMethod

std::string	m_KLFitterLH

bool	m_KLFitterTopMassFixed

bool	m_KLFitterSaveAllPermutations

bool	m_KLFitterFailOnLessThanXJets

bool	m_doPseudoTop

std::string	m_sgKeyDummy

std::string	m_sgKeyEventInfo

std::string	m_sgKeyPrimaryVertices

std::string	m_sgKeyPhotons

std::string	m_sgKeyElectrons

std::string	m_sgKeyFwdElectrons

std::string	m_sgKeyMuons

std::string	m_sgKeySoftMuons

std::string	m_sgKeyTaus

std::string	m_sgKeyJets

std::string	m_sgKeyLargeRJets

std::string	m_sgKeyTrackJets

std::string	m_sgKeyMissingEt

std::string	m_sgKeyMissingEtLoose

std::string	m_sgKeyTruthEvent

std::string	m_sgKeyMCParticle

std::string	m_sgKeyTruthPhotons

std::string	m_sgKeyTruthElectrons

std::string	m_sgKeyTruthMuons

std::string	m_sgKeyTruthTaus

std::string	m_sgKeyTruthJets

std::string	m_sgKeyTruthLargeRJets

std::string	m_sgKeyTruthMET

std::string	m_sgKeyTopPartonHistory

std::string	m_sgKeyTopSystematicEvents

std::string	m_sgKeyTopSystematicEventsLoose

std::string	m_passEventSelectionDecoration

std::string	m_decoKeyJetGhostTrack

std::vector< std::string >	m_jetGhostTrackSystematics

std::vector< std::uint32_t >	m_jetGhostTrackRunPeriods

std::string	m_sgKeyInDetTrackParticles

std::string	m_sgKeyTracks

std::string	m_sgKeyTracksType

std::vector< std::uint32_t >	m_trackRunPeriods

float	m_jetResponseMatchingDeltaR

bool	m_dumpBtagSystsInSystTrees

bool	m_storePerJetBtagSFs

std::string	m_egammaSystematicModel

std::string	m_electronEfficiencySystematicModel

int	m_electronEfficiencySystematicModelNToys

int	m_electronEfficiencySystematicModelToySeed

int	m_electronEfficiencySystematicModelRecoSize

int	m_electronEfficiencySystematicModelIdSize

int	m_electronEfficiencySystematicModelIsoSize

std::string	m_electronEfficiencySystematicModelEtaBinning

std::string	m_electronEfficiencySystematicModelEtBinning

std::string	m_electronID

std::string	m_electronIDLoose

bool	m_electronVetoLArCrack

float	m_electronPtcut

std::string	m_electronIsolation

std::string	m_electronIsolationLoose

std::string	m_electronIsolationSF

std::string	m_electronIsolationSFLoose

std::vector< std::string >	m_electronIsolationWPs

int	m_electron_d0SigCut

float	m_electron_delta_z0

std::string	m_electronIDDecoration

std::string	m_electronIDLooseDecoration

bool	m_useElectronChargeIDSelection

bool	m_useEgammaLeakageCorrection

bool	m_enablePromptLeptonImprovedVetoStudies

std::string	m_electronIDSFFile_path = "Default"

std::string	m_electronIDSFFileLoose_path = "Default"

std::string	m_elTrigEffConfig

bool	m_eid_path_warning = false

float	m_fwdElectronPtcut

float	m_fwdElectronMinEtacut

float	m_fwdElectronMaxEtacut

std::string	m_fwdElectronID

std::string	m_fwdElectronIDLoose

int	m_fwdElectronBCIDCleaningMinRun

int	m_fwdElectronBCIDCleaningMaxRun

float	m_muonPtcut

float	m_muonEtacut

std::string	m_muonQuality

bool	m_muonUseMVALowPt

bool	m_muonUseLowPt

bool	m_muonUse2stationMuonsHighPt

std::string	m_muonQualityLoose

bool	m_muonUseMVALowPtLoose

bool	m_muonUseLowPtLoose

bool	m_muonUse2stationMuonsHighPtLoose

std::string	m_muonIsolation

std::string	m_muonIsolationLoose

std::string	m_muonIsolationSF

std::string	m_muonIsolationSFLoose

std::vector< std::string >	m_muonIsolationWPs

int	m_muon_d0SigCut

float	m_muon_delta_z0

std::string	m_muonCalibMode

std::string	m_muonSmearingSystematicModel

bool	m_muonMuonDoSmearing2stationHighPt

bool	m_muonMuonDoExtraSmearingHighPt

bool	m_muonBreakDownSystematics

std::string	m_muonSFCustomInputFolder

std::string	m_muonSFCustomInputFolderTrigger

std::string	m_muonForcePeriod

int	m_muonForceYear

std::string	m_muonForceTrigger

float	m_softmuonPtcut

float	m_softmuonEtacut

std::string	m_softmuonQuality

bool	m_softmuonUseMVALowPt

bool	m_softmuonUseLowPt

float	m_softmuonDRJetcut

bool	m_softmuonDRJetcutUseRapidity

bool	m_softmuonAdditionalTruthInfo

bool	m_softmuonAdditionalTruthInfoCheckPartonOrigin

bool	m_softmuonAdditionalTruthInfoDoVerbose

float	m_jetPtcut

float	m_jetEtacut

float	m_jetPtGhostTracks

float	m_jetEtaGhostTracks

std::string	m_jetUncertainties_NPModel

std::string	m_jetUncertainties_QGFracFile

std::vector< std::string >	m_jetUncertainties_QGHistPatterns

bool	m_doMultipleJES

std::string	m_jetJERSmearingModel

std::string	m_jetJMSOption

bool	m_doLargeRPseudodataJER

std::string	m_jetCalibSequence

bool	m_allowSmallRJMSforAFII

bool	m_jetStoreTruthLabels

bool	m_doJVTInMETCalculation

bool	m_saveFailJVTJets

std::string	m_JVTWP

bool	m_doForwardJVTInMETCalculation

bool	m_saveFailForwardJVTJets

std::string	m_fJVTWP

std::string	m_METUncertaintiesConfigDir

bool	m_METSignif

std::string	m_METSignifSoftTermParam

std::string	m_METJetSelectionWP

float	m_ghostTrackspT

std::string	m_ghostTracksVertexAssociation

std::string	m_ghostTracksQuality

float	m_largeRJetPtcut

float	m_largeRJetMasscut

float	m_largeRJetEtacut

std::map< std::string, std::string >	m_largeRJetSubstructureVariables

std::string	m_largeRJetUncertainties_NPModel

std::string	m_largeRJetUncertainties_JMR_NPModel

std::string	m_largeRJetUncertaintiesConfigDir

std::string	m_largeRJESJMSConfig

float	m_trackJetPtcut

float	m_trackJetEtacut

float	m_trackPtcut

float	m_trackEtacut

float	m_RCJetPtcut

float	m_RCJetEtacut

float	m_RCInputJetPtMin

float	m_RCInputJetEtaMax

float	m_RCJetTrimcut

float	m_RCJetRadius

bool	m_useRCJetSubstructure

bool	m_useRCJetAdditionalSubstructure

float	m_VarRCJetPtcut

float	m_VarRCJetEtacut

float	m_VarRCJetTrimcut

float	m_VarRCJetMaxRadius

std::string	m_VarRCJetRho

std::string	m_VarRCJetMassScale

bool	m_useVarRCJetSubstructure

bool	m_useVarRCJetAdditionalSubstructure

std::string	m_trackQuality

float	m_JSF

float	m_bJSF

struct {
std::string fileName = "Default"

std::string jetIDWP = "RNNMedium"

bool doRNNID = true

std::string eleIDWP = "RNNMedium"

bool substructureSF = false

bool muOLR = true

float pt = 20000

std::string etaRegions ="[0., 1.37, 1.52, 2.5]"

}	m_tau_configuration

struct {
std::string fileName = "Default"

std::string jetIDWP = "RNNMedium"

bool doRNNID = true

std::string eleIDWP = "RNNMedium"

bool substructureSF = false

bool muOLR = true

float pt = 20000

std::string etaRegions ="[0., 1.37, 1.52, 2.5]"

}	m_tau_configuration_loose

struct {
float pt = 25000

float eta = 2.5

std::string isolation = "None"

std::string identification = "None"

}	m_photon_configuration

struct {
float pt = 25000

float eta = 2.5

std::string isolation = "None"

std::string identification = "None"

}	m_photon_configuration_loose

std::vector< std::string >	m_photonIsolationWPs

struct {
float PtCut

float EtaCut

bool NotFromHadron

bool TauIsHadron

}	m_truth_electron

struct {
float PtCut

float EtaCut

bool NotFromHadron

bool TauIsHadron

}	m_truth_muon

struct {
float PtCut

float EtaCut

}	m_truth_softmuon

struct {
float PtCut

float EtaCut

std::string Origin

std::string Isolation

}	m_truth_photon

struct {
float PtCut

float EtaCut

}	m_truth_tau

struct {
float PtCut

float EtaCut

}	m_truth_jet

struct {
float PtCut

float EtaCut

}	m_truth_largeRJet

std::vector< std::pair< std::string, std::string > >	m_chosen_boostedJetTaggers

std::unordered_map< std::string, std::string >	m_boostedTaggerSFnames

std::unordered_map< std::string, std::vector< std::string > >	m_boostedTaggersSFSysNames

std::vector< std::pair< std::string, std::string > >	m_btagAlgoWP_caloJet

std::vector< std::pair< std::string, std::string > >	m_btagAlgoWP_trkJet

std::vector< std::string >	m_btagWP_caloJet

std::vector< std::string >	m_btagWP_trkJet

std::vector< std::pair< std::string, std::string > >	m_btagAlgoWP_calib_caloJet

std::vector< std::pair< std::string, std::string > >	m_btagAlgoWP_calib_trkJet

std::vector< std::string >	m_btagWP_calib_caloJet

std::vector< std::string >	m_btagWP_calib_trkJet

std::map< std::string, std::string >	m_btag_algos_caloJet

std::map< std::string, std::string >	m_btag_algos_trkJet

std::string	m_bTagSystsExcludedFromEV = ""

bool	m_cdi_path_warning = false

std::string	m_btagging_cdi_path = "Default"

std::string	m_btagging_calibration_B = "default"

std::string	m_btagging_calibration_C = "default"

std::string	m_btagging_calibration_Light = "default"

bool	m_egamma_calibmodel_warning = false

std::string	m_egamma_calibration_model = "es2018_R21_v0"

std::unordered_map< std::string, std::set< std::string > >	bTag_base_names

std::unordered_map< std::string, std::set< std::string > >	bTag_base_names_trkJet

std::unordered_map< std::string, std::set< std::string > >	bTag_named_systs

std::unordered_map< std::string, std::set< std::string > >	bTag_named_systs_trkJet

std::unordered_map< std::string, unsigned int >	bTag_eigen_B

std::unordered_map< std::string, unsigned int >	bTag_eigen_B_trkJet

std::unordered_map< std::string, unsigned int >	bTag_eigen_C

std::unordered_map< std::string, unsigned int >	bTag_eigen_C_trkJet

std::unordered_map< std::string, unsigned int >	bTag_eigen_light

std::unordered_map< std::string, unsigned int >	bTag_eigen_light_trkJet

struct {
std::vector< std::string > pdf_set_names = {}

std::string baseLHAPDF = ""

bool doLHAPDF = false

bool doLHAPDFInNominalTrees = false

bool save_per_event = false

std::unordered_map< std::string, std::vector< float > > pdf_results

}	m_lhapdf_options

struct {
std::vector< std::string > lumi_calc_files = {}

std::vector< std::string > config_files = {}

std::vector< std::string > config_files_FS = {}

std::vector< std::string > config_files_AF = {}

std::vector< std::string > actual_mu_FS = {}

std::vector< std::string > actual_mu_AF = {}

float unrepresented_data_tol = 0.05

bool apply = false

bool use_grl_tool = false

bool mu_dependent = true

std::vector< double > custom_SF = {}

std::vector< int > periodAssignments = {}

}	m_pileup_reweighting

struct {
typedef std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > triggermap_t

bool isActivated = false

triggermap_t trigger

triggermap_t trigger_loose

bool isConfigured = false

std::vector< std::string > electron_trigger_systematics

std::vector< std::string > muon_trigger_systematics

std::vector< std::string > photon_trigger_systematics

std::vector< std::string > electron_trigger_tool_names

std::vector< std::string > muon_trigger_tool_names

std::vector< std::string > photon_trigger_tool_names

}	m_trigGlobalConfiguration

std::shared_ptr< std::vector< std::string > >	m_allSelectionNames

std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > >	m_allTriggers_Tight

std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > >	m_electronTriggers_Tight

std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > >	m_muonTriggers_Tight

std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > >	m_tauTriggers_Tight

std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > >	m_photonTriggers_Tight

std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > >	m_allTriggers_Loose

std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > >	m_electronTriggers_Loose

std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > >	m_muonTriggers_Loose

std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > >	m_tauTriggers_Loose

std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > >	m_photonTriggers_Loose

std::vector< std::pair< std::string, int > >	m_dummyTrigger

bool	m_trigMatchElemRelink

std::string	m_sumOfEventWeightsMetaData

unsigned int	m_forceRandomRunNumber = 0

bool	m_isRun3 = false

std::string	m_objectSelectionName

std::string	m_outputFormat

std::string	m_outputEvents

bool	m_saveOnlySelectedEvents

bool	m_outputFileSetAutoFlushZero

int	m_outputFileNEventAutoFlush

int	m_outputFileBasketSizePrimitive

int	m_outputFileBasketSizeVector

unsigned int	m_numberOfEventsToRun

unsigned int	m_numberOfEventsToSkip

std::size_t	m_nominalHashValue

std::shared_ptr< std::unordered_set< std::size_t > >	m_systHashPhotons

std::shared_ptr< std::unordered_set< std::size_t > >	m_systHashElectrons

std::shared_ptr< std::unordered_set< std::size_t > >	m_systHashFwdElectrons

std::shared_ptr< std::unordered_set< std::size_t > >	m_systHashMuons

std::shared_ptr< std::unordered_set< std::size_t > >	m_systHashSoftMuons

std::shared_ptr< std::unordered_set< std::size_t > >	m_systHashTaus

std::shared_ptr< std::unordered_set< std::size_t > >	m_systHashJets

std::shared_ptr< std::unordered_set< std::size_t > >	m_systHashLargeRJets

std::shared_ptr< std::unordered_set< std::size_t > >	m_systHashTrackJets

std::shared_ptr< std::unordered_set< std::size_t > >	m_systHashTracks

std::shared_ptr< std::unordered_set< std::size_t > >	m_systHashMET

std::shared_ptr< std::unordered_set< std::size_t > >	m_systHashAll

std::shared_ptr< std::list< std::size_t > >	m_list_systHashAll

std::shared_ptr< std::unordered_set< std::size_t > >	m_systHash_electronInJetSubtraction

std::shared_ptr< std::list< std::size_t > >	m_list_systHash_electronInJetSubtraction

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	m_systMapPhotons

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	m_systMapElectrons

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	m_systMapFwdElectrons

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	m_systMapMuons

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	m_systMapSoftMuons

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	m_systMapTaus

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	m_systMapJets

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	m_systMapLargeRJets

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	m_systMapTrackJets

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	m_systMapTracks

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	m_systMapMET

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapPhotons

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapElectrons

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapFwdElectrons

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapMuons

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapSoftMuons

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapTaus

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapJets

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapJets_electronInJetSubtraction

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapJetsLoose_electronInJetSubtraction

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapLargeRJets

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapTrackJets

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapTracks

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapMET

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapPhotons

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapElectrons

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapFwdElectrons

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapMuons

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapSoftMuons

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapTaus

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapJets

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapLargeRJets

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapTrackJets

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapTracks

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapElectrons_electronInJetSubtraction

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapJets_electronInJetSubtraction

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapJetsLoose_electronInJetSubtraction

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapPhotonsTDS

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapPhotonsTDSAux

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapElectronsTDS

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapElectronsTDSAux

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapFwdElectronsTDS

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapFwdElectronsTDSAux

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapMuonsTDS

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapMuonsTDSAux

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapSoftMuonsTDS

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapSoftMuonsTDSAux

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapTausTDS

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapTausTDSAux

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapJetsTDS

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapJetsTDSAux

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapLargeRJetsTDS

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapLargeRJetsTDSAux

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapTrackJetsTDS

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapTrackJetsTDSAux

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapTracksTDS

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapTracksTDSAux

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapElectrons_electronInJetSubtractionTDS

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapElectrons_electronInJetSubtractionTDSAux

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapJets_electronInJetSubtractionTDS

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapJets_electronInJetSubtractionTDSAux

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDS

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDSAux

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapMissingET

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapMissingETLoose

std::string	m_sgKeyKLFitter

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapKLFitter

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapKLFitterLoose

std::string	m_sgKeyPseudoTop

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapPseudoTop

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systSgKeyMapPseudoTopLoose

std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > >	m_systMapJetGhostTrack

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systDecoKeyMapJetGhostTrack

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systAllTTreeNames

std::shared_ptr< std::unordered_map< std::size_t, std::string > >	m_systPersistantAllTTreeNames

std::shared_ptr< std::unordered_map< std::size_t, unsigned int > >	m_systAllTTreeIndex

std::shared_ptr< std::unordered_map< std::size_t, unsigned int > >	m_systAllTTreeLooseIndex

int	m_release_series

bool	m_saveBootstrapWeights

int	m_BootstrapReplicas

bool	m_useBadBatmanCleaning

unsigned int	m_badBatmanCleaningMin

unsigned int	m_badBatmanCleaningMax

bool	m_useEventLevelJetCleaningTool

std::shared_ptr< TreeFilter >	m_treeFilter

std::unordered_map< std::string, std::string >	m_showerMCMCtranslator

std::string	m_year

Detailed Description

Definition at line 41 of file TopConfig.h.

Member Typedef Documentation

◆ triggermap_t

typedef std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > top::TopConfig::triggermap_t

Definition at line 2777 of file TopConfig.h.

Constructor & Destructor Documentation

◆ TopConfig() [1/4]

top::TopConfig::TopConfig ( )

m_tauJetID("SetMe"), m_tauJetIDBkg("SetMe"), m_tauEVetoID("SetMe"), m_tauVetoLArCrack(false), m_tauPtcut(20000.),

Definition at line 24 of file TopConfig.cxx.

                        :
     // Prevent any more configuration
     m_configFixed(false),
     m_makeAllCPTools(true),
  
     // Use which objects
     m_usePhotons(false),
     m_useElectrons(false),
     m_useFwdElectrons(false),
     m_useMuons(false),
     m_useSoftMuons(false),
     m_useAntiMuons(false),
     m_useTaus(false),
     m_useJets(false),
     m_useLargeRJets(false),
     m_useTrackJets(false),
     m_useRCJets(false),
     m_useVarRCJets(false),
     m_useJetGhostTrack(false),
     m_useTracks(false),
     m_useTruthParticles(false),
     m_useTruthElectrons(false),
     m_useTruthMuons(false),
     m_useTruthPhotons(false),
     m_useTruthJets(false),
     m_useTruthLargeRJets(false),
     m_useTruthMET(false),
  
     m_applyTTVACut(true),
  
     m_demandPriVtx(true),
  
     m_jetSubstructureName("None"),
  
     m_recomputeCPvars(true),
  
     // Do systematics? - this needs many more configuration options
     m_systematics("SetMe"),
     m_nominalSystName("Nominal"),
     m_allSystName("All"),
  
     m_DSID(-1),
     m_MapIndex(0),
     m_showeringAlgo(SampleXsection::unknown),
     // Is MC
     m_isMC(false),
     // Is AFII
     m_isAFII(false),
     // Is Data Overlay
     m_isDataOverlay(false),
     // Is Truth xAOD
     m_isTruthDxAOD(false),
     // Derivation name
     m_derivationStream("SetMe"),
     // Do fakes MM weights calculation using FakeBkgTools from IFF
     m_doFakesMMWeightsIFF(false),
     // Configurations for MM fake estimate using FakeBkgTools from IFF
     m_FakesMMConfigIFF("$ROOTCOREBIN/data/TopFakes/efficiencies.xml:1T:1F[T]"),
     // Debug level for MM fake estimate using FakeBkgTools from IFF
     m_doFakesMMIFFDebug(false),
     //options to select if you want to use loose objects for MET rebuilding instead of the tight ones
     m_useLooseObjectsInMETInLooseTree(false),
     m_useLooseObjectsInMETInNominalTree(false),
     //this will write a separate branch with the met built using loose objects
     m_writeMETBuiltWithLooseObjects(false),
     // Apply overlap removal on loose lepton definitons - not the top recommendation, for studies only
     m_doOverlapRemovalOnLooseLeptonDef(false),
     // do overlap removal also with large-R jets
     // (using whatever procedure is used in the official tools)
     m_doLargeJetOverlapRemoval(false),
     // do electron-electron overlap removal
     m_doEleEleOverlapRemoval(false),
     // Dumps the normal non-"*_Loose" trees
     m_doTightEvents(true),
     // Runs Loose selection and dumps the "*_Loose" trees
     m_doLooseEvents(false),
     // Runs systematics on the given selection
     m_doTightSysts(true),
     m_doLooseSysts(true),
     // In the *_Loose trees, lepton SFs are calculated considering
     // tight ID and isolation instead of loose
     // Only tight leptons are considered in the event SF calculation
     m_applyTightSFsInLooseTree(false),
     // For boosted analysis
     m_applyElectronInJetSubtraction(false),
     // Write Truth block info
     m_doTruthBlockInfo(false),
     // Write Truth PDF info
     m_doTruthPDFInfo(false),
     m_doTruthPDFInfoInNominalTrees(false),
     // Write MC generator weights
     m_doMCGeneratorWeights(false),
     m_doMCGeneratorWeightsInNominalTrees(false),
     m_nominalWeightNames(),
     m_nominalWeightName("SetMe"),
     m_nominalWeightIndex(-1),
     m_forceWeightIndex(false),
     // Top Parton History
     m_doTopPartonHistory(false),
     m_isTopPartonHistoryRegisteredInNtuple(false),
     m_doTopPartonLevel(true),
  
     m_doTopParticleLevel(false),
     m_doParticleLevelOverlapRemovalMuJet(true),
     m_doParticleLevelOverlapRemovalElJet(true),
     m_doParticleLevelOverlapRemovalJetPhoton(false),
     m_useParticleLevelOverlapRemovalWithRapidity(true),
  
           // KLFitter
     m_doKLFitter(false),
     m_KLFitterTransferFunctionsPath("SetMe"),
     m_KLFitterOutput("SetMe"),
     m_KLFitterJetSelectionMode("SetMe"),
     m_KLFitterBTaggingMethod("SetMe"),
     m_KLFitterLH("SetMe"),
     m_KLFitterTopMassFixed(true),
     m_KLFitterSaveAllPermutations(false),
     m_KLFitterFailOnLessThanXJets(false),
  
     // PseudoTop
     m_doPseudoTop(false),
  
     // StoreGate / TStore keys
     m_sgKeyDummy("SetMe"),
     m_sgKeyEventInfo("EventInfo"),
     m_sgKeyPrimaryVertices("PrimaryVertices"),
     m_sgKeyPhotons("SetMe"),
     m_sgKeyElectrons("SetMe"),
     m_sgKeyFwdElectrons("SetMe"),
     m_sgKeyMuons("SetMe"),
     m_sgKeySoftMuons("SetMe"),
     m_sgKeyTaus("SetMe"),
     m_sgKeyJets("SetMe"),
     m_sgKeyLargeRJets("SetMe"),
     m_sgKeyTrackJets("SetMe"),
     m_sgKeyMissingEt("MET"),
     m_sgKeyMissingEtLoose("LooseMET"),
  
     m_sgKeyTruthEvent("TruthEvents"),
     m_sgKeyMCParticle("SetMe"),
     m_sgKeyTruthPhotons("TruthPhotons"),
     m_sgKeyTruthElectrons("TruthElectrons"),
     m_sgKeyTruthMuons("TruthMuons"),
     m_sgKeyTruthTaus("TruthTaus"),
     m_sgKeyTruthJets("SetMe"),
     m_sgKeyTruthLargeRJets("SetMe"),
     m_sgKeyTruthMET("MET_Truth"),
     m_sgKeyTopPartonHistory("TopPartonHistory"),
  
     m_sgKeyTopSystematicEvents("TopSystematicEvents"),
     m_sgKeyTopSystematicEventsLoose("TopSystematicEventsLoose"),
     m_passEventSelectionDecoration("passEventSelection"),
     m_decoKeyJetGhostTrack("GhostTrack"),
     m_sgKeyInDetTrackParticles("InDetTrackParticles"),
     m_sgKeyTracks("SetMe"),
  
  
     m_jetResponseMatchingDeltaR(-1),
  
     // special: allow to dump the systematics-shifted b-tagging SFs in the systematics trees
     m_dumpBtagSystsInSystTrees(false),
  
     m_storePerJetBtagSFs(false),
  
     // Electron configuration
     m_egammaSystematicModel("1NP_v1"),
     m_electronEfficiencySystematicModel("TOTAL"),
     m_electronEfficiencySystematicModelNToys(40),
     m_electronEfficiencySystematicModelToySeed(12345),
     m_electronEfficiencySystematicModelRecoSize(400),
     m_electronEfficiencySystematicModelIdSize(400),
     m_electronEfficiencySystematicModelIsoSize(400),
     m_electronEfficiencySystematicModelEtaBinning(""),
     m_electronEfficiencySystematicModelEtBinning(""),
     m_electronID("SetMe"),
     m_electronIDLoose("SetMe"),
     m_electronVetoLArCrack(true),
     m_electronPtcut(25000.),
     m_electronIsolation("SetMe"),
     m_electronIsolationLoose("SetMe"),
     m_electronIsolationSF("SetMe"),
     m_electronIsolationSFLoose("SetMe"),
     m_electron_d0SigCut(5.0),
     m_electron_delta_z0(0.5),
     m_electronIDDecoration("SetMe"),
     m_electronIDLooseDecoration("SetMe"),
     m_useElectronChargeIDSelection(false),
     m_useEgammaLeakageCorrection(true),
     m_enablePromptLeptonImprovedVetoStudies(false),
     m_elTrigEffConfig(" "),
  
     // Fwd electron configuration
     m_fwdElectronPtcut(25000.),
     m_fwdElectronMinEtacut(2.5),
     m_fwdElectronMaxEtacut(4.9),
     m_fwdElectronID("SetMe"),
     m_fwdElectronIDLoose("SetMe"),
     m_fwdElectronBCIDCleaningMinRun(266904),
     m_fwdElectronBCIDCleaningMaxRun(311481),
  
     // Muon configuration
     m_muonPtcut(25000.),
     m_muonEtacut(2.5),
     m_muonQuality("SetMe"),
     m_muonUseMVALowPt(false),
     m_muonUseLowPt(false),
     m_muonUse2stationMuonsHighPt(true),
     m_muonQualityLoose("SetMe"),
     m_muonUseMVALowPtLoose(false),
     m_muonUseLowPtLoose(false),
     m_muonUse2stationMuonsHighPtLoose(true),
     m_muonIsolation("SetMe"),
     m_muonIsolationLoose("SetMe"),
     m_muonIsolationSF("SetMe"),
     m_muonIsolationSFLoose("SetMe"),
     m_muon_d0SigCut(3.0),
     m_muon_delta_z0(0.5),
     m_muonCalibMode("SetMe"),
     m_muonSmearingSystematicModel("SetMe"),
     m_muonMuonDoSmearing2stationHighPt(true),
     m_muonMuonDoExtraSmearingHighPt(false),
     m_muonBreakDownSystematics(false),
     m_muonSFCustomInputFolder(" "),
     m_muonForcePeriod(" "),
     m_muonForceYear(-1),
     m_muonForceTrigger(" "),
  
     // Soft Muon configuration
     m_softmuonPtcut(4000.),
     m_softmuonEtacut(2.5),
     m_softmuonQuality("SetMe"),
     m_softmuonUseMVALowPt(false),
     m_softmuonUseLowPt(false),
     m_softmuonDRJetcut(0.4),
     m_softmuonDRJetcutUseRapidity(false),
     m_softmuonAdditionalTruthInfo(false),
     m_softmuonAdditionalTruthInfoCheckPartonOrigin(false),
     m_softmuonAdditionalTruthInfoDoVerbose(false),
  
     // Jet configuration
     m_jetPtcut(25000.),
     m_jetEtacut(2.5),
     m_jetPtGhostTracks(30000.),
     m_jetEtaGhostTracks(2.5),
     m_jetUncertainties_NPModel("AllNuisanceParameters"),
     m_jetUncertainties_QGFracFile("None"),
     m_jetUncertainties_QGHistPatterns(),
     m_doMultipleJES(false),
     m_jetJERSmearingModel("Simple"),
     m_jetJMSOption("None"),
     m_doLargeRPseudodataJER(false),
     m_jetCalibSequence("GSC"),
     m_allowSmallRJMSforAFII(false),
     m_jetStoreTruthLabels("True"),
     m_doJVTInMETCalculation(true),
     m_saveFailJVTJets(false),
     m_JVTWP("FixedEffPt"),
     m_doForwardJVTInMETCalculation(false),
     m_saveFailForwardJVTJets(false),
     m_fJVTWP("None"),
  
     // MET configuration
     m_METUncertaintiesConfigDir("SetMe"),
     m_METSignif(false),
     m_METSignifSoftTermParam("Random"),
     m_METJetSelectionWP("Tight"),
     
     // Ghost Track Configuration
     m_ghostTrackspT(500.),
     m_ghostTracksVertexAssociation("nominal"),
     m_ghostTracksQuality("TightPrimary"),
  
     m_largeRJetPtcut(25000.),
     m_largeRJetMasscut(0.),
     m_largeRJetEtacut(2.5),
     m_largeRJetUncertainties_NPModel("CategoryJES_FullJER_FullJMS"),
     m_largeRJetUncertainties_JMR_NPModel("FullJMR"),
     m_largeRJetUncertaintiesConfigDir("SetMe"),
     m_largeRJESJMSConfig("SetMe"),
  
     m_trackJetPtcut(7000.0),
     m_trackJetEtacut(2.5),
     
     m_RCJetPtcut(100000.),
     m_RCJetEtacut(2.0),
     m_RCInputJetPtMin(0.),
     m_RCInputJetEtaMax(999.),
     m_RCJetTrimcut(0.05),
     m_RCJetRadius(1.0),
     m_useRCJetSubstructure(false),
     m_useRCJetAdditionalSubstructure(false),
  
     m_VarRCJetPtcut(100000.),
     m_VarRCJetEtacut(2.0),
     m_VarRCJetTrimcut(0.05),
     m_VarRCJetMaxRadius(1.0),
     m_VarRCJetRho("2"),
     m_VarRCJetMassScale("m_w,m_z,m_h,m_t"),
     m_useVarRCJetSubstructure(false),
     m_useVarRCJetAdditionalSubstructure(false),
  
     m_trackQuality("SetMe"),
  
     m_JSF(1.0),
     m_bJSF(1.0),
  
     // Tau configuration
     // [[[-----------------------------------------------
     // Particle Level / Truth Configuration
     m_truth_electron{25000., 2.5, true, false},
     m_truth_muon{25000., 2.5, true, false},
     m_truth_softmuon{4000., 2.5},
     m_truth_photon{25000., 2.5, "SET_ME", "SET_ME"},
     m_truth_jet{25000., 2.5},
     // -----------------------------------------------]]]
  
     // Selections
     m_allSelectionNames(nullptr),
     // Trigger
     m_allTriggers_Tight(nullptr),
     m_electronTriggers_Tight(nullptr),
     m_muonTriggers_Tight(nullptr),
     m_tauTriggers_Tight(nullptr),
     m_photonTriggers_Tight(nullptr),
     m_allTriggers_Loose(nullptr),
     m_electronTriggers_Loose(nullptr),
     m_muonTriggers_Loose(nullptr),
     m_tauTriggers_Loose(nullptr),
     m_photonTriggers_Loose(nullptr),
     m_trigMatchElemRelink(false),
  
     // Where the sum of event weights
     // before derivation framework is kept
     m_sumOfEventWeightsMetaData("CutBookkeepersAux.sumOfEventWeights"),
  
     // Object Selector name
     m_objectSelectionName("SetMe"),
     // Output Format
     m_outputFormat("SetMe"),
     // Output Events
     m_outputEvents("SetMe"),
     m_saveOnlySelectedEvents(true),
     m_outputFileSetAutoFlushZero(false),
     m_outputFileNEventAutoFlush(1000), // 1000 events
     m_outputFileBasketSizePrimitive(4096), // 4kB
     m_outputFileBasketSizeVector(40960),   // 40kB
     // Number of events to run on (only for testing)
     m_numberOfEventsToRun(0),
  
     // Number of events to skip (only for testing)
     m_numberOfEventsToSkip(0),
  
     // Systematics
     m_nominalHashValue(0),
  
     m_systHashPhotons(nullptr),
     m_systHashElectrons(nullptr),
     m_systHashFwdElectrons(nullptr),
     m_systHashMuons(nullptr),
     m_systHashSoftMuons(nullptr),
     m_systHashTaus(nullptr),
     m_systHashJets(nullptr),
     m_systHashLargeRJets(nullptr),
     m_systHashTrackJets(nullptr),
     m_systHashTracks(nullptr),
     m_systHashMET(nullptr),
  
     m_systHashAll(nullptr),
     m_list_systHashAll(nullptr),
     m_systHash_electronInJetSubtraction(nullptr),
     m_list_systHash_electronInJetSubtraction(nullptr),
  
  
     m_systMapPhotons(nullptr),
     m_systMapElectrons(nullptr),
     m_systMapFwdElectrons(nullptr),
     m_systMapMuons(nullptr),
     m_systMapSoftMuons(nullptr),
     m_systMapTaus(nullptr),
     m_systMapJets(nullptr),
     m_systMapLargeRJets(nullptr),
     m_systMapTrackJets(nullptr),
     m_systMapTracks(nullptr),
     m_systMapMET(nullptr),
  
     m_systSgKeyMapPhotons(nullptr),
     m_systSgKeyMapElectrons(nullptr),
     m_systSgKeyMapFwdElectrons(nullptr),
     m_systSgKeyMapMuons(nullptr),
     m_systSgKeyMapSoftMuons(nullptr),
     m_systSgKeyMapTaus(nullptr),
     m_systSgKeyMapJets(nullptr),
     m_systSgKeyMapJets_electronInJetSubtraction(nullptr),
     m_systSgKeyMapJetsLoose_electronInJetSubtraction(nullptr),
     m_systSgKeyMapLargeRJets(nullptr),
     m_systSgKeyMapTrackJets(nullptr),
     m_systSgKeyMapTracks(nullptr),
     m_systSgKeyMapMET(nullptr),
  
     m_systAllSgKeyMapPhotons(nullptr),
     m_systAllSgKeyMapElectrons(nullptr),
     m_systAllSgKeyMapFwdElectrons(nullptr),
     m_systAllSgKeyMapMuons(nullptr),
     m_systAllSgKeyMapSoftMuons(nullptr),
     m_systAllSgKeyMapTaus(nullptr),
     m_systAllSgKeyMapJets(nullptr),
     m_systAllSgKeyMapLargeRJets(nullptr),
     m_systAllSgKeyMapTrackJets(nullptr),
     m_systAllSgKeyMapTracks(nullptr),
     m_systAllSgKeyMapElectrons_electronInJetSubtraction(nullptr),
     m_systAllSgKeyMapJets_electronInJetSubtraction(nullptr),
     m_systAllSgKeyMapJetsLoose_electronInJetSubtraction(nullptr),
  
     m_systAllSgKeyMapPhotonsTDS(nullptr),
     m_systAllSgKeyMapPhotonsTDSAux(nullptr),
     m_systAllSgKeyMapElectronsTDS(nullptr),
     m_systAllSgKeyMapElectronsTDSAux(nullptr),
     m_systAllSgKeyMapFwdElectronsTDS(nullptr),
     m_systAllSgKeyMapFwdElectronsTDSAux(nullptr),
     m_systAllSgKeyMapMuonsTDS(nullptr),
     m_systAllSgKeyMapMuonsTDSAux(nullptr),
     m_systAllSgKeyMapSoftMuonsTDS(nullptr),
     m_systAllSgKeyMapSoftMuonsTDSAux(nullptr),
     m_systAllSgKeyMapTausTDS(nullptr),
     m_systAllSgKeyMapTausTDSAux(nullptr),
     m_systAllSgKeyMapJetsTDS(nullptr),
     m_systAllSgKeyMapJetsTDSAux(nullptr),
     m_systAllSgKeyMapLargeRJetsTDS(nullptr),
     m_systAllSgKeyMapLargeRJetsTDSAux(nullptr),
     m_systAllSgKeyMapTrackJetsTDS(nullptr),
     m_systAllSgKeyMapTrackJetsTDSAux(nullptr),
     m_systAllSgKeyMapTracksTDS(nullptr),
     m_systAllSgKeyMapTracksTDSAux(nullptr),
     m_systAllSgKeyMapElectrons_electronInJetSubtractionTDS(nullptr),
     m_systAllSgKeyMapElectrons_electronInJetSubtractionTDSAux(nullptr),
     m_systAllSgKeyMapJets_electronInJetSubtractionTDS(nullptr),
     m_systAllSgKeyMapJets_electronInJetSubtractionTDSAux(nullptr),
     m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDS(nullptr),
     m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDSAux(nullptr),
  
     m_systSgKeyMapMissingET(nullptr),
     m_systSgKeyMapMissingETLoose(nullptr),
  
     m_sgKeyKLFitter("KLFitterResults"),
     m_systSgKeyMapKLFitter(nullptr),
     m_systSgKeyMapKLFitterLoose(nullptr),
  
     m_sgKeyPseudoTop("PseudoTopResult"),
     m_systSgKeyMapPseudoTop(nullptr),
     m_systSgKeyMapPseudoTopLoose(nullptr),
     m_systMapJetGhostTrack(nullptr),
     m_systDecoKeyMapJetGhostTrack(nullptr),
  
     m_systAllTTreeNames(nullptr),
     m_systPersistantAllTTreeNames(nullptr),
     m_systAllTTreeIndex(nullptr),
     m_systAllTTreeLooseIndex(nullptr),
     m_saveBootstrapWeights(false),
     m_BootstrapReplicas(100),
     m_useBadBatmanCleaning(true),
     m_badBatmanCleaningMin(276262),
     m_badBatmanCleaningMax(311481),
     m_useEventLevelJetCleaningTool(false),
     m_year("UNKNOWN") {
  
     m_allSelectionNames = std::shared_ptr<std::vector<std::string> > (new std::vector<std::string> );
  
     m_systHashPhotons = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
     m_systHashElectrons = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
     m_systHashFwdElectrons = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
     m_systHashMuons = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
     m_systHashSoftMuons = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
     m_systHashTaus = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
     m_systHashJets = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
     m_systHashLargeRJets = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
     m_systHashTrackJets = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
     m_systHashTracks = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
     m_systHashMET = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
  
     m_systHashAll = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
     m_list_systHashAll = std::shared_ptr<std::list<std::size_t> > (new std::list<std::size_t> );
     m_systHash_electronInJetSubtraction =
       std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
     m_list_systHash_electronInJetSubtraction = std::shared_ptr<std::list<std::size_t> > (new std::list<std::size_t> );
  
     m_systMapPhotons =
       std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
                                                                                                    CP::SystematicSet> );
     m_systMapElectrons =
       std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
                                                                                                    CP::SystematicSet> );
     m_systMapFwdElectrons = std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (
       new std::unordered_map<std::size_t, CP::SystematicSet> );
     m_systMapMuons =
       std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
                                                                                                    CP::SystematicSet> );
     m_systMapSoftMuons =
       std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
                                                                                                    CP::SystematicSet> );
     m_systMapTaus =
       std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
                                                                                                    CP::SystematicSet> );
     m_systMapJets =
       std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
                                                                                                    CP::SystematicSet> );
     m_systMapLargeRJets =
       std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
                                                                                                    CP::SystematicSet> );
     m_systMapTrackJets =
       std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
                                                                                                    CP::SystematicSet> );
      m_systMapTracks =
        std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
                                          CP::SystematicSet> );
      
  
  
     m_systMapMET =
       std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
                                                                                                    CP::SystematicSet> );
  
     m_systSgKeyMapPhotons =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systSgKeyMapElectrons =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systSgKeyMapFwdElectrons =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systSgKeyMapMuons =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systSgKeyMapSoftMuons =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systSgKeyMapTaus =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systSgKeyMapJets =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systSgKeyMapJets_electronInJetSubtraction = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systSgKeyMapJetsLoose_electronInJetSubtraction = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systSgKeyMapLargeRJets =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systSgKeyMapTrackJets =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
  
     m_systSgKeyMapTracks =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                              std::string> );
  
     
     m_systSgKeyMapMET =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
  
     m_systAllSgKeyMapPhotons =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapElectrons =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapFwdElectrons = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapMuons =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapSoftMuons =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapTaus =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapJets =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapLargeRJets = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapTrackJets =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapTracks =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                              std::string> );
  
     m_systAllSgKeyMapElectrons_electronInJetSubtraction
       = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                                std::string> );
     m_systAllSgKeyMapJets_electronInJetSubtraction
       = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                                std::string> );
     m_systAllSgKeyMapJetsLoose_electronInJetSubtraction
       = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                                std::string> );
  
     m_systAllSgKeyMapPhotonsTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapPhotonsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapElectronsTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapElectronsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapFwdElectronsTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapFwdElectronsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapMuonsTDS =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapMuonsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapSoftMuonsTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapSoftMuonsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapTausTDS =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapTausTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapJetsTDS =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapJetsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapLargeRJetsTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapLargeRJetsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapTrackJetsTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapTrackJetsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapTracksTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapTracksTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
  
     m_systAllSgKeyMapElectrons_electronInJetSubtractionTDS =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapElectrons_electronInJetSubtractionTDSAux =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapJets_electronInJetSubtractionTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllSgKeyMapJets_electronInJetSubtractionTDSAux =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDS =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDSAux =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
  
  
     m_systSgKeyMapMissingET =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systSgKeyMapMissingETLoose = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
  
     m_systSgKeyMapKLFitter =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systSgKeyMapKLFitterLoose = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
  
     m_systSgKeyMapPseudoTop =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systSgKeyMapPseudoTopLoose = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
  
     m_systMapJetGhostTrack = std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (
       new std::unordered_map<std::size_t, CP::SystematicSet> );
     m_systDecoKeyMapJetGhostTrack = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
  
  
     m_systAllTTreeNames =
       std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
                                                                                              std::string> );
     m_systPersistantAllTTreeNames = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
       new std::unordered_map<std::size_t, std::string> );
     m_systAllTTreeIndex =
       std::shared_ptr<std::unordered_map<std::size_t, unsigned int> > (new std::unordered_map<std::size_t,
                                                                                               unsigned int> );
     m_systAllTTreeLooseIndex =
       std::shared_ptr<std::unordered_map<std::size_t, unsigned int> > (new std::unordered_map<std::size_t,
                                                                                               unsigned int> );
  
     // Nominal has value
     CP::SystematicSet nominal;
     m_nominalHashValue = nominal.hash();
     
     m_treeFilter = std::make_shared<TreeFilter>();
   }

◆ TopConfig() [2/4]

top::TopConfig::TopConfig ( const top::TopPersistentSettings * settings )

explicit

Definition at line 3648 of file TopConfig.cxx.

                                                                :
     // delegate to the default ctor - this is a nice C++11 feature, John likes this a lot
     TopConfig() {
     m_makeAllCPTools = false;
     m_isMC = settings->m_isMC;
     m_isAFII = settings->m_isAFII;
     m_isDataOverlay = settings->m_isDataOverlay;
     m_applyElectronInJetSubtraction = settings->m_applyElectronInJetSubtraction;
     m_doOverlapRemovalOnLooseLeptonDef = settings->m_doOverlapRemovalOnLooseLeptonDef;
     m_doKLFitter = settings->m_doKLFitter;
     m_doPseudoTop = settings->m_doPseudoTop;
  
     m_sgKeyTopSystematicEvents = settings->m_sgKeyTopSystematicEvents;
     m_sgKeyTopSystematicEventsLoose = settings->m_sgKeyTopSystematicEventsLoose;
  
     m_sgKeyEventInfo = settings->m_sgKeyEventInfo;
     m_sgKeyPrimaryVertices = settings->m_sgKeyPrimaryVertices;
     sgKeyPhotons(settings->m_sgKeyPhotons);
     sgKeyElectrons(settings->m_sgKeyElectrons);
     sgKeyFwdElectrons(settings->m_sgKeyFwdElectrons);
     sgKeyMuons(settings->m_sgKeyMuons);
     sgKeySoftMuons(settings->m_sgKeySoftMuons);
     sgKeyTaus(settings->m_sgKeyTaus);
     sgKeyJets(settings->m_sgKeyJets);
     sgKeyLargeRJets(settings->m_sgKeyLargeRJets);
     sgKeyTrackJets(settings->m_sgKeyTrackJets);
     sgKeyTracks(settings->m_sgKeyTracks);
     m_sgKeyMissingEt = settings->m_sgKeyMissingEt;
     m_sgKeyMissingEtLoose = settings->m_sgKeyMissingEtLoose;
  
     m_electronID = settings->m_electronID;
     m_electronIDLoose = settings->m_electronIDLoose;
     m_electronIsolation = settings->m_electronIsolation;
     m_electronIsolationLoose = settings->m_electronIsolationLoose;
     m_useElectronChargeIDSelection = settings->m_useElectronChargeIDSelection;
     m_useEgammaLeakageCorrection = settings->m_useEgammaLeakageCorrection;
     m_enablePromptLeptonImprovedVetoStudies = settings->m_enablePromptLeptonImprovedVetoStudies;
  
     m_fwdElectronID = settings->m_fwdElectronID;
  
     m_muonQuality = settings->m_muonQuality;
     m_muonQualityLoose = settings->m_muonQualityLoose;
     m_muonIsolation = settings->m_muonIsolation;
     m_muonIsolationLoose = settings->m_muonIsolationLoose;
  
     m_softmuonQuality = settings->m_softmuonQuality;
  
     typedef std::map<std::size_t, std::string>::const_iterator Itr;
  
     for (Itr i = settings->m_systSgKeyMapPhotons.begin(); i != settings->m_systSgKeyMapPhotons.end(); ++i)
       m_systSgKeyMapPhotons->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapElectrons.begin(); i != settings->m_systSgKeyMapElectrons.end(); ++i)
       m_systSgKeyMapElectrons->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapFwdElectrons.begin(); i != settings->m_systSgKeyMapFwdElectrons.end(); ++i)
       m_systSgKeyMapFwdElectrons->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapMuons.begin(); i != settings->m_systSgKeyMapMuons.end(); ++i)
       m_systSgKeyMapMuons->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapSoftMuons.begin(); i != settings->m_systSgKeyMapSoftMuons.end(); ++i)
       m_systSgKeyMapSoftMuons->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapTaus.begin(); i != settings->m_systSgKeyMapTaus.end(); ++i)
       m_systSgKeyMapTaus->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapJets.begin(); i != settings->m_systSgKeyMapJets.end(); ++i)
       m_systSgKeyMapJets->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapJets_electronInJetSubtraction.begin();
          i != settings->m_systSgKeyMapJets_electronInJetSubtraction.end(); ++i)
       m_systSgKeyMapJets_electronInJetSubtraction->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapJetsLoose_electronInJetSubtraction.begin();
          i != settings->m_systSgKeyMapJetsLoose_electronInJetSubtraction.end(); ++i)
       m_systSgKeyMapJetsLoose_electronInJetSubtraction->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapLargeRJets.begin(); i != settings->m_systSgKeyMapLargeRJets.end(); ++i)
       m_systSgKeyMapLargeRJets->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapTrackJets.begin(); i != settings->m_systSgKeyMapTrackJets.end(); ++i)
       m_systSgKeyMapTrackJets->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapTracks.begin(); i != settings->m_systSgKeyMapTracks.end(); ++i)
       m_systSgKeyMapTracks->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapMissingET.begin(); i != settings->m_systSgKeyMapMissingET.end(); ++i)
       m_systSgKeyMapMissingET->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapMissingETLoose.begin(); i != settings->m_systSgKeyMapMissingETLoose.end(); ++i)
       m_systSgKeyMapMissingETLoose->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapKLFitter.begin(); i != settings->m_systSgKeyMapKLFitter.end(); ++i)
       m_systSgKeyMapKLFitter->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapKLFitterLoose.begin(); i != settings->m_systSgKeyMapKLFitterLoose.end(); ++i)
       m_systSgKeyMapKLFitterLoose->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapPseudoTop.begin(); i != settings->m_systSgKeyMapPseudoTop.end(); ++i)
       m_systSgKeyMapPseudoTop->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systSgKeyMapPseudoTopLoose.begin(); i != settings->m_systSgKeyMapPseudoTopLoose.end(); ++i)
       m_systSgKeyMapPseudoTopLoose->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systDecoKeyMapJetGhostTrack.begin(); i != settings->m_systDecoKeyMapJetGhostTrack.end();
          ++i)
       m_systDecoKeyMapJetGhostTrack->insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = settings->m_systPersistantAllTTreeNames.begin(); i != settings->m_systPersistantAllTTreeNames.end();
          ++i) {
       m_systPersistantAllTTreeNames->insert(std::make_pair((*i).first, (*i).second));
       m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second));
     }
  
     for (std::vector<std::size_t>::const_iterator i = settings->m_list_systHashAll.begin();
          i != settings->m_list_systHashAll.end(); ++i)
       m_list_systHashAll->push_back(*i);
  
     for (std::vector<std::size_t>::const_iterator i = settings->m_list_systHash_electronInJetSubtraction.begin();
          i != settings->m_list_systHash_electronInJetSubtraction.end(); ++i)
       m_list_systHash_electronInJetSubtraction->push_back(*i);
  
     for (std::vector<std::string>::const_iterator i = settings->m_allSelectionNames.begin();
          i != settings->m_allSelectionNames.end(); ++i)
       m_allSelectionNames->push_back(*i);
  
     m_allTriggers_Tight = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
     m_electronTriggers_Tight = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
     m_muonTriggers_Tight = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
     m_tauTriggers_Tight = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
     m_photonTriggers_Tight = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
  
     m_allTriggers_Loose = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
     m_electronTriggers_Loose = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
     m_muonTriggers_Loose = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
     m_tauTriggers_Loose = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
     m_photonTriggers_Loose = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
  
     for (auto i : settings->m_allTriggers_Tight) {
       m_allTriggers_Tight->insert(i);
     }
     for (auto i : settings->m_electronTriggers_Tight) {
       m_electronTriggers_Tight->insert(i);
     }
     for (auto i : settings->m_muonTriggers_Tight) {
       m_muonTriggers_Tight->insert(i);
     }
     for (auto i : settings->m_tauTriggers_Tight) {
       m_tauTriggers_Tight->insert(i);
     }
     for (auto i : settings->m_photonTriggers_Tight) {
       m_photonTriggers_Tight->insert(i);
     }
  
     for (auto i : settings->m_allTriggers_Loose) {
       m_allTriggers_Loose->insert(i);
     }
     for (auto i : settings->m_electronTriggers_Loose) {
       m_electronTriggers_Loose->insert(i);
     }
     for (auto i : settings->m_muonTriggers_Loose) {
       m_muonTriggers_Loose->insert(i);
     }
     for (auto i : settings->m_tauTriggers_Loose) {
       m_tauTriggers_Loose->insert(i);
     }
     for (auto i : settings->m_photonTriggers_Loose) {
       m_photonTriggers_Loose->insert(i);
     }
  
     fixConfiguration();
   }

◆ ~TopConfig()

virtual top::TopConfig::~TopConfig ( )

inlinevirtual

Definition at line 45 of file TopConfig.h.

45 {}

◆ TopConfig() [3/4]

top::TopConfig::TopConfig ( const TopConfig & rhs )

delete

◆ TopConfig() [4/4]

top::TopConfig::TopConfig ( TopConfig && rhs )

delete

Member Function Documentation

◆ addBTagAlgo()

void top::TopConfig::addBTagAlgo	(	const std::string &	algorithm,
		const std::string &	selectionToolName,
		bool	trackJets = `false`
	)

Definition at line 2207 of file TopConfig.cxx.

                                                                                                             {
     // we only need one tool per algorithm, e.g. DL1r, DL1d
     // the map will by definition only store one
     if (trackJets)
       m_btag_algos_trkJet[algorithm] = selectionToolName;
     else
       m_btag_algos_caloJet[algorithm] = selectionToolName;
   }

◆ addLHAPDFResult()

void top::TopConfig::addLHAPDFResult	(	const std::string &	pdf_name,
		std::vector< float >	sum_of_weights
	)

Definition at line 2248 of file TopConfig.cxx.

                                                                    {
     m_lhapdf_options.pdf_results[ pdf_name ] = sum_of_weights;
   }

◆ allowSmallRJMSforAFII() [1/2]

virtual bool top::TopConfig::allowSmallRJMSforAFII ( ) const

inlinevirtual

Definition at line 1541 of file TopConfig.h.

1541 {return m_allowSmallRJMSforAFII;}

◆ allowSmallRJMSforAFII() [2/2]

virtual void top::TopConfig::allowSmallRJMSforAFII ( const bool setting )

inlinevirtual

Definition at line 1535 of file TopConfig.h.

                                                                   {
       if (!m_configFixed) {
         m_allowSmallRJMSforAFII = setting;
       }
     }

◆ allSelectionNames()

std::shared_ptr<std::vector<std::string> > top::TopConfig::allSelectionNames ( ) const

inline

Definition at line 523 of file TopConfig.h.

523 {return m_allSelectionNames;}

◆ allTriggers_Loose() [1/2]

const std::vector< std::pair< std::string, int > > & top::TopConfig::allTriggers_Loose ( const std::string & selection ) const

virtual

Definition at line 3438 of file TopConfig.cxx.

                                                                                                           {
     std::unordered_map<std::string,
                        std::vector<std::pair<std::string, int> > >::const_iterator key = m_allTriggers_Loose->find(selection);
     if (key != m_allTriggers_Loose->end()) {
       return (*key).second;
     }
     return m_dummyTrigger;
   }

◆ allTriggers_Loose() [2/2]

virtual void top::TopConfig::allTriggers_Loose ( std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers )

inlinevirtual

Definition at line 488 of file TopConfig.h.

                                                                                                                                {
       if (!m_configFixed) {
         m_allTriggers_Loose = triggers;
       }
     }

◆ allTriggers_Tight() [1/2]

const std::vector< std::pair< std::string, int > > & top::TopConfig::allTriggers_Tight ( const std::string & selection ) const

virtual

Definition at line 3393 of file TopConfig.cxx.

                                                                                                           {
     std::unordered_map<std::string,
                        std::vector<std::pair<std::string, int> > >::const_iterator key = m_allTriggers_Tight->find(selection);
     if (key != m_allTriggers_Tight->end()) {
       return (*key).second;
     }
     return m_dummyTrigger;
   }

◆ allTriggers_Tight() [2/2]

virtual void top::TopConfig::allTriggers_Tight ( std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers )

inlinevirtual

Definition at line 453 of file TopConfig.h.

                                                                                                                                {
       if (!m_configFixed) {
         m_allTriggers_Tight = triggers;
       }
     }

◆ applyElectronInJetSubtraction()

bool top::TopConfig::applyElectronInJetSubtraction ( ) const

inline

Definition at line 308 of file TopConfig.h.

308 {return m_applyElectronInJetSubtraction;}

◆ applyTauMVATES()

bool top::TopConfig::applyTauMVATES ( )

inline

Definition at line 1721 of file TopConfig.h.

                                  {
       return true;
     }

◆ contains()

bool top::TopConfig::contains	(	const std::set< std::string > &	systList,
		const std::string &	name
	)		const

Definition at line 2292 of file TopConfig.cxx.

                                                                                          {
     return systList.find(name) != systList.end();
   }

◆ createPersistentSettings()

top::TopPersistentSettings * top::TopConfig::createPersistentSettings ( )

– top::TopPersistentSettings allows us to take a snapshot of top::TopConfig –/// – and save it to a mini-xAOD.

We can then re-create the top::TopConfig from file –///

Definition at line 3485 of file TopConfig.cxx.

                                                                 {
     top::TopPersistentSettings* out = new top::TopPersistentSettings();
  
     out->m_isMC = m_isMC;
     out->m_isAFII = m_isAFII;
     out->m_isDataOverlay = m_isDataOverlay;
     out->m_applyElectronInJetSubtraction = m_applyElectronInJetSubtraction;
     out->m_doOverlapRemovalOnLooseLeptonDef = m_doOverlapRemovalOnLooseLeptonDef;
     out->m_doKLFitter = m_doKLFitter;
     out->m_doPseudoTop = m_doPseudoTop;
  
     out->m_sgKeyTopSystematicEvents = m_sgKeyTopSystematicEvents;
     out->m_sgKeyTopSystematicEventsLoose = m_sgKeyTopSystematicEventsLoose;
  
     out->m_sgKeyEventInfo = m_sgKeyEventInfo;
     out->m_sgKeyPrimaryVertices = m_sgKeyPrimaryVertices;
     out->m_sgKeyPhotons = m_sgKeyPhotons;
     out->m_sgKeyElectrons = m_sgKeyElectrons;
     out->m_sgKeyFwdElectrons = m_sgKeyFwdElectrons;
     out->m_sgKeyMuons = m_sgKeyMuons;
     out->m_sgKeySoftMuons = m_sgKeySoftMuons;
     out->m_sgKeyTaus = m_sgKeyTaus;
     out->m_sgKeyJets = m_sgKeyJets;
     out->m_sgKeyLargeRJets = m_sgKeyLargeRJets;
     out->m_sgKeyTrackJets = m_sgKeyTrackJets;
     out->m_sgKeyTracks = m_sgKeyTracks;
     out->m_sgKeyMissingEt = m_sgKeyMissingEt;
     out->m_sgKeyMissingEtLoose = m_sgKeyMissingEtLoose;
  
     out->m_electronID = m_electronID;
     out->m_electronIDLoose = m_electronIDLoose;
     out->m_electronIsolation = m_electronIsolation;
     out->m_electronIsolationLoose = m_electronIsolationLoose;
     out->m_useElectronChargeIDSelection = m_useElectronChargeIDSelection;
     out->m_useEgammaLeakageCorrection = m_useEgammaLeakageCorrection;
     out->m_enablePromptLeptonImprovedVetoStudies = m_enablePromptLeptonImprovedVetoStudies;
  
     out->m_fwdElectronID = m_fwdElectronID;
  
     out->m_muonQuality = m_muonQuality;
     out->m_muonQualityLoose = m_muonQualityLoose;
     out->m_muonIsolation = m_muonIsolation;
     out->m_muonIsolationLoose = m_muonIsolationLoose;
  
     out->m_softmuonQuality = m_softmuonQuality;
  
     out->m_trackQuality = m_trackQuality;
  
     typedef std::unordered_map<std::size_t, std::string>::const_iterator Itr;
  
     for (const auto& btagWP : m_btagWP_caloJet)
       out->m_chosen_btaggingWP_caloJet.emplace_back(btagWP);
     for (const auto& btagWP : m_btagWP_trkJet)
       out->m_chosen_btaggingWP_trkJet.emplace_back(btagWP);
  
     for (Itr i = m_systSgKeyMapPhotons->begin(); i != m_systSgKeyMapPhotons->end(); ++i)
       out->m_systSgKeyMapPhotons.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapElectrons->begin(); i != m_systSgKeyMapElectrons->end(); ++i)
       out->m_systSgKeyMapElectrons.insert(std::make_pair((*i).first, (*i).second));
  
     for (const auto& i : *(m_systSgKeyMapFwdElectrons))
       out->m_systSgKeyMapFwdElectrons.insert(std::make_pair(i.first, i.second));
  
     for (Itr i = m_systSgKeyMapMuons->begin(); i != m_systSgKeyMapMuons->end(); ++i)
       out->m_systSgKeyMapMuons.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapSoftMuons->begin(); i != m_systSgKeyMapSoftMuons->end(); ++i)
       out->m_systSgKeyMapSoftMuons.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapTaus->begin(); i != m_systSgKeyMapTaus->end(); ++i)
       out->m_systSgKeyMapTaus.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapJets->begin(); i != m_systSgKeyMapJets->end(); ++i)
       out->m_systSgKeyMapJets.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapJets_electronInJetSubtraction->begin();
          i != m_systSgKeyMapJets_electronInJetSubtraction->end(); ++i)
       out->m_systSgKeyMapJets_electronInJetSubtraction.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapJetsLoose_electronInJetSubtraction->begin();
          i != m_systSgKeyMapJetsLoose_electronInJetSubtraction->end(); ++i)
       out->m_systSgKeyMapJetsLoose_electronInJetSubtraction.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapLargeRJets->begin(); i != m_systSgKeyMapLargeRJets->end(); ++i)
       out->m_systSgKeyMapLargeRJets.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapTrackJets->begin(); i != m_systSgKeyMapTrackJets->end(); ++i)
       out->m_systSgKeyMapTrackJets.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapTracks->begin(); i != m_systSgKeyMapTracks->end(); ++i)
       out->m_systSgKeyMapTracks.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapMissingET->begin(); i != m_systSgKeyMapMissingET->end(); ++i)
       out->m_systSgKeyMapMissingET.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapMissingETLoose->begin(); i != m_systSgKeyMapMissingETLoose->end(); ++i)
       out->m_systSgKeyMapMissingETLoose.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapKLFitter->begin(); i != m_systSgKeyMapKLFitter->end(); ++i)
       out->m_systSgKeyMapKLFitter.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapKLFitterLoose->begin(); i != m_systSgKeyMapKLFitterLoose->end(); ++i)
       out->m_systSgKeyMapKLFitterLoose.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapPseudoTop->begin(); i != m_systSgKeyMapPseudoTop->end(); ++i)
       out->m_systSgKeyMapPseudoTop.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systSgKeyMapPseudoTopLoose->begin(); i != m_systSgKeyMapPseudoTopLoose->end(); ++i)
       out->m_systSgKeyMapPseudoTopLoose.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systDecoKeyMapJetGhostTrack->begin(); i != m_systDecoKeyMapJetGhostTrack->end(); ++i)
       out->m_systDecoKeyMapJetGhostTrack.insert(std::make_pair((*i).first, (*i).second));
  
     for (Itr i = m_systPersistantAllTTreeNames->begin(); i != m_systPersistantAllTTreeNames->end(); ++i)
       out->m_systPersistantAllTTreeNames.insert(std::make_pair((*i).first, (*i).second));
  
     for (std::list<std::size_t>::const_iterator i = m_list_systHashAll->begin(); i != m_list_systHashAll->end(); ++i)
       out->m_list_systHashAll.push_back(*i);
  
     for (std::list<std::size_t>::const_iterator i = m_list_systHash_electronInJetSubtraction->begin();
          i != m_list_systHash_electronInJetSubtraction->end(); ++i)
       out->m_list_systHash_electronInJetSubtraction.push_back(*i);
  
     for (std::vector<std::string>::const_iterator i = m_allSelectionNames->begin(); i != m_allSelectionNames->end();
          ++i)
       out->m_allSelectionNames.push_back(*i);
  
     for (auto i : *m_allTriggers_Tight) {
       out->m_allTriggers_Tight.insert(i);
     }
     for (auto i : *m_electronTriggers_Tight) {
       out->m_electronTriggers_Tight.insert(i);
     }
     for (auto i : *m_muonTriggers_Tight) {
       out->m_muonTriggers_Tight.insert(i);
     }
     for (auto i : *m_tauTriggers_Tight) {
       out->m_tauTriggers_Tight.insert(i);
     }
     for (auto i : *m_photonTriggers_Tight) {
       out->m_photonTriggers_Tight.insert(i);
     }
  
     for (auto i : *m_allTriggers_Loose) {
       out->m_allTriggers_Loose.insert(i);
     }
     for (auto i : *m_electronTriggers_Loose) {
       out->m_electronTriggers_Loose.insert(i);
     }
     for (auto i : *m_muonTriggers_Loose) {
       out->m_muonTriggers_Loose.insert(i);
     }
     for (auto i : *m_tauTriggers_Loose) {
       out->m_tauTriggers_Loose.insert(i);
     }
     for (auto i : *m_photonTriggers_Loose) {
       out->m_photonTriggers_Loose.insert(i);
     }
  
     return out;
   }

◆ decoKeyJetGhostTrack() [1/3]

virtual const std::string& top::TopConfig::decoKeyJetGhostTrack ( ) const

inlinevirtual

Definition at line 605 of file TopConfig.h.

605 {return m_decoKeyJetGhostTrack;}

◆ decoKeyJetGhostTrack() [2/3]

const std::string & top::TopConfig::decoKeyJetGhostTrack ( const std::size_t hash ) const

Definition at line 3332 of file TopConfig.cxx.

                                                                              {
     // If it's in the map, use the mapped value, otherwise use the nominal.
     auto it = m_systDecoKeyMapJetGhostTrack->find(hash);
  
     if (it != m_systDecoKeyMapJetGhostTrack->end()) {
       return it->second;
     } else {
       it = m_systDecoKeyMapJetGhostTrack->find(m_nominalHashValue);
       if (it == m_systDecoKeyMapJetGhostTrack->end()) throw std::runtime_error(
                 "TopConfig: Failed to retrieve decoKeyJetGhostTrack.");
       return it->second;
     }
   }

◆ decoKeyJetGhostTrack() [3/3]

void top::TopConfig::decoKeyJetGhostTrack ( const std::string & key )

virtual

Definition at line 2153 of file TopConfig.cxx.

                                                            {
     if (!m_configFixed) {
       m_useJetGhostTrack = false;
       if (key != "None") m_useJetGhostTrack = true;
  
       m_decoKeyJetGhostTrack = key;
     }
   }

◆ electronEfficiencySystematicModel() [2/2]

virtual void top::TopConfig::electronEfficiencySystematicModel ( const std::string & s )

inlinevirtual

Definition at line 706 of file TopConfig.h.

                                                                               {
       if (!m_configFixed) {
         m_electronEfficiencySystematicModel = s;
       }
     }

◆ electronEfficiencySystematicModelEtaBinning() [1/2]

virtual const std::string& top::TopConfig::electronEfficiencySystematicModelEtaBinning ( )

inlinevirtual

Definition at line 841 of file TopConfig.h.

                                                                                   {
       return m_electronEfficiencySystematicModelEtaBinning;
     }

◆ electronEfficiencySystematicModelEtaBinning() [2/2]

virtual void top::TopConfig::electronEfficiencySystematicModelEtaBinning ( const std::string & s )

inlinevirtual

Definition at line 712 of file TopConfig.h.

                                                                                         {
       if (!m_configFixed) {
         m_electronEfficiencySystematicModelEtaBinning = s;
       }
     }

◆ electronEfficiencySystematicModelEtBinning() [1/2]

virtual const std::string& top::TopConfig::electronEfficiencySystematicModelEtBinning ( )

inlinevirtual

Definition at line 844 of file TopConfig.h.

                                                                                  {
       return m_electronEfficiencySystematicModelEtBinning;
     }

◆ electronEfficiencySystematicModelEtBinning() [2/2]

virtual void top::TopConfig::electronEfficiencySystematicModelEtBinning ( const std::string & s )

inlinevirtual

Definition at line 718 of file TopConfig.h.

                                                                                        {
       if (!m_configFixed) {
         m_electronEfficiencySystematicModelEtBinning = s;
       }
     }

◆ electronEfficiencySystematicModelIdSize() [1/2]

virtual const int& top::TopConfig::electronEfficiencySystematicModelIdSize ( )

inlinevirtual

Definition at line 860 of file TopConfig.h.

                                                                         {
       return m_electronEfficiencySystematicModelIdSize;
     }

◆ electronEfficiencySystematicModelIdSize() [2/2]

virtual void top::TopConfig::electronEfficiencySystematicModelIdSize ( const int & s )

inlinevirtual

Definition at line 743 of file TopConfig.h.

                                                                               {
         m_electronEfficiencySystematicModelIdSize = s;
     }

◆ electronEfficiencySystematicModelIsoSize() [1/2]

virtual const int& top::TopConfig::electronEfficiencySystematicModelIsoSize ( )

inlinevirtual

Definition at line 865 of file TopConfig.h.

                                                                          {
       return m_electronEfficiencySystematicModelIsoSize;
     }

◆ electronEfficiencySystematicModelIsoSize() [2/2]

virtual void top::TopConfig::electronEfficiencySystematicModelIsoSize ( const int & s )

inlinevirtual

Definition at line 749 of file TopConfig.h.

                                                                                {
         m_electronEfficiencySystematicModelIsoSize = s;
     }

◆ electronEfficiencySystematicModelNToys() [1/2]

virtual const int& top::TopConfig::electronEfficiencySystematicModelNToys ( )

inlinevirtual

Definition at line 847 of file TopConfig.h.

                                                                        {
       return m_electronEfficiencySystematicModelNToys;
     }

◆ electronEfficiencySystematicModelNToys() [2/2]

virtual void top::TopConfig::electronEfficiencySystematicModelNToys ( const int & s )

inlinevirtual

Definition at line 724 of file TopConfig.h.

                                                                              {
       if (!m_configFixed) {
         m_electronEfficiencySystematicModelNToys = s;
       }
     }

◆ electronEfficiencySystematicModelRecoSize() [1/2]

virtual const int& top::TopConfig::electronEfficiencySystematicModelRecoSize ( )

inlinevirtual

Definition at line 856 of file TopConfig.h.

                                                                           {
       return m_electronEfficiencySystematicModelRecoSize;
     }

◆ electronEfficiencySystematicModelRecoSize() [2/2]

virtual void top::TopConfig::electronEfficiencySystematicModelRecoSize ( const int & s )

inlinevirtual

Definition at line 738 of file TopConfig.h.

                                                                                 {
         m_electronEfficiencySystematicModelRecoSize = s;
     }

◆ electronEfficiencySystematicModelToySeed() [1/2]

virtual const int& top::TopConfig::electronEfficiencySystematicModelToySeed ( )

inlinevirtual

Definition at line 851 of file TopConfig.h.

                                                                          {
       return m_electronEfficiencySystematicModelToySeed;
     }

◆ electronEfficiencySystematicModelToySeed() [2/2]

virtual void top::TopConfig::electronEfficiencySystematicModelToySeed ( const int & s )

inlinevirtual

Definition at line 731 of file TopConfig.h.

                                                                                {
       if (!m_configFixed) {
         m_electronEfficiencySystematicModelToySeed = s;
       }
     }

◆ electronID() [1/2]

virtual const std::string& top::TopConfig::electronID ( ) const

inlinevirtual

Definition at line 869 of file TopConfig.h.

869 {return m_electronID;}

◆ electronID() [2/2]

virtual void top::TopConfig::electronID ( const std::string & s )

inlinevirtual

Definition at line 755 of file TopConfig.h.

                                                        {
       if (!m_configFixed) {
         m_electronID = s;
       }
     }

◆ electronPtcut() [2/2]

virtual void top::TopConfig::electronPtcut ( const float pt )

inlinevirtual

Definition at line 779 of file TopConfig.h.

                                                       {
       if (!m_configFixed) {
         m_electronPtcut = pt;
       }
     }

◆ electronTriggers_Loose() [1/2]

const std::vector< std::pair< std::string, int > > & top::TopConfig::electronTriggers_Loose ( const std::string & selection ) const

virtual

Definition at line 3447 of file TopConfig.cxx.

                                                                                                                {
     std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >::const_iterator key = m_electronTriggers_Loose->find(
       selection);
     if (key != m_electronTriggers_Loose->end()) {
       return (*key).second;
     }
     return m_dummyTrigger;
   }

◆ electronTriggers_Loose() [2/2]

virtual void top::TopConfig::electronTriggers_Loose ( std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers )

inlinevirtual

Definition at line 495 of file TopConfig.h.

                                                                                                                                     {
       if (!m_configFixed) {
         m_electronTriggers_Loose = triggers;
       }
     }

◆ electronTriggers_Tight() [1/2]

const std::vector< std::pair< std::string, int > > & top::TopConfig::electronTriggers_Tight ( const std::string & selection ) const

virtual

Definition at line 3402 of file TopConfig.cxx.

                                                                                                                {
     std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >::const_iterator key = m_electronTriggers_Tight->find(
       selection);
     if (key != m_electronTriggers_Tight->end()) {
       return (*key).second;
     }
     return m_dummyTrigger;
   }

◆ electronTriggers_Tight() [2/2]

virtual void top::TopConfig::electronTriggers_Tight ( std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers )

inlinevirtual

Definition at line 460 of file TopConfig.h.

                                                                                                                                     {
       if (!m_configFixed) {
         m_electronTriggers_Tight = triggers;
       }
     }

◆ electronVetoLArCrack() [1/2]

virtual bool top::TopConfig::electronVetoLArCrack ( ) const

inlinevirtual

Definition at line 871 of file TopConfig.h.

871 {return m_electronVetoLArCrack;}

◆ electronVetoLArCrack() [2/2]

virtual void top::TopConfig::electronVetoLArCrack ( const bool b )

inlinevirtual

Definition at line 773 of file TopConfig.h.

                                                            {
       if (!m_configFixed) {
         m_electronVetoLArCrack = b;
       }
     }

◆ elTrigEffConfig() [1/2]

std::string const& top::TopConfig::elTrigEffConfig ( ) const

inline

Definition at line 886 of file TopConfig.h.

886 {return m_elTrigEffConfig;}

◆ elTrigEffConfig() [2/2]

void top::TopConfig::elTrigEffConfig ( const std::string & s )

inline

Definition at line 887 of file TopConfig.h.

                                             {
       if (!m_configFixed) {
     m_elTrigEffConfig = s;
       }
     }    

◆ enablePromptLeptonImprovedVetoStudies() [1/2]

bool top::TopConfig::enablePromptLeptonImprovedVetoStudies ( ) const

inline

Definition at line 884 of file TopConfig.h.

884 {return m_enablePromptLeptonImprovedVetoStudies;}

◆ enablePromptLeptonImprovedVetoStudies() [2/2]

virtual void top::TopConfig::enablePromptLeptonImprovedVetoStudies ( const std::string & s )

inlinevirtual

Definition at line 833 of file TopConfig.h.

                                                                                   {
       if (!m_configFixed) {
     m_enablePromptLeptonImprovedVetoStudies = (s == "True" || s == "true");
       }
     }

◆ filterPartonLevelBranches()

std::vector<std::string> top::TopConfig::filterPartonLevelBranches ( ) const

inline

Definition at line 142 of file TopConfig.h.

142 {return m_filterPartonLevelBranches;}

◆ fixConfiguration()

void top::TopConfig::fixConfiguration ( )

Definition at line 2480 of file TopConfig.cxx.

                                    {
     ATH_MSG_INFO("TopConfig::fixConfiguration()");
     // Prevent the user from changing anything
     // Yes, this is deliberate
     m_configFixed = true;
  
     // copy hash values in m_systHashAll_list
     // into m_systHashAll
     // The std::unordered_set is faster
     for (std::list<std::size_t>::const_iterator i = m_list_systHashAll->begin(); i != m_list_systHashAll->end(); ++i) {
       m_systHashAll->insert((*i));
     }
     // same for m_systHash_electronInJetSubtraction
     for (std::list<std::size_t>::const_iterator i = m_list_systHash_electronInJetSubtraction->begin();
          i != m_list_systHash_electronInJetSubtraction->end(); ++i) {
       m_systHash_electronInJetSubtraction->insert((*i));
     }
  
  
     // Setup StoreGate keys for TopEvent/SingleSystEvent
     // Let's do ALL string manipulation here, never do it per event
     std::string nominalPhotons("SetMe");
     std::string nominalElectrons("SetMe");
     std::string nominalFwdElectrons("SetMe");
     std::string nominalMuons("SetMe");
     std::string nominalSoftMuons("SetMe");
     std::string nominalTaus("SetMe");
     std::string nominalJets("SetMe");
     std::string nominalLargeRJets("SetMe");
     std::string nominalTrackJets("SetMe");
     std::string nominalTracks("SetMe");
     std::string nominal("nominal");
     std::string tds("TDS");
     std::string tdsAux("TDSAux.");
  
     // Figure out the nominal object collection names
     std::unordered_map<std::size_t, std::string>::const_iterator ph = m_systSgKeyMapPhotons->find(m_nominalHashValue);
     if (ph != m_systSgKeyMapPhotons->end()) {
       nominalPhotons = (*ph).second;
     }
  
     std::unordered_map<std::size_t, std::string>::const_iterator el = m_systSgKeyMapElectrons->find(m_nominalHashValue);
     if (el != m_systSgKeyMapElectrons->end()) {
       nominalElectrons = (*el).second;
     }
  
     std::unordered_map<std::size_t, std::string>::const_iterator fwdel = m_systSgKeyMapFwdElectrons->find(
       m_nominalHashValue);
     if (fwdel != m_systSgKeyMapFwdElectrons->end()) {
       nominalFwdElectrons = (*fwdel).second;
     }
  
     std::unordered_map<std::size_t, std::string>::const_iterator mu = m_systSgKeyMapMuons->find(m_nominalHashValue);
     if (mu != m_systSgKeyMapMuons->end()) {
       nominalMuons = (*mu).second;
     }
  
     std::unordered_map<std::size_t, std::string>::const_iterator softmu = m_systSgKeyMapSoftMuons->find(
       m_nominalHashValue);
     if (softmu != m_systSgKeyMapSoftMuons->end()) {
       nominalSoftMuons = (*softmu).second;
     }
  
     std::unordered_map<std::size_t, std::string>::const_iterator tau = m_systSgKeyMapTaus->find(m_nominalHashValue);
     if (tau != m_systSgKeyMapTaus->end()) {
       nominalTaus = (*tau).second;
     }
  
     std::unordered_map<std::size_t, std::string>::const_iterator jet = m_systSgKeyMapJets->find(m_nominalHashValue);
     if (jet != m_systSgKeyMapJets->end()) {
       nominalJets = (*jet).second;
     }
  
     std::unordered_map<std::size_t, std::string>::const_iterator largeRJet = m_systSgKeyMapLargeRJets->find(
       m_nominalHashValue);
     if (largeRJet != m_systSgKeyMapLargeRJets->end()) {
       nominalLargeRJets = (*largeRJet).second;
     }
  
     std::unordered_map<std::size_t, std::string>::const_iterator trackJet = m_systSgKeyMapTrackJets->find(
       m_nominalHashValue);
     if (trackJet != m_systSgKeyMapTrackJets->end()) {
       nominalTrackJets = (*trackJet).second;
     }
     std::unordered_map<std::size_t, std::string>::const_iterator tracks = m_systSgKeyMapTracks->find(m_nominalHashValue);
     if (tracks != m_systSgKeyMapTracks->end()) {
       nominalTracks = (*tracks).second;
     }
  
  
     for (std::unordered_set<std::size_t>::const_iterator i = m_systHashAll->begin(); i != m_systHashAll->end(); ++i) {
       std::unordered_map<std::size_t, std::string>::const_iterator ph = m_systSgKeyMapPhotons->find(*i);
       if (ph != m_systSgKeyMapPhotons->end()) {
         m_systAllSgKeyMapPhotons->insert(std::make_pair((*i), (*ph).second));
       }
       if (ph == m_systSgKeyMapPhotons->end()) {
         m_systAllSgKeyMapPhotons->insert(std::make_pair((*i), nominalPhotons));
       }
  
       std::unordered_map<std::size_t, std::string>::const_iterator el = m_systSgKeyMapElectrons->find(*i);
       if (el != m_systSgKeyMapElectrons->end()) {
         m_systAllSgKeyMapElectrons->insert(std::make_pair((*i), (*el).second));
       }
       if (el == m_systSgKeyMapElectrons->end()) {
         m_systAllSgKeyMapElectrons->insert(std::make_pair((*i), nominalElectrons));
       }
  
       std::unordered_map<std::size_t, std::string>::const_iterator fwdel = m_systSgKeyMapFwdElectrons->find(*i);
       if (fwdel != m_systSgKeyMapFwdElectrons->end()) {
         m_systAllSgKeyMapFwdElectrons->insert(std::make_pair((*i), (*fwdel).second));
       }
       if (fwdel == m_systSgKeyMapFwdElectrons->end()) {
         m_systAllSgKeyMapFwdElectrons->insert(std::make_pair((*i), nominalFwdElectrons));
       }
  
       std::unordered_map<std::size_t, std::string>::const_iterator mu = m_systSgKeyMapMuons->find(*i);
       if (mu != m_systSgKeyMapMuons->end()) {
         m_systAllSgKeyMapMuons->insert(std::make_pair((*i), (*mu).second));
       }
       if (mu == m_systSgKeyMapMuons->end()) {
         m_systAllSgKeyMapMuons->insert(std::make_pair((*i), nominalMuons));
       }
  
       std::unordered_map<std::size_t, std::string>::const_iterator softmu = m_systSgKeyMapSoftMuons->find(*i);
       if (softmu != m_systSgKeyMapSoftMuons->end()) {
         m_systAllSgKeyMapSoftMuons->insert(std::make_pair((*i), (*softmu).second));
       }
       if (softmu == m_systSgKeyMapSoftMuons->end()) {
         m_systAllSgKeyMapSoftMuons->insert(std::make_pair((*i), nominalSoftMuons));
       }
  
       std::unordered_map<std::size_t, std::string>::const_iterator tau = m_systSgKeyMapTaus->find(*i);
       if (tau != m_systSgKeyMapTaus->end()) {
         m_systAllSgKeyMapTaus->insert(std::make_pair((*i), (*tau).second));
       }
       if (tau == m_systSgKeyMapTaus->end()) {
         m_systAllSgKeyMapTaus->insert(std::make_pair((*i), nominalTaus));
       }
  
       std::unordered_map<std::size_t, std::string>::const_iterator jet = m_systSgKeyMapJets->find(*i);
       if (jet != m_systSgKeyMapJets->end()) {
         m_systAllSgKeyMapJets->insert(std::make_pair((*i), (*jet).second));
       }
       if (jet == m_systSgKeyMapJets->end()) {
         m_systAllSgKeyMapJets->insert(std::make_pair((*i), nominalJets));
       }
  
       std::unordered_map<std::size_t, std::string>::const_iterator largeRJet = m_systSgKeyMapLargeRJets->find(*i);
       if (largeRJet != m_systSgKeyMapLargeRJets->end()) {
         m_systAllSgKeyMapLargeRJets->insert(std::make_pair((*i), (*largeRJet).second));
       }
       if (largeRJet == m_systSgKeyMapLargeRJets->end()) {
         m_systAllSgKeyMapLargeRJets->insert(std::make_pair((*i), nominalLargeRJets));
       }
  
       std::unordered_map<std::size_t, std::string>::const_iterator trackJet = m_systSgKeyMapTrackJets->find(*i);
       if (trackJet != m_systSgKeyMapTrackJets->end()) {
         m_systAllSgKeyMapTrackJets->insert(std::make_pair((*i), (*trackJet).second));
       }
       if (trackJet == m_systSgKeyMapTrackJets->end()) {
         m_systAllSgKeyMapTrackJets->insert(std::make_pair((*i), nominalTrackJets));
       }
  
       std::unordered_map<std::size_t, std::string>::const_iterator tracks = m_systSgKeyMapTracks->find(*i);
       if (tracks != m_systSgKeyMapTracks->end()) {
         m_systAllSgKeyMapTracks->insert(std::make_pair((*i), (*tracks).second));
       }
       if (tracks == m_systSgKeyMapTracks->end()) {
     m_systAllSgKeyMapTracks->insert(std::make_pair((*i), nominalTracks));
       }
  
  
     } // Loop over all systematic hash values
  
  
     if (m_applyElectronInJetSubtraction) {
       // Loop over all systematic hash values again, this time for electronInJetSubtraction
       std::string electronInJetSubtraction_Electrons("electronInJetSubtraction_Electrons_USING_");
       std::string electronInJetSubtraction_Jets("electronInJetSubtraction_Jets_USING_");
       std::string electronInJetSubtraction_JetsLoose("electronInJetSubtraction_JetsLoose_USING_");
       std::string electronInJetSubtraction_nominalElectrons = electronInJetSubtraction_Electrons + nominalElectrons +
                                                               "_AND_" + nominalJets;
       std::string electronInJetSubtraction_nominalJets = electronInJetSubtraction_Jets + nominalElectrons + "_AND_" +
                                                          nominalJets;
       std::string electronInJetSubtraction_nominalJetsLoose = electronInJetSubtraction_JetsLoose + nominalElectrons +
                                                               "_AND_" + nominalJets;
  
       for (std::unordered_set<std::size_t>::const_iterator i = m_systHashAll->begin(); i != m_systHashAll->end(); ++i) {
         std::unordered_map<std::size_t, std::string>::const_iterator el = m_systSgKeyMapElectrons->find(*i);
         std::unordered_map<std::size_t, std::string>::const_iterator jet = m_systSgKeyMapJets->find(*i);
  
         if (el != m_systSgKeyMapElectrons->end()) {
           m_systAllSgKeyMapElectrons_electronInJetSubtraction->insert(std::make_pair((*i),
                                                                                      electronInJetSubtraction_Electrons
                                                                                      + (*el).second + "_AND_" +
           nominalJets));
           m_systAllSgKeyMapJets_electronInJetSubtraction->insert(std::make_pair((*i),
                                                                                 electronInJetSubtraction_Jets +
                                                                                 (*el).second + "_AND_" + nominalJets));
           m_systSgKeyMapJets_electronInJetSubtraction->insert(std::make_pair((*i),
                                                                              electronInJetSubtraction_Jets +
                                                                              (*el).second + "_AND_" + nominalJets));
  
           m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->insert(std::make_pair((*i),
                                                                                      electronInJetSubtraction_JetsLoose
                                                                                      + (*el).second + "_AND_" +
           nominalJets));
           m_systSgKeyMapJetsLoose_electronInJetSubtraction->insert(std::make_pair((*i),
                                                                                   electronInJetSubtraction_JetsLoose +
                                                                                   (*el).second + "_AND_" +
           nominalJets));
         }
         if (jet != m_systSgKeyMapJets->end()) {
           m_systAllSgKeyMapElectrons_electronInJetSubtraction->insert(std::make_pair((*i),
                                                                                      electronInJetSubtraction_Electrons
                                                                                      + nominalElectrons + "_AND_" +
           (*jet).second));
           m_systAllSgKeyMapJets_electronInJetSubtraction->insert(std::make_pair((*i),
                                                                                 electronInJetSubtraction_Jets +
                                                                                 nominalElectrons + "_AND_" +
           (*jet).second));
           m_systSgKeyMapJets_electronInJetSubtraction->insert(std::make_pair((*i),
                                                                              electronInJetSubtraction_Jets +
                                                                              nominalElectrons + "_AND_" +
           (*jet).second));
  
           m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->insert(std::make_pair((*i),
                                                                                      electronInJetSubtraction_JetsLoose
                                                                                      + nominalElectrons + "_AND_" +
           (*jet).second));
           m_systSgKeyMapJetsLoose_electronInJetSubtraction->insert(std::make_pair((*i),
                                                                                   electronInJetSubtraction_JetsLoose +
                                                                                   nominalElectrons + "_AND_" +
           (*jet).second));
         }
         if (el == m_systSgKeyMapElectrons->end() && jet == m_systSgKeyMapJets->end()) {
           m_systAllSgKeyMapElectrons_electronInJetSubtraction->insert(std::make_pair((*i),
                                                                                      electronInJetSubtraction_nominalElectrons));
           m_systAllSgKeyMapJets_electronInJetSubtraction->insert(std::make_pair((*i),
                                                                                 electronInJetSubtraction_nominalJets));
           m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->insert(std::make_pair((*i),
                                                                                      electronInJetSubtraction_nominalJetsLoose));
         }
       } // Loop over all systematic hash values
     } // electron in jet Subtraction
  
  
     // Tempory data store names
     typedef std::unordered_map<std::size_t, std::string>::const_iterator Itr2;
     for (Itr2 i = m_systAllSgKeyMapPhotons->begin(); i != m_systAllSgKeyMapPhotons->end(); ++i) {
       m_systAllSgKeyMapPhotonsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
       m_systAllSgKeyMapPhotonsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
     }
  
     for (Itr2 i = m_systAllSgKeyMapElectrons->begin(); i != m_systAllSgKeyMapElectrons->end(); ++i) {
       m_systAllSgKeyMapElectronsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
       m_systAllSgKeyMapElectronsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
     }
  
     for (const auto& i : *(m_systAllSgKeyMapFwdElectrons)) {
       m_systAllSgKeyMapFwdElectronsTDS->insert(std::make_pair(i.first, i.second + tds));
       m_systAllSgKeyMapFwdElectronsTDSAux->insert(std::make_pair(i.first, i.second + tdsAux));
     }
  
     for (Itr2 i = m_systAllSgKeyMapMuons->begin(); i != m_systAllSgKeyMapMuons->end(); ++i) {
       m_systAllSgKeyMapMuonsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
       m_systAllSgKeyMapMuonsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
     }
  
     for (Itr2 i = m_systAllSgKeyMapSoftMuons->begin(); i != m_systAllSgKeyMapSoftMuons->end(); ++i) {
       m_systAllSgKeyMapSoftMuonsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
       m_systAllSgKeyMapSoftMuonsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
     }
  
     for (Itr2 i = m_systAllSgKeyMapTaus->begin(); i != m_systAllSgKeyMapTaus->end(); ++i) {
       m_systAllSgKeyMapTausTDS->insert(std::make_pair((*i).first, (*i).second + tds));
       m_systAllSgKeyMapTausTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
     }
  
     for (Itr2 i = m_systAllSgKeyMapJets->begin(); i != m_systAllSgKeyMapJets->end(); ++i) {
       m_systAllSgKeyMapJetsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
       m_systAllSgKeyMapJetsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
     }
  
     for (Itr2 i = m_systAllSgKeyMapLargeRJets->begin(); i != m_systAllSgKeyMapLargeRJets->end(); ++i) {
       m_systAllSgKeyMapLargeRJetsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
       m_systAllSgKeyMapLargeRJetsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
     }
  
     for (Itr2 i = m_systAllSgKeyMapElectrons_electronInJetSubtraction->begin();
          i != m_systAllSgKeyMapElectrons_electronInJetSubtraction->end(); ++i) {
       m_systAllSgKeyMapElectrons_electronInJetSubtractionTDS->insert(std::make_pair((*i).first, (*i).second + tds));
       m_systAllSgKeyMapElectrons_electronInJetSubtractionTDSAux->insert(std::make_pair((*i).first,
                                                                                        (*i).second + tdsAux));
     }
  
     for (Itr2 i = m_systAllSgKeyMapTrackJets->begin(); i != m_systAllSgKeyMapTrackJets->end(); ++i) {
       m_systAllSgKeyMapTrackJetsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
       m_systAllSgKeyMapTrackJetsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
     }
  
     for (Itr2 i = m_systAllSgKeyMapTracks->begin(); i != m_systAllSgKeyMapTracks->end(); ++i) {
       m_systAllSgKeyMapTracksTDS->insert(std::make_pair((*i).first, (*i).second + tds));
       m_systAllSgKeyMapTracksTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
     }
  
     for (Itr2 i = m_systAllSgKeyMapJets_electronInJetSubtraction->begin();
          i != m_systAllSgKeyMapJets_electronInJetSubtraction->end(); ++i) {
       m_systAllSgKeyMapJets_electronInJetSubtractionTDS->insert(std::make_pair((*i).first, (*i).second + tds));
       m_systAllSgKeyMapJets_electronInJetSubtractionTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
     }
  
     for (Itr2 i = m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->begin();
          i != m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->end(); ++i) {
       m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDS->insert(std::make_pair((*i).first, (*i).second + tds));
       m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDSAux->insert(std::make_pair((*i).first,
                                                                                        (*i).second + tdsAux));
     }
  
  
     // TTree names
     m_systAllTTreeNames->insert(std::make_pair(m_nominalHashValue, nominal));
     typedef std::unordered_map<std::size_t, CP::SystematicSet>::const_iterator Itr;
  
     if (m_usePhotons) {
       for (Itr i = m_systMapPhotons->begin(); i != m_systMapPhotons->end(); ++i) {
         m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
       }
     }
     if (m_useElectrons) {
       for (Itr i = m_systMapElectrons->begin(); i != m_systMapElectrons->end(); ++i) {
         m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
       }
     }
     if (m_useFwdElectrons) {
       for (Itr i = m_systMapFwdElectrons->begin(); i != m_systMapFwdElectrons->end(); ++i) {
         m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
       }
     }
     if (m_useMuons) {
       for (Itr i = m_systMapMuons->begin(); i != m_systMapMuons->end(); ++i) {
         m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
       }
     }
     if (m_useSoftMuons) {
       for (Itr i = m_systMapSoftMuons->begin(); i != m_systMapSoftMuons->end(); ++i) {
         m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
       }
     }
     if (m_useTaus) {
       for (Itr i = m_systMapTaus->begin(); i != m_systMapTaus->end(); ++i) {
         m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
       }
     }
     if (m_useJets) {
       for (Itr i = m_systMapJets->begin(); i != m_systMapJets->end(); ++i) {
         m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
       }
     }
     if (m_useLargeRJets) {
       for (Itr i = m_systMapLargeRJets->begin(); i != m_systMapLargeRJets->end(); ++i) {
         m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
       }
     }
     if (m_useTrackJets) {
       for (Itr i = m_systMapTrackJets->begin(); i != m_systMapTrackJets->end(); ++i) {
         m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
       }
     }
     if (m_useTracks) {
       for (Itr i = m_systMapTracks->begin(); i != m_systMapTracks->end(); ++i) {
         m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
       }
     }
     if (m_useJetGhostTrack) {
       for (Itr i = m_systMapJetGhostTrack->begin(); i != m_systMapJetGhostTrack->end(); ++i) {
         m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
       }
     }
     for (Itr i = m_systMapMET->begin(); i != m_systMapMET->end(); ++i) {
       m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
     }
  
  
  
     // Missing ET from TTree names
     // KLFitter from TTree names
  
     for (Itr2 i = m_systAllTTreeNames->begin(); i != m_systAllTTreeNames->end(); ++i) {
       if (m_doTightEvents) m_systSgKeyMapMissingET->insert(std::make_pair((*i).first,
                                                                           m_sgKeyMissingEt + "_" + (*i).second));
       if (m_doLooseEvents) m_systSgKeyMapMissingETLoose->insert(std::make_pair((*i).first,
                                                                                m_sgKeyMissingEt + "_Loose_" +
                                                                                (*i).second));
  
       if (m_doTightEvents) m_systSgKeyMapKLFitter->insert(std::make_pair((*i).first,
                                                                          m_sgKeyKLFitter + "_" + (*i).second));
       if (m_doLooseEvents) m_systSgKeyMapKLFitterLoose->insert(std::make_pair((*i).first,
                                                                               m_sgKeyKLFitter + "_Loose_" +
                                                                               (*i).second));
  
       if (m_doTightEvents) m_systSgKeyMapPseudoTop->insert(std::make_pair((*i).first,
                                                                           m_sgKeyPseudoTop + "_" + (*i).second));
       if (m_doLooseEvents) m_systSgKeyMapPseudoTopLoose->insert(std::make_pair((*i).first,
                                                                                m_sgKeyPseudoTop + "_Loose_" +
                                                                                (*i).second));
     }
  
  
     // TTree index
     unsigned int TTreeIndex(0);
     if (m_doTightEvents) {
       for (Itr2 i = m_systAllTTreeNames->begin(); i != m_systAllTTreeNames->end(); ++i) {
         if ((*i).second == "nominal" || m_doTightSysts) {
           m_systAllTTreeIndex->insert(std::make_pair((*i).first, TTreeIndex));
           ++TTreeIndex;
         }
       }
     }
     if (m_doLooseEvents) {
       for (Itr2 i = m_systAllTTreeNames->begin(); i != m_systAllTTreeNames->end(); ++i) {
         if ((*i).second == "nominal" || m_doLooseSysts) {
           m_systAllTTreeLooseIndex->insert(std::make_pair((*i).first, TTreeIndex));
           ++TTreeIndex;
         }
       }
     }
  
     if (m_makeAllCPTools) {
       for (Itr2 i = m_systAllTTreeNames->begin(); i != m_systAllTTreeNames->end(); ++i) {
         m_systPersistantAllTTreeNames->insert(std::make_pair((*i).first, (*i).second));
       }
     }
   }

◆ getShoweringAlgorithm()

SampleXsection::showering top::TopConfig::getShoweringAlgorithm ( ) const

inline

Definition at line 75 of file TopConfig.h.

75 {return m_showeringAlgo;}

◆ getSystematicsList()

bool top::TopConfig::getSystematicsList	(	const std::string &	syst,
		std::set< std::string > &	systList
	)		const

Definition at line 2271 of file TopConfig.cxx.

                                                                                                 {
     if (isSystAll(syststr) || isSystNominal(syststr)) return true;
  
     if (syststr.find(" ") != std::string::npos) {
       ATH_MSG_ERROR("getSystematicsList: systematic string can't contain white spaces");
       return false;
     }
  
     std::string separator = ",";
     std::string::size_type start = 0, end = 0;
     while ((end = syststr.find(separator, start)) != std::string::npos) {
       std::string token = syststr.substr(start, end - start);
       if (token.size()) systList.insert(token);
       start = end + 1;
     }
     std::string lasttoken = syststr.substr(start);
     if (lasttoken.size()) systList.insert(lasttoken);
  
     return true;
   }

◆ getTDPPath()

const std::string& top::TopConfig::getTDPPath ( ) const

inline

Definition at line 71 of file TopConfig.h.

71 {return m_topDataPreparationPath;}

◆ getTreeFilter()

const TreeFilter* top::TopConfig::getTreeFilter ( ) const

inline

Definition at line 2172 of file TopConfig.h.

2172 { return m_treeFilter.get();}

◆ getYear() [1/2]

const std::string& top::TopConfig::getYear ( )

inline

Definition at line 2146 of file TopConfig.h.

2146 {return m_year;}

◆ getYear() [2/2]

std::string top::TopConfig::getYear	(	unsigned int	runnumber,
		const bool	isMC
	)

Definition at line 3864 of file TopConfig.cxx.

                                                                       {
  
     if (isMC) {
       // mc16a - returning only 2015 but is really a mix of 15 + 16
       if (runnumber == 284500) return "2015";
       
       // mc16d
       if (runnumber == 300000) return "2017";
       
       // mc16e
       if (runnumber == 310000) return "2018";
       
       // Run 3 mc21a
       if (runnumber == 410000) return "2022";
  
       return "UNKNOWN";
     }
     
     // Set of runNumbers for data
     // 2015 : 266904 - 284484
     if (runnumber >= 266904 && runnumber <= 284484) return "2015";
  
     // 2016 : 296939 - 311481
     if (runnumber >= 296939 && runnumber <= 311481) return "2016";
  
     // 2017 : 324320 - 348835
     if (runnumber >= 324320 && runnumber <= 348835) return "2017";
  
     // 2018 : > 348835 
     if (runnumber > 348835 && runnumber < 400000) return "2018";
     
     // Run 3: 2022
     if (runnumber > 410000 && runnumber < 999999) return "2022";
     
     return "UNKNOWN";
   }

◆ ghostTrackspT() [1/2]

virtual float top::TopConfig::ghostTrackspT ( ) const

inlinevirtual

Definition at line 1279 of file TopConfig.h.

1279 {return m_ghostTrackspT;}

◆ ghostTrackspT() [2/2]

virtual void top::TopConfig::ghostTrackspT ( const float pt )

inlinevirtual

Definition at line 1258 of file TopConfig.h.

                                                       {
       if (!m_configFixed) {
         m_ghostTrackspT = pt;
       }
     }

◆ ghostTracksQuality() [1/2]

virtual const std::string& top::TopConfig::ghostTracksQuality ( ) const

inlinevirtual

Definition at line 1281 of file TopConfig.h.

1281 {return m_ghostTracksQuality;}

◆ ghostTracksQuality() [2/2]

virtual void top::TopConfig::ghostTracksQuality ( const std::string & ghostTracksQuality )

inlinevirtual

Definition at line 1270 of file TopConfig.h.

                                                                                 {
      if (!m_configFixed) {
         m_ghostTracksQuality = ghostTracksQuality;
      }
     }

◆ ghostTracksVertexAssociation() [1/2]

virtual const std::string& top::TopConfig::ghostTracksVertexAssociation ( ) const

inlinevirtual

Definition at line 1280 of file TopConfig.h.

1280 {return m_ghostTracksVertexAssociation;}

◆ ghostTracksVertexAssociation() [2/2]

virtual void top::TopConfig::ghostTracksVertexAssociation ( const std::string & vertexassociation )

inlinevirtual

Definition at line 1264 of file TopConfig.h.

                                                                                          {
       if (!m_configFixed) {
         m_ghostTracksVertexAssociation = vertexassociation;
       }
     }

◆ isSystAll()

bool top::TopConfig::isSystAll ( const std::string & syst ) const

Definition at line 2267 of file TopConfig.cxx.

                                                        {
     return boost::iequals(syst, m_allSystName);
   }

◆ isSystNominal()

bool top::TopConfig::isSystNominal ( const std::string & syst ) const

syst helper functions

Definition at line 2263 of file TopConfig.cxx.

                                                            {
     return boost::iequals(syst, m_nominalSystName);
   }

◆ jetPtGhostTracks() [1/2]

virtual float top::TopConfig::jetPtGhostTracks ( ) const

inlinevirtual

Definition at line 1283 of file TopConfig.h.

1283 {return m_jetPtGhostTracks;}

◆ jetPtGhostTracks() [2/2]

virtual void top::TopConfig::jetPtGhostTracks	(	const float	pt,
		const float	small_jet_pt
	)

inlinevirtual

Definition at line 1241 of file TopConfig.h.

                                                                                    {
       if (!m_configFixed) {
         if ( small_jet_pt >= pt+4999){  
             m_jetPtGhostTracks = pt;
         }
         else {
             m_jetPtGhostTracks = (small_jet_pt - 5000) > 20000 ? (small_jet_pt - 5000) : 20000;
         }
       }
     }

◆ muonTriggers_Loose() [1/2]

const std::vector< std::pair< std::string, int > > & top::TopConfig::muonTriggers_Loose ( const std::string & selection ) const

virtual

Definition at line 3456 of file TopConfig.cxx.

                                                                                                            {
     std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >::const_iterator key = m_muonTriggers_Loose->find(
       selection);
     if (key != m_muonTriggers_Loose->end()) {
       return (*key).second;
     }
     return m_dummyTrigger;
   }

◆ muonTriggers_Loose() [2/2]

virtual void top::TopConfig::muonTriggers_Loose ( std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers )

inlinevirtual

Definition at line 502 of file TopConfig.h.

                                                                                                                                 {
       if (!m_configFixed) {
         m_muonTriggers_Loose = triggers;
       }
     }

◆ muonTriggers_Tight() [1/2]

const std::vector< std::pair< std::string, int > > & top::TopConfig::muonTriggers_Tight ( const std::string & selection ) const

virtual

Definition at line 3411 of file TopConfig.cxx.

                                                                                                            {
     std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >::const_iterator key = m_muonTriggers_Tight->find(
       selection);
     if (key != m_muonTriggers_Tight->end()) {
       return (*key).second;
     }
     return m_dummyTrigger;
   }

◆ muonTriggers_Tight() [2/2]

virtual void top::TopConfig::muonTriggers_Tight ( std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers )

inlinevirtual

Definition at line 467 of file TopConfig.h.

                                                                                                                                 {
       if (!m_configFixed) {
         m_muonTriggers_Tight = triggers;
       }
     }

◆ muonUse2stationMuonsHighPt() [1/2]

virtual bool top::TopConfig::muonUse2stationMuonsHighPt ( ) const

inlinevirtual

Definition at line 1109 of file TopConfig.h.

1109 {return m_muonUse2stationMuonsHighPt;}

◆ muonUse2stationMuonsHighPt() [2/2]

void top::TopConfig::muonUse2stationMuonsHighPt ( const bool & Use2stationMuonsHighPt )

inline

Definition at line 1035 of file TopConfig.h.

                                                                         {
       if (!m_configFixed) {
     m_muonUse2stationMuonsHighPt = Use2stationMuonsHighPt;
       }
     }

◆ muonUse2stationMuonsHighPtLoose() [1/2]

virtual bool top::TopConfig::muonUse2stationMuonsHighPtLoose ( ) const

inlinevirtual

Definition at line 1112 of file TopConfig.h.

1112 {return m_muonUse2stationMuonsHighPtLoose;}

◆ muonUse2stationMuonsHighPtLoose() [2/2]

void top::TopConfig::muonUse2stationMuonsHighPtLoose ( const bool & Use2stationMuonsHighPtLoose )

inline

Definition at line 1053 of file TopConfig.h.

                                                                                   {
       if (!m_configFixed) {
     m_muonUse2stationMuonsHighPtLoose = Use2stationMuonsHighPtLoose;
       }
     }

◆ muonUseLowPt() [1/2]

virtual bool top::TopConfig::muonUseLowPt ( ) const

inlinevirtual

Definition at line 1108 of file TopConfig.h.

1108 {return m_muonUseLowPt;}

◆ muonUseLowPt() [2/2]

void top::TopConfig::muonUseLowPt ( const bool & UseLowPt )

inline

Definition at line 1029 of file TopConfig.h.

                                             {
       if (!m_configFixed) {
         m_muonUseLowPt = UseLowPt;
       }
     }

◆ muonUseLowPtLoose() [1/2]

virtual bool top::TopConfig::muonUseLowPtLoose ( ) const

inlinevirtual

Definition at line 1111 of file TopConfig.h.

1111 {return m_muonUseLowPtLoose;}

◆ muonUseLowPtLoose() [2/2]

void top::TopConfig::muonUseLowPtLoose ( const bool & UseLowPtLoose )

inline

Definition at line 1047 of file TopConfig.h.

                                                       {
       if (!m_configFixed) {
         m_muonUseLowPtLoose = UseLowPtLoose;
       }
     }

◆ muonUseMVALowPt() [1/2]

virtual bool top::TopConfig::muonUseMVALowPt ( ) const

inlinevirtual

Definition at line 1107 of file TopConfig.h.

1107 {return m_muonUseMVALowPt;}

◆ muonUseMVALowPt() [2/2]

void top::TopConfig::muonUseMVALowPt ( const bool & UseMVALowPt )

inline

Definition at line 1023 of file TopConfig.h.

                                                   {
       if (!m_configFixed) {
     m_muonUseMVALowPt = UseMVALowPt;
       }
     }

◆ muonUseMVALowPtLoose() [1/2]

virtual bool top::TopConfig::muonUseMVALowPtLoose ( ) const

inlinevirtual

Definition at line 1110 of file TopConfig.h.

1110 {return m_muonUseMVALowPtLoose;}

◆ muonUseMVALowPtLoose() [2/2]

void top::TopConfig::muonUseMVALowPtLoose ( const bool & UseMVALowPtLoose )

inline

Definition at line 1041 of file TopConfig.h.

                                                             {
       if (!m_configFixed) {
     m_muonUseMVALowPtLoose = UseMVALowPtLoose;
       }
     }

◆ operator=()

                                         {
     std::istringstream str_btagging_WP(btagWPsettingString);
     std::vector<std::string> all_btagging_WP;
     std::copy(std::istream_iterator<std::string>(str_btagging_WP),
               std::istream_iterator<std::string>(),
               std::back_inserter(all_btagging_WP));
     // loop through all btagging WPs requested
     for (const auto& AlgTag : all_btagging_WP) {
       std::vector<std::string> btagAlg_btagWP;
       tokenize(AlgTag, btagAlg_btagWP, ":");
       // DEFAULT algorithm - May remove in future
       std::string alg = "DL1r";
       std::string tag = "";
       // If no ':' delimiter, assume we want default algorithm, and take the WP from the option
       if (btagAlg_btagWP.size() == 2) {
         alg = btagAlg_btagWP.at(0);
         tag = btagAlg_btagWP.at(1);
       } else {
         ATH_MSG_ERROR("Cannot parse b-tagging ALGORITHM_NAME:WP. Incorrect format.");
         continue;
       }
  
       std::pair<std::string, std::string> alg_tag = std::make_pair(alg, tag);
       btagAlgoWPlist.push_back(alg_tag);
       btagWPlist.push_back(alg + "_" + tag);
     }
     remove_duplicates(btagWPlist);
     remove_duplicates(btagAlgoWPlist);
   }

◆ passEventSelectionDecoration()

const std::string& top::TopConfig::passEventSelectionDecoration ( ) const

inline

Definition at line 603 of file TopConfig.h.

603 {return m_passEventSelectionDecoration;}

◆ photonEtacut() [1/2]

virtual float top::TopConfig::photonEtacut ( ) const

inlinevirtual

Definition at line 1730 of file TopConfig.h.

                                               {
       return m_photon_configuration.eta;
     }

◆ photonEtacut() [2/2]

virtual void top::TopConfig::photonEtacut ( const float eta )

inlinevirtual

Definition at line 962 of file TopConfig.h.

                                                       {
       if (!m_configFixed) {
         m_photon_configuration.eta = eta;
       }
     }

◆ photonIdentification() [1/2]

const std::string& top::TopConfig::photonIdentification ( )

inline

Definition at line 1734 of file TopConfig.h.

                                                    {
       return m_photon_configuration.identification;
     }

◆ photonIdentification() [2/2]

virtual void top::TopConfig::photonIdentification ( const std::string & quality )

inlinevirtual

Definition at line 968 of file TopConfig.h.

                                                                        {
       if (!m_configFixed) {
         m_photon_configuration.identification = quality;
       }
     }

◆ photonIdentificationLoose() [1/2]

const std::string& top::TopConfig::photonIdentificationLoose ( )

inline

Definition at line 1738 of file TopConfig.h.

                                                         {
       return m_photon_configuration_loose.identification;
     }

◆ photonIdentificationLoose() [2/2]

virtual void top::TopConfig::photonIdentificationLoose ( const std::string & quality )

inlinevirtual

Definition at line 974 of file TopConfig.h.

                                                                             {
       if (!m_configFixed) {
         m_photon_configuration_loose.identification = quality;
       }
     }

◆ photonIsolation() [1/2]

const std::string& top::TopConfig::photonIsolation ( )

inline

Definition at line 1742 of file TopConfig.h.

                                               {
       return m_photon_configuration.isolation;
     }

◆ photonIsolation() [2/2]

virtual void top::TopConfig::photonIsolation ( const std::string & quality )

inlinevirtual

Definition at line 980 of file TopConfig.h.

                                                                   {
       if (!m_configFixed) {
         m_photon_configuration.isolation = quality;
       }
     }

◆ photonIsolationLoose() [1/2]

const std::string& top::TopConfig::photonIsolationLoose ( )

inline

Definition at line 1746 of file TopConfig.h.

                                                    {
       return m_photon_configuration_loose.isolation;
     }

◆ photonIsolationLoose() [2/2]

virtual void top::TopConfig::photonIsolationLoose ( const std::string & quality )

inlinevirtual

Definition at line 986 of file TopConfig.h.

                                                                        {
       if (!m_configFixed) {
         m_photon_configuration_loose.isolation = quality;
       }
     }

◆ photonIsolationWPs()

const std::vector<std::string>& top::TopConfig::photonIsolationWPs ( )

inline

Definition at line 1750 of file TopConfig.h.

1750 { return m_photonIsolationWPs; }

◆ photonPtcut() [1/2]

virtual float top::TopConfig::photonPtcut ( ) const

inlinevirtual

Definition at line 1726 of file TopConfig.h.

                                              {
       return m_photon_configuration.pt;
     }

◆ photonPtcut() [2/2]

virtual void top::TopConfig::photonPtcut ( const float pt )

inlinevirtual

Definition at line 956 of file TopConfig.h.

                                                     {
       if (!m_configFixed) {
         m_photon_configuration.pt = pt;
       }
     }

◆ photonTriggers_Loose() [1/2]

const std::vector< std::pair< std::string, int > > & top::TopConfig::photonTriggers_Loose ( const std::string & selection ) const

virtual

Definition at line 3474 of file TopConfig.cxx.

                                                                                                              {
     std::unordered_map<std::string,
                        std::vector<std::pair<std::string, int> > >::const_iterator key = m_photonTriggers_Loose->find(selection);
     if (key != m_photonTriggers_Loose->end()) {
       return (*key).second;
     }
     return m_dummyTrigger;
   }

◆ photonTriggers_Loose() [2/2]

virtual void top::TopConfig::photonTriggers_Loose ( std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers )

inlinevirtual

Definition at line 516 of file TopConfig.h.

                                                                                                                                {
       if (!m_configFixed) {
         m_photonTriggers_Loose = triggers;
       }
     }

◆ photonTriggers_Tight() [1/2]

const std::vector< std::pair< std::string, int > > & top::TopConfig::photonTriggers_Tight ( const std::string & selection ) const

virtual

Definition at line 3429 of file TopConfig.cxx.

                                                                                                              {
     std::unordered_map<std::string,
                        std::vector<std::pair<std::string, int> > >::const_iterator key = m_photonTriggers_Tight->find(selection);
     if (key != m_photonTriggers_Tight->end()) {
       return (*key).second;
     }
     return m_dummyTrigger;
   }

◆ photonTriggers_Tight() [2/2]

virtual void top::TopConfig::photonTriggers_Tight ( std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers )

inlinevirtual

Definition at line 481 of file TopConfig.h.

                                                                                                                                {
       if (!m_configFixed) {
         m_photonTriggers_Tight = triggers;
       }
     }

◆ readFloatOption()

float top::TopConfig::readFloatOption	(	top::ConfigurationSettings *const &	settings,
		std::string	in
	)		const

private

Definition at line 1905 of file TopConfig.cxx.

                                                                                                       {
     float invalue = 99999999.;
  
     try{
       invalue = std::stof(settings->value(instring));
     }
     catch (...) {
       throw std::invalid_argument {
               "TopConfig: cannot convert Option " + instring + "into float"
       };
     }
  
     return invalue;
   }

◆ ReadIsAFII()

void top::TopConfig::ReadIsAFII ( top::ConfigurationSettings *const & settings )

Definition at line 3823 of file TopConfig.cxx.

                                                                       {
     if (settings->value("IsAFII") == "True") this->setIsAFII(true);
     else if (settings->value("IsAFII") == "False") this->setIsAFII(false);
     else if (settings->value("IsAFII") != " ") throw std::runtime_error(
               "TopConfig: option IsAFII must be either True or False");
     else if (this->isMC()) throw std::runtime_error("TopConfig: option IsAFII not set");
   }

◆ ReadIsDataOverlay()

void top::TopConfig::ReadIsDataOverlay ( top::ConfigurationSettings *const & settings )

private

Definition at line 3832 of file TopConfig.cxx.

                                                                              {
     if (settings->value("IsDataOverlay") == "True") this->setIsDataOverlay(true);
     else if (settings->value("IsDataOverlay") == "False") this->setIsDataOverlay(false);
     else if (settings->value("IsDataOverlay") != " ") throw std::runtime_error(
               "TopConfig: option IsDataOverlay must be either True or False");
   }

◆ recomputeCPvars()

bool top::TopConfig::recomputeCPvars ( ) const

inline

Definition at line 77 of file TopConfig.h.

77 {return m_recomputeCPvars;}

◆ removeElectronVetoLArCrack()

void top::TopConfig::removeElectronVetoLArCrack ( )

inline

Definition at line 767 of file TopConfig.h.

                                              {
       if (!m_configFixed) {
         m_electronVetoLArCrack = false;
       }
     }

◆ runPeriodJetGhostTrack()

void top::TopConfig::runPeriodJetGhostTrack ( const std::vector< std::uint32_t > & vect )

virtual

Definition at line 2164 of file TopConfig.cxx.

                                                                            {
     if (m_useJetGhostTrack == true) m_jetGhostTrackRunPeriods = vect;
   }

◆ setApplyElectronInJetSubtraction()

void top::TopConfig::setApplyElectronInJetSubtraction ( )

inline

Definition at line 309 of file TopConfig.h.

                                                    {
       if (!m_configFixed) {
         m_applyElectronInJetSubtraction = true;
       }
     }

◆ setApplyTightSFsInLooseTree()

void top::TopConfig::setApplyTightSFsInLooseTree ( )

inline

Definition at line 298 of file TopConfig.h.

                                               {
       if (!m_configFixed) {
         m_applyTightSFsInLooseTree = true;
       }
     }

◆ setBadBatmanCleaningMax()

void top::TopConfig::setBadBatmanCleaningMax ( const unsigned int value )

inline

Definition at line 2137 of file TopConfig.h.

2137 {m_badBatmanCleaningMax = value;}

◆ setBadBatmanCleaningMin()

void top::TopConfig::setBadBatmanCleaningMin ( const unsigned int value )

inline

Definition at line 2135 of file TopConfig.h.

2135 {m_badBatmanCleaningMin = value;}

◆ setBoostedTaggersSFSysNames()

void top::TopConfig::setBoostedTaggersSFSysNames ( const std::unordered_map< std::string, std::vector< std::string >> & sysNames )

inline

Definition at line 1909 of file TopConfig.h.

1909 {m_boostedTaggersSFSysNames=sysNames;}

◆ setBTaggingSFSysts()

void top::TopConfig::setBTaggingSFSysts	(	std::string	WP,
		const std::set< std::string > &	btagging_SFs,
		bool	isTrackJet = `false`
	)

Definition at line 2175 of file TopConfig.cxx.

                                                                                                               {
     //this avoids code duplication
     std::unordered_map<std::string,
                        std::set<std::string> >& base_names = isTrackJet ? bTag_base_names_trkJet : bTag_base_names;
     std::unordered_map<std::string,
                        std::set<std::string> >& named_systs = isTrackJet ? bTag_named_systs_trkJet : bTag_named_systs;
     std::unordered_map<std::string, unsigned int>& eigen_B = isTrackJet ? bTag_eigen_B_trkJet : bTag_eigen_B;
     std::unordered_map<std::string, unsigned int>& eigen_C = isTrackJet ? bTag_eigen_C_trkJet : bTag_eigen_C;
     std::unordered_map<std::string,
                        unsigned int>& eigen_light = isTrackJet ? bTag_eigen_light_trkJet : bTag_eigen_light;
  
     //names of all systematics
     base_names[WP] = btagging_SF_names;
     //initialise named systematics to empty set
     named_systs[WP] = { };
     // initialise number of eigenvectors
     eigen_B[WP] = 0;
     eigen_C[WP] = 0;
     eigen_light[WP] = 0;
     // loop on systematic names
     for (const auto& SF_name : base_names.at(WP)) {
       if (SF_name.find("_Eigen_B_") != std::string::npos) eigen_B.at(WP)++;
       else if (SF_name.find("_Eigen_C_") != std::string::npos) eigen_C.at(WP)++;
       else if (SF_name.find("_Eigen_Light_") != std::string::npos) eigen_light.at(WP)++;
       else named_systs[WP].insert(SF_name);
     }
   }

◆ setCalibBoostedJetTagger()

void top::TopConfig::setCalibBoostedJetTagger	(	const std::string &	WP,
		const std::string &	SFname
	)

Definition at line 2203 of file TopConfig.cxx.

                                                                                        {
     m_boostedTaggerSFnames[WP] = SFname;
   }

◆ setConfigSettings()

void top::TopConfig::setConfigSettings ( top::ConfigurationSettings *const & settings )

– KLFitter settings –///

Definition at line 740 of file TopConfig.cxx.

                                                                              {
     // Selections
     const std::vector<top::SelectionConfigurationData> allSelections = settings->selections();
  
     for (auto sel : allSelections) {
       m_allSelectionNames->push_back(sel.m_name);
     }
  
     // set GRL file
     this->setGrlDir(settings->value("GRLDir"));
     this->setGrlFile(settings->value("GRLFile"));
  
     // Set TDP file name
     this->setTDPPath(settings->value("TDPPath"));
  
     m_treeFilter->init(settings->value("FilterTrees"));
  
  
     //we need storegate keys so people can pick different collections / met / jets etc.
     this->sgKeyPhotons(settings->value("PhotonCollectionName"));
     this->sgKeyElectrons(settings->value("ElectronCollectionName"));
     this->sgKeyFwdElectrons(settings->value("FwdElectronCollectionName"));
     this->sgKeyMuons(settings->value("MuonCollectionName"));
     //small trick for the soft muons
     if (settings->value("UseSoftMuons") == "True") this->sgKeySoftMuons("Soft" + settings->value("MuonCollectionName"));
  
     else this->sgKeySoftMuons("None");
     this->sgKeyTaus(settings->value("TauCollectionName"));
     this->sgKeyJets(settings->value("JetCollectionName"));
     this->sgKeyLargeRJets(settings->value("LargeJetCollectionName"));
     this->sgKeyTrackJets(settings->value("TrackJetCollectionName"));
     this->sgKeyTracks(settings->value("TrackCollectionName"));
     this->jetSubstructureName(settings->value("LargeJetSubstructure"));
     this->decoKeyJetGhostTrack(settings->value("JetGhostTrackDecoName"));
  
     // ROOTCORE/Analysis release series
     this->setReleaseSeries();
  
     if (settings->value("applyTTVACut") == "False") this->m_applyTTVACut = false;
  
     if (this->isMC()) {
       this->sgKeyMCParticle(settings->value("TruthCollectionName"));
       this->sgKeyTruthElectrons(settings->value("TruthElectronCollectionName"));
       this->sgKeyTruthMuons(settings->value("TruthMuonCollectionName"));
       this->sgKeyTruthPhotons(settings->value("TruthPhotonCollectionName"));
       this->sgKeyTruthMET(settings->value("TruthMETCollectionName"));
       this->sgKeyTruthJets(settings->value("TruthJetCollectionName"));
       this->sgKeyTruthLargeRJets(settings->value("TruthLargeRJetCollectionName"));
       this->sgKeyTruthTaus(settings->value("TruthTauCollectionName"));
  
       // Dump truth block
       if (settings->value("TruthBlockInfo") == "True") this->setTruthBlockInfo();
  
       // Save the Truth PDF information
       if (settings->value("PDFInfo") == "True") {
         this->setTruthPDFInfo();
       } else if (settings->value("PDFInfo") == "Nominal") {
         // Save the Truth PDF information in the reco-level tree instead of the truth-level one
         this->setTruthPDFInfo();
         this->setTruthPDFInfoInNominalTrees();
       }
  
       // Save the MC generator weights
       if (settings->value("MCGeneratorWeights") == "True") {
         this->setMCGeneratorWeights();
       } else if (settings->value("MCGeneratorWeights") == "Nominal") {
         // Save the Truth PDF information in the reco-level tree instead of the truth-level one
         this->setMCGeneratorWeights();
         this->setMCGeneratorWeightsInNominalTrees();
       }
  
       // load the nominal weight names that we should try to get the real nominal weight name
       const std::string& tmp = settings->value("NominalWeightNames");
  
       // Remove the whitespaces between the names but keep
       // the whitespaces within quotation marks
       std::string trimmedName = "";
       bool deleteSpaces = true;
       bool start = false;
       for(unsigned int i = 0; i < tmp.size(); ++i) {
         if(tmp[i] == '\"') {
           start ? start = false : start = true;
           if(start) {
             deleteSpaces = false;
           }
         }
         if(!start) {
           deleteSpaces = true;
         }
         if(deleteSpaces) {
           if(tmp[i] != ' ') {
             trimmedName += tmp[i];
           }
         } else {
           trimmedName += tmp[i];
         }
       }
       boost::split(m_nominalWeightNames, trimmedName, boost::is_any_of(","));
       // now remove all occurences of '"'
       for (std::string& iname : m_nominalWeightNames) {
         iname.erase(std::remove(iname.begin(), iname.end(), '"'), iname.end());
         // and check if we have newline characters (some weight have those...)
         // and parse them properly
         boost::replace_all(iname, "\\n", "\n");
       }
  
       try {
         m_nominalWeightIndex = std::stoi(settings->value("NominalWeightFallbackIndex"));
       } catch (std::invalid_argument &e) {
         ATH_MSG_ERROR("Failed to parse NominalWeightFallbackIndex value: " << settings->value("NominalWeightFallbackIndex"));
         throw;
       }
  
       settings->retrieve("ForceNominalWeightFallbackIndex", m_forceWeightIndex);
  
       // Save the Top Parton History
       if (settings->value("TopPartonHistory") != "False") this->setTopPartonHistory();
       
       // Perform parton-level selection and save particle level objects
       bool topPartonLevel=true;
       settings->retrieve("TopPartonLevel",topPartonLevel);
       this->setTopPartonLevel(topPartonLevel);
       
       // Perform particle-level selection and save particle level objects
       bool topParticleLevel=true;
       settings->retrieve("TopParticleLevel",topParticleLevel);
       this->setTopParticleLevel(topParticleLevel);
  
       // Particle-level OR
       if (settings->value("DoParticleLevelOverlapRemoval") == "True") {
         // Value True -> Do all ORs
         this->setParticleLevelOverlapRemovalElJet(true);
         this->setParticleLevelOverlapRemovalMuJet(true);
         this->setParticleLevelOverlapRemovalJetPhoton(true);
       } else if (settings->value("DoParticleLevelOverlapRemoval") == "False") {
         // Value False -> Do not perform any OR.
         this->setParticleLevelOverlapRemovalElJet(false);
         this->setParticleLevelOverlapRemovalMuJet(false);
         this->setParticleLevelOverlapRemovalJetPhoton(false);
       } else {
         // Explicitly specify the possible OR values.
         std::vector<std::string> tokens;
         tokenize(settings->value("DoParticleLevelOverlapRemoval"), tokens, ",");
         while (tokens.size()) {
           const auto& token = tokens.back();
  
           if (token == "MuonJet") {
             this->setParticleLevelOverlapRemovalMuJet(true);
           } else if (token == "ElectronJet") {
             this->setParticleLevelOverlapRemovalElJet(true);
           } else if (token == "JetPhoton") {
             this->setParticleLevelOverlapRemovalJetPhoton(true);
           } else {
             throw std::runtime_error {
                     "TopConfig: Option DoParticleLevelOverlapRemoval: Invalid Token"
             };
           }
  
           // Remove the last token in the container.
           tokens.pop_back();
         }
       }
  
       // Particle level overlap removal use rapidity in deltaR calculation
       if(settings->value("OverlapRemovalParticleLevelUseRapidity") == "True"){
         this->setParticleLevelOverlapRemovalWithRapidity(true);
       }
       else{
         this->setParticleLevelOverlapRemovalWithRapidity(false);
       }
  
     }
  
     // Get list of branches to be filtered
     if (settings->value("FilterBranches") != " ") {
       std::vector<std::string> branches;
       tokenize(settings->value("FilterBranches"), branches, ",");
  
       if (branches.size() == 0) {
         ATH_MSG_WARNING("You provided \"FilterBranches\" option but you did not provide any meaningful values. Ignoring");
       }
       this->setFilterBranches(branches);
     }
     
     // Get list of PartonLevel branches to be filtered
     if (settings->value("FilterPartonLevelBranches") != " ") {
       std::vector<std::string> branches;
       tokenize(settings->value("FilterPartonLevelBranches"), branches, ",");
  
       if (branches.size() == 0) {
         ATH_MSG_WARNING("You provided \"FilterPartonLevelBranches\" option but you did not provide any meaningful values. Ignoring");
       }
       this->setFilterPartonLevelBranches(branches);
     }
     
     // Get list of ParticleLevel branches to be filtered
     if (settings->value("FilterParticleLevelBranches") != " ") {
       std::vector<std::string> branches;
       tokenize(settings->value("FilterParticleLevelBranches"), branches, ",");
  
       if (branches.size() == 0) {
         ATH_MSG_WARNING("You provided \"FilterParticleLevelBranches\" option but you did not provide any meaningful values. Ignoring");
       }
       this->setFilterParticleLevelBranches(branches);
     }
  
     // Get list of nominal_Loose branches to be filtered
     if (settings->value("FilterNominalLooseBranches") != " ") {
       std::vector<std::string> branches;
       tokenize(settings->value("FilterNominalLooseBranches"), branches, ",");
  
       if (branches.size() == 0) {
         ATH_MSG_WARNING("You provided \"FilterNominalLooseBranches\" option but you did not provide any meaningful values. Ignoring");
       }
       this->setFilterNominalLooseBranches(branches);
     }
  
     // Get list of nominal branches to be filtered
     if (settings->value("FilterNominalBranches") != " ") {
       std::vector<std::string> branches;
       tokenize(settings->value("FilterNominalBranches"), branches, ",");
  
       if (branches.size() == 0) {
         ATH_MSG_WARNING("You provided \"FilterNominalBranches\" option but you did not provide any meaningful values. Ignoring");
       }
       this->setFilterNominalBranches(branches);
     }
  
     // Force recomputation of CP variables?
     if (settings->value("RecomputeCPVariables") == "False") m_recomputeCPvars = false;
  
     // Bootstrapping weights (permitted in MC and Data)
     if (settings->value("SaveBootstrapWeights") == "True") {
       this->setSaveBootstrapWeights(true);
       this->setNumberOfBootstrapReplicas(std::atoi(settings->value("NumberOfBootstrapReplicas").c_str()));
     }
     
     settings->retrieve("UseLooseObjectsInMETInLooseTree", m_useLooseObjectsInMETInLooseTree);
     settings->retrieve("UseLooseObjectsInMETInNominalTree", m_useLooseObjectsInMETInNominalTree);
     settings->retrieve("WriteMETBuiltWithLooseObjects", m_writeMETBuiltWithLooseObjects);
  
     if (this->isMC()) {
       m_doLooseEvents = (settings->value("DoLoose") == "MC" || settings->value("DoLoose") == "Both");
       m_doTightEvents = (settings->value("DoTight") == "MC" || settings->value("DoTight") == "Both");
       m_doLooseSysts = (settings->value("DoSysts") == "Loose" || settings->value("DoSysts") == "Both") &&
                        m_doLooseEvents;
       m_doTightSysts = (settings->value("DoSysts") == "Tight" || settings->value("DoSysts") == "Both") &&
                        m_doTightEvents;
     } else {
       m_doLooseEvents = (settings->value("DoLoose") == "Data" || settings->value("DoLoose") == "Both");
       if (m_doLooseEvents) {
         if (settings->value("FakesMMWeightsIFF") == "True") {
           this->setFakesMMWeightsCalculationIFF();
           std::string configIFF = settings->value("FakesMMConfigIFF");
           if (configIFF != "") {
             this->setFakesMMConfigIFF(configIFF);
           }
           if (settings->value("FakesMMIFFDebug") == "True") {
             this->setFakesMMIFFDebug();
           }
         }
       }
       m_doTightEvents = (settings->value("DoTight") == "Data" || settings->value("DoTight") == "Both");
     }
  
     // Switch to set event BadBatman cleaning
     if (settings->value("UseBadBatmanCleaning") == "False") {
       this->setUseBadBatmanCleaning(false);
     } else if (settings->value("UseBadBatmanCleaning") == "True") {
       this->setUseBadBatmanCleaning(true);
     } else {
       throw std::invalid_argument {
               "TopConfig: Option UseBadBatmanCleaning unknown value, only True or False (default) is allowed"
       };
     }
  
     // now check the ranges of the batman cleaning
     {
       std::vector<std::string> tokens;
       tokenize(settings->value("BadBatmanCleaningRange"), tokens, ":");
       if (tokens.size() != 2) {
         throw std::runtime_error {
                 "TopConfig: Option BadBatmanCleaningRange should be of the form \'RunNumber1:RunNumber2\'"
         };
       }
       unsigned int minRunNumber = 999999;
       unsigned int maxRunNumber = 0;
       try { // convert the values from string to unsigned int
         minRunNumber = std::stoul(tokens.at(0));
         maxRunNumber = std::stoul(tokens.at(1));
       } catch (...) {
         throw std::invalid_argument {
                 "TopConfig: Option BadBatmanCleaningRange cannot convert the RunNumbers into unsigned int"
         };
       }
  
       // check if the first value is not larger than the second value
       if (maxRunNumber < minRunNumber) {
         throw std::invalid_argument {
                 "TopConfig: Option BadBatmanCleaningRange: the first RunNumber cannot be larger than the second!"
         };
       }
  
       // check if there is an overlap with data 2017 as this option should not be used for this period
       static const unsigned int data17_begin = 325713;
       static const unsigned int data17_end = 348835;
  
       if (std::max(minRunNumber, data17_begin) <= std::min(maxRunNumber, data17_end)) {
         throw std::invalid_argument {
                 "TopConfig: Option BadBatmanCleaningRange cannot include RunNumbers from 2017 data taking (325713-348835)"
         };
       }
  
       this->setBadBatmanCleaningMin(minRunNumber);
       this->setBadBatmanCleaningMax(maxRunNumber);
     }
  
     // Switch to set event level jet cleaning tool [false by default]
     if (settings->value("UseEventLevelJetCleaningTool") == "True") {
       this->setUseEventLevelJetCleaningTool(true);
     }
  
     // Object Selection Name
     this->objectSelectionName(settings->value("ObjectSelectionName"));
     // Output Format
     this->outputFormat(settings->value("OutputFormat"));
     // Output Events
     this->outputEvents(settings->value("OutputEvents"));
     // SetAutoFlush(0) on EventSaverFlatNtuple for ANALYSISTO-44 workaround
     m_outputFileSetAutoFlushZero = false;
     if (settings->value("OutputFileSetAutoFlushZero") != "False") {
       ATH_MSG_WARNING("OutputFileSetAutoFlushZero is deprecated in favour of more custom memory options");
     }
     // Configurable TTree options (ANALYSISTO-463)
     if (settings->value("OutputFileNEventAutoFlush") != "") {
       m_outputFileNEventAutoFlush = std::stoi(settings->value("OutputFileNEventAutoFlush"));
     }
     if (settings->value("OutputFileBasketSizePrimitive") != "") {
       m_outputFileBasketSizePrimitive = std::stoi(settings->value("OutputFileBasketSizePrimitive"));
     }
     if (settings->value("OutputFileBasketSizeVector") != "") {
       m_outputFileBasketSizeVector = std::stoi(settings->value("OutputFileBasketSizeVector"));
     }
  
     // The systematics want much much more configuration options.....
     this->systematics(settings->value("Systematics"));
  
     // special: allow to dump the systematics-shifted b-tagging SFs in the systematics trees
     if (settings->value("DumpBtagSystsInSystTrees") == "True") this->dumpBtagSystsInSystTrees(true);
  
     // special: store per-jet btag SFs
     if (settings->value("StorePerJetBtagSFs") == "True") this->storePerJetBtagSFs(true);
  
     // Electron configuration
     this->egammaSystematicModel(settings->value("EgammaSystematicModel"));
     this->electronEfficiencySystematicModel(settings->value("ElectronEfficiencySystematicModel"));
     this->electronEfficiencySystematicModelEtaBinning(settings->value("ElectronEfficiencySystematicModelEtaBinning"));
     this->electronEfficiencySystematicModelEtBinning(settings->value("ElectronEfficiencySystematicModelEtBinning"));
     this->electronEfficiencySystematicModelNToys(std::stof(settings->value("ElectronEfficiencySystematicModelNToys")));
     this->electronEfficiencySystematicModelToySeed(std::stof(settings->value("ElectronEfficiencySystematicModelToySeed")));
     this->electronID(settings->value("ElectronID"));
     this->electronIDLoose(settings->value("ElectronIDLoose"));
     {
       std::string const& cut_wp = settings->value("ElectronIsolation");
       std::string const& sf_wp = settings->value("ElectronIsolationSF");
       this->electronIsolation(cut_wp);
       this->electronIsolationSF(sf_wp == " " ? cut_wp : sf_wp);
  
       const std::string &isoWPs_str = settings->value("ElectronIsolationWPs");
       tokenize(isoWPs_str, m_electronIsolationWPs, " ", true);
       if (cut_wp != "None")
         m_electronIsolationWPs.emplace_back(cut_wp);
     }
     {
       std::string const& cut_wp = settings->value("ElectronIsolationLoose");
       std::string const& sf_wp = settings->value("ElectronIsolationSFLoose");
       this->electronIsolationLoose(cut_wp);
       this->electronIsolationSFLoose(sf_wp == " " ? cut_wp : sf_wp);
       if (cut_wp != "None")
         m_electronIsolationWPs.emplace_back(cut_wp);
     }
     remove_duplicates(m_electronIsolationWPs);
     this->useElectronChargeIDSelection(settings->value("UseElectronChargeIDSelection"));
     this->useEgammaLeakageCorrection(settings->value("UseEgammaLeakageCorrection"));
     this->electronPtcut(std::stof(settings->value("ElectronPt")));
     this->electrond0Sigcut(std::stof(settings->value("Electrond0Sig")));
     this->electrondeltaz0cut(std::stof(settings->value("Electrondeltaz0")));
     this->enablePromptLeptonImprovedVetoStudies(settings->value("EnablePromptLeptonImprovedVetoStudies"));
  
     {
       const std::string elTrigConfig = settings->value("ElectronTriggerEfficiencyConfig");
       if (elTrigConfig == " ") {
         throw std::invalid_argument{"TopConfig: ElectronTriggerEfficiencyConfig not set in the config!"};
       }
       this->elTrigEffConfig(elTrigConfig);
     }
  
     m_electronIDDecoration = "AnalysisTop_" + m_electronID;
     m_electronIDLooseDecoration = "AnalysisTop_" + m_electronIDLoose;
  
     //Fwd electron configuration
     this->fwdElectronID(settings->value("FwdElectronID"));
     this->fwdElectronIDLoose(settings->value("FwdElectronIDLoose"));
     double fwdElPtCut = 99999999.;
     try{
       fwdElPtCut = std::stof(settings->value("FwdElectronPt"));
     }
     catch (...) {
       throw std::invalid_argument {
               "TopConfig: cannot convert Option FwdElectronPt into float"
       };
     }
     this->fwdElectronPtcut(fwdElPtCut);
     double fwdElMinEtaCut = 2.5;
     try{
       fwdElMinEtaCut = std::stof(settings->value("FwdElectronMinEta"));
     }
     catch (...) {
       throw std::invalid_argument {
               "TopConfig: cannot convert Option FwdElectronMinEta into float"
       };
     }
     this->fwdElectronMinEtacut(fwdElMinEtaCut);
     double fwdElMaxEtaCut = 2.5;
     try{
       fwdElMaxEtaCut = std::stof(settings->value("FwdElectronMaxEta"));
     }
     catch (...) {
       throw std::invalid_argument {
               "TopConfig: cannot convert Option FwdElectronMaxEta into float"
       };
     }
     this->fwdElectronMaxEtacut(fwdElMaxEtaCut);
  
     int fwdElectronBCIDCleaningMinRun = 0;
     int fwdElectronBCIDCleaningMaxRun = 0;
     std::vector<std::string> fwd_bcid_tokens;
     tokenize(settings->value("FwdElectronBCIDCleaningRunRange"), fwd_bcid_tokens, ":");
     if (fwd_bcid_tokens.size() != 2) {
       throw std::invalid_argument(
               "TopConfig: Option FwdElectronBCIDCleaningRunRange requires values in the form of \'XXX:YYY\'. The number of values needs to be exactly 2.");
     }
     try{
       fwdElectronBCIDCleaningMinRun = std::stoi(fwd_bcid_tokens[0]);
       fwdElectronBCIDCleaningMaxRun = std::stoi(fwd_bcid_tokens[1]);
     }
     catch (...) {
       throw std::invalid_argument(
               "TopConfig: Cannot convert the strings into integers for the run numbers in Option FwdElectronBCIDCleaningRunRange");
     }
  
     this->fwdElectronBCIDCleaningMinRun(fwdElectronBCIDCleaningMinRun);
     this->fwdElectronBCIDCleaningMaxRun(fwdElectronBCIDCleaningMaxRun);
  
     m_electronIDSFFile_path = settings->value("ElectronIDSFFilePath");
     m_electronIDSFFileLoose_path = settings->value("ElectronIDSFFilePathLoose");
  
  
     // Photon configuration
     this->photonPtcut(std::stof(settings->value("PhotonPt")));
     this->photonEtacut(std::stof(settings->value("PhotonEta")));
     this->photonIdentification(settings->value("PhotonID"));
     this->photonIdentificationLoose(settings->value("PhotonIDLoose"));
     this->photonIsolation(settings->value("PhotonIsolation"));
     this->photonIsolationLoose(settings->value("PhotonIsolationLoose"));
     {
       const std::string &isoWPs_str = settings->value("PhotonIsolationWPs");
       tokenize(isoWPs_str, m_photonIsolationWPs, " ", true);
       if (this->photonIsolation() != "None")
         m_photonIsolationWPs.emplace_back(this->photonIsolation());
       if (this->photonIsolationLoose() != "None")
         m_photonIsolationWPs.emplace_back(this->photonIsolationLoose());
       remove_duplicates(m_photonIsolationWPs);
     }
  
     // Muon configuration
     this->muonPtcut(std::stof(settings->value("MuonPt")));
     this->muonEtacut(std::stof(settings->value("MuonEta")));
     this->muond0Sigcut(std::stof(settings->value("Muond0Sig")));
     this->muondeltaz0cut(std::stof(settings->value("Muondeltaz0")));
     this->muonQuality(settings->value("MuonQuality"));
     this->muonQualityLoose(settings->value("MuonQualityLoose"));
     {
       std::string const& cut_wp = settings->value("MuonIsolation");
       std::string const& sf_wp = settings->value("MuonIsolationSF");
       this->muonIsolation(cut_wp);
       this->muonIsolationSF(sf_wp == " " ? cut_wp : sf_wp);
  
       const std::string &isoWPs_str = settings->value("MuonIsolationWPs");
       tokenize(isoWPs_str, m_muonIsolationWPs, " ", true);
       if (cut_wp != "None")
         m_muonIsolationWPs.emplace_back(cut_wp);
     }
     bool muonUse2stationHighPt = true;
     settings->retrieve("MuonUse2stationHighPt", muonUse2stationHighPt);
     if (settings->value("MuonQuality") != "HighPt") muonUse2stationHighPt = false;
     this->muonUse2stationMuonsHighPt(muonUse2stationHighPt);
     if(settings->value("MuonQuality") == "LowPt") this->muonUseLowPt(true);
     bool muonUseMVALowPt=false;
     settings->retrieve("MuonUseMVALowPt", muonUseMVALowPt);
     if (settings->value("MuonQuality") != "LowPt" && muonUseMVALowPt) {
       ATH_MSG_WARNING("Could not set MuonUseMVALowPt True without using the LowPt muon WP. MuonUseMVALowPt is now setted to the default value (False)");
       muonUseMVALowPt = false;
     }
     this->muonUseMVALowPt(muonUseMVALowPt);
     bool muonUse2stationHighPtLoose = true;
     settings->retrieve("MuonUse2stationHighPtLoose", muonUse2stationHighPtLoose);
     if (settings->value("MuonQualityLoose") != "HighPt") muonUse2stationHighPtLoose = false;
     this->muonUse2stationMuonsHighPtLoose(muonUse2stationHighPtLoose);
     if(settings->value("MuonQualityLoose") == "LowPt") this->muonUseLowPtLoose(true);
     bool muonUseMVALowPtLoose = false;
     settings->retrieve("MuonUseMVALowPtLoose", muonUseMVALowPtLoose);
     if (settings->value("MuonQualityLoose") != "LowPt" && muonUseMVALowPtLoose) {
       ATH_MSG_WARNING("Could not set MuonUseMVALowPtLoose True without using the LowPt muon WP. MuonUseMVALowPtLoose is now setted to the default value (False)");
       muonUseMVALowPtLoose = false;
     }
     
     this->muonUseMVALowPtLoose(muonUseMVALowPtLoose);
     
     std::string const& cut_wp = settings->value("MuonIsolationLoose");
     std::string const& sf_wp = settings->value("MuonIsolationSFLoose");
     this->muonIsolationLoose(cut_wp);
     this->muonIsolationSFLoose(sf_wp == " " ? cut_wp : sf_wp);
     if (cut_wp != "None")
       m_muonIsolationWPs.emplace_back(cut_wp);
     remove_duplicates(m_muonIsolationWPs);
     
     m_muonCalibMode = settings->value("MuonCalibrationMode");
     m_muonSmearingSystematicModel = settings->value("MuonSmearingSystematicModel");
     bool muonDoSmearing2stationHighPt = false;
     settings->retrieve("MuonDoSmearing2stationHighPt", muonDoSmearing2stationHighPt);
     if (settings->value("MuonQuality") != "HighPt" ) muonDoSmearing2stationHighPt = false;
     else if ( !muonUse2stationHighPt && muonDoSmearing2stationHighPt ) {
       ATH_MSG_WARNING("Could not set MuonDoSmearing2stationHighPt True without MuonUse2stationHighPt. MuonDoSmearing2stationHighPt is now setted to False");
       muonDoSmearing2stationHighPt = false;
     }
     this->muonMuonDoSmearing2stationHighPt(muonDoSmearing2stationHighPt);
     bool muonDoExtraSmearingHighPt = false;
     settings->retrieve("MuonDoExtraSmearingHighPt", muonDoExtraSmearingHighPt);
     if ( settings->value("MuonQuality") == "HighPt" && muonDoExtraSmearingHighPt ) {
       ATH_MSG_WARNING("Could not set MuonDoExtraSmearingHighPt True when using the HighPt muon WP, HighPt muons are not affected by this setting. MuonDoExtraSmearingHighPt is now setted to the default value (False)");
       muonDoExtraSmearingHighPt = false;
     }
     this->muonMuonDoExtraSmearingHighPt( muonDoExtraSmearingHighPt );
  
     bool muonBreakDownSystematics(false);
     settings->retrieve("MuonBreakDownSystematics", muonBreakDownSystematics);
     this->muonBreakDownSystematics(muonBreakDownSystematics);
     {
       std::string const& customMuonSF = settings->value("MuonSFCustomInputFolder");
       this->muonSFCustomInputFolder(customMuonSF);
     }
     {
       std::string const& customMuonSFTrigger = settings->value("MuonSFCustomInputFolderTrigger");
       this->muonSFCustomInputFolderTrigger(customMuonSFTrigger);
     }
     {
       int customMuonForceYear = std::stoi(settings->value("MuonForceYear"));
       this->muonForceYear(customMuonForceYear);
     }
     {
       std::string const& customMuonForcePeriod = settings->value("MuonForcePeriod");
       this->muonForcePeriod(customMuonForcePeriod);
     }
     {
       std::string const& customMuonForceTrigger = settings->value("MuonForceTrigger");
       this->muonForceTrigger(customMuonForceTrigger);
     }
     if (settings->value("UseAntiMuons") == "True") this->m_useAntiMuons = true;
     {
       std::string const& customElTrigEffConfig = settings->value("ElectronTriggerEfficiencyConfig");
       this->elTrigEffConfig(customElTrigEffConfig);
     }
  
     // Soft Muon configuration
     this->softmuonPtcut(readFloatOption(settings, "SoftMuonPt"));
     this->softmuonEtacut(readFloatOption(settings, "SoftMuonEta"));
     this->softmuonQuality(settings->value("SoftMuonQuality"));
     if(settings->value("SoftMuonQuality") == "LowPt") this->softmuonUseLowPt(true);
     bool softmuonUseMVALowPtSoftMuon = false;
     settings->retrieve("SoftMuonUseMVALowPt", softmuonUseMVALowPtSoftMuon);
     if (settings->value("SoftMuonQuality") != "LowPt" && softmuonUseMVALowPtSoftMuon) {
       ATH_MSG_WARNING("Could not set SoftMuonUseMVALowPt True without using the LowPt softmuon WP. SoftMuonUseMVALowPt is now setted to the default value (False)");
       softmuonUseMVALowPtSoftMuon = false;
     }
     this->softmuonUseMVALowPt(softmuonUseMVALowPtSoftMuon);
     this->softmuonDRJetcut(readFloatOption(settings, "SoftMuonDRJet"));
     this->softmuonDRJetcutUseRapidity(settings->retrieve("SoftMuonDRJetUseRapidity"));
     this->softmuonAdditionalTruthInfo(settings->retrieve("SoftMuonAdditionalTruthInfo"));
     this->softmuonAdditionalTruthInfoCheckPartonOrigin(settings->retrieve("SoftMuonAdditionalTruthInfoCheckPartonOrigin"));
     this->softmuonAdditionalTruthInfoDoVerbose(settings->retrieve("SoftMuonAdditionalTruthInfoDoVerbose") );
  
     //tau configuration
     this->tauPtcut(std::stof(settings->value("TauPt")));
     this->tauEtaRegions(settings->value("TauEtaRegions"));
     this->tauJetIDWP(settings->value("TauJetIDWP"));
     this->tauJetIDWPLoose(settings->value("TauJetIDWPLoose"));
     this->tauEleIDWP(settings->value("TauEleIDWP"));
     this->tauEleIDWPLoose(settings->value("TauEleIDWPLoose"));
     this->tauMuOLR((settings->value("TauMuOLR") == "True"));
     this->tauMuOLRLoose((settings->value("TauMuOLRLoose") == "True"));
     this->tauJetConfigFile(settings->value("TauJetConfigFile"));
     this->tauJetConfigFileLoose(settings->value("TauJetConfigFileLoose"));
     if (settings->value("ApplyTauMVATES") != "True") throw std::runtime_error {
               "TopConfig: ApplyTauMVATES must be True"
       };
  
     // Jet configuration
     this->jetPtcut(std::stof(settings->value("JetPt")));
     this->jetEtacut(std::stof(settings->value("JetEta")));
     this->jetPtGhostTracks(std::stof(settings->value("JetPtGhostTracks")),std::stof(settings->value("JetPt")));
     if ( m_jetPtcut <= std::stof(settings->value("JetPtGhostTracks"))+5000){  
         ATH_MSG_WARNING("jetPtGhostTracks set to " << m_jetPtGhostTracks <<" to ensure that all the selected jets have the ghost tracks associated");
     }
     this->jetEtaGhostTracks(std::stof(settings->value("JetEtaGhostTracks")));
     this->jetUncertainties_NPModel(settings->value("JetUncertainties_NPModel"));
     this->jetUncertainties_QGFracFile(settings->value("JetUncertainties_QGFracFile"));
     this->jetUncertainties_QGHistPatterns(settings->value("JetUncertainties_QGHistPatterns"));
     this->jetJERSmearingModel(settings->value("JetJERSmearingModel"));
     this->jetJMSOption(settings->value("JetJMSOption"));
     if (settings->value("DoLargeRPseudodataJER") == "False") {
       this->doLargeRPseudodataJER(false);
     } else if (settings->value("DoLargeRPseudodataJER") == "True") {
       this->doLargeRPseudodataJER(true);
     }
     this->jetCalibSequence(settings->value("JetCalibSequence"));
     this->allowSmallRJMSforAFII(settings->value("AllowJMSforAFII") == "True");
     this->doJVTinMET(settings->retrieve("JVTinMETCalculation"));
     this->saveFailJVTJets(settings->retrieve("SaveFailJVTJets"));
     this->setJVTWP(settings->value("JVTWP"));
     this->doForwardJVTinMET(settings->retrieve("ForwardJVTinMETCalculation"));
     this->saveFailForwardJVTJets(settings->retrieve("SaveFailForwardJVTJets"));
     this->setfJVTWP(settings->value("ForwardJVTWP"));
     if (settings->value("ForwardJVTWP") == "Medium" && settings->retrieve("ForwardJVTinMETCalculation")){
       ATH_MSG_WARNING("TopConfig::setConfigSettings: fJVT WP set to Medium and fJVT in MET requested, MET working point will be changed to Tenacious to maintain compatibility with fJVT!!!");
     }
  
  
     this->largeRJetPtcut(std::stof(settings->value("LargeRJetPt")));
     this->largeRJetMasscut(std::stof(settings->value("LargeRJetMass")));
     this->largeRJetEtacut(std::stof(settings->value("LargeRJetEta")));
     
     
     // now get all substructure variables from the config file.
     std::string strSubstructure = settings->value("LargeRJetSubstructureVariables");
     // Making vector of strings with "," used as separator
     std::vector<std::string> helpvecStr;
     tokenize(strSubstructure, helpvecStr, ",");
  
     std::vector<std::string> vecSubstructure;
     // Removing empty spaces
     for (const std::string& x : helpvecStr) {
       std::istringstream istrSubstructure(x);
       std::copy(std::istream_iterator<std::string>(istrSubstructure),
                 std::istream_iterator<std::string>(), std::back_inserter(vecSubstructure));
     }
     // Making map
     for (const std::string&  key: vecSubstructure) {
       std::vector<std::string> pairs;
       tokenize(key,pairs,":");
       if(pairs.size() == 1) m_largeRJetSubstructureVariables[pairs[0]]=pairs[0];
       else if(pairs.size() == 2) m_largeRJetSubstructureVariables[pairs[0]]=pairs[1];
       else throw std::runtime_error {
         "TopConfig: Options in LargeRJetSubstructureVariables should be of the form \'x:y\' or \'y\'."
       };
     }
  
     this->largeRJetUncertainties_NPModel(settings->value("LargeRJetUncertainties_JESJERJMS_NPModel"));
     this->largeRJetUncertainties_JMR_NPModel(settings->value("LargeRJetUncertainties_JMR_NPModel"));
     this->largeRJetUncertaintiesConfigDir(settings->value("AdvancedUsage_LargeRJetUncertaintiesConfigDir"));
     this->largeRJESJMSConfig(settings->value("LargeRJESJMSConfig"));
  
     this->trackJetPtcut(std::stof(settings->value("TrackJetPt")));
     this->trackJetEtacut(std::stof(settings->value("TrackJetEta")));
     
     //Ghost track associated to jets quality
     this->ghostTrackspT(std::stof(settings->value("GhostTrackspT")));
     this->ghostTracksVertexAssociation(settings->value("GhostTracksVertexAssociation"));
     this->ghostTracksQuality(settings->value("GhostTracksQuality"));
  
     this->trackPtcut(std::stof(settings->value("TrackPt")));
     this->trackEtacut(std::stof(settings->value("TrackEta")));
     this->trackQuality(settings->value("TrackQuality"));
  
     // Jet configuration reclustered jets
     this->RCJetPtcut(std::stof(settings->value("RCJetPt")));
     this->RCJetEtacut(std::stof(settings->value("RCJetEta")));
     this->RCInputJetPtMin(std::stof(settings->value("RCInputJetPtMin")));
     this->RCInputJetEtaMax(std::stof(settings->value("RCInputJetEtaMax")));
     this->RCJetTrimcut(std::stof(settings->value("RCJetTrim")));
     this->RCJetRadius(std::stof(settings->value("RCJetRadius")));
     if (settings->value("UseRCJets") == "True" || settings->value("UseRCJets") == "true") this->m_useRCJets = true;
     if (settings->value("UseRCJetSubstructure") == "True" ||
         settings->value("UseRCJetSubstructure") == "true") this->m_useRCJetSubstructure = true;
     else this->m_useRCJetSubstructure = false;
  
     if (settings->value("UseRCJetAdditionalSubstructure") == "True" ||
         settings->value("UseRCJetAdditionalSubstructure") == "true") this->m_useRCJetAdditionalSubstructure = true;
     else this->m_useRCJetAdditionalSubstructure = false;
  
     this->VarRCJetPtcut(std::stof(settings->value("VarRCJetPt")));
     this->VarRCJetEtacut(std::stof(settings->value("VarRCJetEta")));
     this->VarRCJetTrimcut(std::stof(settings->value("VarRCJetTrim")));
     this->VarRCJetMaxRadius(std::stof(settings->value("VarRCJetMaxRadius")));
     this->VarRCJetRho(settings->value("VarRCJetRho"));
     this->VarRCJetMassScale(settings->value("VarRCJetMassScale"));
     if (settings->value("UseVarRCJets") == "True" ||
         settings->value("UseVarRCJets") == "true") this->m_useVarRCJets = true;
     if (settings->value("UseVarRCJetSubstructure") == "True" ||
         settings->value("UseVarRCJetSubstructure") == "true") this->m_useVarRCJetSubstructure = true;
     else this->m_useVarRCJetSubstructure = false;
     if (settings->value("UseVarRCJetAdditionalSubstructure") == "True" ||
         settings->value("UseVarRCJetAdditionalSubstructure") ==
         "true") this->m_useVarRCJetAdditionalSubstructure = true;
     else this->m_useVarRCJetAdditionalSubstructure = false;
  
     if (settings->value("StoreJetTruthLabels") == "False") {
       this->jetStoreTruthLabels(false);
     } else if (settings->value("StoreJetTruthLabels") == "True") {
       this->jetStoreTruthLabels(true);
     } else {
       ATH_MSG_WARNING("TopConfig::setConfigSettings: Unrecognized option for \"StoreJetTruthLabels\", assuming True");
       this->jetStoreTruthLabels(true);
     }
  
     // MET Configuration
     this->METUncertaintiesConfigDir(settings->value("AdvancedUsage_METUncertaintiesConfigDir"));
     // MET Significance
     if(settings->value("METSignificance") == "True"){this->METSignificance(true);}
     this->METSignifSoftTermParam(settings->value("METSignificanceSoftTermParam"));
     // MET JetSelection for NNJvt
     this->setMETJetSelectionWP(settings->value("METJetSelectionWP"));
  
     // for top mass analysis, per default set to 1.0!
     m_JSF = std::stof(settings->value("JSF"));
     m_bJSF = std::stof(settings->value("bJSF"));
  
     // If parameter exists remove electron crack veto
     if (settings->value("ElectronVetoLArCrack") == "False") this->removeElectronVetoLArCrack();
  
     // By default the top group does overlap removal on the tight lepton definitions
     // If you use this you are going off piste and need to report
     // your findings to the top reconstruction meeting
     if (settings->value("OverlapRemovalLeptonDef") == "Loose") this->setOverlapRemovalOnLooseLeptonDef();
  
     m_overlap_removal_procedure = settings->value("OverlapRemovalProcedure");
  
     // do overlap removal also with large-R jets
     // (using whatever procedure is used in the official tools)
     if (settings->value("LargeJetOverlapRemoval") == "True") {
       this->setLargeJetOverlapRemoval();// only usefull in case of MC
     }
  
     //do electron-electron overlap removal
     if (settings->value("EleEleOverlapRemoval") == "True"){
       this->setEleEleOverlapRemoval();
     }
  
     // In the *_Loose trees, lepton SFs are calculated considering
     // tight ID and isolation instead of loose
     // Only tight leptons are considered in the event SF calculation
     // only usefull in case of MC
     if (settings->value("ApplyTightSFsInLooseTree") == "True" && this->isMC()) this->setApplyTightSFsInLooseTree();
  
     // Apply Electron In Jet Subtraction - boosted analysis
     if (settings->value("ApplyElectronInJetSubtraction") == "True") this->setApplyElectronInJetSubtraction();
  
     // Set Number of events to run on (for testing)
     this->numberOfEventsToRun(std::stoi(settings->value("NEvents")));
  
     // Set Number of the first Event to run skip (for testing)
     this->numberOfEventsToSkip(std::stoi(settings->value("FirstEvent")));
  
     // [[[-----------------------------------------------
     //; Particle Level / Truth Configuration
     this->truth_electron_PtCut(std::stof(settings->value("TruthElectronPt")));
     this->truth_electron_EtaCut(std::stof(settings->value("TruthElectronEta")));
  
     this->truth_muon_PtCut(std::stof(settings->value("TruthMuonPt")));
     this->truth_muon_EtaCut(std::stof(settings->value("TruthMuonEta")));
     
     float truth_softmu_ptcut=4000.;
     try{
       truth_softmu_ptcut=std::stof(settings->value("TruthSoftMuonPt"));
     }
     catch (...) {
         throw std::runtime_error {
                 "TopConfig: can't convert provided TruthSoftMuonPt into float"
         };
     }
     
     float truth_softmu_etacut=2.5;
     try{
       truth_softmu_etacut=std::stof(settings->value("TruthSoftMuonEta"));
     }
     catch (...) {
         throw std::runtime_error {
                 "TopConfig: can't convert provided TruthSoftMuonEta into float"
         };
     }
     
     this->truth_softmuon_PtCut(truth_softmu_ptcut);
     this->truth_softmuon_EtaCut(truth_softmu_etacut);
  
     this->truth_photon_PtCut(std::stof(settings->value("TruthPhotonPt")));
     this->truth_photon_EtaCut(std::stof(settings->value("TruthPhotonEta")));
     // The TruthPhoton Origin and Isolation parameters are validated inside the
     // TopParticleLevel Loader Class.
     this->truth_photon_Origin(settings->value("TruthPhotonOrigin"));
     this->truth_photon_Isolation(settings->value("TruthPhotonIsolation"));
  
     this->truth_jet_PtCut(std::stof(settings->value("TruthJetPt")));
     this->truth_jet_EtaCut(std::stof(settings->value("TruthJetEta")));
  
     this->truth_jet_largeR_PtCut(std::stof(settings->value("TruthLargeRJetPt")));
     this->truth_jet_largeR_EtaCut(std::stof(settings->value("TruthLargeRJetEta")));
  
     this->truth_tau_PtCut(std::stof(settings->value("TruthTauPt")));
     this->truth_tau_EtaCut(std::stof(settings->value("TruthTauEta")));
  
     // -----------------------------------------------]]]
  
     // LHAPDF Reweighting configuration
     std::istringstream lha_pdf_ss(settings->value("LHAPDFSets"));
     std::copy(std::istream_iterator<std::string>(lha_pdf_ss),
               std::istream_iterator<std::string>(),
               std::back_inserter(m_lhapdf_options.pdf_set_names));
  
     // if provided, it will be used to recompute XF1,XF2 (if any is zero)
     const std::string LHAPDFBase = settings->value("LHAPDFBaseSet");
     if (LHAPDFBase.find_first_not_of(' ') != std::string::npos) {
       // should only set one base PDF set
       if (LHAPDFBase.find(' ') != std::string::npos)
         ATH_MSG_WARNING("LHAPDFBaseSet: " << LHAPDFBase << " -- only one PDF set allowed for recomputing XF1,XF2 !!!");
       m_lhapdf_options.baseLHAPDF = LHAPDFBase;
     }
     // if not already present, add to the list of PDF sets
     if (!m_lhapdf_options.baseLHAPDF.empty() &&
         !(std::find(m_lhapdf_options.pdf_set_names.begin(),
                     m_lhapdf_options.pdf_set_names.end(),
                     m_lhapdf_options.baseLHAPDF) !=
           m_lhapdf_options.pdf_set_names.end())) m_lhapdf_options.pdf_set_names.push_back(m_lhapdf_options.baseLHAPDF);
  
     if (m_lhapdf_options.pdf_set_names.size() && this->isMC()) m_lhapdf_options.doLHAPDF = true;
  
     if (m_lhapdf_options.pdf_set_names.size() && this->isMC() && settings->value("LHAPDFEventWeights") == "True") {
       m_lhapdf_options.save_per_event = true;
     } else if (m_lhapdf_options.pdf_set_names.size() && this->isMC() &&
                settings->value("LHAPDFEventWeights") == "Nominal") {
       m_lhapdf_options.save_per_event = true;
       m_lhapdf_options.doLHAPDFInNominalTrees = true;
     }
  
     // now get all Boosted jet taggers from the config file.
     std::string str_boostedJetTagger = settings->value("BoostedJetTagging");
     std::vector<std::string> helpvec_str;
     tokenize(str_boostedJetTagger, helpvec_str, ",");
  
     std::vector<std::string> vec_boostedJetTaggers;
  
     for (const std::string& x : helpvec_str) {
       std::istringstream istr_boostedJetTaggers(x);
       std::copy(std::istream_iterator<std::string>(istr_boostedJetTaggers),
                 std::istream_iterator<std::string>(), std::back_inserter(vec_boostedJetTaggers));
     }
  
     for (const std::string& tagger : vec_boostedJetTaggers) {
       std::vector<std::string> helpvec;
       tokenize(tagger, helpvec, ":");
       if (helpvec.size() != 2) throw std::runtime_error {
                 "TopConfig: Options in BoostedJetTagging should be of the form \'x:y\' where x is tagging type and y is shortened tagger name."
         };
       m_chosen_boostedJetTaggers.push_back(std::make_pair(helpvec[0], helpvec[1]));
     }
  
     m_btagging_cdi_path = settings->value("BTagCDIPath");
  
     // now get all Btagging WP from the config file, and store them properly in a map.
     // Need function to compare the cut value with the WP and vice versa
     parse_bTagWPs(settings->value("BTaggingCaloJetWP"), m_btagAlgoWP_calib_caloJet, m_btagWP_calib_caloJet);
     parse_bTagWPs(settings->value("BTaggingCaloJetUncalibWP"), m_btagAlgoWP_caloJet, m_btagWP_caloJet);
     parse_bTagWPs(settings->value("BTaggingTrackJetWP"), m_btagAlgoWP_calib_trkJet, m_btagWP_calib_trkJet);
     parse_bTagWPs(settings->value("BTaggingTrackJetUncalibWP"), m_btagAlgoWP_trkJet, m_btagWP_trkJet);
  
     // below variables store all WPs for btag decision, both calibrated and uncalibrated
     // therefore copy the calibrated WPs into the list of all WPs
     m_btagAlgoWP_caloJet.insert(m_btagAlgoWP_caloJet.end(), m_btagAlgoWP_calib_caloJet.begin(), m_btagAlgoWP_calib_caloJet.end());
     m_btagAlgoWP_trkJet.insert(m_btagAlgoWP_trkJet.end(), m_btagAlgoWP_calib_trkJet.begin(), m_btagAlgoWP_calib_trkJet.end());
     m_btagWP_caloJet.insert(m_btagWP_caloJet.end(), m_btagWP_calib_caloJet.begin(), m_btagWP_calib_caloJet.end());
     m_btagWP_trkJet.insert(m_btagWP_trkJet.end(), m_btagWP_calib_trkJet.begin(), m_btagWP_calib_trkJet.end());
  
     remove_duplicates(m_btagWP_caloJet);
     remove_duplicates(m_btagWP_trkJet);
     remove_duplicates(m_btagAlgoWP_caloJet);
     remove_duplicates(m_btagAlgoWP_trkJet);
  
     auto print_btag_WPs = [](const std::vector<std::string> &WPlist) {
       for (const std::string &WP : WPlist)
         ATH_MSG_INFO("BTagging algorithm: " << WP);
     };
     ATH_MSG_INFO("The following b-tagging WPs are configured for tagging decision for " << m_sgKeyJets);
     print_btag_WPs(m_btagWP_caloJet);
     ATH_MSG_INFO("Out of those, the calibration SFs will be computed for following WPs:");
     print_btag_WPs(m_btagWP_calib_caloJet);
     if (m_useTrackJets) {
       ATH_MSG_INFO("The following b-tagging WPs are configured for tagging decision for " << m_sgKeyTrackJets);
       print_btag_WPs(m_btagWP_trkJet);
       ATH_MSG_INFO("Out of those, the calibration SFs will be computed for following WPs:");
       print_btag_WPs(m_btagWP_calib_trkJet);
     }
  
     m_btagging_calibration_B = settings->value("BTaggingCalibrationB");
     m_btagging_calibration_C = settings->value("BTaggingCalibrationC");
     m_btagging_calibration_Light = settings->value("BTaggingCalibrationLight");
     m_bTagSystsExcludedFromEV = settings->value("BTaggingSystExcludedFromEV");
  
     // egamma calibration model
     m_egamma_calibration_model = settings->value("EGammaCalibrationModel");
  
     // Set translatio ndictionary for MCMC maps
     if (settings->value("RedefineMCMCMap") != " ") {
       std::vector<std::string> tmp;
       tokenize(settings->value("RedefineMCMCMap"), tmp, ",");
       for (const std::string& dictionaries : tmp) {
         std::vector<std::string> dictionary;
         tokenize(dictionaries, dictionary, ":");
         if (dictionary.size() != 2) {
           throw std::invalid_argument{"Wrong input argument for RedefineMCMCMap. Expected format is: \"shower1:shower2,shower3:shower4\""};
         }
  
         m_showerMCMCtranslator.insert({dictionary.at(0), dictionary.at(1)});
       }
     }
  
     /************************************************************
      *
      * Loop through all suplied config files and make into a
      * vector if we have at least one config and at least one
      * lumi calc file (and is MC) then apply PU reweighting
      * Note: PathResolving done in TopCPTools.
      *
      ***********************************************************/
  
     std::istringstream pileup_config_ss(settings->value("PRWConfigFiles"));
     std::copy(std::istream_iterator<std::string>(pileup_config_ss),
               std::istream_iterator<std::string>(),
               std::back_inserter(m_pileup_reweighting.config_files));
  
     std::istringstream pileup_lumi_ss(settings->value("PRWLumiCalcFiles"));
     std::copy(std::istream_iterator<std::string>(pileup_lumi_ss),
               std::istream_iterator<std::string>(),
               std::back_inserter(m_pileup_reweighting.lumi_calc_files));
  
     std::istringstream pileup_config_FS_ss(settings->value("PRWConfigFiles_FS"));
     std::copy(std::istream_iterator<std::string>(pileup_config_FS_ss),
               std::istream_iterator<std::string>(),
               std::back_inserter(m_pileup_reweighting.config_files_FS));
  
     std::istringstream pileup_config_AF_ss(settings->value("PRWConfigFiles_AF"));
     std::copy(std::istream_iterator<std::string>(pileup_config_AF_ss),
               std::istream_iterator<std::string>(),
               std::back_inserter(m_pileup_reweighting.config_files_AF));
  
     std::istringstream actual_mu_FS_ss(settings->value("PRWActualMu_FS"));
     std::copy(std::istream_iterator<std::string>(actual_mu_FS_ss),
               std::istream_iterator<std::string>(),
               std::back_inserter(m_pileup_reweighting.actual_mu_FS));
  
     std::istringstream actual_mu_AF_ss(settings->value("PRWActualMu_AF"));
     std::copy(std::istream_iterator<std::string>(actual_mu_AF_ss),
               std::istream_iterator<std::string>(),
               std::back_inserter(m_pileup_reweighting.actual_mu_AF));
  
     m_pileup_reweighting.unrepresented_data_tol = std::stof(settings->value("PRWUnrepresentedDataTolerance"));
  
     m_pileup_reweighting.mu_dependent = (settings->value("PRWMuDependent") == "True");
  
     // now even if the user don't provide a PRWConfigFiles, PRW is done on MC, using the default calibration file
     if (m_pileup_reweighting.lumi_calc_files.size() > 0) {
       m_pileup_reweighting.apply = true;
     }
  
     if (m_pileup_reweighting.apply && m_grlFile.size() > 0 &&
         settings->value("PRWUseGRLTool") == "True") m_pileup_reweighting.use_grl_tool = true;
  
     // if provided, using custom Data Scale-Factors for pile-up reweighting
     // nominal:up:down
     // also allowing to specify under this form: 1/1.2:1.0:1/1.4
     if (m_pileup_reweighting.apply && settings->value("PRWCustomScaleFactor") != " ") {
       std::vector<std::string> SFs_tokens;
       tokenize(settings->value("PRWCustomScaleFactor"), SFs_tokens, ":");
       if (SFs_tokens.size() != 3) throw std::runtime_error {
                 "TopConfig: Option PRWCustomScaleFactor should be of the form \'nominal:up:down\'"
         };
       try {
         std::vector<std::string> nomSF_tokens;
         tokenize(SFs_tokens[0], nomSF_tokens, "/");
         if (nomSF_tokens.size() == 1) m_pileup_reweighting.custom_SF.push_back(std::stof(nomSF_tokens[0]));
         else if (nomSF_tokens.size() == 2) m_pileup_reweighting.custom_SF.push_back(std::stof(
                                                                                       nomSF_tokens[0]) /
                                                                                     std::stof(nomSF_tokens[1]));
         else throw std::runtime_error {
                   "TopConfig: issue in division"
           };
       } catch (...) {
         throw std::runtime_error {
                 "TopConfig: can't convert provided PRW nominal Data SF into float"
         };
       }
       try {
         std::vector<std::string> upSF_tokens;
         tokenize(SFs_tokens[1], upSF_tokens, "/");
         if (upSF_tokens.size() == 1) m_pileup_reweighting.custom_SF.push_back(std::stof(upSF_tokens[0]));
         else if (upSF_tokens.size() == 2) m_pileup_reweighting.custom_SF.push_back(std::stof(
                                                                                      upSF_tokens[0]) /
                                                                                    std::stof(upSF_tokens[1]));
         else throw std::runtime_error {
                   "TopConfig: issue in division"
           };
       } catch (...) {
         throw std::runtime_error {
                 "TopConfig: can't convert provided PRW up Data SF into float"
         };
       }
       try {
         std::vector<std::string> downSF_tokens;
         tokenize(SFs_tokens[2], downSF_tokens, "/");
         if (downSF_tokens.size() == 1) m_pileup_reweighting.custom_SF.push_back(std::stof(downSF_tokens[0]));
         else if (downSF_tokens.size() == 2) m_pileup_reweighting.custom_SF.push_back(std::stof(
                                                                                        downSF_tokens[0]) /
                                                                                      std::stof(downSF_tokens[1]));
         else throw std::runtime_error {
                   "TopConfig: issue in division"
           };
       } catch (...) {
         throw std::runtime_error {
                 "TopConfig: can't convert provided PRW down Data SF into float"
         };
       }
       ATH_MSG_INFO("Custom PRW scale-factors - nominal:" << SFs_tokens[0] << "=" << m_pileup_reweighting.custom_SF[0] <<
         " up:" << SFs_tokens[1] << "=" << m_pileup_reweighting.custom_SF[1] << " down:" << SFs_tokens[2] << "=" <<
         m_pileup_reweighting.custom_SF[2]);
     }
  
     if (m_pileup_reweighting.apply && settings->value("PRWPeriodAssignments") != " ") {
       std::vector<std::string> period_tokens;
       tokenize(settings->value("PRWPeriodAssignments"), period_tokens, ":");
       if (period_tokens.size() % 3 != 0) {
         throw std::invalid_argument(
                 "TopConfig: Option PRWPeriodAssignments requires values in the form of \'value:value:value\'. The number of values needs to be divisible by 3.");
       }
       try {
         for (const std::string& per : period_tokens) {
           m_pileup_reweighting.periodAssignments.emplace_back(std::stoi(per));
         }
       } catch (...) {
         throw std::invalid_argument(
                 "TopConfig: Cannot convert the strings into integers for the run numbers in Option PRWPeriodAssignments");
       }
     }
  
     // TRUTH derivations do not contain pile-up weights
     if (m_isTruthDxAOD) m_pileup_reweighting.apply = false;
  
  
     //Switch off PRW for MC samples with data overlay
     if(m_isDataOverlay) m_pileup_reweighting.apply = false;
  
     const std::string randomRunNumberSetting = settings->value("ForceRandomRunNumber");
     if (randomRunNumberSetting != " ") {
       unsigned int randomRunNumber(0);
       try {
         randomRunNumber = std::stoul(randomRunNumberSetting);
       } catch (...) {
         throw std::invalid_argument{"ForceRandomRunNumber cannot be converted to an integer"};
       }
  
       if (randomRunNumber < 1 || randomRunNumber > 999999) {
         throw std::invalid_argument{"ForceRandomRunNumber cannot be smaller than 0 or larger than 999999"};
       }
       // disable PRW
       m_pileup_reweighting.apply = false;
       this->setForceRandomRunNumber(randomRunNumber);
     }
  
     const std::string isRun3 = settings->value("IsRun3");
     this->setIsRun3(isRun3 == "True");
  
     m_trigMatchElemRelink = settings->retrieve("TriggerMatchingElementRelinking");
  
     if (settings->value("DemandPrimaryVertex") == "False")
       m_demandPriVtx = false;
  
     m_KLFitterTransferFunctionsPath = settings->value("KLFitterTransferFunctionsPath");
     m_KLFitterOutput = settings->value("KLFitterOutput");
     m_KLFitterJetSelectionMode = settings->value("KLFitterJetSelectionMode");
     m_KLFitterBTaggingMethod = settings->value("KLFitterBTaggingMethod");
     m_KLFitterLH = settings->value("KLFitterLH");
  
     if (settings->value("KLFitterTopMassFixed") == "True") m_KLFitterTopMassFixed = true;
     if (settings->value("KLFitterTopMassFixed") == "False") m_KLFitterTopMassFixed = false;
     if (settings->value("KLFitterSaveAllPermutations") == "True") m_KLFitterSaveAllPermutations = true;
     if (settings->value("KLFitterSaveAllPermutations") == "False") m_KLFitterSaveAllPermutations = false;
     if (settings->value("KLFitterFailOnLessThanXJets") == "True") m_KLFitterFailOnLessThanXJets = true;
     if (settings->value("KLFitterFailOnLessThanXJets") == "False") m_KLFitterFailOnLessThanXJets = false;
  
     //--- Check for configuration on the global lepton triggers ---//
     if (settings->value("UseGlobalLeptonTriggerSF") == "True") {
       auto parseTriggerString =
         [settings](std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >& triggersByPeriod,
                    std::string const& key) {
           /* parse a string of the form "2015@triggerfoo,triggerbar,... 2016@triggerfoo,triggerbaz,... ..." */
           std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > result;
           std::vector<std::string> pairs;
           boost::split(pairs, settings->value(key), boost::is_any_of(" "));
           for (std::string const& pair : pairs) {
             if (pair.empty() || pair == "None") continue;
             auto i = pair.find('@');
             if (!(i != std::string::npos &&
                   pair.find('@', i + 1) == std::string::npos)) throw std::invalid_argument(
                       std::string() + "Malformed trigger list in configuration item `" + key + "'");
             auto&& period = pair.substr(0, i), triggerstr = pair.substr(i + 1);
             auto&& triggers = result[period];
             if (!triggers.empty()) throw std::invalid_argument(
                       std::string() + "Period `" + period + "' appears multiple times in configuration item `" + key +
                       "'");
  
             // get the vector of strings split by ","
             std::vector<std::string> tmp;
             for (const auto& i : triggers) {
               tmp.push_back(i.first);
             }
             boost::split(tmp, triggerstr, boost::is_any_of(","));
             // attach a dummy 1 to the pair
             std::vector<std::pair<std::string, int> > modified;
             for (const auto& i : tmp) {
               modified.emplace_back(i, 1);
             }
  
             // pass it to the triggers vector
             std::swap(triggers, modified);
           }
           /* merge trigger map from this configuration line into triggersByPeriod */
           for (auto&& kv : result) {
             auto&& src = kv.second;
             auto&& dst = triggersByPeriod[kv.first];
             for (std::pair<std::string, int> const& trigger : src) {
               if (std::find(dst.begin(), dst.end(),
                             trigger) != dst.end()) throw std::invalid_argument(
                         std::string() + "Trigger `" + trigger.first + "' was specified multiple times");
               dst.push_back(trigger);
             }
           }
         };
       m_trigGlobalConfiguration.isActivated = true;
       parseTriggerString(m_trigGlobalConfiguration.trigger, "ElectronTriggers");
       parseTriggerString(m_trigGlobalConfiguration.trigger_loose, "ElectronTriggersLoose");
       parseTriggerString(m_trigGlobalConfiguration.trigger, "MuonTriggers");
       parseTriggerString(m_trigGlobalConfiguration.trigger_loose, "MuonTriggersLoose");
       parseTriggerString(m_trigGlobalConfiguration.trigger, "GlobalTriggers");
       parseTriggerString(m_trigGlobalConfiguration.trigger_loose, "GlobalTriggersLoose");
     }
   }

◆ setDerivationStream()

void top::TopConfig::setDerivationStream ( const std::string & value )

inline

Definition at line 183 of file TopConfig.h.

                                                             {
       if (!m_configFixed) {
         m_derivationStream = value;
       }
     }

◆ setDSID()

void top::TopConfig::setDSID ( unsigned int value )

inline

Definition at line 190 of file TopConfig.h.

                                             {
       // Check here if this is a sherpa 2.2 V+jets sample
       // (see below to set DSIDs)
       setIsSherpa22Vjets(value);
       m_DSID = value;
     }

◆ setEleEleOverlapRemoval()

void top::TopConfig::setEleEleOverlapRemoval ( )

inline

Definition at line 287 of file TopConfig.h.

                                           {
       if (!m_configFixed) {
         m_doEleEleOverlapRemoval = true;
       }
     }

◆ setFakesMMConfigIFF()

void top::TopConfig::setFakesMMConfigIFF ( const std::string & configIFF )

inline

Definition at line 242 of file TopConfig.h.

243 {m_FakesMMConfigIFF = configIFF;}

◆ setFakesMMIFFDebug()

void top::TopConfig::setFakesMMIFFDebug ( )

inline

Definition at line 244 of file TopConfig.h.

245 {m_doFakesMMIFFDebug = true;}

◆ setFakesMMWeightsCalculationIFF()

void top::TopConfig::setFakesMMWeightsCalculationIFF ( )

inline

Definition at line 240 of file TopConfig.h.

241 {m_doFakesMMWeightsIFF = true;}

◆ setFilterBranches()

void top::TopConfig::setFilterBranches ( const std::vector< std::string > & value )

inline

Definition at line 135 of file TopConfig.h.

                                                                      {
       if (!m_configFixed) {
         m_filterBranches = value;
       }
     }

◆ setFilterNominalBranches()

void top::TopConfig::setFilterNominalBranches ( const std::vector< std::string > & value )

inline

Definition at line 167 of file TopConfig.h.

                                                                             {
       if (!m_configFixed) {
         m_filterNominalBranches = value;
       }
     }

◆ setFilterNominalLooseBranches()

void top::TopConfig::setFilterNominalLooseBranches ( const std::vector< std::string > & value )

inline

Definition at line 159 of file TopConfig.h.

                                                                                  {
       if (!m_configFixed) {
         m_filterNominalLooseBranches = value;
       }
     }

◆ setFilterParticleLevelBranches()

void top::TopConfig::setFilterParticleLevelBranches ( const std::vector< std::string > & value )

inline

Definition at line 151 of file TopConfig.h.

                                                                                   {
       if (!m_configFixed) {
         m_filterParticleLevelBranches = value;
       }
     }

◆ setFilterPartonLevelBranches()

void top::TopConfig::setFilterPartonLevelBranches ( const std::vector< std::string > & value )

inline

Definition at line 143 of file TopConfig.h.

                                                                                 {
       if (!m_configFixed) {
         m_filterPartonLevelBranches = value;
       }
     }

◆ setfJVTWP()

void top::TopConfig::setfJVTWP ( const std::string & value )

inline

Definition at line 1585 of file TopConfig.h.

1585 {m_fJVTWP = value;}

◆ setForceRandomRunNumber()

void top::TopConfig::setForceRandomRunNumber ( const unsigned int randomRunNumber )

inline

Definition at line 1988 of file TopConfig.h.

1988 {m_forceRandomRunNumber = randomRunNumber;}

◆ setGlobalTriggerConfiguration()

void top::TopConfig::setGlobalTriggerConfiguration	(	std::vector< std::string >	electron_trigger_systematics,
		std::vector< std::string >	muon_trigger_systematics,
		std::vector< std::string >	photon_trigger_systematics,
		std::vector< std::string >	electron_tool_names,
		std::vector< std::string >	muon_tool_names,
		std::vector< std::string >	photon_tool_names
	)

Definition at line 3923 of file TopConfig.cxx.

                                                  {
     m_trigGlobalConfiguration.electron_trigger_systematics = electron_trigger_systematics;
     m_trigGlobalConfiguration.muon_trigger_systematics = muon_trigger_systematics;
     m_trigGlobalConfiguration.photon_trigger_systematics = photon_trigger_systematics;
     m_trigGlobalConfiguration.electron_trigger_tool_names = electron_tool_names;
     m_trigGlobalConfiguration.muon_trigger_tool_names = muon_tool_names;
     m_trigGlobalConfiguration.photon_trigger_tool_names = photon_tool_names;
     m_trigGlobalConfiguration.isConfigured = true;
     return;
   }

◆ setGrlDir()

void top::TopConfig::setGrlDir ( const std::string & s )

Definition at line 1920 of file TopConfig.cxx.

                                               {
     if (!m_configFixed) {
       m_grlDir = s;
       m_grlDir.erase(remove_if(m_grlDir.begin(), m_grlDir.end(), isspace), m_grlDir.end());
     }
   }

◆ setGrlFile()

void top::TopConfig::setGrlFile ( const std::string & s )

Definition at line 1927 of file TopConfig.cxx.

                                                {
     if (!m_configFixed) {
       std::istringstream grl_files_ss(s);
       std::vector<std::string> temp_grls = {};
       std::copy(std::istream_iterator<std::string>(grl_files_ss),
                 std::istream_iterator<std::string>(),
                 std::back_inserter(temp_grls));
       // m_grlFile = s;
       for (std::string grl : temp_grls) {
         grl.erase(remove_if(grl.begin(), grl.end(), isspace), grl.end());
         m_grlFile.push_back(grl);
       }
     }
   }

◆ setIsAFII()

void top::TopConfig::setIsAFII ( const bool value )

inline

Definition at line 119 of file TopConfig.h.

                                             {
       if (!m_configFixed) {
         m_isAFII = value;
       }
     }

◆ setIsDataOverlay()

void top::TopConfig::setIsDataOverlay ( const bool value )

inline

Definition at line 127 of file TopConfig.h.

                                                    {
       if (!m_configFixed) {
         m_isDataOverlay = value;
       }
     }

◆ setIsMC()

void top::TopConfig::setIsMC ( const bool value )

inline

Definition at line 111 of file TopConfig.h.

                                           {
       if (!m_configFixed) {
         m_isMC = value;
       }
     }

◆ setIsRun3()

void top::TopConfig::setIsRun3 ( const bool isRun3 )

inline

Definition at line 1991 of file TopConfig.h.

1991 {m_isRun3 = isRun3;}

◆ setIsSherpa22Vjets()

void top::TopConfig::setIsSherpa22Vjets ( unsigned int dsid )

inline

Definition at line 200 of file TopConfig.h.

                                                       {
       // m_is_sherpa_22_vjets = false by default
       // Sherpa 2.2 W+jets (from TopDataPrep)
       if (dsid >= 363331 && dsid <= 363354) m_is_sherpa_22_vjets = true;
       if (dsid >= 363436 && dsid <= 363483) m_is_sherpa_22_vjets = true;
       // Sherpa 2.2 Z+jets (from TopDataPrep)
       if (dsid >= 363102 && dsid <= 363122) m_is_sherpa_22_vjets = true;
       if (dsid >= 363361 && dsid <= 363435) m_is_sherpa_22_vjets = true;
     }

◆ setIsTruthDxAOD()

void top::TopConfig::setIsTruthDxAOD ( const bool value )

inline

Definition at line 175 of file TopConfig.h.

                                                   {
       if (!m_configFixed) {
         m_isTruthDxAOD = value;
       }
     }

◆ setJetResponseMatchingDeltaR()

void top::TopConfig::setJetResponseMatchingDeltaR ( const float value )

inline

Definition at line 572 of file TopConfig.h.

572 {m_jetResponseMatchingDeltaR = value;}

◆ setJVTWP()

void top::TopConfig::setJVTWP ( const std::string & value )

inline

Definition at line 1567 of file TopConfig.h.

1567 {m_JVTWP = value;}

◆ setKLFitter()

void top::TopConfig::setKLFitter ( )

inline

Definition at line 428 of file TopConfig.h.

                               {
       if (!m_configFixed) {
         m_doKLFitter = true;
       }
     }

◆ setLargeJetOverlapRemoval()

void top::TopConfig::setLargeJetOverlapRemoval ( )

inline

Definition at line 278 of file TopConfig.h.

                                             {
       if (!m_configFixed) {
         m_doLargeJetOverlapRemoval = true;
       }
     }

◆ setMapIndex()

void top::TopConfig::setMapIndex ( unsigned int value )

inline

Definition at line 212 of file TopConfig.h.

212 {m_MapIndex = value;}

◆ setMCGeneratorWeights()

void top::TopConfig::setMCGeneratorWeights ( )

inline

Definition at line 341 of file TopConfig.h.

                                         {
       if (!m_configFixed) {
         m_doMCGeneratorWeights = true;
       }
     }

◆ setMCGeneratorWeightsInNominalTrees()

void top::TopConfig::setMCGeneratorWeightsInNominalTrees ( )

inline

Definition at line 349 of file TopConfig.h.

                                                       {
       if (!m_configFixed) {
         m_doMCGeneratorWeightsInNominalTrees = true;
       }
     }

◆ setMETJetSelectionWP()

void top::TopConfig::setMETJetSelectionWP ( const std::string & value )

inline

Definition at line 1614 of file TopConfig.h.

1614 {m_METJetSelectionWP = value;};

◆ setNominalAvailable()

virtual void top::TopConfig::setNominalAvailable ( const bool s )

inlinevirtual

Definition at line 2152 of file TopConfig.h.

2152 {m_isNominalAvailable = s;}

◆ setNominalWeightIndex()

void top::TopConfig::setNominalWeightIndex ( size_t index )

inline

Definition at line 359 of file TopConfig.h.

                                                     {
       m_nominalWeightIndex = index;
     }

◆ setNominalWeightName()

void top::TopConfig::setNominalWeightName ( const std::string & name )

inline

Definition at line 356 of file TopConfig.h.

                                                             {
       m_nominalWeightName = name;
     }

◆ setNumberOfBootstrapReplicas()

void top::TopConfig::setNumberOfBootstrapReplicas ( const int value )

inline

Definition at line 2129 of file TopConfig.h.

2129 {m_BootstrapReplicas = value;}

◆ setOverlapRemovalOnLooseLeptonDef()

void top::TopConfig::setOverlapRemovalOnLooseLeptonDef ( )

inline

Definition at line 259 of file TopConfig.h.

                                                     {
       if (!m_configFixed) {
         m_doOverlapRemovalOnLooseLeptonDef = true;
       }
     }

◆ setParticleLevelOverlapRemovalElJet()

void top::TopConfig::setParticleLevelOverlapRemovalElJet ( bool value )

inline

Definition at line 408 of file TopConfig.h.

                                                                 {
       if (!m_configFixed) {
         m_doParticleLevelOverlapRemovalElJet = value;
       }
     }

◆ setParticleLevelOverlapRemovalJetPhoton()

void top::TopConfig::setParticleLevelOverlapRemovalJetPhoton ( bool value )

inline

Definition at line 414 of file TopConfig.h.

                                                                     {
       if (!m_configFixed) {
         m_doParticleLevelOverlapRemovalJetPhoton = value;
       }
     }

◆ setParticleLevelOverlapRemovalMuJet()

void top::TopConfig::setParticleLevelOverlapRemovalMuJet ( bool value )

inline

Definition at line 402 of file TopConfig.h.

                                                                 {
       if (!m_configFixed) {
         m_doParticleLevelOverlapRemovalMuJet = value;
       }
     }

◆ setParticleLevelOverlapRemovalWithRapidity()

void top::TopConfig::setParticleLevelOverlapRemovalWithRapidity ( bool value )

inline

Definition at line 420 of file TopConfig.h.

                                                                       {
       if(!m_configFixed){
         m_useParticleLevelOverlapRemovalWithRapidity = value;
       }
     }

◆ setPrintCDIpathWarning()

void top::TopConfig::setPrintCDIpathWarning ( bool flag )

inline

Definition at line 1936 of file TopConfig.h.

1937 {m_cdi_path_warning = flag;}

◆ setPrintEgammaCalibModelWarning()

void top::TopConfig::setPrintEgammaCalibModelWarning ( bool flag )

inline

Definition at line 1950 of file TopConfig.h.

1951 {m_egamma_calibmodel_warning = flag;}

◆ setPrintEIDFileWarning()

void top::TopConfig::setPrintEIDFileWarning ( bool flag )

inline

Definition at line 952 of file TopConfig.h.

953 {m_eid_path_warning = flag;}

◆ setPseudoTop()

void top::TopConfig::setPseudoTop ( )

inline

Definition at line 446 of file TopConfig.h.

                                {
       if (!m_configFixed) {
         m_doPseudoTop = true;
       }
     }

◆ setReleaseSeries()

void top::TopConfig::setReleaseSeries ( )

Definition at line 3840 of file TopConfig.cxx.

                                    {
     // Method taken from TopCPTools
     std::string release_series = "";
     const char* rel_temp = std::getenv("ROOTCORE_RELEASE_SERIES");
     if (rel_temp) {
       release_series = std::string(rel_temp);
     } else {
       release_series = "";
     }
  
     if (release_series == "23") {
       m_release_series = 23; // 2.3
     } else if (release_series == "24") {
       m_release_series = 24; // 2.4 R20.7
     } else if (release_series == "25") {
       m_release_series = 25; // 2.6 R21
     } else {
       // Default to R21 because this build has moved away from ROOTCORE
       m_release_series = 25;
     }
     return;
   }

◆ setSaveBootstrapWeights()

void top::TopConfig::setSaveBootstrapWeights ( const bool value )

inline

Definition at line 2127 of file TopConfig.h.

2127 {m_saveBootstrapWeights = value;}

◆ setShoweringAlgorithm()

void top::TopConfig::setShoweringAlgorithm ( SampleXsection::showering in )

inline

Definition at line 74 of file TopConfig.h.

74 { m_showeringAlgo=in; }

◆ setTDPPath()

void top::TopConfig::setTDPPath ( const std::string & s )

Definition at line 1942 of file TopConfig.cxx.

                                                {
     if (!m_configFixed) {
       m_topDataPreparationPath = s;
     }
   }

◆ setTopParticleLevel()

void top::TopConfig::setTopParticleLevel ( bool in )

inline

Definition at line 392 of file TopConfig.h.

                                              {
       if (!m_configFixed) {
         m_doTopParticleLevel = in;
       }
     }

◆ setTopPartonHistory()

void top::TopConfig::setTopPartonHistory ( )

inline

Definition at line 368 of file TopConfig.h.

                                       {
       if (!m_configFixed) {
         m_doTopPartonHistory = true;
       }
     }

◆ setTopPartonHistoryRegisteredInNtuple()

void top::TopConfig::setTopPartonHistoryRegisteredInNtuple ( )

inline

Definition at line 380 of file TopConfig.h.

381 {m_isTopPartonHistoryRegisteredInNtuple = true;}

◆ setTopPartonLevel()

void top::TopConfig::setTopPartonLevel ( bool in )

inline

Definition at line 384 of file TopConfig.h.

                                            {
       if (!m_configFixed) {
         m_doTopPartonLevel = in;
       }
     }

◆ SetTriggersToYear()

void top::TopConfig::SetTriggersToYear ( const bool isMC )

Definition at line 3901 of file TopConfig.cxx.

                                                    {
     if (m_year == "UNKNOWN") return;
  
     std::string year2("");
     if (isMC && m_year == "2015") year2 = "2016";
     if (isMC && m_year == "2016") year2 = "2015";
  
     auto removeYears = [](std::unordered_map<std::string,std::vector<std::pair<std::string, int> > >& trig, const std::string& year1, const std::string& year2) {
       auto itr = trig.begin();
       while (itr != trig.end()) {
         if ((*itr).first != year1 && (*itr).first != year2) {
           itr = trig.erase(itr);
         } else {
           itr++;
         }
       }
     };
  
     removeYears(m_trigGlobalConfiguration.trigger, m_year, year2);
     removeYears(m_trigGlobalConfiguration.trigger_loose, m_year, year2);
   }

◆ setTruthBlockInfo()

void top::TopConfig::setTruthBlockInfo ( )

inline

Definition at line 317 of file TopConfig.h.

                                     {
       if (!m_configFixed) {
         m_doTruthBlockInfo = true;
       }
     }

◆ setTruthPDFInfo()

void top::TopConfig::setTruthPDFInfo ( )

inline

Definition at line 325 of file TopConfig.h.

                                   {
       if (!m_configFixed) {
         m_doTruthPDFInfo = true;
       }
     }

◆ setTruthPDFInfoInNominalTrees()

void top::TopConfig::setTruthPDFInfoInNominalTrees ( )

inline

Definition at line 333 of file TopConfig.h.

                                                 {
       if (!m_configFixed) {
         m_doTruthPDFInfoInNominalTrees = true;
       }
     }

◆ sgKeyElectrons() [3/3]

void top::TopConfig::sgKeyElectrons ( const std::string & s )

virtual

Definition at line 2004 of file TopConfig.cxx.

                                                    {
     if (!m_configFixed) {
       m_useElectrons = false;
       if (s != "None") m_useElectrons = true;
  
       m_sgKeyElectrons = s;
     }
   }

◆ sgKeyElectronsStandAlone()

const std::string & top::TopConfig::sgKeyElectronsStandAlone ( const std::size_t hash ) const

virtual

Definition at line 2999 of file TopConfig.cxx.

                                                                                  {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapElectrons->find(hash);
     if (key != m_systAllSgKeyMapElectrons->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyElectronsTDS()

const std::string & top::TopConfig::sgKeyElectronsTDS ( const std::size_t hash ) const

Definition at line 2959 of file TopConfig.cxx.

                                                                           {
     if (!m_applyElectronInJetSubtraction) {
       std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapElectronsTDS->find(hash);
       if (key != m_systAllSgKeyMapElectronsTDS->end()) {
         return (*key).second;
       }
     }
  
     if (m_applyElectronInJetSubtraction) {
       std::unordered_map<std::size_t,
                          std::string>::const_iterator key =
         m_systAllSgKeyMapElectrons_electronInJetSubtractionTDS->find(hash);
       if (key != m_systAllSgKeyMapElectrons_electronInJetSubtractionTDS->end()) {
         return (*key).second;
       }
     }
  
     return m_sgKeyDummy;
   }

◆ sgKeyElectronsTDSAux()

const std::string & top::TopConfig::sgKeyElectronsTDSAux ( const std::size_t hash ) const

Definition at line 2979 of file TopConfig.cxx.

                                                                              {
     if (!m_applyElectronInJetSubtraction) {
       std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapElectronsTDSAux->find(hash);
       if (key != m_systAllSgKeyMapElectronsTDSAux->end()) {
         return (*key).second;
       }
     }
  
     if (m_applyElectronInJetSubtraction) {
       std::unordered_map<std::size_t,
                          std::string>::const_iterator key =
         m_systAllSgKeyMapElectrons_electronInJetSubtractionTDSAux->find(hash);
       if (key != m_systAllSgKeyMapElectrons_electronInJetSubtractionTDSAux->end()) {
         return (*key).second;
       }
     }
  
     return m_sgKeyDummy;
   }

◆ sgKeyEventInfo()

const std::string& top::TopConfig::sgKeyEventInfo ( ) const

inline

Definition at line 574 of file TopConfig.h.

574 {return m_sgKeyEventInfo;}

◆ sgKeyFwdElectrons() [1/3]

virtual const std::string& top::TopConfig::sgKeyFwdElectrons ( ) const

inlinevirtual

Definition at line 578 of file TopConfig.h.

578 {return m_sgKeyFwdElectrons;}

◆ sgKeyFwdElectrons() [2/3]

const std::string & top::TopConfig::sgKeyFwdElectrons ( const std::size_t hash ) const

virtual

Definition at line 3007 of file TopConfig.cxx.

                                                                           {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapFwdElectrons->find(hash);
     if (key != m_systAllSgKeyMapFwdElectrons->end()) {
       return (*key).second;
     }
  
     return m_sgKeyDummy;
   }

◆ sgKeyFwdElectrons() [3/3]

void top::TopConfig::sgKeyFwdElectrons ( const std::string & s )

virtual

Definition at line 2013 of file TopConfig.cxx.

                                                       {
     if (!m_configFixed) {
       m_useFwdElectrons = false;
       if (s != "None") m_useFwdElectrons = true;
  
       m_sgKeyFwdElectrons = s;
     }
   }

◆ sgKeyFwdElectronsStandAlone()

const std::string & top::TopConfig::sgKeyFwdElectronsStandAlone ( const std::size_t hash ) const

virtual

Definition at line 3034 of file TopConfig.cxx.

                                                                                     {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapFwdElectrons->find(hash);
     if (key != m_systAllSgKeyMapFwdElectrons->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyFwdElectronsTDS()

const std::string & top::TopConfig::sgKeyFwdElectronsTDS ( const std::size_t hash ) const

Definition at line 3016 of file TopConfig.cxx.

                                                                              {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapFwdElectronsTDS->find(hash);
     if (key != m_systAllSgKeyMapFwdElectronsTDS->end()) {
       return (*key).second;
     }
  
     return m_sgKeyDummy;
   }

◆ sgKeyFwdElectronsTDSAux()

const std::string & top::TopConfig::sgKeyFwdElectronsTDSAux ( const std::size_t hash ) const

Definition at line 3025 of file TopConfig.cxx.

                                                                                 {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapFwdElectronsTDSAux->find(hash);
     if (key != m_systAllSgKeyMapFwdElectronsTDSAux->end()) {
       return (*key).second;
     }
  
     return m_sgKeyDummy;
   }

◆ sgKeyInDetTrackParticles()

const std::string& top::TopConfig::sgKeyInDetTrackParticles ( ) const

inline

Definition at line 588 of file TopConfig.h.

588 {return m_sgKeyInDetTrackParticles;}

◆ sgKeyJets() [1/3]

virtual const std::string& top::TopConfig::sgKeyJets ( ) const

inlinevirtual

Definition at line 582 of file TopConfig.h.

582 {return m_sgKeyJets;}

◆ sgKeyJets() [2/3]

const std::string & top::TopConfig::sgKeyJets	(	const std::size_t	hash,
		const bool	useLooseLeptonJets
	)		const

virtual

Definition at line 3114 of file TopConfig.cxx.

                                                                                                  {
     if (!m_applyElectronInJetSubtraction) {
       std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapJets->find(hash);
       if (key != m_systAllSgKeyMapJets->end()) {
         return (*key).second;
       }
     }
  
     if (m_applyElectronInJetSubtraction) {
       if (!useLooseLeptonJets) {
         std::unordered_map<std::size_t,
                            std::string>::const_iterator key =
           m_systAllSgKeyMapJets_electronInJetSubtraction->find(hash);
         if (key != m_systAllSgKeyMapJets_electronInJetSubtraction->end()) {
           return (*key).second;
         }
       }
       if (useLooseLeptonJets) {
         std::unordered_map<std::size_t,
                            std::string>::const_iterator key = m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->find(
           hash);
         if (key != m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->end()) {
           return (*key).second;
         }
       }
     }
  
     return m_sgKeyDummy;
   }

◆ sgKeyJets() [3/3]

void top::TopConfig::sgKeyJets ( const std::string & s )

virtual

Definition at line 2049 of file TopConfig.cxx.

                                               {
     if (!m_configFixed) {
       m_useJets = false;
       if (s != "None") m_useJets = true;
  
       m_sgKeyJets = s;
  
       // If anti-kt4 pflow jets then...
       if (m_sgKeyJets == "AntiKt4EMPFlowJets") m_useParticleFlowJets = true;
     }
   }

◆ sgKeyJetsStandAlone()

const std::string & top::TopConfig::sgKeyJetsStandAlone ( const std::size_t hash ) const

virtual

Definition at line 3204 of file TopConfig.cxx.

                                                                             {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapJets->find(hash);
     if (key != m_systAllSgKeyMapJets->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyJetsTDS()

const std::string & top::TopConfig::sgKeyJetsTDS	(	const std::size_t	hash,
		const bool	useLooseLeptonJets
	)		const

Definition at line 3144 of file TopConfig.cxx.

                                                                                                     {
     if (!m_applyElectronInJetSubtraction) {
       std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapJetsTDS->find(hash);
       if (key != m_systAllSgKeyMapJetsTDS->end()) {
         return (*key).second;
       }
     }
  
     if (m_applyElectronInJetSubtraction) {
       if (!useLooseLeptonJets) {
         std::unordered_map<std::size_t,
                            std::string>::const_iterator key = m_systAllSgKeyMapJets_electronInJetSubtractionTDS->find(
           hash);
         if (key != m_systAllSgKeyMapJets_electronInJetSubtractionTDS->end()) {
           return (*key).second;
         }
       }
       if (useLooseLeptonJets) {
         std::unordered_map<std::size_t,
                            std::string>::const_iterator key =
           m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDS->find(hash);
         if (key != m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDS->end()) {
           return (*key).second;
         }
       }
     }
  
     return m_sgKeyDummy;
   }

◆ sgKeyJetsTDSAux()

const std::string & top::TopConfig::sgKeyJetsTDSAux	(	const std::size_t	hash,
		const bool	useLooseLeptonJets
	)		const

Definition at line 3174 of file TopConfig.cxx.

                                                                                                        {
     if (!m_applyElectronInJetSubtraction) {
       std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapJetsTDSAux->find(hash);
       if (key != m_systAllSgKeyMapJetsTDSAux->end()) {
         return (*key).second;
       }
     }
  
     if (m_applyElectronInJetSubtraction) {
       if (!useLooseLeptonJets) {
         std::unordered_map<std::size_t,
                            std::string>::const_iterator key =
           m_systAllSgKeyMapJets_electronInJetSubtractionTDSAux->find(hash);
         if (key != m_systAllSgKeyMapJets_electronInJetSubtractionTDSAux->end()) {
           return (*key).second;
         }
       }
       if (useLooseLeptonJets) {
         std::unordered_map<std::size_t,
                            std::string>::const_iterator key =
           m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDSAux->find(hash);
         if (key != m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDSAux->end()) {
           return (*key).second;
         }
       }
     }
  
     return m_sgKeyDummy;
   }

◆ sgKeyKLFitter()

const std::string & top::TopConfig::sgKeyKLFitter ( const std::size_t hash ) const

Definition at line 3300 of file TopConfig.cxx.

                                                                       {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systSgKeyMapKLFitter->find(hash);
     if (key != m_systSgKeyMapKLFitter->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyKLFitterLoose()

const std::string & top::TopConfig::sgKeyKLFitterLoose ( const std::size_t hash ) const

Definition at line 3308 of file TopConfig.cxx.

                                                                            {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systSgKeyMapKLFitterLoose->find(hash);
     if (key != m_systSgKeyMapKLFitterLoose->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyLargeRJets() [1/3]

virtual const std::string& top::TopConfig::sgKeyLargeRJets ( ) const

inlinevirtual

Definition at line 583 of file TopConfig.h.

583 {return m_sgKeyLargeRJets;}

◆ sgKeyLargeRJets() [2/3]

const std::string & top::TopConfig::sgKeyLargeRJets ( const std::size_t hash ) const

virtual

Definition at line 3212 of file TopConfig.cxx.

                                                                         {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapLargeRJets->find(hash);
     if (key != m_systAllSgKeyMapLargeRJets->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyLargeRJets() [3/3]

void top::TopConfig::sgKeyLargeRJets ( const std::string & s )

virtual

Definition at line 2061 of file TopConfig.cxx.

                                                     {
     if (!m_configFixed) {
       m_useLargeRJets = false;
       if (s != "None") m_useLargeRJets = true;
  
       m_sgKeyLargeRJets = s;
     }
   }

◆ sgKeyLargeRJetsTDS()

const std::string & top::TopConfig::sgKeyLargeRJetsTDS ( const std::size_t hash ) const

Definition at line 3220 of file TopConfig.cxx.

                                                                            {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapLargeRJetsTDS->find(hash);
     if (key != m_systAllSgKeyMapLargeRJetsTDS->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyLargeRJetsTDSAux()

const std::string & top::TopConfig::sgKeyLargeRJetsTDSAux ( const std::size_t hash ) const

Definition at line 3228 of file TopConfig.cxx.

                                                                               {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapLargeRJetsTDSAux->find(hash);
     if (key != m_systAllSgKeyMapLargeRJetsTDSAux->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyMCParticle() [1/2]

virtual const std::string& top::TopConfig::sgKeyMCParticle ( ) const

inlinevirtual

Definition at line 591 of file TopConfig.h.

591 {return m_sgKeyMCParticle;}

◆ sgKeyMCParticle() [2/2]

void top::TopConfig::sgKeyMCParticle ( const std::string & s )

virtual

Definition at line 1986 of file TopConfig.cxx.

                                                     {
     if (!m_configFixed) {
       m_useTruthParticles = false;
       if (s != "None") m_useTruthParticles = true;
  
       m_sgKeyMCParticle = s;
     }
   }

◆ sgKeyMissingEt() [1/3]

virtual const std::string& top::TopConfig::sgKeyMissingEt ( ) const

inlinevirtual

Definition at line 586 of file TopConfig.h.

586 {return m_sgKeyMissingEt;}

◆ sgKeyMissingEt() [2/3]

const std::string & top::TopConfig::sgKeyMissingEt ( const std::size_t hash ) const

virtual

Definition at line 3284 of file TopConfig.cxx.

                                                                        {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systSgKeyMapMissingET->find(hash);
     if (key != m_systSgKeyMapMissingET->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyMissingEt() [3/3]

virtual void top::TopConfig::sgKeyMissingEt ( const std::string & s )

inlinevirtual

Definition at line 559 of file TopConfig.h.

                                                            {
       if (!m_configFixed) {
         m_sgKeyMissingEt = s;
       }
     }

◆ sgKeyMissingEtLoose() [1/3]

virtual const std::string& top::TopConfig::sgKeyMissingEtLoose ( ) const

inlinevirtual

Definition at line 587 of file TopConfig.h.

587 {return m_sgKeyMissingEtLoose;}

◆ sgKeyMissingEtLoose() [2/3]

const std::string & top::TopConfig::sgKeyMissingEtLoose ( const std::size_t hash ) const

virtual

Definition at line 3292 of file TopConfig.cxx.

                                                                             {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systSgKeyMapMissingETLoose->find(hash);
     if (key != m_systSgKeyMapMissingETLoose->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyMissingEtLoose() [3/3]

virtual void top::TopConfig::sgKeyMissingEtLoose ( const std::string & s )

inlinevirtual

Definition at line 565 of file TopConfig.h.

                                                                 {
       if (!m_configFixed) {
         m_sgKeyMissingEtLoose = s;
       }
     }

◆ sgKeyMuons() [1/3]

virtual const std::string& top::TopConfig::sgKeyMuons ( ) const

inlinevirtual

Definition at line 579 of file TopConfig.h.

579 {return m_sgKeyMuons;}

◆ sgKeyMuons() [2/3]

const std::string & top::TopConfig::sgKeyMuons ( const std::size_t hash ) const

virtual

Definition at line 3042 of file TopConfig.cxx.

                                                                    {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapMuons->find(hash);
     if (key != m_systAllSgKeyMapMuons->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyMuons() [3/3]

void top::TopConfig::sgKeyMuons ( const std::string & s )

virtual

Definition at line 2022 of file TopConfig.cxx.

                                                {
     if (!m_configFixed) {
       m_useMuons = false;
       if (s != "None") m_useMuons = true;
  
       m_sgKeyMuons = s;
     }
   }

◆ sgKeyMuonsTDS()

const std::string & top::TopConfig::sgKeyMuonsTDS ( const std::size_t hash ) const

Definition at line 3050 of file TopConfig.cxx.

                                                                       {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapMuonsTDS->find(hash);
     if (key != m_systAllSgKeyMapMuonsTDS->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyMuonsTDSAux()

const std::string & top::TopConfig::sgKeyMuonsTDSAux ( const std::size_t hash ) const

Definition at line 3058 of file TopConfig.cxx.

                                                                          {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapMuonsTDSAux->find(hash);
     if (key != m_systAllSgKeyMapMuonsTDSAux->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyPhotons() [1/3]

virtual const std::string& top::TopConfig::sgKeyPhotons ( ) const

inlinevirtual

Definition at line 576 of file TopConfig.h.

576 {return m_sgKeyPhotons;}

◆ sgKeyPhotons() [2/3]

const std::string & top::TopConfig::sgKeyPhotons ( const std::size_t hash ) const

virtual

Definition at line 2915 of file TopConfig.cxx.

                                                                      {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapPhotons->find(hash);
     if (key != m_systAllSgKeyMapPhotons->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyPhotons() [3/3]

void top::TopConfig::sgKeyPhotons ( const std::string & s )

virtual

Definition at line 1995 of file TopConfig.cxx.

                                                  {
     if (!m_configFixed) {
       m_usePhotons = false;
       if (s != "None") m_usePhotons = true;
  
       m_sgKeyPhotons = s;
     }
   }

◆ sgKeyPhotonsTDS()

const std::string & top::TopConfig::sgKeyPhotonsTDS ( const std::size_t hash ) const

Definition at line 2923 of file TopConfig.cxx.

                                                                         {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapPhotonsTDS->find(hash);
     if (key != m_systAllSgKeyMapPhotonsTDS->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyPhotonsTDSAux()

const std::string & top::TopConfig::sgKeyPhotonsTDSAux ( const std::size_t hash ) const

Definition at line 2931 of file TopConfig.cxx.

                                                                            {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapPhotonsTDSAux->find(hash);
     if (key != m_systAllSgKeyMapPhotonsTDSAux->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyPrimaryVertices()

const std::string& top::TopConfig::sgKeyPrimaryVertices ( ) const

inline

Definition at line 575 of file TopConfig.h.

575 {return m_sgKeyPrimaryVertices;}

◆ sgKeyPseudoTop() [1/2]

const std::string & top::TopConfig::sgKeyPseudoTop ( const std::size_t hash ) const

Definition at line 3316 of file TopConfig.cxx.

                                                                        {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systSgKeyMapPseudoTop->find(hash);
     if (key != m_systSgKeyMapPseudoTop->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyPseudoTop() [2/2]

const std::string& top::TopConfig::sgKeyPseudoTop ( const std::string ) const

◆ sgKeyPseudoTopLoose() [1/2]

const std::string & top::TopConfig::sgKeyPseudoTopLoose ( const std::size_t hash ) const

Definition at line 3324 of file TopConfig.cxx.

                                                                             {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systSgKeyMapPseudoTopLoose->find(hash);
     if (key != m_systSgKeyMapPseudoTopLoose->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyPseudoTopLoose() [2/2]

const std::string& top::TopConfig::sgKeyPseudoTopLoose ( const std::string ) const

◆ sgKeySoftMuons() [1/3]

virtual const std::string& top::TopConfig::sgKeySoftMuons ( ) const

inlinevirtual

Definition at line 580 of file TopConfig.h.

580 {return m_sgKeySoftMuons;}

◆ sgKeySoftMuons() [2/3]

const std::string & top::TopConfig::sgKeySoftMuons ( const std::size_t hash ) const

virtual

Definition at line 3066 of file TopConfig.cxx.

                                                                        {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapSoftMuons->find(hash);
     if (key != m_systAllSgKeyMapSoftMuons->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeySoftMuons() [3/3]

void top::TopConfig::sgKeySoftMuons ( const std::string & s )

virtual

Definition at line 2031 of file TopConfig.cxx.

                                                    {
     if (!m_configFixed) {
       m_useSoftMuons = false;
       if (s != "None") m_useSoftMuons = true;
  
       m_sgKeySoftMuons = s;
     }
   }

◆ sgKeySoftMuonsTDS()

const std::string & top::TopConfig::sgKeySoftMuonsTDS ( const std::size_t hash ) const

Definition at line 3074 of file TopConfig.cxx.

                                                                           {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapSoftMuonsTDS->find(hash);
     if (key != m_systAllSgKeyMapSoftMuonsTDS->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeySoftMuonsTDSAux()

const std::string & top::TopConfig::sgKeySoftMuonsTDSAux ( const std::size_t hash ) const

Definition at line 3082 of file TopConfig.cxx.

                                                                              {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapSoftMuonsTDSAux->find(hash);
     if (key != m_systAllSgKeyMapSoftMuonsTDSAux->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyTaus() [1/3]

virtual const std::string& top::TopConfig::sgKeyTaus ( ) const

inlinevirtual

Definition at line 581 of file TopConfig.h.

581 {return m_sgKeyTaus;}

◆ sgKeyTaus() [2/3]

const std::string & top::TopConfig::sgKeyTaus ( const std::size_t hash ) const

virtual

Definition at line 3090 of file TopConfig.cxx.

                                                                   {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTaus->find(hash);
     if (key != m_systAllSgKeyMapTaus->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyTaus() [3/3]

void top::TopConfig::sgKeyTaus ( const std::string & s )

virtual

Definition at line 2040 of file TopConfig.cxx.

                                               {
     if (!m_configFixed) {
       m_useTaus = false;
       if (s != "None") m_useTaus = true;
  
       m_sgKeyTaus = s;
     }
   }

◆ sgKeyTausTDS()

const std::string & top::TopConfig::sgKeyTausTDS ( const std::size_t hash ) const

Definition at line 3098 of file TopConfig.cxx.

                                                                      {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTausTDS->find(hash);
     if (key != m_systAllSgKeyMapTausTDS->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyTausTDSAux()

const std::string & top::TopConfig::sgKeyTausTDSAux ( const std::size_t hash ) const

Definition at line 3106 of file TopConfig.cxx.

                                                                         {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTausTDSAux->find(hash);
     if (key != m_systAllSgKeyMapTausTDSAux->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyTopPartonHistory()

const std::string& top::TopConfig::sgKeyTopPartonHistory ( ) const

inline

Definition at line 599 of file TopConfig.h.

599 {return m_sgKeyTopPartonHistory;}

◆ sgKeyTopSystematicEvents()

const std::string& top::TopConfig::sgKeyTopSystematicEvents ( ) const

inline

Definition at line 601 of file TopConfig.h.

601 {return m_sgKeyTopSystematicEvents;}

◆ sgKeyTopSystematicEventsLoose()

const std::string& top::TopConfig::sgKeyTopSystematicEventsLoose ( ) const

inline

Definition at line 602 of file TopConfig.h.

602 {return m_sgKeyTopSystematicEventsLoose;}

◆ sgKeyTrackJets() [1/3]

virtual const std::string& top::TopConfig::sgKeyTrackJets ( ) const

inlinevirtual

Definition at line 584 of file TopConfig.h.

584 {return m_sgKeyTrackJets;}

◆ sgKeyTrackJets() [2/3]

const std::string & top::TopConfig::sgKeyTrackJets ( const std::size_t hash ) const

virtual

Definition at line 3236 of file TopConfig.cxx.

                                                                        {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTrackJets->find(hash);
     if (key != m_systAllSgKeyMapTrackJets->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyTrackJets() [3/3]

void top::TopConfig::sgKeyTrackJets ( const std::string & s )

virtual

Definition at line 2070 of file TopConfig.cxx.

                                                    {
     if (!m_configFixed) {
       m_useTrackJets = false;
       if (s != "None") m_useTrackJets = true;
  
       m_sgKeyTrackJets = s;
     }
   }

◆ sgKeyTrackJetsTDS()

const std::string & top::TopConfig::sgKeyTrackJetsTDS ( const std::size_t hash ) const

Definition at line 3244 of file TopConfig.cxx.

                                                                           {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTrackJetsTDS->find(hash);
     if (key != m_systAllSgKeyMapTrackJetsTDS->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyTrackJetsTDSAux()

const std::string & top::TopConfig::sgKeyTrackJetsTDSAux ( const std::size_t hash ) const

Definition at line 3252 of file TopConfig.cxx.

                                                                              {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTrackJetsTDSAux->find(hash);
     if (key != m_systAllSgKeyMapTrackJetsTDSAux->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyTracks() [1/3]

virtual const std::string& top::TopConfig::sgKeyTracks ( ) const

inlinevirtual

Definition at line 585 of file TopConfig.h.

585 {return m_sgKeyTracks;}

◆ sgKeyTracks() [2/3]

const std::string & top::TopConfig::sgKeyTracks ( const std::size_t hash ) const

virtual

Definition at line 3260 of file TopConfig.cxx.

                                                                     {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTracks->find(hash);
     if (key != m_systAllSgKeyMapTracks->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyTracks() [3/3]

void top::TopConfig::sgKeyTracks ( const std::string & s )

virtual

Definition at line 2079 of file TopConfig.cxx.

                                                 {
     
     if (!m_configFixed) {
       m_useTracks = false;
       if (s != "None") m_useTracks = true;
       m_sgKeyTracks = s;
     }
   }

◆ sgKeyTracksTDS()

const std::string & top::TopConfig::sgKeyTracksTDS ( const std::size_t hash ) const

Definition at line 3268 of file TopConfig.cxx.

                                                                        {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTracksTDS->find(hash);
     if (key != m_systAllSgKeyMapTracksTDS->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyTracksTDSAux()

const std::string & top::TopConfig::sgKeyTracksTDSAux ( const std::size_t hash ) const

Definition at line 3276 of file TopConfig.cxx.

                                                                           {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTracksTDSAux->find(hash);
     if (key != m_systAllSgKeyMapTracksTDSAux->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ sgKeyTruthElectrons() [1/2]

const std::string& top::TopConfig::sgKeyTruthElectrons ( ) const

inline

Definition at line 593 of file TopConfig.h.

593 {return m_sgKeyTruthElectrons;}

◆ sgKeyTruthElectrons() [2/2]

void top::TopConfig::sgKeyTruthElectrons ( const std::string & s )

virtual

Definition at line 2088 of file TopConfig.cxx.

                                                         {
     if (!m_configFixed) {
       m_useTruthElectrons = false;
       if (s != "None") m_useTruthElectrons = true;
  
       m_sgKeyTruthElectrons = s;
     }
   }

◆ systAllTTreeNames()

std::shared_ptr<std::unordered_map<std::size_t, std::string> > top::TopConfig::systAllTTreeNames ( ) const

inline

Definition at line 2115 of file TopConfig.h.

2115 {return m_systAllTTreeNames;}

◆ systematicName()

const std::string & top::TopConfig::systematicName ( const std::size_t hash ) const

Definition at line 3346 of file TopConfig.cxx.

                                                                        {
     std::unordered_map<std::size_t, std::string>::const_iterator key = m_systPersistantAllTTreeNames
                                                                         ->find(hash);
     if (key != m_systPersistantAllTTreeNames->end()) {
       return (*key).second;
     }
     return m_sgKeyDummy;
   }

◆ systematics() [1/2]

virtual const std::string& top::TopConfig::systematics ( ) const

inlinevirtual

Definition at line 2050 of file TopConfig.h.

2050 {return m_systematics;}

◆ systematics() [2/2]

virtual void top::TopConfig::systematics ( const std::string & s )

inlinevirtual

Definition at line 2044 of file TopConfig.h.

                                                         {
       if (!m_configFixed) {
         m_systematics = s;
       }
     }

◆ systematicsElectrons()

void top::TopConfig::systematicsElectrons ( const std::list< CP::SystematicSet > & syst )

virtual

Definition at line 2310 of file TopConfig.cxx.

                                                                            {
     if (!m_configFixed) {
       for (auto s : syst) {
         m_systHashElectrons->insert(s.hash());
         m_list_systHashAll->push_back(s.hash());
         m_list_systHash_electronInJetSubtraction->push_back(s.hash());
         m_systMapElectrons->insert(std::make_pair(s.hash(), s));
         m_systSgKeyMapElectrons->insert(std::make_pair(s.hash(), m_sgKeyElectrons + "_" + s.name()));
       }
       m_list_systHashAll->sort();
       m_list_systHashAll->unique();
       m_list_systHash_electronInJetSubtraction->sort();
       m_list_systHash_electronInJetSubtraction->unique();
     }
   }

◆ systematicsFwdElectrons()

void top::TopConfig::systematicsFwdElectrons ( const std::list< CP::SystematicSet > & syst )

virtual

Definition at line 2326 of file TopConfig.cxx.

                                                                               {
     if (!m_configFixed) {
       for (const auto& s : syst) {  
         m_systHashFwdElectrons->insert(s.hash());
         m_list_systHashAll->push_back(s.hash());
         m_systMapFwdElectrons->insert(std::make_pair(s.hash(), s));
         m_systSgKeyMapFwdElectrons->insert(std::make_pair(s.hash(), m_sgKeyFwdElectrons + "_" + s.name()));
       }
       m_list_systHashAll->sort();
       m_list_systHashAll->unique();
     }
   }

◆ systematicsJetGhostTrack() [1/2]

const std::vector<std::string>& top::TopConfig::systematicsJetGhostTrack ( ) const

inline

Definition at line 665 of file TopConfig.h.

665 {return m_jetGhostTrackSystematics;}

◆ systematicsJetGhostTrack() [2/2]

void top::TopConfig::systematicsJetGhostTrack ( const std::list< CP::SystematicSet > & syst )

virtual

Definition at line 2433 of file TopConfig.cxx.

                                                                                {
     if (!m_configFixed) {
       // Add the nominal (for reporting purposes).
       (*m_systMapJetGhostTrack)[m_nominalHashValue] = {};
       (*m_systDecoKeyMapJetGhostTrack)[m_nominalHashValue] = m_decoKeyJetGhostTrack + "_";
       m_jetGhostTrackSystematics.push_back("");
  
       for (auto s : syst) { 
         (*m_systMapJetGhostTrack)[s.hash()] = s;
         (*m_systDecoKeyMapJetGhostTrack)[s.hash()] = m_decoKeyJetGhostTrack + "_" + s.name();
         m_list_systHashAll->push_back(s.hash());
         m_jetGhostTrackSystematics.push_back(s.name());
       }
  
       // Ensure that elements are unique.
       std::sort(m_jetGhostTrackSystematics.begin(),
                 m_jetGhostTrackSystematics.end());
       auto last = std::unique(m_jetGhostTrackSystematics.begin(),
                               m_jetGhostTrackSystematics.end());
       m_jetGhostTrackSystematics.erase(last,
                                        m_jetGhostTrackSystematics.end());
  
       m_list_systHashAll->sort();
       m_list_systHashAll->unique();
     }
   }

◆ systematicsJets()

void top::TopConfig::systematicsJets ( const std::list< CP::SystematicSet > & syst )

virtual

Definition at line 2378 of file TopConfig.cxx.

                                                                       {
     if (!m_configFixed) {
       for (auto s : syst) {
         m_systHashJets->insert(s.hash());
         m_list_systHashAll->push_back(s.hash());
         m_list_systHash_electronInJetSubtraction->push_back(s.hash());
         m_systMapJets->insert(std::make_pair(s.hash(), s));
         m_systSgKeyMapJets->insert(std::make_pair(s.hash(), m_sgKeyJets + "_" + s.name()));
       }
       m_list_systHashAll->sort();
       m_list_systHashAll->unique();
       m_list_systHash_electronInJetSubtraction->sort();
       m_list_systHash_electronInJetSubtraction->unique();
     }
   }

◆ systematicsLargeRJets()

void top::TopConfig::systematicsLargeRJets ( const std::list< CP::SystematicSet > & syst )

virtual

Definition at line 2394 of file TopConfig.cxx.

                                                                             {
     if (!m_configFixed) {
       for (auto s : syst) {
         m_systHashLargeRJets->insert(s.hash());
         m_list_systHashAll->push_back(s.hash());
         m_systMapLargeRJets->insert(std::make_pair(s.hash(), s));
         m_systSgKeyMapLargeRJets->insert(std::make_pair(s.hash(), m_sgKeyLargeRJets + "_" + s.name()));
       }
       m_list_systHashAll->sort();
       m_list_systHashAll->unique();
     }
   }

◆ systematicsMET()

void top::TopConfig::systematicsMET ( const std::list< CP::SystematicSet > & syst )

virtual

Definition at line 2420 of file TopConfig.cxx.

                                                                      {
     if (!m_configFixed) {
       for (auto s : syst) { 
         m_systHashMET->insert(s.hash());
         m_list_systHashAll->push_back(s.hash());
         m_systMapMET->insert(std::make_pair(s.hash(), s));
         m_systSgKeyMapMET->insert(std::make_pair(s.hash(), m_sgKeyLargeRJets + "_" + s.name()));
       }
       m_list_systHashAll->sort();
       m_list_systHashAll->unique();
     }
   }

◆ systematicsMuons()

void top::TopConfig::systematicsMuons ( const std::list< CP::SystematicSet > & syst )

virtual

Definition at line 2339 of file TopConfig.cxx.

                                                                        {
     if (!m_configFixed) {
       for (auto s : syst) { 
         m_systHashMuons->insert(s.hash());
         m_list_systHashAll->push_back(s.hash());
         m_systMapMuons->insert(std::make_pair(s.hash(), s));
         m_systSgKeyMapMuons->insert(std::make_pair(s.hash(), m_sgKeyMuons + "_" + s.name()));
       }
       m_list_systHashAll->sort();
       m_list_systHashAll->unique();
     }
   }

◆ systematicsPhotons()

void top::TopConfig::systematicsPhotons ( const std::list< CP::SystematicSet > & syst )

virtual

Definition at line 2297 of file TopConfig.cxx.

                                                                          {
     if (!m_configFixed) {
       for (auto s : syst) {
         m_systHashPhotons->insert(s.hash());
         m_list_systHashAll->push_back(s.hash());
         m_systMapPhotons->insert(std::make_pair(s.hash(), s));
         m_systSgKeyMapPhotons->insert(std::make_pair(s.hash(), m_sgKeyPhotons + "_" + s.name()));
       }
       m_list_systHashAll->sort();
       m_list_systHashAll->unique();
     }
   }

◆ systematicsSoftMuons()

void top::TopConfig::systematicsSoftMuons ( const std::list< CP::SystematicSet > & syst )

virtual

Definition at line 2352 of file TopConfig.cxx.

                                                                            {
     if (!m_configFixed) {
       for (const CP::SystematicSet& s : syst) { 
         m_systHashSoftMuons->insert(s.hash());
         m_list_systHashAll->push_back(s.hash());
         m_systMapSoftMuons->insert(std::make_pair(s.hash(), s));
         m_systSgKeyMapSoftMuons->insert(std::make_pair(s.hash(), m_sgKeySoftMuons + "_" + s.name()));
       }
       m_list_systHashAll->sort();
       m_list_systHashAll->unique();
     }
   }

◆ systematicsTaus()

void top::TopConfig::systematicsTaus ( const std::list< CP::SystematicSet > & syst )

virtual

Definition at line 2365 of file TopConfig.cxx.

                                                                       {
     if (!m_configFixed) {
       for (auto s : syst) { 
         m_systHashTaus->insert(s.hash());
         m_list_systHashAll->push_back(s.hash());
         m_systMapTaus->insert(std::make_pair(s.hash(), s));
         m_systSgKeyMapTaus->insert(std::make_pair(s.hash(), m_sgKeyTaus + "_" + s.name()));
       }
       m_list_systHashAll->sort();
       m_list_systHashAll->unique();
     }
   }

◆ systematicsTrackJets()

void top::TopConfig::systematicsTrackJets ( const std::list< CP::SystematicSet > & syst )

virtual

Definition at line 2407 of file TopConfig.cxx.

                                                                            {
     if (!m_configFixed) {
       for (auto s : syst) {
     m_systHashTrackJets->insert(s.hash());
         m_list_systHashAll->push_back(s.hash());
         m_systMapTrackJets->insert(std::make_pair(s.hash(), s));
         m_systSgKeyMapTrackJets->insert(std::make_pair(s.hash(), m_sgKeyTrackJets + "_" + s.name()));
       }
       m_list_systHashAll->sort();
       m_list_systHashAll->unique();
     }
   }

◆ systematicsTracks()

void top::TopConfig::systematicsTracks ( const std::list< CP::SystematicSet > & syst )

virtual

Definition at line 2460 of file TopConfig.cxx.

                                                                         {
  
     if (!m_configFixed) {
  
       for (auto s : syst) {
         m_systHashTracks->insert(s.hash());
     m_list_systHashAll->push_back(s.hash());
         m_systMapTracks->insert(std::make_pair(s.hash(), s));
  
         m_systSgKeyMapTracks->insert(std::make_pair(s.hash(), m_sgKeyTracks + "_" + s.name()));
  
       }
       
       m_list_systHashAll->sort();
       m_list_systHashAll->unique();
     }
     
   }

◆ systSgKeyMapJets()

std::shared_ptr< std::unordered_map< std::size_t, std::string > > top::TopConfig::systSgKeyMapJets ( const bool useLooseLeptonJets ) const

Definition at line 3355 of file TopConfig.cxx.

                                          {
     if (m_applyElectronInJetSubtraction) {
       if (useLooseLeptonJets) {
         return m_systSgKeyMapJetsLoose_electronInJetSubtraction;
       }
       return m_systSgKeyMapJets_electronInJetSubtraction;
     }
     return m_systSgKeyMapJets;
   }

◆ tauEleIDWP() [2/2]

virtual void top::TopConfig::tauEleIDWP ( const std::string & s )

inlinevirtual

Definition at line 1639 of file TopConfig.h.

                                                        {
       if (!m_configFixed) m_tau_configuration.eleIDWP = s;
     }

◆ tauEleIDWPLoose() [1/2]

const std::string& top::TopConfig::tauEleIDWPLoose ( ) const

inline

Definition at line 1692 of file TopConfig.h.

                                                     {
       return m_tau_configuration_loose.eleIDWP;
     }

◆ tauEleIDWPLoose() [2/2]

virtual void top::TopConfig::tauEleIDWPLoose ( const std::string & s )

inlinevirtual

Definition at line 1643 of file TopConfig.h.

                                                             {
       if (!m_configFixed) m_tau_configuration_loose.eleIDWP = s;
     }

◆ tauEtaRegions() [1/2]

const std::string& top::TopConfig::tauEtaRegions ( ) const

inline

Definition at line 1676 of file TopConfig.h.

                                                   {
        return m_tau_configuration.etaRegions;
     }

◆ tauEtaRegions() [2/2]

virtual void top::TopConfig::tauEtaRegions ( const std::string & etaRegions )

inlinevirtual

Definition at line 1624 of file TopConfig.h.

                                                                    {
       if (!m_configFixed) {
         m_tau_configuration.etaRegions = etaRegions;
         m_tau_configuration_loose.etaRegions = etaRegions;
       }
     }

◆ tauJetConfigFile() [1/2]

const std::string& top::TopConfig::tauJetConfigFile ( )

inline

Definition at line 1704 of file TopConfig.h.

                                                {
       return m_tau_configuration.fileName;
     }

◆ tauJetConfigFile() [2/2]

virtual void top::TopConfig::tauJetConfigFile ( const std::string & s )

inlinevirtual

Definition at line 1655 of file TopConfig.h.

                                                              {
       if (!m_configFixed) m_tau_configuration.fileName = s;
     }

◆ tauJetConfigFileLoose() [1/2]

const std::string& top::TopConfig::tauJetConfigFileLoose ( )

inline

Definition at line 1708 of file TopConfig.h.

                                                     {
       return m_tau_configuration_loose.fileName;
     }

◆ tauJetConfigFileLoose() [2/2]

virtual void top::TopConfig::tauJetConfigFileLoose ( const std::string & s )

inlinevirtual

Definition at line 1659 of file TopConfig.h.

                                                                   {
       if (!m_configFixed) m_tau_configuration_loose.fileName = s;
     }

◆ tauJetIDWP() [1/2]

const std::string& top::TopConfig::tauJetIDWP ( ) const

inline

Definition at line 1680 of file TopConfig.h.

                                                {
       return m_tau_configuration.jetIDWP;
     }

◆ tauJetIDWP() [2/2]

virtual void top::TopConfig::tauJetIDWP ( const std::string & s )

inlinevirtual

Definition at line 1631 of file TopConfig.h.

                                                        {
       if (!m_configFixed) m_tau_configuration.jetIDWP = s;
     }

◆ tauJetIDWPLoose() [1/2]

const std::string& top::TopConfig::tauJetIDWPLoose ( ) const

inline

Definition at line 1684 of file TopConfig.h.

                                                     {
       return m_tau_configuration_loose.jetIDWP;
     }

◆ tauJetIDWPLoose() [2/2]

virtual void top::TopConfig::tauJetIDWPLoose ( const std::string & s )

inlinevirtual

Definition at line 1635 of file TopConfig.h.

                                                             {
       if (!m_configFixed) m_tau_configuration_loose.jetIDWP = s;
     }

◆ tauMuOLR() [1/2]

virtual bool top::TopConfig::tauMuOLR ( )

inlinevirtual

Definition at line 1696 of file TopConfig.h.

                                    {
       return m_tau_configuration.muOLR;
     }

◆ tauMuOLR() [2/2]

virtual void top::TopConfig::tauMuOLR ( bool do_tau_ele_olr )

inlinevirtual

Definition at line 1647 of file TopConfig.h.

                                                       {
       if (!m_configFixed) m_tau_configuration.muOLR = do_tau_ele_olr;
     }

◆ tauMuOLRLoose() [1/2]

virtual bool top::TopConfig::tauMuOLRLoose ( )

inlinevirtual

Definition at line 1700 of file TopConfig.h.

                                         {
       return m_tau_configuration_loose.muOLR;
     }

◆ tauMuOLRLoose() [2/2]

virtual void top::TopConfig::tauMuOLRLoose ( bool do_tau_ele_olr )

inlinevirtual

Definition at line 1651 of file TopConfig.h.

                                                            {
       if (!m_configFixed) m_tau_configuration_loose.muOLR = do_tau_ele_olr;
     }

◆ tauPtcut() [1/2]

virtual float top::TopConfig::tauPtcut ( ) const

inlinevirtual

Definition at line 1672 of file TopConfig.h.

                                           {
       return m_tau_configuration.pt;
     }

◆ tauPtcut() [2/2]

virtual void top::TopConfig::tauPtcut ( const float pt )

inlinevirtual

Definition at line 1617 of file TopConfig.h.

                                                  {
       if (!m_configFixed) {
         m_tau_configuration.pt = pt;
         m_tau_configuration_loose.pt = pt;
       }
     }

◆ tauSubstructureSF() [1/2]

virtual bool top::TopConfig::tauSubstructureSF ( )

inlinevirtual

Definition at line 1712 of file TopConfig.h.

                                             {
       return m_tau_configuration.substructureSF;
     }

◆ tauSubstructureSF() [2/2]

virtual void top::TopConfig::tauSubstructureSF ( bool do_tau_substructure_sf )

inlinevirtual

Definition at line 1663 of file TopConfig.h.

                                                                        {
       if (!m_configFixed) m_tau_configuration.substructureSF = do_tau_substructure_sf;
     }

◆ tauSubstructureSFLoose() [1/2]

virtual bool top::TopConfig::tauSubstructureSFLoose ( )

inlinevirtual

Definition at line 1716 of file TopConfig.h.

                                                  {
       return m_tau_configuration_loose.substructureSF;
     }

◆ tauSubstructureSFLoose() [2/2]

virtual void top::TopConfig::tauSubstructureSFLoose ( bool do_tau_substructure_sf )

inlinevirtual

Definition at line 1667 of file TopConfig.h.

                                                                             {
       if (!m_configFixed) m_tau_configuration_loose.substructureSF = do_tau_substructure_sf;
     }

◆ tauTriggers_Loose() [1/2]

const std::vector< std::pair< std::string, int > > & top::TopConfig::tauTriggers_Loose ( const std::string & selection ) const

virtual

Definition at line 3465 of file TopConfig.cxx.

                                                                                                           {
     std::unordered_map<std::string,
                        std::vector<std::pair<std::string, int> > >::const_iterator key = m_tauTriggers_Loose->find(selection);
     if (key != m_tauTriggers_Loose->end()) {
       return (*key).second;
     }
     return m_dummyTrigger;
   }

◆ tauTriggers_Loose() [2/2]

virtual void top::TopConfig::tauTriggers_Loose ( std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers )

inlinevirtual

Definition at line 509 of file TopConfig.h.

                                                                                                                                {
       if (!m_configFixed) {
         m_tauTriggers_Loose = triggers;
       }
     }

◆ tauTriggers_Tight() [1/2]

const std::vector< std::pair< std::string, int > > & top::TopConfig::tauTriggers_Tight ( const std::string & selection ) const

virtual

Definition at line 3420 of file TopConfig.cxx.

                                                                                                           {
     std::unordered_map<std::string,
                        std::vector<std::pair<std::string, int> > >::const_iterator key = m_tauTriggers_Tight->find(selection);
     if (key != m_tauTriggers_Tight->end()) {
       return (*key).second;
     }
     return m_dummyTrigger;
   }

◆ tauTriggers_Tight() [2/2]

virtual void top::TopConfig::tauTriggers_Tight ( std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers )

inlinevirtual

Definition at line 474 of file TopConfig.h.

                                                                                                                                {
       if (!m_configFixed) {
         m_tauTriggers_Tight = triggers;
       }
     }

◆ trackEtacut() [1/2]

virtual float top::TopConfig::trackEtacut ( ) const

inlinevirtual

Definition at line 1375 of file TopConfig.h.

1375 {return m_trackEtacut;}

◆ trackEtacut() [2/2]

virtual void top::TopConfig::trackEtacut ( const float eta )

inlinevirtual

Definition at line 1360 of file TopConfig.h.

                                                      {
       if (!m_configFixed) {
         m_trackEtacut = eta;
       }
     }

◆ trackJetEtacut() [1/2]

virtual float top::TopConfig::trackJetEtacut ( ) const

inlinevirtual

Definition at line 1351 of file TopConfig.h.

1351 {return m_trackJetEtacut;}

◆ trackJetEtacut() [2/2]

virtual void top::TopConfig::trackJetEtacut ( const float eta )

inlinevirtual

Definition at line 1344 of file TopConfig.h.

                                                         {
       if (!m_configFixed) {
         m_trackJetEtacut = eta;
       }
     }

◆ trackJetPtcut() [1/2]

virtual float top::TopConfig::trackJetPtcut ( ) const

inlinevirtual

Definition at line 1350 of file TopConfig.h.

1350 {return m_trackJetPtcut;}

◆ trackJetPtcut() [2/2]

virtual void top::TopConfig::trackJetPtcut ( const float pt )

inlinevirtual

Definition at line 1338 of file TopConfig.h.

                                                       {
       if (!m_configFixed) {
         m_trackJetPtcut = pt;
       }
     }

◆ trackPtcut() [1/2]

virtual float top::TopConfig::trackPtcut ( ) const

inlinevirtual

Definition at line 1374 of file TopConfig.h.

1374 {return m_trackPtcut;}

◆ trackPtcut() [2/2]

virtual void top::TopConfig::trackPtcut ( const float pt )

inlinevirtual

Definition at line 1354 of file TopConfig.h.

                                                    {
       if (!m_configFixed) {
         m_trackPtcut = pt;
       }
     }

◆ trackQuality() [1/2]

virtual const std::string& top::TopConfig::trackQuality ( ) const

inlinevirtual

Definition at line 1373 of file TopConfig.h.

1373 {return m_trackQuality;}

◆ trackQuality() [2/2]

virtual void top::TopConfig::trackQuality ( const std::string & quality )

inlinevirtual

Definition at line 1366 of file TopConfig.h.

                                                                {
       if (!m_configFixed) {
         m_trackQuality = quality;
       }
     }

◆ truth_tau_PtCut() [2/2]

virtual void top::TopConfig::truth_tau_PtCut ( const float pt )

inlinevirtual

Definition at line 1875 of file TopConfig.h.

                                                         {
       if (!m_configFixed) {
         m_truth_tau.PtCut = pt;
       }
     }

◆ ttreeIndex()

unsigned int top::TopConfig::ttreeIndex ( const std::size_t hash ) const

Definition at line 3367 of file TopConfig.cxx.

                                                                {
     unsigned int index(99999); // This will crash the job if not set properly
  
     std::unordered_map<std::size_t, unsigned int>::const_iterator Itr = m_systAllTTreeIndex->find(hash);
     if (Itr != m_systAllTTreeIndex->end()) {
       index = (*Itr).second;
     }
     if (index == 99999) {
       ATH_MSG_WARNING("ttreeIndex is crazy, something has gone wrong with the hash value = " << hash);
     }
     return index;
   }

◆ ttreeIndexLoose()

unsigned int top::TopConfig::ttreeIndexLoose ( const std::size_t hash ) const

Definition at line 3380 of file TopConfig.cxx.

                                                                     {
     unsigned int index(99999); // This will crash the job if not set properly
  
     std::unordered_map<std::size_t, unsigned int>::const_iterator Itr = m_systAllTTreeLooseIndex->find(hash);
     if (Itr != m_systAllTTreeLooseIndex->end()) {
       index = (*Itr).second;
     }
     if (index == 99999) {
       ATH_MSG_WARNING("ttreeIndex is crazy, something has gone wrong with the hash value = " << hash);
     }
     return index;
   }

◆ writeMETBuiltWithLooseObjects()

bool top::TopConfig::writeMETBuiltWithLooseObjects ( )

inline

Definition at line 254 of file TopConfig.h.

254 {return m_writeMETBuiltWithLooseObjects;}

Member Data Documentation

◆ actual_mu_AF

std::vector<std::string> top::TopConfig::actual_mu_AF = {}

Definition at line 2755 of file TopConfig.h.

◆ actual_mu_FS

std::vector<std::string> top::TopConfig::actual_mu_FS = {}

Definition at line 2754 of file TopConfig.h.

◆ apply

bool top::TopConfig::apply = false

Definition at line 2758 of file TopConfig.h.

std::unordered_map<std::string, std::set<std::string> > top::TopConfig::bTag_named_systs_trkJet

private

Definition at line 2719 of file TopConfig.h.

◆ config_files

std::vector<std::string> top::TopConfig::config_files = {}

Definition at line 2749 of file TopConfig.h.

◆ config_files_AF

std::vector<std::string> top::TopConfig::config_files_AF = {}

Definition at line 2753 of file TopConfig.h.

◆ config_files_FS

std::vector<std::string> top::TopConfig::config_files_FS = {}

Definition at line 2752 of file TopConfig.h.

◆ custom_SF

std::vector<double> top::TopConfig::custom_SF = {}

Definition at line 2768 of file TopConfig.h.

◆ doLHAPDF

bool top::TopConfig::doLHAPDF = false

Definition at line 2736 of file TopConfig.h.

◆ doLHAPDFInNominalTrees

bool top::TopConfig::doLHAPDFInNominalTrees = false

Definition at line 2737 of file TopConfig.h.

◆ doRNNID

bool top::TopConfig::doRNNID = true

Definition at line 2585 of file TopConfig.h.

◆ electron_trigger_systematics

std::vector<std::string> top::TopConfig::electron_trigger_systematics

Definition at line 2789 of file TopConfig.h.

◆ electron_trigger_tool_names

std::vector<std::string> top::TopConfig::electron_trigger_tool_names

Definition at line 2795 of file TopConfig.h.

◆ eleIDWP

std::string top::TopConfig::eleIDWP = "RNNMedium"

Definition at line 2587 of file TopConfig.h.

◆ eta

float top::TopConfig::eta = 2.5

Definition at line 2600 of file TopConfig.h.

◆ EtaCut

float top::TopConfig::EtaCut

Definition at line 2614 of file TopConfig.h.

◆ etaRegions

std::string top::TopConfig::etaRegions ="[0., 1.37, 1.52, 2.5]"

Definition at line 2593 of file TopConfig.h.

◆ fileName

std::string top::TopConfig::fileName = "Default"

Definition at line 2581 of file TopConfig.h.

◆ identification

std::string top::TopConfig::identification = "None"

Definition at line 2602 of file TopConfig.h.

◆ isActivated

bool top::TopConfig::isActivated = false

Definition at line 2780 of file TopConfig.h.

◆ isConfigured

bool top::TopConfig::isConfigured = false

Definition at line 2787 of file TopConfig.h.

◆ isolation

std::string top::TopConfig::isolation = "None"

Definition at line 2601 of file TopConfig.h.

◆ Isolation

std::string top::TopConfig::Isolation

Definition at line 2653 of file TopConfig.h.

◆ jetIDWP

std::string top::TopConfig::jetIDWP = "RNNMedium"

Definition at line 2584 of file TopConfig.h.

std::string top::TopConfig::m_largeRJetUncertaintiesConfigDir

private

bool top::TopConfig::m_trigMatchElemRelink

private

Definition at line 2819 of file TopConfig.h.

◆ m_truth_electron

struct { ... } top::TopConfig::m_truth_electron

◆ m_truth_jet

struct { ... } top::TopConfig::m_truth_jet

◆ m_truth_largeRJet

struct { ... } top::TopConfig::m_truth_largeRJet

◆ m_truth_muon

struct { ... } top::TopConfig::m_truth_muon

◆ m_truth_photon

◆ muOLR

bool top::TopConfig::muOLR = true

Definition at line 2590 of file TopConfig.h.

◆ muon_trigger_systematics

std::vector<std::string> top::TopConfig::muon_trigger_systematics

Definition at line 2791 of file TopConfig.h.

◆ muon_trigger_tool_names

std::vector<std::string> top::TopConfig::muon_trigger_tool_names

Definition at line 2797 of file TopConfig.h.

◆ NotFromHadron

bool top::TopConfig::NotFromHadron

Definition at line 2616 of file TopConfig.h.

◆ Origin

std::string top::TopConfig::Origin

Definition at line 2651 of file TopConfig.h.

◆ pdf_results

std::unordered_map< std::string, std::vector<float> > top::TopConfig::pdf_results

Definition at line 2742 of file TopConfig.h.

◆ pdf_set_names

std::vector<std::string> top::TopConfig::pdf_set_names = {}

Definition at line 2732 of file TopConfig.h.

◆ periodAssignments

std::vector<int> top::TopConfig::periodAssignments = {}

Definition at line 2770 of file TopConfig.h.

◆ photon_trigger_systematics

std::vector<std::string> top::TopConfig::photon_trigger_systematics

Definition at line 2793 of file TopConfig.h.

◆ photon_trigger_tool_names

std::vector<std::string> top::TopConfig::photon_trigger_tool_names

Definition at line 2799 of file TopConfig.h.

◆ pt

float top::TopConfig::pt = 20000

Definition at line 2592 of file TopConfig.h.

◆ PtCut

float top::TopConfig::PtCut

Definition at line 2611 of file TopConfig.h.

◆ save_per_event

bool top::TopConfig::save_per_event = false

Definition at line 2739 of file TopConfig.h.

◆ substructureSF

bool top::TopConfig::substructureSF = false

Definition at line 2588 of file TopConfig.h.

◆ TauIsHadron

bool top::TopConfig::TauIsHadron

Definition at line 2618 of file TopConfig.h.

◆ trigger

triggermap_t top::TopConfig::trigger

Definition at line 2782 of file TopConfig.h.

◆ trigger_loose

triggermap_t top::TopConfig::trigger_loose

Definition at line 2783 of file TopConfig.h.

◆ unrepresented_data_tol

float top::TopConfig::unrepresented_data_tol = 0.05

Definition at line 2756 of file TopConfig.h.

◆ use_grl_tool

bool top::TopConfig::use_grl_tool = false

Definition at line 2760 of file TopConfig.h.

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ triggermap_t

Constructor & Destructor Documentation

◆ TopConfig() [1/4]

◆ TopConfig() [2/4]

◆ ~TopConfig()

◆ TopConfig() [3/4]

◆ TopConfig() [4/4]

Member Function Documentation

◆ addBTagAlgo()

◆ addLHAPDFResult()

◆ allowSmallRJMSforAFII() [1/2]

◆ allowSmallRJMSforAFII() [2/2]

◆ allSelectionNames()

◆ allTriggers_Loose() [1/2]

◆ allTriggers_Loose() [2/2]

◆ allTriggers_Tight() [1/2]

◆ allTriggers_Tight() [2/2]

◆ applyElectronInJetSubtraction()

◆ applyTauMVATES()

◆ applyTightSFsInLooseTree()

◆ applyTTVACut()

◆ badBatmanCleaningMax()

◆ badBatmanCleaningMin()

◆ baseLHAPDF()

◆ bJSF()

◆ boostedJetTaggers()

◆ boostedTaggerSFnames()

◆ boostedTaggersSFSysNames()

◆ bTagAlgos()

◆ bTagAlgos_trkJet()

◆ bTagAlgoWP()

◆ bTagAlgoWP_calib()

◆ bTagAlgoWP_calib_trkJet()

◆ bTagAlgoWP_trkJet()

◆ btagging_namedSysts()

◆ btagging_num_B_eigenvars()

◆ btagging_num_C_eigenvars()

◆ btagging_num_Light_eigenvars()

◆ bTaggingCalibration_B()

◆ bTaggingCalibration_C()

◆ bTaggingCalibration_Light()

◆ bTaggingCDIPath()

◆ bTagSystsExcludedFromEV()

◆ bTagWP()

◆ bTagWP_calib()

◆ bTagWP_calib_trkJet()

◆ bTagWP_trkJet()

◆ contains()

◆ createPersistentSettings()

◆ decoKeyJetGhostTrack() [1/3]

◆ decoKeyJetGhostTrack() [2/3]

◆ decoKeyJetGhostTrack() [3/3]

◆ demandPriVtx()

◆ doEleEleOverlapRemoval()

◆ doFakesMMWeightsIFF()

◆ doForwardJVTinMET() [1/2]

◆ doForwardJVTinMET() [2/2]

◆ doJVTinMET() [1/2]

◆ doJVTinMET() [2/2]

◆ doKLFitter()

◆ doLargeJetOverlapRemoval()

◆ doLargeRPseudodataJER() [1/2]

◆ doLargeRPseudodataJER() [2/2]

◆ doLHAPDF()

◆ doLHAPDFInNominalTrees()

◆ doLooseEvents()

◆ doLooseSysts()

◆ doMCGeneratorWeights()

◆ doMCGeneratorWeightsInNominalTrees()

◆ doMultipleJES()

◆ doOverlapRemovalOnLooseLeptonDef()

◆ doParticleLevelOverlapRemovalElJet()

◆ doParticleLevelOverlapRemovalJetPhoton()

◆ doParticleLevelOverlapRemovalMuJet()

◆ doPileupReweighting()