ATLAS Offline Software
TopConfig.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "TopConfiguration/TopConfig.h"
6 #include "TopConfiguration/ConfigurationSettings.h"
7 #include <algorithm>
8 #include <cassert>
9 #include <iterator>
10 #include <sstream>
11 #include <stdexcept>
12 
13 #include <boost/algorithm/string.hpp>
14 #include <boost/algorithm/string/replace.hpp>
15 
16 #include "TopConfiguration/Tokenize.h"
17 #include "TopConfiguration/DuplicateRemoval.h"
18 
19 #include "TopConfiguration/MsgCategory.h"
20 
21 using namespace TopConfiguration;
22 
23 namespace top {
24  TopConfig::TopConfig() :
25  // Prevent any more configuration
26  m_configFixed(false),
27  m_makeAllCPTools(true),
28 
29  // Use which objects
30  m_usePhotons(false),
31  m_useElectrons(false),
32  m_useFwdElectrons(false),
33  m_useMuons(false),
34  m_useSoftMuons(false),
35  m_useAntiMuons(false),
36  m_useTaus(false),
37  m_useJets(false),
38  m_useLargeRJets(false),
39  m_useTrackJets(false),
40  m_useRCJets(false),
41  m_useVarRCJets(false),
42  m_useJetGhostTrack(false),
43  m_useTracks(false),
44  m_useTruthParticles(false),
45  m_useTruthElectrons(false),
46  m_useTruthMuons(false),
47  m_useTruthPhotons(false),
48  m_useTruthJets(false),
49  m_useTruthLargeRJets(false),
50  m_useTruthMET(false),
51 
52  m_applyTTVACut(true),
53 
54  m_demandPriVtx(true),
55 
56  m_jetSubstructureName("None"),
57 
58  m_recomputeCPvars(true),
59 
60  // Do systematics? - this needs many more configuration options
61  m_systematics("SetMe"),
63  m_nominalSystName("Nominal"),
64  m_allSystName("All"),
65 
66  m_DSID(-1),
67  m_MapIndex(0),
68  m_showeringAlgo(SampleXsection::unknown),
69  // Is MC
70  m_isMC(false),
71  // Is AFII
72  m_isAFII(false),
73  // Is Data Overlay
74  m_isDataOverlay(false),
75  // Is Truth xAOD
76  m_isTruthDxAOD(false),
77  // Derivation name
78  m_derivationStream("SetMe"),
79  // Do fakes MM weights calculation using FakeBkgTools from IFF
80  m_doFakesMMWeightsIFF(false),
81  // Configurations for MM fake estimate using FakeBkgTools from IFF
82  m_FakesMMConfigIFF("$ROOTCOREBIN/data/TopFakes/efficiencies.xml:1T:1F[T]"),
83  // Debug level for MM fake estimate using FakeBkgTools from IFF
84  m_doFakesMMIFFDebug(false),
85  //options to select if you want to use loose objects for MET rebuilding instead of the tight ones
86  m_useLooseObjectsInMETInLooseTree(false),
87  m_useLooseObjectsInMETInNominalTree(false),
88  //this will write a separate branch with the met built using loose objects
89  m_writeMETBuiltWithLooseObjects(false),
90  // Apply overlap removal on loose lepton definitons - not the top recommendation, for studies only
91  m_doOverlapRemovalOnLooseLeptonDef(false),
92  // do overlap removal also with large-R jets
93  // (using whatever procedure is used in the official tools)
94  m_doLargeJetOverlapRemoval(false),
95  // do electron-electron overlap removal
96  m_doEleEleOverlapRemoval(false),
97  // Dumps the normal non-"*_Loose" trees
98  m_doTightEvents(true),
99  // Runs Loose selection and dumps the "*_Loose" trees
100  m_doLooseEvents(false),
101  // Runs systematics on the given selection
102  m_doTightSysts(true),
103  m_doLooseSysts(true),
104  // In the *_Loose trees, lepton SFs are calculated considering
105  // tight ID and isolation instead of loose
106  // Only tight leptons are considered in the event SF calculation
107  m_applyTightSFsInLooseTree(false),
108  // For boosted analysis
109  m_applyElectronInJetSubtraction(false),
110  // Write Truth block info
111  m_doTruthBlockInfo(false),
112  // Write Truth PDF info
113  m_doTruthPDFInfo(false),
114  m_doTruthPDFInfoInNominalTrees(false),
115  // Write MC generator weights
116  m_doMCGeneratorWeights(false),
117  m_doMCGeneratorWeightsInNominalTrees(false),
118  m_nominalWeightNames(),
119  m_nominalWeightName("SetMe"),
120  m_nominalWeightIndex(-1),
121  m_forceWeightIndex(false),
122  // Top Parton History
123  m_doTopPartonHistory(false),
124  m_isTopPartonHistoryRegisteredInNtuple(false),
125  m_doTopPartonLevel(true),
126 
127  m_doTopParticleLevel(false),
128  m_doParticleLevelOverlapRemovalMuJet(true),
129  m_doParticleLevelOverlapRemovalElJet(true),
130  m_doParticleLevelOverlapRemovalJetPhoton(false),
131  m_useParticleLevelOverlapRemovalWithRapidity(true),
132 
133  // KLFitter
134  m_doKLFitter(false),
135  m_KLFitterTransferFunctionsPath("SetMe"),
136  m_KLFitterOutput("SetMe"),
137  m_KLFitterJetSelectionMode("SetMe"),
138  m_KLFitterBTaggingMethod("SetMe"),
139  m_KLFitterLH("SetMe"),
140  m_KLFitterTopMassFixed(true),
141  m_KLFitterSaveAllPermutations(false),
142  m_KLFitterFailOnLessThanXJets(false),
143 
144  // PseudoTop
145  m_doPseudoTop(false),
146 
147  // StoreGate / TStore keys
148  m_sgKeyDummy("SetMe"),
149  m_sgKeyEventInfo("EventInfo"),
150  m_sgKeyPrimaryVertices("PrimaryVertices"),
151  m_sgKeyPhotons("SetMe"),
152  m_sgKeyElectrons("SetMe"),
153  m_sgKeyFwdElectrons("SetMe"),
154  m_sgKeyMuons("SetMe"),
155  m_sgKeySoftMuons("SetMe"),
156  m_sgKeyTaus("SetMe"),
157  m_sgKeyJets("SetMe"),
158  m_sgKeyLargeRJets("SetMe"),
159  m_sgKeyTrackJets("SetMe"),
160  m_sgKeyMissingEt("MET"),
161  m_sgKeyMissingEtLoose("LooseMET"),
162 
163  m_sgKeyTruthEvent("TruthEvents"),
164  m_sgKeyMCParticle("SetMe"),
165  m_sgKeyTruthPhotons("TruthPhotons"),
166  m_sgKeyTruthElectrons("TruthElectrons"),
167  m_sgKeyTruthMuons("TruthMuons"),
168  m_sgKeyTruthTaus("TruthTaus"),
169  m_sgKeyTruthJets("SetMe"),
170  m_sgKeyTruthLargeRJets("SetMe"),
171  m_sgKeyTruthMET("MET_Truth"),
172  m_sgKeyTopPartonHistory("TopPartonHistory"),
173 
174  m_sgKeyTopSystematicEvents("TopSystematicEvents"),
175  m_sgKeyTopSystematicEventsLoose("TopSystematicEventsLoose"),
176  m_passEventSelectionDecoration("passEventSelection"),
177  m_decoKeyJetGhostTrack("GhostTrack"),
178  m_sgKeyInDetTrackParticles("InDetTrackParticles"),
179  m_sgKeyTracks("SetMe"),
180 
181 
182  m_jetResponseMatchingDeltaR(-1),
183 
184  // special: allow to dump the systematics-shifted b-tagging SFs in the systematics trees
185  m_dumpBtagSystsInSystTrees(false),
186 
187  m_storePerJetBtagSFs(false),
188 
189  // Electron configuration
190  m_egammaSystematicModel("1NP_v1"),
191  m_electronEfficiencySystematicModel("TOTAL"),
192  m_electronEfficiencySystematicModelNToys(40),
193  m_electronEfficiencySystematicModelToySeed(12345),
194  m_electronEfficiencySystematicModelRecoSize(400),
195  m_electronEfficiencySystematicModelIdSize(400),
196  m_electronEfficiencySystematicModelIsoSize(400),
197  m_electronEfficiencySystematicModelEtaBinning(""),
198  m_electronEfficiencySystematicModelEtBinning(""),
199  m_electronID("SetMe"),
200  m_electronIDLoose("SetMe"),
201  m_electronVetoLArCrack(true),
202  m_electronPtcut(25000.),
203  m_electronIsolation("SetMe"),
204  m_electronIsolationLoose("SetMe"),
205  m_electronIsolationSF("SetMe"),
206  m_electronIsolationSFLoose("SetMe"),
207  m_electron_d0SigCut(5.0),
208  m_electron_delta_z0(0.5),
209  m_electronIDDecoration("SetMe"),
210  m_electronIDLooseDecoration("SetMe"),
211  m_useElectronChargeIDSelection(false),
212  m_useEgammaLeakageCorrection(true),
213  m_enablePromptLeptonImprovedVetoStudies(false),
214  m_elTrigEffConfig(" "),
215 
216  // Fwd electron configuration
217  m_fwdElectronPtcut(25000.),
218  m_fwdElectronMinEtacut(2.5),
219  m_fwdElectronMaxEtacut(4.9),
220  m_fwdElectronID("SetMe"),
221  m_fwdElectronIDLoose("SetMe"),
222  m_fwdElectronBCIDCleaningMinRun(266904),
223  m_fwdElectronBCIDCleaningMaxRun(311481),
224 
225  // Muon configuration
226  m_muonPtcut(25000.),
227  m_muonEtacut(2.5),
228  m_muonQuality("SetMe"),
229  m_muonUseMVALowPt(false),
230  m_muonUseLowPt(false),
231  m_muonUse2stationMuonsHighPt(true),
232  m_muonQualityLoose("SetMe"),
233  m_muonUseMVALowPtLoose(false),
234  m_muonUseLowPtLoose(false),
235  m_muonUse2stationMuonsHighPtLoose(true),
236  m_muonIsolation("SetMe"),
237  m_muonIsolationLoose("SetMe"),
238  m_muonIsolationSF("SetMe"),
239  m_muonIsolationSFLoose("SetMe"),
240  m_muon_d0SigCut(3.0),
241  m_muon_delta_z0(0.5),
242  m_muonCalibMode("SetMe"),
243  m_muonSmearingSystematicModel("SetMe"),
244  m_muonMuonDoSmearing2stationHighPt(true),
245  m_muonMuonDoExtraSmearingHighPt(false),
246  m_muonBreakDownSystematics(false),
247  m_muonSFCustomInputFolder(" "),
248  m_muonForcePeriod(" "),
249  m_muonForceYear(-1),
250  m_muonForceTrigger(" "),
251 
252  // Soft Muon configuration
253  m_softmuonPtcut(4000.),
254  m_softmuonEtacut(2.5),
255  m_softmuonQuality("SetMe"),
256  m_softmuonUseMVALowPt(false),
257  m_softmuonUseLowPt(false),
258  m_softmuonDRJetcut(0.4),
259  m_softmuonDRJetcutUseRapidity(false),
260  m_softmuonAdditionalTruthInfo(false),
261  m_softmuonAdditionalTruthInfoCheckPartonOrigin(false),
262  m_softmuonAdditionalTruthInfoDoVerbose(false),
263 
264  // Jet configuration
265  m_jetPtcut(25000.),
266  m_jetEtacut(2.5),
267  m_jetPtGhostTracks(30000.),
268  m_jetEtaGhostTracks(2.5),
269  m_jetUncertainties_NPModel("AllNuisanceParameters"),
270  m_jetUncertainties_QGFracFile("None"),
271  m_jetUncertainties_QGHistPatterns(),
272  m_doMultipleJES(false),
273  m_jetJERSmearingModel("Simple"),
274  m_jetJMSOption("None"),
275  m_doLargeRPseudodataJER(false),
276  m_jetCalibSequence("GSC"),
277  m_allowSmallRJMSforAFII(false),
278  m_jetStoreTruthLabels("True"),
279  m_doJVTInMETCalculation(true),
280  m_saveFailJVTJets(false),
281  m_JVTWP("FixedEffPt"),
282  m_doForwardJVTInMETCalculation(false),
283  m_saveFailForwardJVTJets(false),
284  m_fJVTWP("None"),
285 
286  // MET configuration
287  m_METUncertaintiesConfigDir("SetMe"),
288  m_METSignif(false),
289  m_METSignifSoftTermParam("Random"),
290  m_METJetSelectionWP("Tight"),
291 
292  // Ghost Track Configuration
293  m_ghostTrackspT(500.),
294  m_ghostTracksVertexAssociation("nominal"),
295  m_ghostTracksQuality("TightPrimary"),
296 
297  m_largeRJetPtcut(25000.),
298  m_largeRJetMasscut(0.),
299  m_largeRJetEtacut(2.5),
300  m_largeRJetUncertainties_NPModel("CategoryJES_FullJER_FullJMS"),
301  m_largeRJetUncertainties_JMR_NPModel("FullJMR"),
302  m_largeRJetUncertaintiesConfigDir("SetMe"),
303  m_largeRJESJMSConfig("SetMe"),
304 
305  m_trackJetPtcut(7000.0),
306  m_trackJetEtacut(2.5),
307 
308  m_RCJetPtcut(100000.),
309  m_RCJetEtacut(2.0),
310  m_RCInputJetPtMin(0.),
311  m_RCInputJetEtaMax(999.),
312  m_RCJetTrimcut(0.05),
313  m_RCJetRadius(1.0),
314  m_useRCJetSubstructure(false),
315  m_useRCJetAdditionalSubstructure(false),
316 
317  m_VarRCJetPtcut(100000.),
318  m_VarRCJetEtacut(2.0),
319  m_VarRCJetTrimcut(0.05),
320  m_VarRCJetMaxRadius(1.0),
321  m_VarRCJetRho("2"),
322  m_VarRCJetMassScale("m_w,m_z,m_h,m_t"),
323  m_useVarRCJetSubstructure(false),
324  m_useVarRCJetAdditionalSubstructure(false),
325 
326  m_trackQuality("SetMe"),
327 
328  m_JSF(1.0),
329  m_bJSF(1.0),
330 
331  // Tau configuration
340  // [[[-----------------------------------------------
341  // Particle Level / Truth Configuration
342  m_truth_electron{25000., 2.5, true, false},
343  m_truth_muon{25000., 2.5, true, false},
344  m_truth_softmuon{4000., 2.5},
345  m_truth_photon{25000., 2.5, "SET_ME", "SET_ME"},
346  m_truth_jet{25000., 2.5},
347  // -----------------------------------------------]]]
348 
349  // Selections
350  m_allSelectionNames(nullptr),
351  // Trigger
352  m_allTriggers_Tight(nullptr),
353  m_electronTriggers_Tight(nullptr),
354  m_muonTriggers_Tight(nullptr),
355  m_tauTriggers_Tight(nullptr),
356  m_photonTriggers_Tight(nullptr),
357  m_allTriggers_Loose(nullptr),
358  m_electronTriggers_Loose(nullptr),
359  m_muonTriggers_Loose(nullptr),
360  m_tauTriggers_Loose(nullptr),
361  m_photonTriggers_Loose(nullptr),
362  m_trigMatchElemRelink(false),
363 
364  // Where the sum of event weights
365  // before derivation framework is kept
366  m_sumOfEventWeightsMetaData("CutBookkeepersAux.sumOfEventWeights"),
367 
368  // Object Selector name
369  m_objectSelectionName("SetMe"),
370  // Output Format
371  m_outputFormat("SetMe"),
372  // Output Events
373  m_outputEvents("SetMe"),
374  m_saveOnlySelectedEvents(true),
375  m_outputFileSetAutoFlushZero(false),
376  m_outputFileNEventAutoFlush(1000), // 1000 events
377  m_outputFileBasketSizePrimitive(4096), // 4kB
378  m_outputFileBasketSizeVector(40960), // 40kB
379  // Number of events to run on (only for testing)
380  m_numberOfEventsToRun(0),
381 
382  // Number of events to skip (only for testing)
383  m_numberOfEventsToSkip(0),
384 
385  // Systematics
386  m_nominalHashValue(0),
387 
388  m_systHashPhotons(nullptr),
389  m_systHashElectrons(nullptr),
390  m_systHashFwdElectrons(nullptr),
391  m_systHashMuons(nullptr),
392  m_systHashSoftMuons(nullptr),
393  m_systHashTaus(nullptr),
394  m_systHashJets(nullptr),
395  m_systHashLargeRJets(nullptr),
396  m_systHashTrackJets(nullptr),
397  m_systHashTracks(nullptr),
398  m_systHashMET(nullptr),
399 
400  m_systHashAll(nullptr),
401  m_list_systHashAll(nullptr),
402  m_systHash_electronInJetSubtraction(nullptr),
403  m_list_systHash_electronInJetSubtraction(nullptr),
404 
405 
406  m_systMapPhotons(nullptr),
407  m_systMapElectrons(nullptr),
408  m_systMapFwdElectrons(nullptr),
409  m_systMapMuons(nullptr),
410  m_systMapSoftMuons(nullptr),
411  m_systMapTaus(nullptr),
412  m_systMapJets(nullptr),
413  m_systMapLargeRJets(nullptr),
414  m_systMapTrackJets(nullptr),
415  m_systMapTracks(nullptr),
416  m_systMapMET(nullptr),
417 
418  m_systSgKeyMapPhotons(nullptr),
419  m_systSgKeyMapElectrons(nullptr),
420  m_systSgKeyMapFwdElectrons(nullptr),
421  m_systSgKeyMapMuons(nullptr),
422  m_systSgKeyMapSoftMuons(nullptr),
423  m_systSgKeyMapTaus(nullptr),
424  m_systSgKeyMapJets(nullptr),
425  m_systSgKeyMapJets_electronInJetSubtraction(nullptr),
426  m_systSgKeyMapJetsLoose_electronInJetSubtraction(nullptr),
427  m_systSgKeyMapLargeRJets(nullptr),
428  m_systSgKeyMapTrackJets(nullptr),
429  m_systSgKeyMapTracks(nullptr),
430  m_systSgKeyMapMET(nullptr),
431 
432  m_systAllSgKeyMapPhotons(nullptr),
433  m_systAllSgKeyMapElectrons(nullptr),
434  m_systAllSgKeyMapFwdElectrons(nullptr),
435  m_systAllSgKeyMapMuons(nullptr),
436  m_systAllSgKeyMapSoftMuons(nullptr),
437  m_systAllSgKeyMapTaus(nullptr),
438  m_systAllSgKeyMapJets(nullptr),
439  m_systAllSgKeyMapLargeRJets(nullptr),
440  m_systAllSgKeyMapTrackJets(nullptr),
441  m_systAllSgKeyMapTracks(nullptr),
442  m_systAllSgKeyMapElectrons_electronInJetSubtraction(nullptr),
443  m_systAllSgKeyMapJets_electronInJetSubtraction(nullptr),
444  m_systAllSgKeyMapJetsLoose_electronInJetSubtraction(nullptr),
445 
446  m_systAllSgKeyMapPhotonsTDS(nullptr),
447  m_systAllSgKeyMapPhotonsTDSAux(nullptr),
448  m_systAllSgKeyMapElectronsTDS(nullptr),
449  m_systAllSgKeyMapElectronsTDSAux(nullptr),
450  m_systAllSgKeyMapFwdElectronsTDS(nullptr),
451  m_systAllSgKeyMapFwdElectronsTDSAux(nullptr),
452  m_systAllSgKeyMapMuonsTDS(nullptr),
453  m_systAllSgKeyMapMuonsTDSAux(nullptr),
454  m_systAllSgKeyMapSoftMuonsTDS(nullptr),
455  m_systAllSgKeyMapSoftMuonsTDSAux(nullptr),
456  m_systAllSgKeyMapTausTDS(nullptr),
457  m_systAllSgKeyMapTausTDSAux(nullptr),
458  m_systAllSgKeyMapJetsTDS(nullptr),
459  m_systAllSgKeyMapJetsTDSAux(nullptr),
460  m_systAllSgKeyMapLargeRJetsTDS(nullptr),
461  m_systAllSgKeyMapLargeRJetsTDSAux(nullptr),
462  m_systAllSgKeyMapTrackJetsTDS(nullptr),
463  m_systAllSgKeyMapTrackJetsTDSAux(nullptr),
464  m_systAllSgKeyMapTracksTDS(nullptr),
465  m_systAllSgKeyMapTracksTDSAux(nullptr),
466  m_systAllSgKeyMapElectrons_electronInJetSubtractionTDS(nullptr),
467  m_systAllSgKeyMapElectrons_electronInJetSubtractionTDSAux(nullptr),
468  m_systAllSgKeyMapJets_electronInJetSubtractionTDS(nullptr),
469  m_systAllSgKeyMapJets_electronInJetSubtractionTDSAux(nullptr),
470  m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDS(nullptr),
471  m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDSAux(nullptr),
472 
473  m_systSgKeyMapMissingET(nullptr),
474  m_systSgKeyMapMissingETLoose(nullptr),
475 
476  m_sgKeyKLFitter("KLFitterResults"),
477  m_systSgKeyMapKLFitter(nullptr),
478  m_systSgKeyMapKLFitterLoose(nullptr),
479 
480  m_sgKeyPseudoTop("PseudoTopResult"),
481  m_systSgKeyMapPseudoTop(nullptr),
482  m_systSgKeyMapPseudoTopLoose(nullptr),
483  m_systMapJetGhostTrack(nullptr),
484  m_systDecoKeyMapJetGhostTrack(nullptr),
485 
486  m_systAllTTreeNames(nullptr),
487  m_systPersistantAllTTreeNames(nullptr),
488  m_systAllTTreeIndex(nullptr),
489  m_systAllTTreeLooseIndex(nullptr),
490  m_saveBootstrapWeights(false),
491  m_BootstrapReplicas(100),
492  m_useBadBatmanCleaning(true),
493  m_badBatmanCleaningMin(276262),
494  m_badBatmanCleaningMax(311481),
495  m_useEventLevelJetCleaningTool(false),
496  m_year("UNKNOWN") {
497 
498  m_allSelectionNames = std::shared_ptr<std::vector<std::string> > (new std::vector<std::string> );
499 
500  m_systHashPhotons = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
501  m_systHashElectrons = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
502  m_systHashFwdElectrons = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
503  m_systHashMuons = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
504  m_systHashSoftMuons = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
505  m_systHashTaus = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
506  m_systHashJets = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
507  m_systHashLargeRJets = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
508  m_systHashTrackJets = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
509  m_systHashTracks = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
510  m_systHashMET = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
511 
512  m_systHashAll = std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
513  m_list_systHashAll = std::shared_ptr<std::list<std::size_t> > (new std::list<std::size_t> );
514  m_systHash_electronInJetSubtraction =
515  std::shared_ptr<std::unordered_set<std::size_t> > (new std::unordered_set<std::size_t> );
516  m_list_systHash_electronInJetSubtraction = std::shared_ptr<std::list<std::size_t> > (new std::list<std::size_t> );
517 
518  m_systMapPhotons =
519  std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
520  CP::SystematicSet> );
521  m_systMapElectrons =
522  std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
523  CP::SystematicSet> );
524  m_systMapFwdElectrons = std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (
525  new std::unordered_map<std::size_t, CP::SystematicSet> );
526  m_systMapMuons =
527  std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
528  CP::SystematicSet> );
529  m_systMapSoftMuons =
530  std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
531  CP::SystematicSet> );
532  m_systMapTaus =
533  std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
534  CP::SystematicSet> );
535  m_systMapJets =
536  std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
537  CP::SystematicSet> );
538  m_systMapLargeRJets =
539  std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
540  CP::SystematicSet> );
541  m_systMapTrackJets =
542  std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
543  CP::SystematicSet> );
544  m_systMapTracks =
545  std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
546  CP::SystematicSet> );
547 
548 
549 
550  m_systMapMET =
551  std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (new std::unordered_map<std::size_t,
552  CP::SystematicSet> );
553 
554  m_systSgKeyMapPhotons =
555  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
556  std::string> );
557  m_systSgKeyMapElectrons =
558  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
559  std::string> );
560  m_systSgKeyMapFwdElectrons =
561  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
562  std::string> );
563  m_systSgKeyMapMuons =
564  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
565  std::string> );
566  m_systSgKeyMapSoftMuons =
567  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
568  std::string> );
569  m_systSgKeyMapTaus =
570  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
571  std::string> );
572  m_systSgKeyMapJets =
573  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
574  std::string> );
575  m_systSgKeyMapJets_electronInJetSubtraction = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
576  new std::unordered_map<std::size_t, std::string> );
577  m_systSgKeyMapJetsLoose_electronInJetSubtraction = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
578  new std::unordered_map<std::size_t, std::string> );
579  m_systSgKeyMapLargeRJets =
580  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
581  std::string> );
582  m_systSgKeyMapTrackJets =
583  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
584  std::string> );
585 
586  m_systSgKeyMapTracks =
587  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
588  std::string> );
589 
590 
591  m_systSgKeyMapMET =
592  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
593  std::string> );
594 
595  m_systAllSgKeyMapPhotons =
596  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
597  std::string> );
598  m_systAllSgKeyMapElectrons =
599  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
600  std::string> );
601  m_systAllSgKeyMapFwdElectrons = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
602  new std::unordered_map<std::size_t, std::string> );
603  m_systAllSgKeyMapMuons =
604  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
605  std::string> );
606  m_systAllSgKeyMapSoftMuons =
607  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
608  std::string> );
609  m_systAllSgKeyMapTaus =
610  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
611  std::string> );
612  m_systAllSgKeyMapJets =
613  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
614  std::string> );
615  m_systAllSgKeyMapLargeRJets = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
616  new std::unordered_map<std::size_t, std::string> );
617  m_systAllSgKeyMapTrackJets =
618  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
619  std::string> );
620  m_systAllSgKeyMapTracks =
621  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
622  std::string> );
623 
624  m_systAllSgKeyMapElectrons_electronInJetSubtraction
625  = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
626  std::string> );
627  m_systAllSgKeyMapJets_electronInJetSubtraction
628  = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
629  std::string> );
630  m_systAllSgKeyMapJetsLoose_electronInJetSubtraction
631  = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
632  std::string> );
633 
634  m_systAllSgKeyMapPhotonsTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
635  new std::unordered_map<std::size_t, std::string> );
636  m_systAllSgKeyMapPhotonsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
637  new std::unordered_map<std::size_t, std::string> );
638  m_systAllSgKeyMapElectronsTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
639  new std::unordered_map<std::size_t, std::string> );
640  m_systAllSgKeyMapElectronsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
641  new std::unordered_map<std::size_t, std::string> );
642  m_systAllSgKeyMapFwdElectronsTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
643  new std::unordered_map<std::size_t, std::string> );
644  m_systAllSgKeyMapFwdElectronsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
645  new std::unordered_map<std::size_t, std::string> );
646  m_systAllSgKeyMapMuonsTDS =
647  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
648  std::string> );
649  m_systAllSgKeyMapMuonsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
650  new std::unordered_map<std::size_t, std::string> );
651  m_systAllSgKeyMapSoftMuonsTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
652  new std::unordered_map<std::size_t, std::string> );
653  m_systAllSgKeyMapSoftMuonsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
654  new std::unordered_map<std::size_t, std::string> );
655  m_systAllSgKeyMapTausTDS =
656  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
657  std::string> );
658  m_systAllSgKeyMapTausTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
659  new std::unordered_map<std::size_t, std::string> );
660  m_systAllSgKeyMapJetsTDS =
661  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
662  std::string> );
663  m_systAllSgKeyMapJetsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
664  new std::unordered_map<std::size_t, std::string> );
665  m_systAllSgKeyMapLargeRJetsTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
666  new std::unordered_map<std::size_t, std::string> );
667  m_systAllSgKeyMapLargeRJetsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
668  new std::unordered_map<std::size_t, std::string> );
669  m_systAllSgKeyMapTrackJetsTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
670  new std::unordered_map<std::size_t, std::string> );
671  m_systAllSgKeyMapTrackJetsTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
672  new std::unordered_map<std::size_t, std::string> );
673  m_systAllSgKeyMapTracksTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
674  new std::unordered_map<std::size_t, std::string> );
675  m_systAllSgKeyMapTracksTDSAux = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
676  new std::unordered_map<std::size_t, std::string> );
677 
678  m_systAllSgKeyMapElectrons_electronInJetSubtractionTDS =
679  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
680  std::string> );
681  m_systAllSgKeyMapElectrons_electronInJetSubtractionTDSAux =
682  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
683  std::string> );
684  m_systAllSgKeyMapJets_electronInJetSubtractionTDS = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
685  new std::unordered_map<std::size_t, std::string> );
686  m_systAllSgKeyMapJets_electronInJetSubtractionTDSAux =
687  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
688  std::string> );
689  m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDS =
690  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
691  std::string> );
692  m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDSAux =
693  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
694  std::string> );
695 
696 
697  m_systSgKeyMapMissingET =
698  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
699  std::string> );
700  m_systSgKeyMapMissingETLoose = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
701  new std::unordered_map<std::size_t, std::string> );
702 
703  m_systSgKeyMapKLFitter =
704  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
705  std::string> );
706  m_systSgKeyMapKLFitterLoose = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
707  new std::unordered_map<std::size_t, std::string> );
708 
709  m_systSgKeyMapPseudoTop =
710  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
711  std::string> );
712  m_systSgKeyMapPseudoTopLoose = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
713  new std::unordered_map<std::size_t, std::string> );
714 
715  m_systMapJetGhostTrack = std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > (
716  new std::unordered_map<std::size_t, CP::SystematicSet> );
717  m_systDecoKeyMapJetGhostTrack = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
718  new std::unordered_map<std::size_t, std::string> );
719 
720 
721  m_systAllTTreeNames =
722  std::shared_ptr<std::unordered_map<std::size_t, std::string> > (new std::unordered_map<std::size_t,
723  std::string> );
724  m_systPersistantAllTTreeNames = std::shared_ptr<std::unordered_map<std::size_t, std::string> > (
725  new std::unordered_map<std::size_t, std::string> );
726  m_systAllTTreeIndex =
727  std::shared_ptr<std::unordered_map<std::size_t, unsigned int> > (new std::unordered_map<std::size_t,
728  unsigned int> );
729  m_systAllTTreeLooseIndex =
730  std::shared_ptr<std::unordered_map<std::size_t, unsigned int> > (new std::unordered_map<std::size_t,
731  unsigned int> );
732 
733  // Nominal has value
734  CP::SystematicSet nominal;
735  m_nominalHashValue = nominal.hash();
736 
737  m_treeFilter = std::make_shared<TreeFilter>();
738  }
739 
740  void TopConfig::setConfigSettings(top::ConfigurationSettings* const& settings) {
741  // Selections
742  const std::vector<top::SelectionConfigurationData> allSelections = settings->selections();
743 
744  for (auto sel : allSelections) {
745  m_allSelectionNames->push_back(sel.m_name);
746  }
747 
748  // set GRL file
749  this->setGrlDir(settings->value("GRLDir"));
750  this->setGrlFile(settings->value("GRLFile"));
751 
752  // Set TDP file name
753  this->setTDPPath(settings->value("TDPPath"));
754 
755  m_treeFilter->init(settings->value("FilterTrees"));
756 
757 
758  //we need storegate keys so people can pick different collections / met / jets etc.
759  this->sgKeyPhotons(settings->value("PhotonCollectionName"));
760  this->sgKeyElectrons(settings->value("ElectronCollectionName"));
761  this->sgKeyFwdElectrons(settings->value("FwdElectronCollectionName"));
762  this->sgKeyMuons(settings->value("MuonCollectionName"));
763  //small trick for the soft muons
764  if (settings->value("UseSoftMuons") == "True") this->sgKeySoftMuons("Soft" + settings->value("MuonCollectionName"));
765 
766  else this->sgKeySoftMuons("None");
767  this->sgKeyTaus(settings->value("TauCollectionName"));
768  this->sgKeyJets(settings->value("JetCollectionName"));
769  this->sgKeyLargeRJets(settings->value("LargeJetCollectionName"));
770  this->sgKeyTrackJets(settings->value("TrackJetCollectionName"));
771  this->sgKeyTracks(settings->value("TrackCollectionName"));
772  this->jetSubstructureName(settings->value("LargeJetSubstructure"));
773  this->decoKeyJetGhostTrack(settings->value("JetGhostTrackDecoName"));
774 
775  // ROOTCORE/Analysis release series
776  this->setReleaseSeries();
777 
778  if (settings->value("applyTTVACut") == "False") this->m_applyTTVACut = false;
779 
780  if (this->isMC()) {
781  this->sgKeyMCParticle(settings->value("TruthCollectionName"));
782  this->sgKeyTruthElectrons(settings->value("TruthElectronCollectionName"));
783  this->sgKeyTruthMuons(settings->value("TruthMuonCollectionName"));
784  this->sgKeyTruthPhotons(settings->value("TruthPhotonCollectionName"));
785  this->sgKeyTruthMET(settings->value("TruthMETCollectionName"));
786  this->sgKeyTruthJets(settings->value("TruthJetCollectionName"));
787  this->sgKeyTruthLargeRJets(settings->value("TruthLargeRJetCollectionName"));
788  this->sgKeyTruthTaus(settings->value("TruthTauCollectionName"));
789 
790  // Dump truth block
791  if (settings->value("TruthBlockInfo") == "True") this->setTruthBlockInfo();
792 
793  // Save the Truth PDF information
794  if (settings->value("PDFInfo") == "True") {
795  this->setTruthPDFInfo();
796  } else if (settings->value("PDFInfo") == "Nominal") {
797  // Save the Truth PDF information in the reco-level tree instead of the truth-level one
798  this->setTruthPDFInfo();
799  this->setTruthPDFInfoInNominalTrees();
800  }
801 
802  // Save the MC generator weights
803  if (settings->value("MCGeneratorWeights") == "True") {
804  this->setMCGeneratorWeights();
805  } else if (settings->value("MCGeneratorWeights") == "Nominal") {
806  // Save the Truth PDF information in the reco-level tree instead of the truth-level one
807  this->setMCGeneratorWeights();
808  this->setMCGeneratorWeightsInNominalTrees();
809  }
810 
811  // load the nominal weight names that we should try to get the real nominal weight name
812  const std::string& tmp = settings->value("NominalWeightNames");
813 
814  // Remove the whitespaces between the names but keep
815  // the whitespaces within quotation marks
816  std::string trimmedName = "";
817  bool deleteSpaces = true;
818  bool start = false;
819  for(unsigned int i = 0; i < tmp.size(); ++i) {
820  if(tmp[i] == '\"') {
821  start ? start = false : start = true;
822  if(start) {
823  deleteSpaces = false;
824  }
825  }
826  if(!start) {
827  deleteSpaces = true;
828  }
829  if(deleteSpaces) {
830  if(tmp[i] != ' ') {
831  trimmedName += tmp[i];
832  }
833  } else {
834  trimmedName += tmp[i];
835  }
836  }
837  boost::split(m_nominalWeightNames, trimmedName, boost::is_any_of(","));
838  // now remove all occurences of '"'
839  for (std::string& iname : m_nominalWeightNames) {
840  iname.erase(std::remove(iname.begin(), iname.end(), '"'), iname.end());
841  // and check if we have newline characters (some weight have those...)
842  // and parse them properly
843  boost::replace_all(iname, "\\n", "\n");
844  }
845 
846  try {
847  m_nominalWeightIndex = std::stoi(settings->value("NominalWeightFallbackIndex"));
848  } catch (std::invalid_argument &e) {
849  ATH_MSG_ERROR("Failed to parse NominalWeightFallbackIndex value: " << settings->value("NominalWeightFallbackIndex"));
850  throw;
851  }
852 
853  settings->retrieve("ForceNominalWeightFallbackIndex", m_forceWeightIndex);
854 
855  // Save the Top Parton History
856  if (settings->value("TopPartonHistory") != "False") this->setTopPartonHistory();
857 
858  // Perform parton-level selection and save particle level objects
859  bool topPartonLevel=true;
860  settings->retrieve("TopPartonLevel",topPartonLevel);
861  this->setTopPartonLevel(topPartonLevel);
862 
863  // Perform particle-level selection and save particle level objects
864  bool topParticleLevel=true;
865  settings->retrieve("TopParticleLevel",topParticleLevel);
866  this->setTopParticleLevel(topParticleLevel);
867 
868  // Particle-level OR
869  if (settings->value("DoParticleLevelOverlapRemoval") == "True") {
870  // Value True -> Do all ORs
871  this->setParticleLevelOverlapRemovalElJet(true);
872  this->setParticleLevelOverlapRemovalMuJet(true);
873  this->setParticleLevelOverlapRemovalJetPhoton(true);
874  } else if (settings->value("DoParticleLevelOverlapRemoval") == "False") {
875  // Value False -> Do not perform any OR.
876  this->setParticleLevelOverlapRemovalElJet(false);
877  this->setParticleLevelOverlapRemovalMuJet(false);
878  this->setParticleLevelOverlapRemovalJetPhoton(false);
879  } else {
880  // Explicitly specify the possible OR values.
881  std::vector<std::string> tokens;
882  tokenize(settings->value("DoParticleLevelOverlapRemoval"), tokens, ",");
883  while (tokens.size()) {
884  const auto& token = tokens.back();
885 
886  if (token == "MuonJet") {
887  this->setParticleLevelOverlapRemovalMuJet(true);
888  } else if (token == "ElectronJet") {
889  this->setParticleLevelOverlapRemovalElJet(true);
890  } else if (token == "JetPhoton") {
891  this->setParticleLevelOverlapRemovalJetPhoton(true);
892  } else {
893  throw std::runtime_error {
894  "TopConfig: Option DoParticleLevelOverlapRemoval: Invalid Token"
895  };
896  }
897 
898  // Remove the last token in the container.
899  tokens.pop_back();
900  }
901  }
902 
903  // Particle level overlap removal use rapidity in deltaR calculation
904  if(settings->value("OverlapRemovalParticleLevelUseRapidity") == "True"){
905  this->setParticleLevelOverlapRemovalWithRapidity(true);
906  }
907  else{
908  this->setParticleLevelOverlapRemovalWithRapidity(false);
909  }
910 
911  }
912 
913  // Get list of branches to be filtered
914  if (settings->value("FilterBranches") != " ") {
915  std::vector<std::string> branches;
916  tokenize(settings->value("FilterBranches"), branches, ",");
917 
918  if (branches.size() == 0) {
919  ATH_MSG_WARNING("You provided \"FilterBranches\" option but you did not provide any meaningful values. Ignoring");
920  }
921  this->setFilterBranches(branches);
922  }
923 
924  // Get list of PartonLevel branches to be filtered
925  if (settings->value("FilterPartonLevelBranches") != " ") {
926  std::vector<std::string> branches;
927  tokenize(settings->value("FilterPartonLevelBranches"), branches, ",");
928 
929  if (branches.size() == 0) {
930  ATH_MSG_WARNING("You provided \"FilterPartonLevelBranches\" option but you did not provide any meaningful values. Ignoring");
931  }
932  this->setFilterPartonLevelBranches(branches);
933  }
934 
935  // Get list of ParticleLevel branches to be filtered
936  if (settings->value("FilterParticleLevelBranches") != " ") {
937  std::vector<std::string> branches;
938  tokenize(settings->value("FilterParticleLevelBranches"), branches, ",");
939 
940  if (branches.size() == 0) {
941  ATH_MSG_WARNING("You provided \"FilterParticleLevelBranches\" option but you did not provide any meaningful values. Ignoring");
942  }
943  this->setFilterParticleLevelBranches(branches);
944  }
945 
946  // Get list of nominal_Loose branches to be filtered
947  if (settings->value("FilterNominalLooseBranches") != " ") {
948  std::vector<std::string> branches;
949  tokenize(settings->value("FilterNominalLooseBranches"), branches, ",");
950 
951  if (branches.size() == 0) {
952  ATH_MSG_WARNING("You provided \"FilterNominalLooseBranches\" option but you did not provide any meaningful values. Ignoring");
953  }
954  this->setFilterNominalLooseBranches(branches);
955  }
956 
957  // Get list of nominal branches to be filtered
958  if (settings->value("FilterNominalBranches") != " ") {
959  std::vector<std::string> branches;
960  tokenize(settings->value("FilterNominalBranches"), branches, ",");
961 
962  if (branches.size() == 0) {
963  ATH_MSG_WARNING("You provided \"FilterNominalBranches\" option but you did not provide any meaningful values. Ignoring");
964  }
965  this->setFilterNominalBranches(branches);
966  }
967 
968  // Force recomputation of CP variables?
969  if (settings->value("RecomputeCPVariables") == "False") m_recomputeCPvars = false;
970 
971  // Bootstrapping weights (permitted in MC and Data)
972  if (settings->value("SaveBootstrapWeights") == "True") {
973  this->setSaveBootstrapWeights(true);
974  this->setNumberOfBootstrapReplicas(std::atoi(settings->value("NumberOfBootstrapReplicas").c_str()));
975  }
976 
977  settings->retrieve("UseLooseObjectsInMETInLooseTree", m_useLooseObjectsInMETInLooseTree);
978  settings->retrieve("UseLooseObjectsInMETInNominalTree", m_useLooseObjectsInMETInNominalTree);
979  settings->retrieve("WriteMETBuiltWithLooseObjects", m_writeMETBuiltWithLooseObjects);
980 
981  if (this->isMC()) {
982  m_doLooseEvents = (settings->value("DoLoose") == "MC" || settings->value("DoLoose") == "Both");
983  m_doTightEvents = (settings->value("DoTight") == "MC" || settings->value("DoTight") == "Both");
984  m_doLooseSysts = (settings->value("DoSysts") == "Loose" || settings->value("DoSysts") == "Both") &&
985  m_doLooseEvents;
986  m_doTightSysts = (settings->value("DoSysts") == "Tight" || settings->value("DoSysts") == "Both") &&
987  m_doTightEvents;
988  } else {
989  m_doLooseEvents = (settings->value("DoLoose") == "Data" || settings->value("DoLoose") == "Both");
990  if (m_doLooseEvents) {
991  if (settings->value("FakesMMWeightsIFF") == "True") {
992  this->setFakesMMWeightsCalculationIFF();
993  std::string configIFF = settings->value("FakesMMConfigIFF");
994  if (configIFF != "") {
995  this->setFakesMMConfigIFF(configIFF);
996  }
997  if (settings->value("FakesMMIFFDebug") == "True") {
998  this->setFakesMMIFFDebug();
999  }
1000  }
1001  }
1002  m_doTightEvents = (settings->value("DoTight") == "Data" || settings->value("DoTight") == "Both");
1003  }
1004 
1005  // Switch to set event BadBatman cleaning
1006  if (settings->value("UseBadBatmanCleaning") == "False") {
1007  this->setUseBadBatmanCleaning(false);
1008  } else if (settings->value("UseBadBatmanCleaning") == "True") {
1009  this->setUseBadBatmanCleaning(true);
1010  } else {
1011  throw std::invalid_argument {
1012  "TopConfig: Option UseBadBatmanCleaning unknown value, only True or False (default) is allowed"
1013  };
1014  }
1015 
1016  // now check the ranges of the batman cleaning
1017  {
1018  std::vector<std::string> tokens;
1019  tokenize(settings->value("BadBatmanCleaningRange"), tokens, ":");
1020  if (tokens.size() != 2) {
1021  throw std::runtime_error {
1022  "TopConfig: Option BadBatmanCleaningRange should be of the form \'RunNumber1:RunNumber2\'"
1023  };
1024  }
1025  unsigned int minRunNumber = 999999;
1026  unsigned int maxRunNumber = 0;
1027  try { // convert the values from string to unsigned int
1028  minRunNumber = std::stoul(tokens.at(0));
1029  maxRunNumber = std::stoul(tokens.at(1));
1030  } catch (...) {
1031  throw std::invalid_argument {
1032  "TopConfig: Option BadBatmanCleaningRange cannot convert the RunNumbers into unsigned int"
1033  };
1034  }
1035 
1036  // check if the first value is not larger than the second value
1037  if (maxRunNumber < minRunNumber) {
1038  throw std::invalid_argument {
1039  "TopConfig: Option BadBatmanCleaningRange: the first RunNumber cannot be larger than the second!"
1040  };
1041  }
1042 
1043  // check if there is an overlap with data 2017 as this option should not be used for this period
1044  static const unsigned int data17_begin = 325713;
1045  static const unsigned int data17_end = 348835;
1046 
1047  if (std::max(minRunNumber, data17_begin) <= std::min(maxRunNumber, data17_end)) {
1048  throw std::invalid_argument {
1049  "TopConfig: Option BadBatmanCleaningRange cannot include RunNumbers from 2017 data taking (325713-348835)"
1050  };
1051  }
1052 
1053  this->setBadBatmanCleaningMin(minRunNumber);
1054  this->setBadBatmanCleaningMax(maxRunNumber);
1055  }
1056 
1057  // Switch to set event level jet cleaning tool [false by default]
1058  if (settings->value("UseEventLevelJetCleaningTool") == "True") {
1059  this->setUseEventLevelJetCleaningTool(true);
1060  }
1061 
1062  // Object Selection Name
1063  this->objectSelectionName(settings->value("ObjectSelectionName"));
1064  // Output Format
1065  this->outputFormat(settings->value("OutputFormat"));
1066  // Output Events
1067  this->outputEvents(settings->value("OutputEvents"));
1068  // SetAutoFlush(0) on EventSaverFlatNtuple for ANALYSISTO-44 workaround
1069  m_outputFileSetAutoFlushZero = false;
1070  if (settings->value("OutputFileSetAutoFlushZero") != "False") {
1071  ATH_MSG_WARNING("OutputFileSetAutoFlushZero is deprecated in favour of more custom memory options");
1072  }
1073  // Configurable TTree options (ANALYSISTO-463)
1074  if (settings->value("OutputFileNEventAutoFlush") != "") {
1075  m_outputFileNEventAutoFlush = std::stoi(settings->value("OutputFileNEventAutoFlush"));
1076  }
1077  if (settings->value("OutputFileBasketSizePrimitive") != "") {
1078  m_outputFileBasketSizePrimitive = std::stoi(settings->value("OutputFileBasketSizePrimitive"));
1079  }
1080  if (settings->value("OutputFileBasketSizeVector") != "") {
1081  m_outputFileBasketSizeVector = std::stoi(settings->value("OutputFileBasketSizeVector"));
1082  }
1083 
1084  // The systematics want much much more configuration options.....
1085  this->systematics(settings->value("Systematics"));
1086 
1087  // special: allow to dump the systematics-shifted b-tagging SFs in the systematics trees
1088  if (settings->value("DumpBtagSystsInSystTrees") == "True") this->dumpBtagSystsInSystTrees(true);
1089 
1090  // special: store per-jet btag SFs
1091  if (settings->value("StorePerJetBtagSFs") == "True") this->storePerJetBtagSFs(true);
1092 
1093  // Electron configuration
1094  this->egammaSystematicModel(settings->value("EgammaSystematicModel"));
1095  this->electronEfficiencySystematicModel(settings->value("ElectronEfficiencySystematicModel"));
1096  this->electronEfficiencySystematicModelEtaBinning(settings->value("ElectronEfficiencySystematicModelEtaBinning"));
1097  this->electronEfficiencySystematicModelEtBinning(settings->value("ElectronEfficiencySystematicModelEtBinning"));
1098  this->electronEfficiencySystematicModelNToys(std::stof(settings->value("ElectronEfficiencySystematicModelNToys")));
1099  this->electronEfficiencySystematicModelToySeed(std::stof(settings->value("ElectronEfficiencySystematicModelToySeed")));
1100  this->electronID(settings->value("ElectronID"));
1101  this->electronIDLoose(settings->value("ElectronIDLoose"));
1102  {
1103  std::string const& cut_wp = settings->value("ElectronIsolation");
1104  std::string const& sf_wp = settings->value("ElectronIsolationSF");
1105  this->electronIsolation(cut_wp);
1106  this->electronIsolationSF(sf_wp == " " ? cut_wp : sf_wp);
1107 
1108  const std::string &isoWPs_str = settings->value("ElectronIsolationWPs");
1109  tokenize(isoWPs_str, m_electronIsolationWPs, " ", true);
1110  if (cut_wp != "None")
1111  m_electronIsolationWPs.emplace_back(cut_wp);
1112  }
1113  {
1114  std::string const& cut_wp = settings->value("ElectronIsolationLoose");
1115  std::string const& sf_wp = settings->value("ElectronIsolationSFLoose");
1116  this->electronIsolationLoose(cut_wp);
1117  this->electronIsolationSFLoose(sf_wp == " " ? cut_wp : sf_wp);
1118  if (cut_wp != "None")
1119  m_electronIsolationWPs.emplace_back(cut_wp);
1120  }
1121  remove_duplicates(m_electronIsolationWPs);
1122  this->useElectronChargeIDSelection(settings->value("UseElectronChargeIDSelection"));
1123  this->useEgammaLeakageCorrection(settings->value("UseEgammaLeakageCorrection"));
1124  this->electronPtcut(std::stof(settings->value("ElectronPt")));
1125  this->electrond0Sigcut(std::stof(settings->value("Electrond0Sig")));
1126  this->electrondeltaz0cut(std::stof(settings->value("Electrondeltaz0")));
1127  this->enablePromptLeptonImprovedVetoStudies(settings->value("EnablePromptLeptonImprovedVetoStudies"));
1128 
1129  {
1130  const std::string elTrigConfig = settings->value("ElectronTriggerEfficiencyConfig");
1131  if (elTrigConfig == " ") {
1132  throw std::invalid_argument{"TopConfig: ElectronTriggerEfficiencyConfig not set in the config!"};
1133  }
1134  this->elTrigEffConfig(elTrigConfig);
1135  }
1136 
1137  m_electronIDDecoration = "AnalysisTop_" + m_electronID;
1138  m_electronIDLooseDecoration = "AnalysisTop_" + m_electronIDLoose;
1139 
1140  //Fwd electron configuration
1141  this->fwdElectronID(settings->value("FwdElectronID"));
1142  this->fwdElectronIDLoose(settings->value("FwdElectronIDLoose"));
1143  double fwdElPtCut = 99999999.;
1144  try{
1145  fwdElPtCut = std::stof(settings->value("FwdElectronPt"));
1146  }
1147  catch (...) {
1148  throw std::invalid_argument {
1149  "TopConfig: cannot convert Option FwdElectronPt into float"
1150  };
1151  }
1152  this->fwdElectronPtcut(fwdElPtCut);
1153  double fwdElMinEtaCut = 2.5;
1154  try{
1155  fwdElMinEtaCut = std::stof(settings->value("FwdElectronMinEta"));
1156  }
1157  catch (...) {
1158  throw std::invalid_argument {
1159  "TopConfig: cannot convert Option FwdElectronMinEta into float"
1160  };
1161  }
1162  this->fwdElectronMinEtacut(fwdElMinEtaCut);
1163  double fwdElMaxEtaCut = 2.5;
1164  try{
1165  fwdElMaxEtaCut = std::stof(settings->value("FwdElectronMaxEta"));
1166  }
1167  catch (...) {
1168  throw std::invalid_argument {
1169  "TopConfig: cannot convert Option FwdElectronMaxEta into float"
1170  };
1171  }
1172  this->fwdElectronMaxEtacut(fwdElMaxEtaCut);
1173 
1174  int fwdElectronBCIDCleaningMinRun = 0;
1175  int fwdElectronBCIDCleaningMaxRun = 0;
1176  std::vector<std::string> fwd_bcid_tokens;
1177  tokenize(settings->value("FwdElectronBCIDCleaningRunRange"), fwd_bcid_tokens, ":");
1178  if (fwd_bcid_tokens.size() != 2) {
1179  throw std::invalid_argument(
1180  "TopConfig: Option FwdElectronBCIDCleaningRunRange requires values in the form of \'XXX:YYY\'. The number of values needs to be exactly 2.");
1181  }
1182  try{
1183  fwdElectronBCIDCleaningMinRun = std::stoi(fwd_bcid_tokens[0]);
1184  fwdElectronBCIDCleaningMaxRun = std::stoi(fwd_bcid_tokens[1]);
1185  }
1186  catch (...) {
1187  throw std::invalid_argument(
1188  "TopConfig: Cannot convert the strings into integers for the run numbers in Option FwdElectronBCIDCleaningRunRange");
1189  }
1190 
1191  this->fwdElectronBCIDCleaningMinRun(fwdElectronBCIDCleaningMinRun);
1192  this->fwdElectronBCIDCleaningMaxRun(fwdElectronBCIDCleaningMaxRun);
1193 
1194  m_electronIDSFFile_path = settings->value("ElectronIDSFFilePath");
1195  m_electronIDSFFileLoose_path = settings->value("ElectronIDSFFilePathLoose");
1196 
1197 
1198  // Photon configuration
1199  this->photonPtcut(std::stof(settings->value("PhotonPt")));
1200  this->photonEtacut(std::stof(settings->value("PhotonEta")));
1201  this->photonIdentification(settings->value("PhotonID"));
1202  this->photonIdentificationLoose(settings->value("PhotonIDLoose"));
1203  this->photonIsolation(settings->value("PhotonIsolation"));
1204  this->photonIsolationLoose(settings->value("PhotonIsolationLoose"));
1205  {
1206  const std::string &isoWPs_str = settings->value("PhotonIsolationWPs");
1207  tokenize(isoWPs_str, m_photonIsolationWPs, " ", true);
1208  if (this->photonIsolation() != "None")
1209  m_photonIsolationWPs.emplace_back(this->photonIsolation());
1210  if (this->photonIsolationLoose() != "None")
1211  m_photonIsolationWPs.emplace_back(this->photonIsolationLoose());
1212  remove_duplicates(m_photonIsolationWPs);
1213  }
1214 
1215  // Muon configuration
1216  this->muonPtcut(std::stof(settings->value("MuonPt")));
1217  this->muonEtacut(std::stof(settings->value("MuonEta")));
1218  this->muond0Sigcut(std::stof(settings->value("Muond0Sig")));
1219  this->muondeltaz0cut(std::stof(settings->value("Muondeltaz0")));
1220  this->muonQuality(settings->value("MuonQuality"));
1221  this->muonQualityLoose(settings->value("MuonQualityLoose"));
1222  {
1223  std::string const& cut_wp = settings->value("MuonIsolation");
1224  std::string const& sf_wp = settings->value("MuonIsolationSF");
1225  this->muonIsolation(cut_wp);
1226  this->muonIsolationSF(sf_wp == " " ? cut_wp : sf_wp);
1227 
1228  const std::string &isoWPs_str = settings->value("MuonIsolationWPs");
1229  tokenize(isoWPs_str, m_muonIsolationWPs, " ", true);
1230  if (cut_wp != "None")
1231  m_muonIsolationWPs.emplace_back(cut_wp);
1232  }
1233  bool muonUse2stationHighPt = true;
1234  settings->retrieve("MuonUse2stationHighPt", muonUse2stationHighPt);
1235  if (settings->value("MuonQuality") != "HighPt") muonUse2stationHighPt = false;
1236  this->muonUse2stationMuonsHighPt(muonUse2stationHighPt);
1237  if(settings->value("MuonQuality") == "LowPt") this->muonUseLowPt(true);
1238  bool muonUseMVALowPt=false;
1239  settings->retrieve("MuonUseMVALowPt", muonUseMVALowPt);
1240  if (settings->value("MuonQuality") != "LowPt" && muonUseMVALowPt) {
1241  ATH_MSG_WARNING("Could not set MuonUseMVALowPt True without using the LowPt muon WP. MuonUseMVALowPt is now setted to the default value (False)");
1242  muonUseMVALowPt = false;
1243  }
1244  this->muonUseMVALowPt(muonUseMVALowPt);
1245  bool muonUse2stationHighPtLoose = true;
1246  settings->retrieve("MuonUse2stationHighPtLoose", muonUse2stationHighPtLoose);
1247  if (settings->value("MuonQualityLoose") != "HighPt") muonUse2stationHighPtLoose = false;
1248  this->muonUse2stationMuonsHighPtLoose(muonUse2stationHighPtLoose);
1249  if(settings->value("MuonQualityLoose") == "LowPt") this->muonUseLowPtLoose(true);
1250  bool muonUseMVALowPtLoose = false;
1251  settings->retrieve("MuonUseMVALowPtLoose", muonUseMVALowPtLoose);
1252  if (settings->value("MuonQualityLoose") != "LowPt" && muonUseMVALowPtLoose) {
1253  ATH_MSG_WARNING("Could not set MuonUseMVALowPtLoose True without using the LowPt muon WP. MuonUseMVALowPtLoose is now setted to the default value (False)");
1254  muonUseMVALowPtLoose = false;
1255  }
1256 
1257  this->muonUseMVALowPtLoose(muonUseMVALowPtLoose);
1258 
1259  std::string const& cut_wp = settings->value("MuonIsolationLoose");
1260  std::string const& sf_wp = settings->value("MuonIsolationSFLoose");
1261  this->muonIsolationLoose(cut_wp);
1262  this->muonIsolationSFLoose(sf_wp == " " ? cut_wp : sf_wp);
1263  if (cut_wp != "None")
1264  m_muonIsolationWPs.emplace_back(cut_wp);
1265  remove_duplicates(m_muonIsolationWPs);
1266 
1267  m_muonCalibMode = settings->value("MuonCalibrationMode");
1268  m_muonSmearingSystematicModel = settings->value("MuonSmearingSystematicModel");
1269  bool muonDoSmearing2stationHighPt = false;
1270  settings->retrieve("MuonDoSmearing2stationHighPt", muonDoSmearing2stationHighPt);
1271  if (settings->value("MuonQuality") != "HighPt" ) muonDoSmearing2stationHighPt = false;
1272  else if ( !muonUse2stationHighPt && muonDoSmearing2stationHighPt ) {
1273  ATH_MSG_WARNING("Could not set MuonDoSmearing2stationHighPt True without MuonUse2stationHighPt. MuonDoSmearing2stationHighPt is now setted to False");
1274  muonDoSmearing2stationHighPt = false;
1275  }
1276  this->muonMuonDoSmearing2stationHighPt(muonDoSmearing2stationHighPt);
1277  bool muonDoExtraSmearingHighPt = false;
1278  settings->retrieve("MuonDoExtraSmearingHighPt", muonDoExtraSmearingHighPt);
1279  if ( settings->value("MuonQuality") == "HighPt" && muonDoExtraSmearingHighPt ) {
1280  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)");
1281  muonDoExtraSmearingHighPt = false;
1282  }
1283  this->muonMuonDoExtraSmearingHighPt( muonDoExtraSmearingHighPt );
1284 
1285  bool muonBreakDownSystematics(false);
1286  settings->retrieve("MuonBreakDownSystematics", muonBreakDownSystematics);
1287  this->muonBreakDownSystematics(muonBreakDownSystematics);
1288  {
1289  std::string const& customMuonSF = settings->value("MuonSFCustomInputFolder");
1290  this->muonSFCustomInputFolder(customMuonSF);
1291  }
1292  {
1293  std::string const& customMuonSFTrigger = settings->value("MuonSFCustomInputFolderTrigger");
1294  this->muonSFCustomInputFolderTrigger(customMuonSFTrigger);
1295  }
1296  {
1297  int customMuonForceYear = std::stoi(settings->value("MuonForceYear"));
1298  this->muonForceYear(customMuonForceYear);
1299  }
1300  {
1301  std::string const& customMuonForcePeriod = settings->value("MuonForcePeriod");
1302  this->muonForcePeriod(customMuonForcePeriod);
1303  }
1304  {
1305  std::string const& customMuonForceTrigger = settings->value("MuonForceTrigger");
1306  this->muonForceTrigger(customMuonForceTrigger);
1307  }
1308  if (settings->value("UseAntiMuons") == "True") this->m_useAntiMuons = true;
1309  {
1310  std::string const& customElTrigEffConfig = settings->value("ElectronTriggerEfficiencyConfig");
1311  this->elTrigEffConfig(customElTrigEffConfig);
1312  }
1313 
1314  // Soft Muon configuration
1315  this->softmuonPtcut(readFloatOption(settings, "SoftMuonPt"));
1316  this->softmuonEtacut(readFloatOption(settings, "SoftMuonEta"));
1317  this->softmuonQuality(settings->value("SoftMuonQuality"));
1318  if(settings->value("SoftMuonQuality") == "LowPt") this->softmuonUseLowPt(true);
1319  bool softmuonUseMVALowPtSoftMuon = false;
1320  settings->retrieve("SoftMuonUseMVALowPt", softmuonUseMVALowPtSoftMuon);
1321  if (settings->value("SoftMuonQuality") != "LowPt" && softmuonUseMVALowPtSoftMuon) {
1322  ATH_MSG_WARNING("Could not set SoftMuonUseMVALowPt True without using the LowPt softmuon WP. SoftMuonUseMVALowPt is now setted to the default value (False)");
1323  softmuonUseMVALowPtSoftMuon = false;
1324  }
1325  this->softmuonUseMVALowPt(softmuonUseMVALowPtSoftMuon);
1326  this->softmuonDRJetcut(readFloatOption(settings, "SoftMuonDRJet"));
1327  this->softmuonDRJetcutUseRapidity(settings->retrieve("SoftMuonDRJetUseRapidity"));
1328  this->softmuonAdditionalTruthInfo(settings->retrieve("SoftMuonAdditionalTruthInfo"));
1329  this->softmuonAdditionalTruthInfoCheckPartonOrigin(settings->retrieve("SoftMuonAdditionalTruthInfoCheckPartonOrigin"));
1330  this->softmuonAdditionalTruthInfoDoVerbose(settings->retrieve("SoftMuonAdditionalTruthInfoDoVerbose") );
1331 
1332  //tau configuration
1333  this->tauPtcut(std::stof(settings->value("TauPt")));
1334  this->tauEtaRegions(settings->value("TauEtaRegions"));
1335  this->tauJetIDWP(settings->value("TauJetIDWP"));
1336  this->tauJetIDWPLoose(settings->value("TauJetIDWPLoose"));
1337  this->tauEleIDWP(settings->value("TauEleIDWP"));
1338  this->tauEleIDWPLoose(settings->value("TauEleIDWPLoose"));
1339  this->tauMuOLR((settings->value("TauMuOLR") == "True"));
1340  this->tauMuOLRLoose((settings->value("TauMuOLRLoose") == "True"));
1341  this->tauJetConfigFile(settings->value("TauJetConfigFile"));
1342  this->tauJetConfigFileLoose(settings->value("TauJetConfigFileLoose"));
1343  if (settings->value("ApplyTauMVATES") != "True") throw std::runtime_error {
1344  "TopConfig: ApplyTauMVATES must be True"
1345  };
1346 
1347  // Jet configuration
1348  this->jetPtcut(std::stof(settings->value("JetPt")));
1349  this->jetEtacut(std::stof(settings->value("JetEta")));
1350  this->jetPtGhostTracks(std::stof(settings->value("JetPtGhostTracks")),std::stof(settings->value("JetPt")));
1351  if ( m_jetPtcut <= std::stof(settings->value("JetPtGhostTracks"))+5000){
1352  ATH_MSG_WARNING("jetPtGhostTracks set to " << m_jetPtGhostTracks <<" to ensure that all the selected jets have the ghost tracks associated");
1353  }
1354  this->jetEtaGhostTracks(std::stof(settings->value("JetEtaGhostTracks")));
1355  this->jetUncertainties_NPModel(settings->value("JetUncertainties_NPModel"));
1356  this->jetUncertainties_QGFracFile(settings->value("JetUncertainties_QGFracFile"));
1357  this->jetUncertainties_QGHistPatterns(settings->value("JetUncertainties_QGHistPatterns"));
1358  this->jetJERSmearingModel(settings->value("JetJERSmearingModel"));
1359  this->jetJMSOption(settings->value("JetJMSOption"));
1360  if (settings->value("DoLargeRPseudodataJER") == "False") {
1361  this->doLargeRPseudodataJER(false);
1362  } else if (settings->value("DoLargeRPseudodataJER") == "True") {
1363  this->doLargeRPseudodataJER(true);
1364  }
1365  this->jetCalibSequence(settings->value("JetCalibSequence"));
1366  this->allowSmallRJMSforAFII(settings->value("AllowJMSforAFII") == "True");
1367  this->doJVTinMET(settings->retrieve("JVTinMETCalculation"));
1368  this->saveFailJVTJets(settings->retrieve("SaveFailJVTJets"));
1369  this->setJVTWP(settings->value("JVTWP"));
1370  this->doForwardJVTinMET(settings->retrieve("ForwardJVTinMETCalculation"));
1371  this->saveFailForwardJVTJets(settings->retrieve("SaveFailForwardJVTJets"));
1372  this->setfJVTWP(settings->value("ForwardJVTWP"));
1373  if (settings->value("ForwardJVTWP") == "Medium" && settings->retrieve("ForwardJVTinMETCalculation")){
1374  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!!!");
1375  }
1376 
1377 
1378  this->largeRJetPtcut(std::stof(settings->value("LargeRJetPt")));
1379  this->largeRJetMasscut(std::stof(settings->value("LargeRJetMass")));
1380  this->largeRJetEtacut(std::stof(settings->value("LargeRJetEta")));
1381 
1382 
1383  // now get all substructure variables from the config file.
1384  std::string strSubstructure = settings->value("LargeRJetSubstructureVariables");
1385  // Making vector of strings with "," used as separator
1386  std::vector<std::string> helpvecStr;
1387  tokenize(strSubstructure, helpvecStr, ",");
1388 
1389  std::vector<std::string> vecSubstructure;
1390  // Removing empty spaces
1391  for (const std::string& x : helpvecStr) {
1392  std::istringstream istrSubstructure(x);
1393  std::copy(std::istream_iterator<std::string>(istrSubstructure),
1394  std::istream_iterator<std::string>(), std::back_inserter(vecSubstructure));
1395  }
1396  // Making map
1397  for (const std::string& key: vecSubstructure) {
1398  std::vector<std::string> pairs;
1399  tokenize(key,pairs,":");
1400  if(pairs.size() == 1) m_largeRJetSubstructureVariables[pairs[0]]=pairs[0];
1401  else if(pairs.size() == 2) m_largeRJetSubstructureVariables[pairs[0]]=pairs[1];
1402  else throw std::runtime_error {
1403  "TopConfig: Options in LargeRJetSubstructureVariables should be of the form \'x:y\' or \'y\'."
1404  };
1405  }
1406 
1407  this->largeRJetUncertainties_NPModel(settings->value("LargeRJetUncertainties_JESJERJMS_NPModel"));
1408  this->largeRJetUncertainties_JMR_NPModel(settings->value("LargeRJetUncertainties_JMR_NPModel"));
1409  this->largeRJetUncertaintiesConfigDir(settings->value("AdvancedUsage_LargeRJetUncertaintiesConfigDir"));
1410  this->largeRJESJMSConfig(settings->value("LargeRJESJMSConfig"));
1411 
1412  this->trackJetPtcut(std::stof(settings->value("TrackJetPt")));
1413  this->trackJetEtacut(std::stof(settings->value("TrackJetEta")));
1414 
1415  //Ghost track associated to jets quality
1416  this->ghostTrackspT(std::stof(settings->value("GhostTrackspT")));
1417  this->ghostTracksVertexAssociation(settings->value("GhostTracksVertexAssociation"));
1418  this->ghostTracksQuality(settings->value("GhostTracksQuality"));
1419 
1420  this->trackPtcut(std::stof(settings->value("TrackPt")));
1421  this->trackEtacut(std::stof(settings->value("TrackEta")));
1422  this->trackQuality(settings->value("TrackQuality"));
1423 
1424  // Jet configuration reclustered jets
1425  this->RCJetPtcut(std::stof(settings->value("RCJetPt")));
1426  this->RCJetEtacut(std::stof(settings->value("RCJetEta")));
1427  this->RCInputJetPtMin(std::stof(settings->value("RCInputJetPtMin")));
1428  this->RCInputJetEtaMax(std::stof(settings->value("RCInputJetEtaMax")));
1429  this->RCJetTrimcut(std::stof(settings->value("RCJetTrim")));
1430  this->RCJetRadius(std::stof(settings->value("RCJetRadius")));
1431  if (settings->value("UseRCJets") == "True" || settings->value("UseRCJets") == "true") this->m_useRCJets = true;
1432  if (settings->value("UseRCJetSubstructure") == "True" ||
1433  settings->value("UseRCJetSubstructure") == "true") this->m_useRCJetSubstructure = true;
1434  else this->m_useRCJetSubstructure = false;
1435 
1436  if (settings->value("UseRCJetAdditionalSubstructure") == "True" ||
1437  settings->value("UseRCJetAdditionalSubstructure") == "true") this->m_useRCJetAdditionalSubstructure = true;
1438  else this->m_useRCJetAdditionalSubstructure = false;
1439 
1440  this->VarRCJetPtcut(std::stof(settings->value("VarRCJetPt")));
1441  this->VarRCJetEtacut(std::stof(settings->value("VarRCJetEta")));
1442  this->VarRCJetTrimcut(std::stof(settings->value("VarRCJetTrim")));
1443  this->VarRCJetMaxRadius(std::stof(settings->value("VarRCJetMaxRadius")));
1444  this->VarRCJetRho(settings->value("VarRCJetRho"));
1445  this->VarRCJetMassScale(settings->value("VarRCJetMassScale"));
1446  if (settings->value("UseVarRCJets") == "True" ||
1447  settings->value("UseVarRCJets") == "true") this->m_useVarRCJets = true;
1448  if (settings->value("UseVarRCJetSubstructure") == "True" ||
1449  settings->value("UseVarRCJetSubstructure") == "true") this->m_useVarRCJetSubstructure = true;
1450  else this->m_useVarRCJetSubstructure = false;
1451  if (settings->value("UseVarRCJetAdditionalSubstructure") == "True" ||
1452  settings->value("UseVarRCJetAdditionalSubstructure") ==
1453  "true") this->m_useVarRCJetAdditionalSubstructure = true;
1454  else this->m_useVarRCJetAdditionalSubstructure = false;
1455 
1456  if (settings->value("StoreJetTruthLabels") == "False") {
1457  this->jetStoreTruthLabels(false);
1458  } else if (settings->value("StoreJetTruthLabels") == "True") {
1459  this->jetStoreTruthLabels(true);
1460  } else {
1461  ATH_MSG_WARNING("TopConfig::setConfigSettings: Unrecognized option for \"StoreJetTruthLabels\", assuming True");
1462  this->jetStoreTruthLabels(true);
1463  }
1464 
1465  // MET Configuration
1466  this->METUncertaintiesConfigDir(settings->value("AdvancedUsage_METUncertaintiesConfigDir"));
1467  // MET Significance
1468  if(settings->value("METSignificance") == "True"){this->METSignificance(true);}
1469  this->METSignifSoftTermParam(settings->value("METSignificanceSoftTermParam"));
1470  // MET JetSelection for NNJvt
1471  this->setMETJetSelectionWP(settings->value("METJetSelectionWP"));
1472 
1473  // for top mass analysis, per default set to 1.0!
1474  m_JSF = std::stof(settings->value("JSF"));
1475  m_bJSF = std::stof(settings->value("bJSF"));
1476 
1477  // If parameter exists remove electron crack veto
1478  if (settings->value("ElectronVetoLArCrack") == "False") this->removeElectronVetoLArCrack();
1479 
1480  // By default the top group does overlap removal on the tight lepton definitions
1481  // If you use this you are going off piste and need to report
1482  // your findings to the top reconstruction meeting
1483  if (settings->value("OverlapRemovalLeptonDef") == "Loose") this->setOverlapRemovalOnLooseLeptonDef();
1484 
1485  m_overlap_removal_procedure = settings->value("OverlapRemovalProcedure");
1486 
1487  // do overlap removal also with large-R jets
1488  // (using whatever procedure is used in the official tools)
1489  if (settings->value("LargeJetOverlapRemoval") == "True") {
1490  this->setLargeJetOverlapRemoval();// only usefull in case of MC
1491  }
1492 
1493  //do electron-electron overlap removal
1494  if (settings->value("EleEleOverlapRemoval") == "True"){
1495  this->setEleEleOverlapRemoval();
1496  }
1497 
1498  // In the *_Loose trees, lepton SFs are calculated considering
1499  // tight ID and isolation instead of loose
1500  // Only tight leptons are considered in the event SF calculation
1501  // only usefull in case of MC
1502  if (settings->value("ApplyTightSFsInLooseTree") == "True" && this->isMC()) this->setApplyTightSFsInLooseTree();
1503 
1504  // Apply Electron In Jet Subtraction - boosted analysis
1505  if (settings->value("ApplyElectronInJetSubtraction") == "True") this->setApplyElectronInJetSubtraction();
1506 
1507  // Set Number of events to run on (for testing)
1508  this->numberOfEventsToRun(std::stoi(settings->value("NEvents")));
1509 
1510  // Set Number of the first Event to run skip (for testing)
1511  this->numberOfEventsToSkip(std::stoi(settings->value("FirstEvent")));
1512 
1513  // [[[-----------------------------------------------
1514  //; Particle Level / Truth Configuration
1515  this->truth_electron_PtCut(std::stof(settings->value("TruthElectronPt")));
1516  this->truth_electron_EtaCut(std::stof(settings->value("TruthElectronEta")));
1517 
1518  this->truth_muon_PtCut(std::stof(settings->value("TruthMuonPt")));
1519  this->truth_muon_EtaCut(std::stof(settings->value("TruthMuonEta")));
1520 
1521  float truth_softmu_ptcut=4000.;
1522  try{
1523  truth_softmu_ptcut=std::stof(settings->value("TruthSoftMuonPt"));
1524  }
1525  catch (...) {
1526  throw std::runtime_error {
1527  "TopConfig: can't convert provided TruthSoftMuonPt into float"
1528  };
1529  }
1530 
1531  float truth_softmu_etacut=2.5;
1532  try{
1533  truth_softmu_etacut=std::stof(settings->value("TruthSoftMuonEta"));
1534  }
1535  catch (...) {
1536  throw std::runtime_error {
1537  "TopConfig: can't convert provided TruthSoftMuonEta into float"
1538  };
1539  }
1540 
1541  this->truth_softmuon_PtCut(truth_softmu_ptcut);
1542  this->truth_softmuon_EtaCut(truth_softmu_etacut);
1543 
1544  this->truth_photon_PtCut(std::stof(settings->value("TruthPhotonPt")));
1545  this->truth_photon_EtaCut(std::stof(settings->value("TruthPhotonEta")));
1546  // The TruthPhoton Origin and Isolation parameters are validated inside the
1547  // TopParticleLevel Loader Class.
1548  this->truth_photon_Origin(settings->value("TruthPhotonOrigin"));
1549  this->truth_photon_Isolation(settings->value("TruthPhotonIsolation"));
1550 
1551  this->truth_jet_PtCut(std::stof(settings->value("TruthJetPt")));
1552  this->truth_jet_EtaCut(std::stof(settings->value("TruthJetEta")));
1553 
1554  this->truth_jet_largeR_PtCut(std::stof(settings->value("TruthLargeRJetPt")));
1555  this->truth_jet_largeR_EtaCut(std::stof(settings->value("TruthLargeRJetEta")));
1556 
1557  this->truth_tau_PtCut(std::stof(settings->value("TruthTauPt")));
1558  this->truth_tau_EtaCut(std::stof(settings->value("TruthTauEta")));
1559 
1560  // -----------------------------------------------]]]
1561 
1562  // LHAPDF Reweighting configuration
1563  std::istringstream lha_pdf_ss(settings->value("LHAPDFSets"));
1564  std::copy(std::istream_iterator<std::string>(lha_pdf_ss),
1565  std::istream_iterator<std::string>(),
1566  std::back_inserter(m_lhapdf_options.pdf_set_names));
1567 
1568  // if provided, it will be used to recompute XF1,XF2 (if any is zero)
1569  const std::string LHAPDFBase = settings->value("LHAPDFBaseSet");
1570  if (LHAPDFBase.find_first_not_of(' ') != std::string::npos) {
1571  // should only set one base PDF set
1572  if (LHAPDFBase.find(' ') != std::string::npos)
1573  ATH_MSG_WARNING("LHAPDFBaseSet: " << LHAPDFBase << " -- only one PDF set allowed for recomputing XF1,XF2 !!!");
1574  m_lhapdf_options.baseLHAPDF = LHAPDFBase;
1575  }
1576  // if not already present, add to the list of PDF sets
1577  if (!m_lhapdf_options.baseLHAPDF.empty() &&
1578  !(std::find(m_lhapdf_options.pdf_set_names.begin(),
1579  m_lhapdf_options.pdf_set_names.end(),
1580  m_lhapdf_options.baseLHAPDF) !=
1581  m_lhapdf_options.pdf_set_names.end())) m_lhapdf_options.pdf_set_names.push_back(m_lhapdf_options.baseLHAPDF);
1582 
1583  if (m_lhapdf_options.pdf_set_names.size() && this->isMC()) m_lhapdf_options.doLHAPDF = true;
1584 
1585  if (m_lhapdf_options.pdf_set_names.size() && this->isMC() && settings->value("LHAPDFEventWeights") == "True") {
1586  m_lhapdf_options.save_per_event = true;
1587  } else if (m_lhapdf_options.pdf_set_names.size() && this->isMC() &&
1588  settings->value("LHAPDFEventWeights") == "Nominal") {
1589  m_lhapdf_options.save_per_event = true;
1590  m_lhapdf_options.doLHAPDFInNominalTrees = true;
1591  }
1592 
1593  // now get all Boosted jet taggers from the config file.
1594  std::string str_boostedJetTagger = settings->value("BoostedJetTagging");
1595  std::vector<std::string> helpvec_str;
1596  tokenize(str_boostedJetTagger, helpvec_str, ",");
1597 
1598  std::vector<std::string> vec_boostedJetTaggers;
1599 
1600  for (const std::string& x : helpvec_str) {
1601  std::istringstream istr_boostedJetTaggers(x);
1602  std::copy(std::istream_iterator<std::string>(istr_boostedJetTaggers),
1603  std::istream_iterator<std::string>(), std::back_inserter(vec_boostedJetTaggers));
1604  }
1605 
1606  for (const std::string& tagger : vec_boostedJetTaggers) {
1607  std::vector<std::string> helpvec;
1608  tokenize(tagger, helpvec, ":");
1609  if (helpvec.size() != 2) throw std::runtime_error {
1610  "TopConfig: Options in BoostedJetTagging should be of the form \'x:y\' where x is tagging type and y is shortened tagger name."
1611  };
1612  m_chosen_boostedJetTaggers.push_back(std::make_pair(helpvec[0], helpvec[1]));
1613  }
1614 
1615  m_btagging_cdi_path = settings->value("BTagCDIPath");
1616 
1617  // now get all Btagging WP from the config file, and store them properly in a map.
1618  // Need function to compare the cut value with the WP and vice versa
1619  parse_bTagWPs(settings->value("BTaggingCaloJetWP"), m_btagAlgoWP_calib_caloJet, m_btagWP_calib_caloJet);
1620  parse_bTagWPs(settings->value("BTaggingCaloJetUncalibWP"), m_btagAlgoWP_caloJet, m_btagWP_caloJet);
1621  parse_bTagWPs(settings->value("BTaggingTrackJetWP"), m_btagAlgoWP_calib_trkJet, m_btagWP_calib_trkJet);
1622  parse_bTagWPs(settings->value("BTaggingTrackJetUncalibWP"), m_btagAlgoWP_trkJet, m_btagWP_trkJet);
1623 
1624  // below variables store all WPs for btag decision, both calibrated and uncalibrated
1625  // therefore copy the calibrated WPs into the list of all WPs
1626  m_btagAlgoWP_caloJet.insert(m_btagAlgoWP_caloJet.end(), m_btagAlgoWP_calib_caloJet.begin(), m_btagAlgoWP_calib_caloJet.end());
1627  m_btagAlgoWP_trkJet.insert(m_btagAlgoWP_trkJet.end(), m_btagAlgoWP_calib_trkJet.begin(), m_btagAlgoWP_calib_trkJet.end());
1628  m_btagWP_caloJet.insert(m_btagWP_caloJet.end(), m_btagWP_calib_caloJet.begin(), m_btagWP_calib_caloJet.end());
1629  m_btagWP_trkJet.insert(m_btagWP_trkJet.end(), m_btagWP_calib_trkJet.begin(), m_btagWP_calib_trkJet.end());
1630 
1631  remove_duplicates(m_btagWP_caloJet);
1632  remove_duplicates(m_btagWP_trkJet);
1633  remove_duplicates(m_btagAlgoWP_caloJet);
1634  remove_duplicates(m_btagAlgoWP_trkJet);
1635 
1636  auto print_btag_WPs = [](const std::vector<std::string> &WPlist) {
1637  for (const std::string &WP : WPlist)
1638  ATH_MSG_INFO("BTagging algorithm: " << WP);
1639  };
1640  ATH_MSG_INFO("The following b-tagging WPs are configured for tagging decision for " << m_sgKeyJets);
1641  print_btag_WPs(m_btagWP_caloJet);
1642  ATH_MSG_INFO("Out of those, the calibration SFs will be computed for following WPs:");
1643  print_btag_WPs(m_btagWP_calib_caloJet);
1644  if (m_useTrackJets) {
1645  ATH_MSG_INFO("The following b-tagging WPs are configured for tagging decision for " << m_sgKeyTrackJets);
1646  print_btag_WPs(m_btagWP_trkJet);
1647  ATH_MSG_INFO("Out of those, the calibration SFs will be computed for following WPs:");
1648  print_btag_WPs(m_btagWP_calib_trkJet);
1649  }
1650 
1651  m_btagging_calibration_B = settings->value("BTaggingCalibrationB");
1652  m_btagging_calibration_C = settings->value("BTaggingCalibrationC");
1653  m_btagging_calibration_Light = settings->value("BTaggingCalibrationLight");
1654  m_bTagSystsExcludedFromEV = settings->value("BTaggingSystExcludedFromEV");
1655 
1656  // egamma calibration model
1657  m_egamma_calibration_model = settings->value("EGammaCalibrationModel");
1658 
1659  // Set translatio ndictionary for MCMC maps
1660  if (settings->value("RedefineMCMCMap") != " ") {
1661  std::vector<std::string> tmp;
1662  tokenize(settings->value("RedefineMCMCMap"), tmp, ",");
1663  for (const std::string& dictionaries : tmp) {
1664  std::vector<std::string> dictionary;
1665  tokenize(dictionaries, dictionary, ":");
1666  if (dictionary.size() != 2) {
1667  throw std::invalid_argument{"Wrong input argument for RedefineMCMCMap. Expected format is: \"shower1:shower2,shower3:shower4\""};
1668  }
1669 
1670  m_showerMCMCtranslator.insert({dictionary.at(0), dictionary.at(1)});
1671  }
1672  }
1673 
1674  /************************************************************
1675  *
1676  * Loop through all suplied config files and make into a
1677  * vector if we have at least one config and at least one
1678  * lumi calc file (and is MC) then apply PU reweighting
1679  * Note: PathResolving done in TopCPTools.
1680  *
1681  ***********************************************************/
1682 
1683  std::istringstream pileup_config_ss(settings->value("PRWConfigFiles"));
1684  std::copy(std::istream_iterator<std::string>(pileup_config_ss),
1685  std::istream_iterator<std::string>(),
1686  std::back_inserter(m_pileup_reweighting.config_files));
1687 
1688  std::istringstream pileup_lumi_ss(settings->value("PRWLumiCalcFiles"));
1689  std::copy(std::istream_iterator<std::string>(pileup_lumi_ss),
1690  std::istream_iterator<std::string>(),
1691  std::back_inserter(m_pileup_reweighting.lumi_calc_files));
1692 
1693  std::istringstream pileup_config_FS_ss(settings->value("PRWConfigFiles_FS"));
1694  std::copy(std::istream_iterator<std::string>(pileup_config_FS_ss),
1695  std::istream_iterator<std::string>(),
1696  std::back_inserter(m_pileup_reweighting.config_files_FS));
1697 
1698  std::istringstream pileup_config_AF_ss(settings->value("PRWConfigFiles_AF"));
1699  std::copy(std::istream_iterator<std::string>(pileup_config_AF_ss),
1700  std::istream_iterator<std::string>(),
1701  std::back_inserter(m_pileup_reweighting.config_files_AF));
1702 
1703  std::istringstream actual_mu_FS_ss(settings->value("PRWActualMu_FS"));
1704  std::copy(std::istream_iterator<std::string>(actual_mu_FS_ss),
1705  std::istream_iterator<std::string>(),
1706  std::back_inserter(m_pileup_reweighting.actual_mu_FS));
1707 
1708  std::istringstream actual_mu_AF_ss(settings->value("PRWActualMu_AF"));
1709  std::copy(std::istream_iterator<std::string>(actual_mu_AF_ss),
1710  std::istream_iterator<std::string>(),
1711  std::back_inserter(m_pileup_reweighting.actual_mu_AF));
1712 
1713  m_pileup_reweighting.unrepresented_data_tol = std::stof(settings->value("PRWUnrepresentedDataTolerance"));
1714 
1715  m_pileup_reweighting.mu_dependent = (settings->value("PRWMuDependent") == "True");
1716 
1717  // now even if the user don't provide a PRWConfigFiles, PRW is done on MC, using the default calibration file
1718  if (m_pileup_reweighting.lumi_calc_files.size() > 0) {
1719  m_pileup_reweighting.apply = true;
1720  }
1721 
1722  if (m_pileup_reweighting.apply && m_grlFile.size() > 0 &&
1723  settings->value("PRWUseGRLTool") == "True") m_pileup_reweighting.use_grl_tool = true;
1724 
1725  // if provided, using custom Data Scale-Factors for pile-up reweighting
1726  // nominal:up:down
1727  // also allowing to specify under this form: 1/1.2:1.0:1/1.4
1728  if (m_pileup_reweighting.apply && settings->value("PRWCustomScaleFactor") != " ") {
1729  std::vector<std::string> SFs_tokens;
1730  tokenize(settings->value("PRWCustomScaleFactor"), SFs_tokens, ":");
1731  if (SFs_tokens.size() != 3) throw std::runtime_error {
1732  "TopConfig: Option PRWCustomScaleFactor should be of the form \'nominal:up:down\'"
1733  };
1734  try {
1735  std::vector<std::string> nomSF_tokens;
1736  tokenize(SFs_tokens[0], nomSF_tokens, "/");
1737  if (nomSF_tokens.size() == 1) m_pileup_reweighting.custom_SF.push_back(std::stof(nomSF_tokens[0]));
1738  else if (nomSF_tokens.size() == 2) m_pileup_reweighting.custom_SF.push_back(std::stof(
1739  nomSF_tokens[0]) /
1740  std::stof(nomSF_tokens[1]));
1741  else throw std::runtime_error {
1742  "TopConfig: issue in division"
1743  };
1744  } catch (...) {
1745  throw std::runtime_error {
1746  "TopConfig: can't convert provided PRW nominal Data SF into float"
1747  };
1748  }
1749  try {
1750  std::vector<std::string> upSF_tokens;
1751  tokenize(SFs_tokens[1], upSF_tokens, "/");
1752  if (upSF_tokens.size() == 1) m_pileup_reweighting.custom_SF.push_back(std::stof(upSF_tokens[0]));
1753  else if (upSF_tokens.size() == 2) m_pileup_reweighting.custom_SF.push_back(std::stof(
1754  upSF_tokens[0]) /
1755  std::stof(upSF_tokens[1]));
1756  else throw std::runtime_error {
1757  "TopConfig: issue in division"
1758  };
1759  } catch (...) {
1760  throw std::runtime_error {
1761  "TopConfig: can't convert provided PRW up Data SF into float"
1762  };
1763  }
1764  try {
1765  std::vector<std::string> downSF_tokens;
1766  tokenize(SFs_tokens[2], downSF_tokens, "/");
1767  if (downSF_tokens.size() == 1) m_pileup_reweighting.custom_SF.push_back(std::stof(downSF_tokens[0]));
1768  else if (downSF_tokens.size() == 2) m_pileup_reweighting.custom_SF.push_back(std::stof(
1769  downSF_tokens[0]) /
1770  std::stof(downSF_tokens[1]));
1771  else throw std::runtime_error {
1772  "TopConfig: issue in division"
1773  };
1774  } catch (...) {
1775  throw std::runtime_error {
1776  "TopConfig: can't convert provided PRW down Data SF into float"
1777  };
1778  }
1779  ATH_MSG_INFO("Custom PRW scale-factors - nominal:" << SFs_tokens[0] << "=" << m_pileup_reweighting.custom_SF[0] <<
1780  " up:" << SFs_tokens[1] << "=" << m_pileup_reweighting.custom_SF[1] << " down:" << SFs_tokens[2] << "=" <<
1781  m_pileup_reweighting.custom_SF[2]);
1782  }
1783 
1784  if (m_pileup_reweighting.apply && settings->value("PRWPeriodAssignments") != " ") {
1785  std::vector<std::string> period_tokens;
1786  tokenize(settings->value("PRWPeriodAssignments"), period_tokens, ":");
1787  if (period_tokens.size() % 3 != 0) {
1788  throw std::invalid_argument(
1789  "TopConfig: Option PRWPeriodAssignments requires values in the form of \'value:value:value\'. The number of values needs to be divisible by 3.");
1790  }
1791  try {
1792  for (const std::string& per : period_tokens) {
1793  m_pileup_reweighting.periodAssignments.emplace_back(std::stoi(per));
1794  }
1795  } catch (...) {
1796  throw std::invalid_argument(
1797  "TopConfig: Cannot convert the strings into integers for the run numbers in Option PRWPeriodAssignments");
1798  }
1799  }
1800 
1801  // TRUTH derivations do not contain pile-up weights
1802  if (m_isTruthDxAOD) m_pileup_reweighting.apply = false;
1803 
1804 
1805  //Switch off PRW for MC samples with data overlay
1806  if(m_isDataOverlay) m_pileup_reweighting.apply = false;
1807 
1808  const std::string randomRunNumberSetting = settings->value("ForceRandomRunNumber");
1809  if (randomRunNumberSetting != " ") {
1810  unsigned int randomRunNumber(0);
1811  try {
1812  randomRunNumber = std::stoul(randomRunNumberSetting);
1813  } catch (...) {
1814  throw std::invalid_argument{"ForceRandomRunNumber cannot be converted to an integer"};
1815  }
1816 
1817  if (randomRunNumber < 1 || randomRunNumber > 999999) {
1818  throw std::invalid_argument{"ForceRandomRunNumber cannot be smaller than 0 or larger than 999999"};
1819  }
1820  // disable PRW
1821  m_pileup_reweighting.apply = false;
1822  this->setForceRandomRunNumber(randomRunNumber);
1823  }
1824 
1825  const std::string isRun3 = settings->value("IsRun3");
1826  this->setIsRun3(isRun3 == "True");
1827 
1828  m_trigMatchElemRelink = settings->retrieve("TriggerMatchingElementRelinking");
1829 
1830  if (settings->value("DemandPrimaryVertex") == "False")
1831  m_demandPriVtx = false;
1832 
1834  m_KLFitterTransferFunctionsPath = settings->value("KLFitterTransferFunctionsPath");
1835  m_KLFitterOutput = settings->value("KLFitterOutput");
1836  m_KLFitterJetSelectionMode = settings->value("KLFitterJetSelectionMode");
1837  m_KLFitterBTaggingMethod = settings->value("KLFitterBTaggingMethod");
1838  m_KLFitterLH = settings->value("KLFitterLH");
1839 
1840  if (settings->value("KLFitterTopMassFixed") == "True") m_KLFitterTopMassFixed = true;
1841  if (settings->value("KLFitterTopMassFixed") == "False") m_KLFitterTopMassFixed = false;
1842  if (settings->value("KLFitterSaveAllPermutations") == "True") m_KLFitterSaveAllPermutations = true;
1843  if (settings->value("KLFitterSaveAllPermutations") == "False") m_KLFitterSaveAllPermutations = false;
1844  if (settings->value("KLFitterFailOnLessThanXJets") == "True") m_KLFitterFailOnLessThanXJets = true;
1845  if (settings->value("KLFitterFailOnLessThanXJets") == "False") m_KLFitterFailOnLessThanXJets = false;
1846 
1847  //--- Check for configuration on the global lepton triggers ---//
1848  if (settings->value("UseGlobalLeptonTriggerSF") == "True") {
1849  auto parseTriggerString =
1850  [settings](std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >& triggersByPeriod,
1851  std::string const& key) {
1852  /* parse a string of the form "2015@triggerfoo,triggerbar,... 2016@triggerfoo,triggerbaz,... ..." */
1853  std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > result;
1854  std::vector<std::string> pairs;
1855  boost::split(pairs, settings->value(key), boost::is_any_of(" "));
1856  for (std::string const& pair : pairs) {
1857  if (pair.empty() || pair == "None") continue;
1858  auto i = pair.find('@');
1859  if (!(i != std::string::npos &&
1860  pair.find('@', i + 1) == std::string::npos)) throw std::invalid_argument(
1861  std::string() + "Malformed trigger list in configuration item `" + key + "'");
1862  auto&& period = pair.substr(0, i), triggerstr = pair.substr(i + 1);
1863  auto&& triggers = result[period];
1864  if (!triggers.empty()) throw std::invalid_argument(
1865  std::string() + "Period `" + period + "' appears multiple times in configuration item `" + key +
1866  "'");
1867 
1868  // get the vector of strings split by ","
1869  std::vector<std::string> tmp;
1870  for (const auto& i : triggers) {
1871  tmp.push_back(i.first);
1872  }
1873  boost::split(tmp, triggerstr, boost::is_any_of(","));
1874  // attach a dummy 1 to the pair
1875  std::vector<std::pair<std::string, int> > modified;
1876  for (const auto& i : tmp) {
1877  modified.emplace_back(i, 1);
1878  }
1879 
1880  // pass it to the triggers vector
1881  std::swap(triggers, modified);
1882  }
1883  /* merge trigger map from this configuration line into triggersByPeriod */
1884  for (auto&& kv : result) {
1885  auto&& src = kv.second;
1886  auto&& dst = triggersByPeriod[kv.first];
1887  for (std::pair<std::string, int> const& trigger : src) {
1888  if (std::find(dst.begin(), dst.end(),
1889  trigger) != dst.end()) throw std::invalid_argument(
1890  std::string() + "Trigger `" + trigger.first + "' was specified multiple times");
1891  dst.push_back(trigger);
1892  }
1893  }
1894  };
1895  m_trigGlobalConfiguration.isActivated = true;
1896  parseTriggerString(m_trigGlobalConfiguration.trigger, "ElectronTriggers");
1897  parseTriggerString(m_trigGlobalConfiguration.trigger_loose, "ElectronTriggersLoose");
1898  parseTriggerString(m_trigGlobalConfiguration.trigger, "MuonTriggers");
1899  parseTriggerString(m_trigGlobalConfiguration.trigger_loose, "MuonTriggersLoose");
1900  parseTriggerString(m_trigGlobalConfiguration.trigger, "GlobalTriggers");
1901  parseTriggerString(m_trigGlobalConfiguration.trigger_loose, "GlobalTriggersLoose");
1902  }
1903  }
1904 
1905  float TopConfig::readFloatOption(top::ConfigurationSettings* const& settings, std::string instring) const {
1906  float invalue = 99999999.;
1907 
1908  try{
1909  invalue = std::stof(settings->value(instring));
1910  }
1911  catch (...) {
1912  throw std::invalid_argument {
1913  "TopConfig: cannot convert Option " + instring + "into float"
1914  };
1915  }
1916 
1917  return invalue;
1918  }
1919 
1920  void TopConfig::setGrlDir(const std::string& s) {
1921  if (!m_configFixed) {
1922  m_grlDir = s;
1923  m_grlDir.erase(remove_if(m_grlDir.begin(), m_grlDir.end(), isspace), m_grlDir.end());
1924  }
1925  }
1926 
1927  void TopConfig::setGrlFile(const std::string& s) {
1928  if (!m_configFixed) {
1929  std::istringstream grl_files_ss(s);
1930  std::vector<std::string> temp_grls = {};
1931  std::copy(std::istream_iterator<std::string>(grl_files_ss),
1932  std::istream_iterator<std::string>(),
1933  std::back_inserter(temp_grls));
1934  // m_grlFile = s;
1935  for (std::string grl : temp_grls) {
1936  grl.erase(remove_if(grl.begin(), grl.end(), isspace), grl.end());
1937  m_grlFile.push_back(grl);
1938  }
1939  }
1940  }
1941 
1942  void TopConfig::setTDPPath(const std::string& s) {
1943  if (!m_configFixed) {
1944  m_topDataPreparationPath = s;
1945  }
1946  }
1947 
1948  void TopConfig::jetUncertainties_NPModel(const std::string& s) {
1949  if (!m_configFixed) {
1950  m_jetUncertainties_NPModel = s;
1951  m_doMultipleJES = false;
1952  if (m_jetUncertainties_NPModel == "StrongReduction") {
1953  m_doMultipleJES = true;
1954  }
1955  }
1956  }
1957 
1958  void TopConfig::jetUncertainties_QGFracFile(const std::string& s) {
1959  if (!m_configFixed) {
1960  m_jetUncertainties_QGFracFile = s;
1961  }
1962  }
1963 
1964  void TopConfig::jetUncertainties_QGHistPatterns(const std::string& s) {
1965  if (!m_configFixed) {
1966  std::vector<std::string> outVector;
1967  if (s.find(" ") != std::string::npos) {
1968  throw std::runtime_error {
1969  "TopConfig: jetUncertainties_QGHistPatterns string can't contain white spaces"
1970  };
1971  }
1972  if (s != "None") {
1973  tokenize(s, outVector, ","); // list of DSIDs separated by commas
1974  if (outVector.size() != 1) // if size is !=1, we need to check if these are DSIDs
1975  for (const auto& s : outVector) {
1976  int i = std::atoi(s.c_str());
1977  if (i < 300000 || i >= 1000000) throw std::runtime_error {
1978  "TopConfig: jetUncertainties_QGHistPatterns string doesn't look like a list of DISDs! You can either specify a single string pattern or a list of DSIDs separated by commas."
1979  };
1980  }
1981  }
1982  m_jetUncertainties_QGHistPatterns = outVector;
1983  }
1984  }
1985 
1986  void TopConfig::sgKeyMCParticle(const std::string& s) {
1987  if (!m_configFixed) {
1988  m_useTruthParticles = false;
1989  if (s != "None") m_useTruthParticles = true;
1990 
1991  m_sgKeyMCParticle = s;
1992  }
1993  }
1994 
1995  void TopConfig::sgKeyPhotons(const std::string& s) {
1996  if (!m_configFixed) {
1997  m_usePhotons = false;
1998  if (s != "None") m_usePhotons = true;
1999 
2000  m_sgKeyPhotons = s;
2001  }
2002  }
2003 
2004  void TopConfig::sgKeyElectrons(const std::string& s) {
2005  if (!m_configFixed) {
2006  m_useElectrons = false;
2007  if (s != "None") m_useElectrons = true;
2008 
2009  m_sgKeyElectrons = s;
2010  }
2011  }
2012 
2013  void TopConfig::sgKeyFwdElectrons(const std::string& s) {
2014  if (!m_configFixed) {
2015  m_useFwdElectrons = false;
2016  if (s != "None") m_useFwdElectrons = true;
2017 
2018  m_sgKeyFwdElectrons = s;
2019  }
2020  }
2021 
2022  void TopConfig::sgKeyMuons(const std::string& s) {
2023  if (!m_configFixed) {
2024  m_useMuons = false;
2025  if (s != "None") m_useMuons = true;
2026 
2027  m_sgKeyMuons = s;
2028  }
2029  }
2030 
2031  void TopConfig::sgKeySoftMuons(const std::string& s) {
2032  if (!m_configFixed) {
2033  m_useSoftMuons = false;
2034  if (s != "None") m_useSoftMuons = true;
2035 
2036  m_sgKeySoftMuons = s;
2037  }
2038  }
2039 
2040  void TopConfig::sgKeyTaus(const std::string& s) {
2041  if (!m_configFixed) {
2042  m_useTaus = false;
2043  if (s != "None") m_useTaus = true;
2044 
2045  m_sgKeyTaus = s;
2046  }
2047  }
2048 
2049  void TopConfig::sgKeyJets(const std::string& s) {
2050  if (!m_configFixed) {
2051  m_useJets = false;
2052  if (s != "None") m_useJets = true;
2053 
2054  m_sgKeyJets = s;
2055 
2056  // If anti-kt4 pflow jets then...
2057  if (m_sgKeyJets == "AntiKt4EMPFlowJets") m_useParticleFlowJets = true;
2058  }
2059  }
2060 
2061  void TopConfig::sgKeyLargeRJets(const std::string& s) {
2062  if (!m_configFixed) {
2063  m_useLargeRJets = false;
2064  if (s != "None") m_useLargeRJets = true;
2065 
2066  m_sgKeyLargeRJets = s;
2067  }
2068  }
2069 
2070  void TopConfig::sgKeyTrackJets(const std::string& s) {
2071  if (!m_configFixed) {
2072  m_useTrackJets = false;
2073  if (s != "None") m_useTrackJets = true;
2074 
2075  m_sgKeyTrackJets = s;
2076  }
2077  }
2078 
2079  void TopConfig::sgKeyTracks(const std::string& s) {
2080 
2081  if (!m_configFixed) {
2082  m_useTracks = false;
2083  if (s != "None") m_useTracks = true;
2084  m_sgKeyTracks = s;
2085  }
2086  }
2087 
2088  void TopConfig::sgKeyTruthElectrons(const std::string& s) {
2089  if (!m_configFixed) {
2090  m_useTruthElectrons = false;
2091  if (s != "None") m_useTruthElectrons = true;
2092 
2093  m_sgKeyTruthElectrons = s;
2094  }
2095  }
2096 
2097  void TopConfig::sgKeyTruthMuons(const std::string& s) {
2098  if (!m_configFixed) {
2099  m_useTruthMuons = false;
2100  if (s != "None") m_useTruthMuons = true;
2101 
2102  m_sgKeyTruthMuons = s;
2103  }
2104  }
2105 
2106  void TopConfig::sgKeyTruthPhotons(const std::string& s) {
2107  if (!m_configFixed) {
2108  m_useTruthPhotons = false;
2109  if (s != "None") {
2110  m_useTruthPhotons = true;
2111  }
2112 
2113  m_sgKeyTruthPhotons = s;
2114  }
2115  }
2116 
2117  void TopConfig::sgKeyTruthMET(const std::string& s) {
2118  if (!m_configFixed) {
2119  m_useTruthMET = false;
2120  if (s != "None") m_useTruthMET = true;
2121 
2122  m_sgKeyTruthMET = s;
2123  }
2124  }
2125 
2126  void TopConfig::sgKeyTruthJets(const std::string& s) {
2127  if (!m_configFixed) {
2128  m_useTruthJets = false;
2129  if (s != "None") m_useTruthJets = true;
2130 
2131  m_sgKeyTruthJets = s;
2132  }
2133  }
2134 
2135  void TopConfig::sgKeyTruthLargeRJets(const std::string& s) {
2136  if (!m_configFixed) {
2137  m_useTruthLargeRJets = false;
2138  if (s != "None") m_useTruthLargeRJets = true;
2139 
2140  m_sgKeyTruthLargeRJets = s;
2141  }
2142  }
2143 
2144  void TopConfig::sgKeyTruthTaus(const std::string& s) {
2145  if (!m_configFixed) {
2146  m_useTruthTaus = false;
2147  if (s != "None") m_useTruthTaus = true;
2148 
2149  m_sgKeyTruthTaus = s;
2150  }
2151  }
2152 
2153  void TopConfig::decoKeyJetGhostTrack(const std::string& key) {
2154  if (!m_configFixed) {
2155  m_useJetGhostTrack = false;
2156  if (key != "None") m_useJetGhostTrack = true;
2157 
2158  m_decoKeyJetGhostTrack = key;
2159  }
2160  }
2161 
2162  // setting the run periods for ghost track
2163  // even if configuration is fixed - could be changed later
2164  void TopConfig::runPeriodJetGhostTrack(const std::vector<std::uint32_t>& vect) {
2165  if (m_useJetGhostTrack == true) m_jetGhostTrackRunPeriods = vect;
2166  }
2167 
2168  // setting the run periods for tracks
2169  // even if configuration is fixed - could be changed later
2170  void TopConfig::runPeriodTrack(const std::vector<std::uint32_t>& vect) {
2171  if (m_useTracks) m_trackRunPeriods = vect;
2172  }
2173 
2174 
2175  void TopConfig::setBTaggingSFSysts(std::string WP, const std::set<std::string>& btagging_SF_names, bool isTrackJet) {
2176  //this avoids code duplication
2177  std::unordered_map<std::string,
2178  std::set<std::string> >& base_names = isTrackJet ? bTag_base_names_trkJet : bTag_base_names;
2179  std::unordered_map<std::string,
2180  std::set<std::string> >& named_systs = isTrackJet ? bTag_named_systs_trkJet : bTag_named_systs;
2181  std::unordered_map<std::string, unsigned int>& eigen_B = isTrackJet ? bTag_eigen_B_trkJet : bTag_eigen_B;
2182  std::unordered_map<std::string, unsigned int>& eigen_C = isTrackJet ? bTag_eigen_C_trkJet : bTag_eigen_C;
2183  std::unordered_map<std::string,
2184  unsigned int>& eigen_light = isTrackJet ? bTag_eigen_light_trkJet : bTag_eigen_light;
2185 
2186  //names of all systematics
2187  base_names[WP] = btagging_SF_names;
2188  //initialise named systematics to empty set
2189  named_systs[WP] = { };
2190  // initialise number of eigenvectors
2191  eigen_B[WP] = 0;
2192  eigen_C[WP] = 0;
2193  eigen_light[WP] = 0;
2194  // loop on systematic names
2195  for (const auto& SF_name : base_names.at(WP)) {
2196  if (SF_name.find("_Eigen_B_") != std::string::npos) eigen_B.at(WP)++;
2197  else if (SF_name.find("_Eigen_C_") != std::string::npos) eigen_C.at(WP)++;
2198  else if (SF_name.find("_Eigen_Light_") != std::string::npos) eigen_light.at(WP)++;
2199  else named_systs[WP].insert(SF_name);
2200  }
2201  }
2202 
2203  void TopConfig::setCalibBoostedJetTagger(const std::string& WP, const std::string& SFname) {
2204  m_boostedTaggerSFnames[WP] = SFname;
2205  }
2206 
2207  void TopConfig::addBTagAlgo(const std::string& algorithm, const std::string& selectionToolName, bool trackJets) {
2208  // we only need one tool per algorithm, e.g. DL1r, DL1d
2209  // the map will by definition only store one
2210  if (trackJets)
2211  m_btag_algos_trkJet[algorithm] = selectionToolName;
2212  else
2213  m_btag_algos_caloJet[algorithm] = selectionToolName;
2214  }
2215 
2216  void TopConfig::parse_bTagWPs(const std::string& btagWPsettingString,
2217  std::vector<std::pair<std::string, std::string>>& btagAlgoWPlist,
2218  std::vector<std::string>& btagWPlist) {
2219  std::istringstream str_btagging_WP(btagWPsettingString);
2220  std::vector<std::string> all_btagging_WP;
2221  std::copy(std::istream_iterator<std::string>(str_btagging_WP),
2222  std::istream_iterator<std::string>(),
2223  std::back_inserter(all_btagging_WP));
2224  // loop through all btagging WPs requested
2225  for (const auto& AlgTag : all_btagging_WP) {
2226  std::vector<std::string> btagAlg_btagWP;
2227  tokenize(AlgTag, btagAlg_btagWP, ":");
2228  // DEFAULT algorithm - May remove in future
2229  std::string alg = "DL1r";
2230  std::string tag = "";
2231  // If no ':' delimiter, assume we want default algorithm, and take the WP from the option
2232  if (btagAlg_btagWP.size() == 2) {
2233  alg = btagAlg_btagWP.at(0);
2234  tag = btagAlg_btagWP.at(1);
2235  } else {
2236  ATH_MSG_ERROR("Cannot parse b-tagging ALGORITHM_NAME:WP. Incorrect format.");
2237  continue;
2238  }
2239 
2240  std::pair<std::string, std::string> alg_tag = std::make_pair(alg, tag);
2241  btagAlgoWPlist.push_back(alg_tag);
2242  btagWPlist.push_back(alg + "_" + tag);
2243  }
2244  remove_duplicates(btagWPlist);
2245  remove_duplicates(btagAlgoWPlist);
2246  }
2247 
2248  void TopConfig::addLHAPDFResult(const std::string& pdf_name,
2249  std::vector<float> sum_of_weights) {
2250  m_lhapdf_options.pdf_results[ pdf_name ] = sum_of_weights;
2251  }
2252 
2253  void TopConfig::outputEvents(const std::string& s) {
2254  if (!m_configFixed) {
2255  m_outputEvents = s;
2256  if (m_outputEvents == "AllEvents") {
2257  m_saveOnlySelectedEvents = false;
2258  }
2259  }
2260  }
2261 
2263  bool TopConfig::isSystNominal(const std::string& syst) const {
2264  return boost::iequals(syst, m_nominalSystName);
2265  }
2266 
2267  bool TopConfig::isSystAll(const std::string& syst) const {
2268  return boost::iequals(syst, m_allSystName);
2269  }
2270 
2271  bool TopConfig::getSystematicsList(const std::string& syststr, std::set<std::string>& systList) const {
2272  if (isSystAll(syststr) || isSystNominal(syststr)) return true;
2273 
2274  if (syststr.find(" ") != std::string::npos) {
2275  ATH_MSG_ERROR("getSystematicsList: systematic string can't contain white spaces");
2276  return false;
2277  }
2278 
2279  std::string separator = ",";
2280  std::string::size_type start = 0, end = 0;
2281  while ((end = syststr.find(separator, start)) != std::string::npos) {
2282  std::string token = syststr.substr(start, end - start);
2283  if (token.size()) systList.insert(token);
2284  start = end + 1;
2285  }
2286  std::string lasttoken = syststr.substr(start);
2287  if (lasttoken.size()) systList.insert(lasttoken);
2288 
2289  return true;
2290  }
2291 
2292  bool TopConfig::contains(const std::set<std::string>& systList, const std::string& name) const {
2293  return systList.find(name) != systList.end();
2294  }
2295 
2296  // set systematics
2297  void TopConfig::systematicsPhotons(const std::list<CP::SystematicSet>& syst) {
2298  if (!m_configFixed) {
2299  for (auto s : syst) {
2300  m_systHashPhotons->insert(s.hash());
2301  m_list_systHashAll->push_back(s.hash());
2302  m_systMapPhotons->insert(std::make_pair(s.hash(), s));
2303  m_systSgKeyMapPhotons->insert(std::make_pair(s.hash(), m_sgKeyPhotons + "_" + s.name()));
2304  }
2305  m_list_systHashAll->sort();
2306  m_list_systHashAll->unique();
2307  }
2308  }
2309 
2310  void TopConfig::systematicsElectrons(const std::list<CP::SystematicSet>& syst) {
2311  if (!m_configFixed) {
2312  for (auto s : syst) {
2313  m_systHashElectrons->insert(s.hash());
2314  m_list_systHashAll->push_back(s.hash());
2315  m_list_systHash_electronInJetSubtraction->push_back(s.hash());
2316  m_systMapElectrons->insert(std::make_pair(s.hash(), s));
2317  m_systSgKeyMapElectrons->insert(std::make_pair(s.hash(), m_sgKeyElectrons + "_" + s.name()));
2318  }
2319  m_list_systHashAll->sort();
2320  m_list_systHashAll->unique();
2321  m_list_systHash_electronInJetSubtraction->sort();
2322  m_list_systHash_electronInJetSubtraction->unique();
2323  }
2324  }
2325 
2326  void TopConfig::systematicsFwdElectrons(const std::list<CP::SystematicSet>& syst) {
2327  if (!m_configFixed) {
2328  for (const auto& s : syst) {
2329  m_systHashFwdElectrons->insert(s.hash());
2330  m_list_systHashAll->push_back(s.hash());
2331  m_systMapFwdElectrons->insert(std::make_pair(s.hash(), s));
2332  m_systSgKeyMapFwdElectrons->insert(std::make_pair(s.hash(), m_sgKeyFwdElectrons + "_" + s.name()));
2333  }
2334  m_list_systHashAll->sort();
2335  m_list_systHashAll->unique();
2336  }
2337  }
2338 
2339  void TopConfig::systematicsMuons(const std::list<CP::SystematicSet>& syst) {
2340  if (!m_configFixed) {
2341  for (auto s : syst) {
2342  m_systHashMuons->insert(s.hash());
2343  m_list_systHashAll->push_back(s.hash());
2344  m_systMapMuons->insert(std::make_pair(s.hash(), s));
2345  m_systSgKeyMapMuons->insert(std::make_pair(s.hash(), m_sgKeyMuons + "_" + s.name()));
2346  }
2347  m_list_systHashAll->sort();
2348  m_list_systHashAll->unique();
2349  }
2350  }
2351 
2352  void TopConfig::systematicsSoftMuons(const std::list<CP::SystematicSet>& syst) {
2353  if (!m_configFixed) {
2354  for (const CP::SystematicSet& s : syst) {
2355  m_systHashSoftMuons->insert(s.hash());
2356  m_list_systHashAll->push_back(s.hash());
2357  m_systMapSoftMuons->insert(std::make_pair(s.hash(), s));
2358  m_systSgKeyMapSoftMuons->insert(std::make_pair(s.hash(), m_sgKeySoftMuons + "_" + s.name()));
2359  }
2360  m_list_systHashAll->sort();
2361  m_list_systHashAll->unique();
2362  }
2363  }
2364 
2365  void TopConfig::systematicsTaus(const std::list<CP::SystematicSet>& syst) {
2366  if (!m_configFixed) {
2367  for (auto s : syst) {
2368  m_systHashTaus->insert(s.hash());
2369  m_list_systHashAll->push_back(s.hash());
2370  m_systMapTaus->insert(std::make_pair(s.hash(), s));
2371  m_systSgKeyMapTaus->insert(std::make_pair(s.hash(), m_sgKeyTaus + "_" + s.name()));
2372  }
2373  m_list_systHashAll->sort();
2374  m_list_systHashAll->unique();
2375  }
2376  }
2377 
2378  void TopConfig::systematicsJets(const std::list<CP::SystematicSet>& syst) {
2379  if (!m_configFixed) {
2380  for (auto s : syst) {
2381  m_systHashJets->insert(s.hash());
2382  m_list_systHashAll->push_back(s.hash());
2383  m_list_systHash_electronInJetSubtraction->push_back(s.hash());
2384  m_systMapJets->insert(std::make_pair(s.hash(), s));
2385  m_systSgKeyMapJets->insert(std::make_pair(s.hash(), m_sgKeyJets + "_" + s.name()));
2386  }
2387  m_list_systHashAll->sort();
2388  m_list_systHashAll->unique();
2389  m_list_systHash_electronInJetSubtraction->sort();
2390  m_list_systHash_electronInJetSubtraction->unique();
2391  }
2392  }
2393 
2394  void TopConfig::systematicsLargeRJets(const std::list<CP::SystematicSet>& syst) {
2395  if (!m_configFixed) {
2396  for (auto s : syst) {
2397  m_systHashLargeRJets->insert(s.hash());
2398  m_list_systHashAll->push_back(s.hash());
2399  m_systMapLargeRJets->insert(std::make_pair(s.hash(), s));
2400  m_systSgKeyMapLargeRJets->insert(std::make_pair(s.hash(), m_sgKeyLargeRJets + "_" + s.name()));
2401  }
2402  m_list_systHashAll->sort();
2403  m_list_systHashAll->unique();
2404  }
2405  }
2406 
2407  void TopConfig::systematicsTrackJets(const std::list<CP::SystematicSet>& syst) {
2408  if (!m_configFixed) {
2409  for (auto s : syst) {
2410  m_systHashTrackJets->insert(s.hash());
2411  m_list_systHashAll->push_back(s.hash());
2412  m_systMapTrackJets->insert(std::make_pair(s.hash(), s));
2413  m_systSgKeyMapTrackJets->insert(std::make_pair(s.hash(), m_sgKeyTrackJets + "_" + s.name()));
2414  }
2415  m_list_systHashAll->sort();
2416  m_list_systHashAll->unique();
2417  }
2418  }
2419 
2420  void TopConfig::systematicsMET(const std::list<CP::SystematicSet>& syst) {
2421  if (!m_configFixed) {
2422  for (auto s : syst) {
2423  m_systHashMET->insert(s.hash());
2424  m_list_systHashAll->push_back(s.hash());
2425  m_systMapMET->insert(std::make_pair(s.hash(), s));
2426  m_systSgKeyMapMET->insert(std::make_pair(s.hash(), m_sgKeyLargeRJets + "_" + s.name()));
2427  }
2428  m_list_systHashAll->sort();
2429  m_list_systHashAll->unique();
2430  }
2431  }
2432 
2433  void TopConfig::systematicsJetGhostTrack(const std::list<CP::SystematicSet>& syst) {
2434  if (!m_configFixed) {
2435  // Add the nominal (for reporting purposes).
2436  (*m_systMapJetGhostTrack)[m_nominalHashValue] = {};
2437  (*m_systDecoKeyMapJetGhostTrack)[m_nominalHashValue] = m_decoKeyJetGhostTrack + "_";
2438  m_jetGhostTrackSystematics.push_back("");
2439 
2440  for (auto s : syst) {
2441  (*m_systMapJetGhostTrack)[s.hash()] = s;
2442  (*m_systDecoKeyMapJetGhostTrack)[s.hash()] = m_decoKeyJetGhostTrack + "_" + s.name();
2443  m_list_systHashAll->push_back(s.hash());
2444  m_jetGhostTrackSystematics.push_back(s.name());
2445  }
2446 
2447  // Ensure that elements are unique.
2448  std::sort(m_jetGhostTrackSystematics.begin(),
2449  m_jetGhostTrackSystematics.end());
2450  auto last = std::unique(m_jetGhostTrackSystematics.begin(),
2451  m_jetGhostTrackSystematics.end());
2452  m_jetGhostTrackSystematics.erase(last,
2453  m_jetGhostTrackSystematics.end());
2454 
2455  m_list_systHashAll->sort();
2456  m_list_systHashAll->unique();
2457  }
2458  }
2459 
2460  void TopConfig::systematicsTracks(const std::list<CP::SystematicSet>& syst) {
2461 
2462  if (!m_configFixed) {
2463 
2464  for (auto s : syst) {
2465  m_systHashTracks->insert(s.hash());
2466  m_list_systHashAll->push_back(s.hash());
2467  m_systMapTracks->insert(std::make_pair(s.hash(), s));
2468 
2469  m_systSgKeyMapTracks->insert(std::make_pair(s.hash(), m_sgKeyTracks + "_" + s.name()));
2470 
2471  }
2472 
2473  m_list_systHashAll->sort();
2474  m_list_systHashAll->unique();
2475  }
2476 
2477  }
2478 
2479 
2480  void TopConfig::fixConfiguration() {
2481  ATH_MSG_INFO("TopConfig::fixConfiguration()");
2482  // Prevent the user from changing anything
2483  // Yes, this is deliberate
2484  m_configFixed = true;
2485 
2486  // copy hash values in m_systHashAll_list
2487  // into m_systHashAll
2488  // The std::unordered_set is faster
2489  for (std::list<std::size_t>::const_iterator i = m_list_systHashAll->begin(); i != m_list_systHashAll->end(); ++i) {
2490  m_systHashAll->insert((*i));
2491  }
2492  // same for m_systHash_electronInJetSubtraction
2493  for (std::list<std::size_t>::const_iterator i = m_list_systHash_electronInJetSubtraction->begin();
2494  i != m_list_systHash_electronInJetSubtraction->end(); ++i) {
2495  m_systHash_electronInJetSubtraction->insert((*i));
2496  }
2497 
2498 
2499  // Setup StoreGate keys for TopEvent/SingleSystEvent
2500  // Let's do ALL string manipulation here, never do it per event
2501  std::string nominalPhotons("SetMe");
2502  std::string nominalElectrons("SetMe");
2503  std::string nominalFwdElectrons("SetMe");
2504  std::string nominalMuons("SetMe");
2505  std::string nominalSoftMuons("SetMe");
2506  std::string nominalTaus("SetMe");
2507  std::string nominalJets("SetMe");
2508  std::string nominalLargeRJets("SetMe");
2509  std::string nominalTrackJets("SetMe");
2510  std::string nominalTracks("SetMe");
2511  std::string nominal("nominal");
2512  std::string tds("TDS");
2513  std::string tdsAux("TDSAux.");
2514 
2515  // Figure out the nominal object collection names
2516  std::unordered_map<std::size_t, std::string>::const_iterator ph = m_systSgKeyMapPhotons->find(m_nominalHashValue);
2517  if (ph != m_systSgKeyMapPhotons->end()) {
2518  nominalPhotons = (*ph).second;
2519  }
2520 
2521  std::unordered_map<std::size_t, std::string>::const_iterator el = m_systSgKeyMapElectrons->find(m_nominalHashValue);
2522  if (el != m_systSgKeyMapElectrons->end()) {
2523  nominalElectrons = (*el).second;
2524  }
2525 
2526  std::unordered_map<std::size_t, std::string>::const_iterator fwdel = m_systSgKeyMapFwdElectrons->find(
2527  m_nominalHashValue);
2528  if (fwdel != m_systSgKeyMapFwdElectrons->end()) {
2529  nominalFwdElectrons = (*fwdel).second;
2530  }
2531 
2532  std::unordered_map<std::size_t, std::string>::const_iterator mu = m_systSgKeyMapMuons->find(m_nominalHashValue);
2533  if (mu != m_systSgKeyMapMuons->end()) {
2534  nominalMuons = (*mu).second;
2535  }
2536 
2537  std::unordered_map<std::size_t, std::string>::const_iterator softmu = m_systSgKeyMapSoftMuons->find(
2538  m_nominalHashValue);
2539  if (softmu != m_systSgKeyMapSoftMuons->end()) {
2540  nominalSoftMuons = (*softmu).second;
2541  }
2542 
2543  std::unordered_map<std::size_t, std::string>::const_iterator tau = m_systSgKeyMapTaus->find(m_nominalHashValue);
2544  if (tau != m_systSgKeyMapTaus->end()) {
2545  nominalTaus = (*tau).second;
2546  }
2547 
2548  std::unordered_map<std::size_t, std::string>::const_iterator jet = m_systSgKeyMapJets->find(m_nominalHashValue);
2549  if (jet != m_systSgKeyMapJets->end()) {
2550  nominalJets = (*jet).second;
2551  }
2552 
2553  std::unordered_map<std::size_t, std::string>::const_iterator largeRJet = m_systSgKeyMapLargeRJets->find(
2554  m_nominalHashValue);
2555  if (largeRJet != m_systSgKeyMapLargeRJets->end()) {
2556  nominalLargeRJets = (*largeRJet).second;
2557  }
2558 
2559  std::unordered_map<std::size_t, std::string>::const_iterator trackJet = m_systSgKeyMapTrackJets->find(
2560  m_nominalHashValue);
2561  if (trackJet != m_systSgKeyMapTrackJets->end()) {
2562  nominalTrackJets = (*trackJet).second;
2563  }
2564  std::unordered_map<std::size_t, std::string>::const_iterator tracks = m_systSgKeyMapTracks->find(m_nominalHashValue);
2565  if (tracks != m_systSgKeyMapTracks->end()) {
2566  nominalTracks = (*tracks).second;
2567  }
2568 
2569 
2570  for (std::unordered_set<std::size_t>::const_iterator i = m_systHashAll->begin(); i != m_systHashAll->end(); ++i) {
2571  std::unordered_map<std::size_t, std::string>::const_iterator ph = m_systSgKeyMapPhotons->find(*i);
2572  if (ph != m_systSgKeyMapPhotons->end()) {
2573  m_systAllSgKeyMapPhotons->insert(std::make_pair((*i), (*ph).second));
2574  }
2575  if (ph == m_systSgKeyMapPhotons->end()) {
2576  m_systAllSgKeyMapPhotons->insert(std::make_pair((*i), nominalPhotons));
2577  }
2578 
2579  std::unordered_map<std::size_t, std::string>::const_iterator el = m_systSgKeyMapElectrons->find(*i);
2580  if (el != m_systSgKeyMapElectrons->end()) {
2581  m_systAllSgKeyMapElectrons->insert(std::make_pair((*i), (*el).second));
2582  }
2583  if (el == m_systSgKeyMapElectrons->end()) {
2584  m_systAllSgKeyMapElectrons->insert(std::make_pair((*i), nominalElectrons));
2585  }
2586 
2587  std::unordered_map<std::size_t, std::string>::const_iterator fwdel = m_systSgKeyMapFwdElectrons->find(*i);
2588  if (fwdel != m_systSgKeyMapFwdElectrons->end()) {
2589  m_systAllSgKeyMapFwdElectrons->insert(std::make_pair((*i), (*fwdel).second));
2590  }
2591  if (fwdel == m_systSgKeyMapFwdElectrons->end()) {
2592  m_systAllSgKeyMapFwdElectrons->insert(std::make_pair((*i), nominalFwdElectrons));
2593  }
2594 
2595  std::unordered_map<std::size_t, std::string>::const_iterator mu = m_systSgKeyMapMuons->find(*i);
2596  if (mu != m_systSgKeyMapMuons->end()) {
2597  m_systAllSgKeyMapMuons->insert(std::make_pair((*i), (*mu).second));
2598  }
2599  if (mu == m_systSgKeyMapMuons->end()) {
2600  m_systAllSgKeyMapMuons->insert(std::make_pair((*i), nominalMuons));
2601  }
2602 
2603  std::unordered_map<std::size_t, std::string>::const_iterator softmu = m_systSgKeyMapSoftMuons->find(*i);
2604  if (softmu != m_systSgKeyMapSoftMuons->end()) {
2605  m_systAllSgKeyMapSoftMuons->insert(std::make_pair((*i), (*softmu).second));
2606  }
2607  if (softmu == m_systSgKeyMapSoftMuons->end()) {
2608  m_systAllSgKeyMapSoftMuons->insert(std::make_pair((*i), nominalSoftMuons));
2609  }
2610 
2611  std::unordered_map<std::size_t, std::string>::const_iterator tau = m_systSgKeyMapTaus->find(*i);
2612  if (tau != m_systSgKeyMapTaus->end()) {
2613  m_systAllSgKeyMapTaus->insert(std::make_pair((*i), (*tau).second));
2614  }
2615  if (tau == m_systSgKeyMapTaus->end()) {
2616  m_systAllSgKeyMapTaus->insert(std::make_pair((*i), nominalTaus));
2617  }
2618 
2619  std::unordered_map<std::size_t, std::string>::const_iterator jet = m_systSgKeyMapJets->find(*i);
2620  if (jet != m_systSgKeyMapJets->end()) {
2621  m_systAllSgKeyMapJets->insert(std::make_pair((*i), (*jet).second));
2622  }
2623  if (jet == m_systSgKeyMapJets->end()) {
2624  m_systAllSgKeyMapJets->insert(std::make_pair((*i), nominalJets));
2625  }
2626 
2627  std::unordered_map<std::size_t, std::string>::const_iterator largeRJet = m_systSgKeyMapLargeRJets->find(*i);
2628  if (largeRJet != m_systSgKeyMapLargeRJets->end()) {
2629  m_systAllSgKeyMapLargeRJets->insert(std::make_pair((*i), (*largeRJet).second));
2630  }
2631  if (largeRJet == m_systSgKeyMapLargeRJets->end()) {
2632  m_systAllSgKeyMapLargeRJets->insert(std::make_pair((*i), nominalLargeRJets));
2633  }
2634 
2635  std::unordered_map<std::size_t, std::string>::const_iterator trackJet = m_systSgKeyMapTrackJets->find(*i);
2636  if (trackJet != m_systSgKeyMapTrackJets->end()) {
2637  m_systAllSgKeyMapTrackJets->insert(std::make_pair((*i), (*trackJet).second));
2638  }
2639  if (trackJet == m_systSgKeyMapTrackJets->end()) {
2640  m_systAllSgKeyMapTrackJets->insert(std::make_pair((*i), nominalTrackJets));
2641  }
2642 
2643  std::unordered_map<std::size_t, std::string>::const_iterator tracks = m_systSgKeyMapTracks->find(*i);
2644  if (tracks != m_systSgKeyMapTracks->end()) {
2645  m_systAllSgKeyMapTracks->insert(std::make_pair((*i), (*tracks).second));
2646  }
2647  if (tracks == m_systSgKeyMapTracks->end()) {
2648  m_systAllSgKeyMapTracks->insert(std::make_pair((*i), nominalTracks));
2649  }
2650 
2651 
2652  } // Loop over all systematic hash values
2653 
2654 
2655  if (m_applyElectronInJetSubtraction) {
2656  // Loop over all systematic hash values again, this time for electronInJetSubtraction
2657  std::string electronInJetSubtraction_Electrons("electronInJetSubtraction_Electrons_USING_");
2658  std::string electronInJetSubtraction_Jets("electronInJetSubtraction_Jets_USING_");
2659  std::string electronInJetSubtraction_JetsLoose("electronInJetSubtraction_JetsLoose_USING_");
2660  std::string electronInJetSubtraction_nominalElectrons = electronInJetSubtraction_Electrons + nominalElectrons +
2661  "_AND_" + nominalJets;
2662  std::string electronInJetSubtraction_nominalJets = electronInJetSubtraction_Jets + nominalElectrons + "_AND_" +
2663  nominalJets;
2664  std::string electronInJetSubtraction_nominalJetsLoose = electronInJetSubtraction_JetsLoose + nominalElectrons +
2665  "_AND_" + nominalJets;
2666 
2667  for (std::unordered_set<std::size_t>::const_iterator i = m_systHashAll->begin(); i != m_systHashAll->end(); ++i) {
2668  std::unordered_map<std::size_t, std::string>::const_iterator el = m_systSgKeyMapElectrons->find(*i);
2669  std::unordered_map<std::size_t, std::string>::const_iterator jet = m_systSgKeyMapJets->find(*i);
2670 
2671  if (el != m_systSgKeyMapElectrons->end()) {
2672  m_systAllSgKeyMapElectrons_electronInJetSubtraction->insert(std::make_pair((*i),
2673  electronInJetSubtraction_Electrons
2674  + (*el).second + "_AND_" +
2675  nominalJets));
2676  m_systAllSgKeyMapJets_electronInJetSubtraction->insert(std::make_pair((*i),
2677  electronInJetSubtraction_Jets +
2678  (*el).second + "_AND_" + nominalJets));
2679  m_systSgKeyMapJets_electronInJetSubtraction->insert(std::make_pair((*i),
2680  electronInJetSubtraction_Jets +
2681  (*el).second + "_AND_" + nominalJets));
2682 
2683  m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->insert(std::make_pair((*i),
2684  electronInJetSubtraction_JetsLoose
2685  + (*el).second + "_AND_" +
2686  nominalJets));
2687  m_systSgKeyMapJetsLoose_electronInJetSubtraction->insert(std::make_pair((*i),
2688  electronInJetSubtraction_JetsLoose +
2689  (*el).second + "_AND_" +
2690  nominalJets));
2691  }
2692  if (jet != m_systSgKeyMapJets->end()) {
2693  m_systAllSgKeyMapElectrons_electronInJetSubtraction->insert(std::make_pair((*i),
2694  electronInJetSubtraction_Electrons
2695  + nominalElectrons + "_AND_" +
2696  (*jet).second));
2697  m_systAllSgKeyMapJets_electronInJetSubtraction->insert(std::make_pair((*i),
2698  electronInJetSubtraction_Jets +
2699  nominalElectrons + "_AND_" +
2700  (*jet).second));
2701  m_systSgKeyMapJets_electronInJetSubtraction->insert(std::make_pair((*i),
2702  electronInJetSubtraction_Jets +
2703  nominalElectrons + "_AND_" +
2704  (*jet).second));
2705 
2706  m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->insert(std::make_pair((*i),
2707  electronInJetSubtraction_JetsLoose
2708  + nominalElectrons + "_AND_" +
2709  (*jet).second));
2710  m_systSgKeyMapJetsLoose_electronInJetSubtraction->insert(std::make_pair((*i),
2711  electronInJetSubtraction_JetsLoose +
2712  nominalElectrons + "_AND_" +
2713  (*jet).second));
2714  }
2715  if (el == m_systSgKeyMapElectrons->end() && jet == m_systSgKeyMapJets->end()) {
2716  m_systAllSgKeyMapElectrons_electronInJetSubtraction->insert(std::make_pair((*i),
2717  electronInJetSubtraction_nominalElectrons));
2718  m_systAllSgKeyMapJets_electronInJetSubtraction->insert(std::make_pair((*i),
2719  electronInJetSubtraction_nominalJets));
2720  m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->insert(std::make_pair((*i),
2721  electronInJetSubtraction_nominalJetsLoose));
2722  }
2723  } // Loop over all systematic hash values
2724  } // electron in jet Subtraction
2725 
2726 
2727  // Tempory data store names
2728  typedef std::unordered_map<std::size_t, std::string>::const_iterator Itr2;
2729  for (Itr2 i = m_systAllSgKeyMapPhotons->begin(); i != m_systAllSgKeyMapPhotons->end(); ++i) {
2730  m_systAllSgKeyMapPhotonsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
2731  m_systAllSgKeyMapPhotonsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
2732  }
2733 
2734  for (Itr2 i = m_systAllSgKeyMapElectrons->begin(); i != m_systAllSgKeyMapElectrons->end(); ++i) {
2735  m_systAllSgKeyMapElectronsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
2736  m_systAllSgKeyMapElectronsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
2737  }
2738 
2739  for (const auto& i : *(m_systAllSgKeyMapFwdElectrons)) {
2740  m_systAllSgKeyMapFwdElectronsTDS->insert(std::make_pair(i.first, i.second + tds));
2741  m_systAllSgKeyMapFwdElectronsTDSAux->insert(std::make_pair(i.first, i.second + tdsAux));
2742  }
2743 
2744  for (Itr2 i = m_systAllSgKeyMapMuons->begin(); i != m_systAllSgKeyMapMuons->end(); ++i) {
2745  m_systAllSgKeyMapMuonsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
2746  m_systAllSgKeyMapMuonsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
2747  }
2748 
2749  for (Itr2 i = m_systAllSgKeyMapSoftMuons->begin(); i != m_systAllSgKeyMapSoftMuons->end(); ++i) {
2750  m_systAllSgKeyMapSoftMuonsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
2751  m_systAllSgKeyMapSoftMuonsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
2752  }
2753 
2754  for (Itr2 i = m_systAllSgKeyMapTaus->begin(); i != m_systAllSgKeyMapTaus->end(); ++i) {
2755  m_systAllSgKeyMapTausTDS->insert(std::make_pair((*i).first, (*i).second + tds));
2756  m_systAllSgKeyMapTausTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
2757  }
2758 
2759  for (Itr2 i = m_systAllSgKeyMapJets->begin(); i != m_systAllSgKeyMapJets->end(); ++i) {
2760  m_systAllSgKeyMapJetsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
2761  m_systAllSgKeyMapJetsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
2762  }
2763 
2764  for (Itr2 i = m_systAllSgKeyMapLargeRJets->begin(); i != m_systAllSgKeyMapLargeRJets->end(); ++i) {
2765  m_systAllSgKeyMapLargeRJetsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
2766  m_systAllSgKeyMapLargeRJetsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
2767  }
2768 
2769  for (Itr2 i = m_systAllSgKeyMapElectrons_electronInJetSubtraction->begin();
2770  i != m_systAllSgKeyMapElectrons_electronInJetSubtraction->end(); ++i) {
2771  m_systAllSgKeyMapElectrons_electronInJetSubtractionTDS->insert(std::make_pair((*i).first, (*i).second + tds));
2772  m_systAllSgKeyMapElectrons_electronInJetSubtractionTDSAux->insert(std::make_pair((*i).first,
2773  (*i).second + tdsAux));
2774  }
2775 
2776  for (Itr2 i = m_systAllSgKeyMapTrackJets->begin(); i != m_systAllSgKeyMapTrackJets->end(); ++i) {
2777  m_systAllSgKeyMapTrackJetsTDS->insert(std::make_pair((*i).first, (*i).second + tds));
2778  m_systAllSgKeyMapTrackJetsTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
2779  }
2780 
2781  for (Itr2 i = m_systAllSgKeyMapTracks->begin(); i != m_systAllSgKeyMapTracks->end(); ++i) {
2782  m_systAllSgKeyMapTracksTDS->insert(std::make_pair((*i).first, (*i).second + tds));
2783  m_systAllSgKeyMapTracksTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
2784  }
2785 
2786  for (Itr2 i = m_systAllSgKeyMapJets_electronInJetSubtraction->begin();
2787  i != m_systAllSgKeyMapJets_electronInJetSubtraction->end(); ++i) {
2788  m_systAllSgKeyMapJets_electronInJetSubtractionTDS->insert(std::make_pair((*i).first, (*i).second + tds));
2789  m_systAllSgKeyMapJets_electronInJetSubtractionTDSAux->insert(std::make_pair((*i).first, (*i).second + tdsAux));
2790  }
2791 
2792  for (Itr2 i = m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->begin();
2793  i != m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->end(); ++i) {
2794  m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDS->insert(std::make_pair((*i).first, (*i).second + tds));
2795  m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDSAux->insert(std::make_pair((*i).first,
2796  (*i).second + tdsAux));
2797  }
2798 
2799 
2800  // TTree names
2801  m_systAllTTreeNames->insert(std::make_pair(m_nominalHashValue, nominal));
2802  typedef std::unordered_map<std::size_t, CP::SystematicSet>::const_iterator Itr;
2803 
2804  if (m_usePhotons) {
2805  for (Itr i = m_systMapPhotons->begin(); i != m_systMapPhotons->end(); ++i) {
2806  m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
2807  }
2808  }
2809  if (m_useElectrons) {
2810  for (Itr i = m_systMapElectrons->begin(); i != m_systMapElectrons->end(); ++i) {
2811  m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
2812  }
2813  }
2814  if (m_useFwdElectrons) {
2815  for (Itr i = m_systMapFwdElectrons->begin(); i != m_systMapFwdElectrons->end(); ++i) {
2816  m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
2817  }
2818  }
2819  if (m_useMuons) {
2820  for (Itr i = m_systMapMuons->begin(); i != m_systMapMuons->end(); ++i) {
2821  m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
2822  }
2823  }
2824  if (m_useSoftMuons) {
2825  for (Itr i = m_systMapSoftMuons->begin(); i != m_systMapSoftMuons->end(); ++i) {
2826  m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
2827  }
2828  }
2829  if (m_useTaus) {
2830  for (Itr i = m_systMapTaus->begin(); i != m_systMapTaus->end(); ++i) {
2831  m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
2832  }
2833  }
2834  if (m_useJets) {
2835  for (Itr i = m_systMapJets->begin(); i != m_systMapJets->end(); ++i) {
2836  m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
2837  }
2838  }
2839  if (m_useLargeRJets) {
2840  for (Itr i = m_systMapLargeRJets->begin(); i != m_systMapLargeRJets->end(); ++i) {
2841  m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
2842  }
2843  }
2844  if (m_useTrackJets) {
2845  for (Itr i = m_systMapTrackJets->begin(); i != m_systMapTrackJets->end(); ++i) {
2846  m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
2847  }
2848  }
2849  if (m_useTracks) {
2850  for (Itr i = m_systMapTracks->begin(); i != m_systMapTracks->end(); ++i) {
2851  m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
2852  }
2853  }
2854  if (m_useJetGhostTrack) {
2855  for (Itr i = m_systMapJetGhostTrack->begin(); i != m_systMapJetGhostTrack->end(); ++i) {
2856  m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
2857  }
2858  }
2859  for (Itr i = m_systMapMET->begin(); i != m_systMapMET->end(); ++i) {
2860  m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second.name()));
2861  }
2862 
2863 
2864 
2865  // Missing ET from TTree names
2866  // KLFitter from TTree names
2867 
2868  for (Itr2 i = m_systAllTTreeNames->begin(); i != m_systAllTTreeNames->end(); ++i) {
2869  if (m_doTightEvents) m_systSgKeyMapMissingET->insert(std::make_pair((*i).first,
2870  m_sgKeyMissingEt + "_" + (*i).second));
2871  if (m_doLooseEvents) m_systSgKeyMapMissingETLoose->insert(std::make_pair((*i).first,
2872  m_sgKeyMissingEt + "_Loose_" +
2873  (*i).second));
2874 
2875  if (m_doTightEvents) m_systSgKeyMapKLFitter->insert(std::make_pair((*i).first,
2876  m_sgKeyKLFitter + "_" + (*i).second));
2877  if (m_doLooseEvents) m_systSgKeyMapKLFitterLoose->insert(std::make_pair((*i).first,
2878  m_sgKeyKLFitter + "_Loose_" +
2879  (*i).second));
2880 
2881  if (m_doTightEvents) m_systSgKeyMapPseudoTop->insert(std::make_pair((*i).first,
2882  m_sgKeyPseudoTop + "_" + (*i).second));
2883  if (m_doLooseEvents) m_systSgKeyMapPseudoTopLoose->insert(std::make_pair((*i).first,
2884  m_sgKeyPseudoTop + "_Loose_" +
2885  (*i).second));
2886  }
2887 
2888 
2889  // TTree index
2890  unsigned int TTreeIndex(0);
2891  if (m_doTightEvents) {
2892  for (Itr2 i = m_systAllTTreeNames->begin(); i != m_systAllTTreeNames->end(); ++i) {
2893  if ((*i).second == "nominal" || m_doTightSysts) {
2894  m_systAllTTreeIndex->insert(std::make_pair((*i).first, TTreeIndex));
2895  ++TTreeIndex;
2896  }
2897  }
2898  }
2899  if (m_doLooseEvents) {
2900  for (Itr2 i = m_systAllTTreeNames->begin(); i != m_systAllTTreeNames->end(); ++i) {
2901  if ((*i).second == "nominal" || m_doLooseSysts) {
2902  m_systAllTTreeLooseIndex->insert(std::make_pair((*i).first, TTreeIndex));
2903  ++TTreeIndex;
2904  }
2905  }
2906  }
2907 
2908  if (m_makeAllCPTools) {
2909  for (Itr2 i = m_systAllTTreeNames->begin(); i != m_systAllTTreeNames->end(); ++i) {
2910  m_systPersistantAllTTreeNames->insert(std::make_pair((*i).first, (*i).second));
2911  }
2912  }
2913  }
2914 
2915  const std::string& TopConfig::sgKeyPhotons(const std::size_t hash) const {
2916  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapPhotons->find(hash);
2917  if (key != m_systAllSgKeyMapPhotons->end()) {
2918  return (*key).second;
2919  }
2920  return m_sgKeyDummy;
2921  }
2922 
2923  const std::string& TopConfig::sgKeyPhotonsTDS(const std::size_t hash) const {
2924  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapPhotonsTDS->find(hash);
2925  if (key != m_systAllSgKeyMapPhotonsTDS->end()) {
2926  return (*key).second;
2927  }
2928  return m_sgKeyDummy;
2929  }
2930 
2931  const std::string& TopConfig::sgKeyPhotonsTDSAux(const std::size_t hash) const {
2932  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapPhotonsTDSAux->find(hash);
2933  if (key != m_systAllSgKeyMapPhotonsTDSAux->end()) {
2934  return (*key).second;
2935  }
2936  return m_sgKeyDummy;
2937  }
2938 
2939  const std::string& TopConfig::sgKeyElectrons(const std::size_t hash) const {
2940  if (!m_applyElectronInJetSubtraction) {
2941  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapElectrons->find(hash);
2942  if (key != m_systAllSgKeyMapElectrons->end()) {
2943  return (*key).second;
2944  }
2945  }
2946 
2947  if (m_applyElectronInJetSubtraction) {
2948  std::unordered_map<std::size_t,
2949  std::string>::const_iterator key = m_systAllSgKeyMapElectrons_electronInJetSubtraction->find(
2950  hash);
2951  if (key != m_systAllSgKeyMapElectrons_electronInJetSubtraction->end()) {
2952  return (*key).second;
2953  }
2954  }
2955 
2956  return m_sgKeyDummy;
2957  }
2958 
2959  const std::string& TopConfig::sgKeyElectronsTDS(const std::size_t hash) const {
2960  if (!m_applyElectronInJetSubtraction) {
2961  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapElectronsTDS->find(hash);
2962  if (key != m_systAllSgKeyMapElectronsTDS->end()) {
2963  return (*key).second;
2964  }
2965  }
2966 
2967  if (m_applyElectronInJetSubtraction) {
2968  std::unordered_map<std::size_t,
2969  std::string>::const_iterator key =
2970  m_systAllSgKeyMapElectrons_electronInJetSubtractionTDS->find(hash);
2971  if (key != m_systAllSgKeyMapElectrons_electronInJetSubtractionTDS->end()) {
2972  return (*key).second;
2973  }
2974  }
2975 
2976  return m_sgKeyDummy;
2977  }
2978 
2979  const std::string& TopConfig::sgKeyElectronsTDSAux(const std::size_t hash) const {
2980  if (!m_applyElectronInJetSubtraction) {
2981  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapElectronsTDSAux->find(hash);
2982  if (key != m_systAllSgKeyMapElectronsTDSAux->end()) {
2983  return (*key).second;
2984  }
2985  }
2986 
2987  if (m_applyElectronInJetSubtraction) {
2988  std::unordered_map<std::size_t,
2989  std::string>::const_iterator key =
2990  m_systAllSgKeyMapElectrons_electronInJetSubtractionTDSAux->find(hash);
2991  if (key != m_systAllSgKeyMapElectrons_electronInJetSubtractionTDSAux->end()) {
2992  return (*key).second;
2993  }
2994  }
2995 
2996  return m_sgKeyDummy;
2997  }
2998 
2999  const std::string& TopConfig::sgKeyElectronsStandAlone(const std::size_t hash) const {
3000  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapElectrons->find(hash);
3001  if (key != m_systAllSgKeyMapElectrons->end()) {
3002  return (*key).second;
3003  }
3004  return m_sgKeyDummy;
3005  }
3006 
3007  const std::string& TopConfig::sgKeyFwdElectrons(const std::size_t hash) const {
3008  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapFwdElectrons->find(hash);
3009  if (key != m_systAllSgKeyMapFwdElectrons->end()) {
3010  return (*key).second;
3011  }
3012 
3013  return m_sgKeyDummy;
3014  }
3015 
3016  const std::string& TopConfig::sgKeyFwdElectronsTDS(const std::size_t hash) const {
3017  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapFwdElectronsTDS->find(hash);
3018  if (key != m_systAllSgKeyMapFwdElectronsTDS->end()) {
3019  return (*key).second;
3020  }
3021 
3022  return m_sgKeyDummy;
3023  }
3024 
3025  const std::string& TopConfig::sgKeyFwdElectronsTDSAux(const std::size_t hash) const {
3026  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapFwdElectronsTDSAux->find(hash);
3027  if (key != m_systAllSgKeyMapFwdElectronsTDSAux->end()) {
3028  return (*key).second;
3029  }
3030 
3031  return m_sgKeyDummy;
3032  }
3033 
3034  const std::string& TopConfig::sgKeyFwdElectronsStandAlone(const std::size_t hash) const {
3035  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapFwdElectrons->find(hash);
3036  if (key != m_systAllSgKeyMapFwdElectrons->end()) {
3037  return (*key).second;
3038  }
3039  return m_sgKeyDummy;
3040  }
3041 
3042  const std::string& TopConfig::sgKeyMuons(const std::size_t hash) const {
3043  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapMuons->find(hash);
3044  if (key != m_systAllSgKeyMapMuons->end()) {
3045  return (*key).second;
3046  }
3047  return m_sgKeyDummy;
3048  }
3049 
3050  const std::string& TopConfig::sgKeyMuonsTDS(const std::size_t hash) const {
3051  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapMuonsTDS->find(hash);
3052  if (key != m_systAllSgKeyMapMuonsTDS->end()) {
3053  return (*key).second;
3054  }
3055  return m_sgKeyDummy;
3056  }
3057 
3058  const std::string& TopConfig::sgKeyMuonsTDSAux(const std::size_t hash) const {
3059  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapMuonsTDSAux->find(hash);
3060  if (key != m_systAllSgKeyMapMuonsTDSAux->end()) {
3061  return (*key).second;
3062  }
3063  return m_sgKeyDummy;
3064  }
3065 
3066  const std::string& TopConfig::sgKeySoftMuons(const std::size_t hash) const {
3067  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapSoftMuons->find(hash);
3068  if (key != m_systAllSgKeyMapSoftMuons->end()) {
3069  return (*key).second;
3070  }
3071  return m_sgKeyDummy;
3072  }
3073 
3074  const std::string& TopConfig::sgKeySoftMuonsTDS(const std::size_t hash) const {
3075  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapSoftMuonsTDS->find(hash);
3076  if (key != m_systAllSgKeyMapSoftMuonsTDS->end()) {
3077  return (*key).second;
3078  }
3079  return m_sgKeyDummy;
3080  }
3081 
3082  const std::string& TopConfig::sgKeySoftMuonsTDSAux(const std::size_t hash) const {
3083  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapSoftMuonsTDSAux->find(hash);
3084  if (key != m_systAllSgKeyMapSoftMuonsTDSAux->end()) {
3085  return (*key).second;
3086  }
3087  return m_sgKeyDummy;
3088  }
3089 
3090  const std::string& TopConfig::sgKeyTaus(const std::size_t hash) const {
3091  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTaus->find(hash);
3092  if (key != m_systAllSgKeyMapTaus->end()) {
3093  return (*key).second;
3094  }
3095  return m_sgKeyDummy;
3096  }
3097 
3098  const std::string& TopConfig::sgKeyTausTDS(const std::size_t hash) const {
3099  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTausTDS->find(hash);
3100  if (key != m_systAllSgKeyMapTausTDS->end()) {
3101  return (*key).second;
3102  }
3103  return m_sgKeyDummy;
3104  }
3105 
3106  const std::string& TopConfig::sgKeyTausTDSAux(const std::size_t hash) const {
3107  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTausTDSAux->find(hash);
3108  if (key != m_systAllSgKeyMapTausTDSAux->end()) {
3109  return (*key).second;
3110  }
3111  return m_sgKeyDummy;
3112  }
3113 
3114  const std::string& TopConfig::sgKeyJets(const std::size_t hash, const bool useLooseLeptonJets) const {
3115  if (!m_applyElectronInJetSubtraction) {
3116  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapJets->find(hash);
3117  if (key != m_systAllSgKeyMapJets->end()) {
3118  return (*key).second;
3119  }
3120  }
3121 
3122  if (m_applyElectronInJetSubtraction) {
3123  if (!useLooseLeptonJets) {
3124  std::unordered_map<std::size_t,
3125  std::string>::const_iterator key =
3126  m_systAllSgKeyMapJets_electronInJetSubtraction->find(hash);
3127  if (key != m_systAllSgKeyMapJets_electronInJetSubtraction->end()) {
3128  return (*key).second;
3129  }
3130  }
3131  if (useLooseLeptonJets) {
3132  std::unordered_map<std::size_t,
3133  std::string>::const_iterator key = m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->find(
3134  hash);
3135  if (key != m_systAllSgKeyMapJetsLoose_electronInJetSubtraction->end()) {
3136  return (*key).second;
3137  }
3138  }
3139  }
3140 
3141  return m_sgKeyDummy;
3142  }
3143 
3144  const std::string& TopConfig::sgKeyJetsTDS(const std::size_t hash, const bool useLooseLeptonJets) const {
3145  if (!m_applyElectronInJetSubtraction) {
3146  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapJetsTDS->find(hash);
3147  if (key != m_systAllSgKeyMapJetsTDS->end()) {
3148  return (*key).second;
3149  }
3150  }
3151 
3152  if (m_applyElectronInJetSubtraction) {
3153  if (!useLooseLeptonJets) {
3154  std::unordered_map<std::size_t,
3155  std::string>::const_iterator key = m_systAllSgKeyMapJets_electronInJetSubtractionTDS->find(
3156  hash);
3157  if (key != m_systAllSgKeyMapJets_electronInJetSubtractionTDS->end()) {
3158  return (*key).second;
3159  }
3160  }
3161  if (useLooseLeptonJets) {
3162  std::unordered_map<std::size_t,
3163  std::string>::const_iterator key =
3164  m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDS->find(hash);
3165  if (key != m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDS->end()) {
3166  return (*key).second;
3167  }
3168  }
3169  }
3170 
3171  return m_sgKeyDummy;
3172  }
3173 
3174  const std::string& TopConfig::sgKeyJetsTDSAux(const std::size_t hash, const bool useLooseLeptonJets) const {
3175  if (!m_applyElectronInJetSubtraction) {
3176  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapJetsTDSAux->find(hash);
3177  if (key != m_systAllSgKeyMapJetsTDSAux->end()) {
3178  return (*key).second;
3179  }
3180  }
3181 
3182  if (m_applyElectronInJetSubtraction) {
3183  if (!useLooseLeptonJets) {
3184  std::unordered_map<std::size_t,
3185  std::string>::const_iterator key =
3186  m_systAllSgKeyMapJets_electronInJetSubtractionTDSAux->find(hash);
3187  if (key != m_systAllSgKeyMapJets_electronInJetSubtractionTDSAux->end()) {
3188  return (*key).second;
3189  }
3190  }
3191  if (useLooseLeptonJets) {
3192  std::unordered_map<std::size_t,
3193  std::string>::const_iterator key =
3194  m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDSAux->find(hash);
3195  if (key != m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDSAux->end()) {
3196  return (*key).second;
3197  }
3198  }
3199  }
3200 
3201  return m_sgKeyDummy;
3202  }
3203 
3204  const std::string& TopConfig::sgKeyJetsStandAlone(const std::size_t hash) const {
3205  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapJets->find(hash);
3206  if (key != m_systAllSgKeyMapJets->end()) {
3207  return (*key).second;
3208  }
3209  return m_sgKeyDummy;
3210  }
3211 
3212  const std::string& TopConfig::sgKeyLargeRJets(const std::size_t hash) const {
3213  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapLargeRJets->find(hash);
3214  if (key != m_systAllSgKeyMapLargeRJets->end()) {
3215  return (*key).second;
3216  }
3217  return m_sgKeyDummy;
3218  }
3219 
3220  const std::string& TopConfig::sgKeyLargeRJetsTDS(const std::size_t hash) const {
3221  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapLargeRJetsTDS->find(hash);
3222  if (key != m_systAllSgKeyMapLargeRJetsTDS->end()) {
3223  return (*key).second;
3224  }
3225  return m_sgKeyDummy;
3226  }
3227 
3228  const std::string& TopConfig::sgKeyLargeRJetsTDSAux(const std::size_t hash) const {
3229  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapLargeRJetsTDSAux->find(hash);
3230  if (key != m_systAllSgKeyMapLargeRJetsTDSAux->end()) {
3231  return (*key).second;
3232  }
3233  return m_sgKeyDummy;
3234  }
3235 
3236  const std::string& TopConfig::sgKeyTrackJets(const std::size_t hash) const {
3237  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTrackJets->find(hash);
3238  if (key != m_systAllSgKeyMapTrackJets->end()) {
3239  return (*key).second;
3240  }
3241  return m_sgKeyDummy;
3242  }
3243 
3244  const std::string& TopConfig::sgKeyTrackJetsTDS(const std::size_t hash) const {
3245  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTrackJetsTDS->find(hash);
3246  if (key != m_systAllSgKeyMapTrackJetsTDS->end()) {
3247  return (*key).second;
3248  }
3249  return m_sgKeyDummy;
3250  }
3251 
3252  const std::string& TopConfig::sgKeyTrackJetsTDSAux(const std::size_t hash) const {
3253  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTrackJetsTDSAux->find(hash);
3254  if (key != m_systAllSgKeyMapTrackJetsTDSAux->end()) {
3255  return (*key).second;
3256  }
3257  return m_sgKeyDummy;
3258  }
3259 
3260  const std::string& TopConfig::sgKeyTracks(const std::size_t hash) const {
3261  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTracks->find(hash);
3262  if (key != m_systAllSgKeyMapTracks->end()) {
3263  return (*key).second;
3264  }
3265  return m_sgKeyDummy;
3266  }
3267 
3268  const std::string& TopConfig::sgKeyTracksTDS(const std::size_t hash) const {
3269  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTracksTDS->find(hash);
3270  if (key != m_systAllSgKeyMapTracksTDS->end()) {
3271  return (*key).second;
3272  }
3273  return m_sgKeyDummy;
3274  }
3275 
3276  const std::string& TopConfig::sgKeyTracksTDSAux(const std::size_t hash) const {
3277  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systAllSgKeyMapTracksTDSAux->find(hash);
3278  if (key != m_systAllSgKeyMapTracksTDSAux->end()) {
3279  return (*key).second;
3280  }
3281  return m_sgKeyDummy;
3282  }
3283 
3284  const std::string& TopConfig::sgKeyMissingEt(const std::size_t hash) const {
3285  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systSgKeyMapMissingET->find(hash);
3286  if (key != m_systSgKeyMapMissingET->end()) {
3287  return (*key).second;
3288  }
3289  return m_sgKeyDummy;
3290  }
3291 
3292  const std::string& TopConfig::sgKeyMissingEtLoose(const std::size_t hash) const {
3293  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systSgKeyMapMissingETLoose->find(hash);
3294  if (key != m_systSgKeyMapMissingETLoose->end()) {
3295  return (*key).second;
3296  }
3297  return m_sgKeyDummy;
3298  }
3299 
3300  const std::string& TopConfig::sgKeyKLFitter(const std::size_t hash) const {
3301  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systSgKeyMapKLFitter->find(hash);
3302  if (key != m_systSgKeyMapKLFitter->end()) {
3303  return (*key).second;
3304  }
3305  return m_sgKeyDummy;
3306  }
3307 
3308  const std::string& TopConfig::sgKeyKLFitterLoose(const std::size_t hash) const {
3309  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systSgKeyMapKLFitterLoose->find(hash);
3310  if (key != m_systSgKeyMapKLFitterLoose->end()) {
3311  return (*key).second;
3312  }
3313  return m_sgKeyDummy;
3314  }
3315 
3316  const std::string& TopConfig::sgKeyPseudoTop(const std::size_t hash) const {
3317  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systSgKeyMapPseudoTop->find(hash);
3318  if (key != m_systSgKeyMapPseudoTop->end()) {
3319  return (*key).second;
3320  }
3321  return m_sgKeyDummy;
3322  }
3323 
3324  const std::string& TopConfig::sgKeyPseudoTopLoose(const std::size_t hash) const {
3325  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systSgKeyMapPseudoTopLoose->find(hash);
3326  if (key != m_systSgKeyMapPseudoTopLoose->end()) {
3327  return (*key).second;
3328  }
3329  return m_sgKeyDummy;
3330  }
3331 
3332  const std::string& TopConfig::decoKeyJetGhostTrack(const std::size_t hash) const {
3333  // If it's in the map, use the mapped value, otherwise use the nominal.
3334  auto it = m_systDecoKeyMapJetGhostTrack->find(hash);
3335 
3336  if (it != m_systDecoKeyMapJetGhostTrack->end()) {
3337  return it->second;
3338  } else {
3339  it = m_systDecoKeyMapJetGhostTrack->find(m_nominalHashValue);
3340  if (it == m_systDecoKeyMapJetGhostTrack->end()) throw std::runtime_error(
3341  "TopConfig: Failed to retrieve decoKeyJetGhostTrack.");
3342  return it->second;
3343  }
3344  }
3345 
3346  const std::string& TopConfig::systematicName(const std::size_t hash) const {
3347  std::unordered_map<std::size_t, std::string>::const_iterator key = m_systPersistantAllTTreeNames
3348  ->find(hash);
3349  if (key != m_systPersistantAllTTreeNames->end()) {
3350  return (*key).second;
3351  }
3352  return m_sgKeyDummy;
3353  }
3354 
3355  std::shared_ptr<std::unordered_map<std::size_t, std::string> > TopConfig::systSgKeyMapJets(
3356  const bool useLooseLeptonJets) const {
3357  if (m_applyElectronInJetSubtraction) {
3358  if (useLooseLeptonJets) {
3359  return m_systSgKeyMapJetsLoose_electronInJetSubtraction;
3360  }
3361  return m_systSgKeyMapJets_electronInJetSubtraction;
3362  }
3363  return m_systSgKeyMapJets;
3364  }
3365 
3366  // TTree index
3367  unsigned int TopConfig::ttreeIndex(const std::size_t hash) const {
3368  unsigned int index(99999); // This will crash the job if not set properly
3369 
3370  std::unordered_map<std::size_t, unsigned int>::const_iterator Itr = m_systAllTTreeIndex->find(hash);
3371  if (Itr != m_systAllTTreeIndex->end()) {
3372  index = (*Itr).second;
3373  }
3374  if (index == 99999) {
3375  ATH_MSG_WARNING("ttreeIndex is crazy, something has gone wrong with the hash value = " << hash);
3376  }
3377  return index;
3378  }
3379 
3380  unsigned int TopConfig::ttreeIndexLoose(const std::size_t hash) const {
3381  unsigned int index(99999); // This will crash the job if not set properly
3382 
3383  std::unordered_map<std::size_t, unsigned int>::const_iterator Itr = m_systAllTTreeLooseIndex->find(hash);
3384  if (Itr != m_systAllTTreeLooseIndex->end()) {
3385  index = (*Itr).second;
3386  }
3387  if (index == 99999) {
3388  ATH_MSG_WARNING("ttreeIndex is crazy, something has gone wrong with the hash value = " << hash);
3389  }
3390  return index;
3391  }
3392 
3393  const std::vector<std::pair<std::string, int> >& TopConfig::allTriggers_Tight(const std::string& selection) const {
3394  std::unordered_map<std::string,
3395  std::vector<std::pair<std::string, int> > >::const_iterator key = m_allTriggers_Tight->find(selection);
3396  if (key != m_allTriggers_Tight->end()) {
3397  return (*key).second;
3398  }
3399  return m_dummyTrigger;
3400  }
3401 
3402  const std::vector<std::pair<std::string, int> >& TopConfig::electronTriggers_Tight(const std::string& selection) const {
3403  std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >::const_iterator key = m_electronTriggers_Tight->find(
3404  selection);
3405  if (key != m_electronTriggers_Tight->end()) {
3406  return (*key).second;
3407  }
3408  return m_dummyTrigger;
3409  }
3410 
3411  const std::vector<std::pair<std::string, int> >& TopConfig::muonTriggers_Tight(const std::string& selection) const {
3412  std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >::const_iterator key = m_muonTriggers_Tight->find(
3413  selection);
3414  if (key != m_muonTriggers_Tight->end()) {
3415  return (*key).second;
3416  }
3417  return m_dummyTrigger;
3418  }
3419 
3420  const std::vector<std::pair<std::string, int> >& TopConfig::tauTriggers_Tight(const std::string& selection) const {
3421  std::unordered_map<std::string,
3422  std::vector<std::pair<std::string, int> > >::const_iterator key = m_tauTriggers_Tight->find(selection);
3423  if (key != m_tauTriggers_Tight->end()) {
3424  return (*key).second;
3425  }
3426  return m_dummyTrigger;
3427  }
3428 
3429  const std::vector<std::pair<std::string, int> >& TopConfig::photonTriggers_Tight(const std::string& selection) const {
3430  std::unordered_map<std::string,
3431  std::vector<std::pair<std::string, int> > >::const_iterator key = m_photonTriggers_Tight->find(selection);
3432  if (key != m_photonTriggers_Tight->end()) {
3433  return (*key).second;
3434  }
3435  return m_dummyTrigger;
3436  }
3437 
3438  const std::vector<std::pair<std::string, int> >& TopConfig::allTriggers_Loose(const std::string& selection) const {
3439  std::unordered_map<std::string,
3440  std::vector<std::pair<std::string, int> > >::const_iterator key = m_allTriggers_Loose->find(selection);
3441  if (key != m_allTriggers_Loose->end()) {
3442  return (*key).second;
3443  }
3444  return m_dummyTrigger;
3445  }
3446 
3447  const std::vector<std::pair<std::string, int> >& TopConfig::electronTriggers_Loose(const std::string& selection) const {
3448  std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >::const_iterator key = m_electronTriggers_Loose->find(
3449  selection);
3450  if (key != m_electronTriggers_Loose->end()) {
3451  return (*key).second;
3452  }
3453  return m_dummyTrigger;
3454  }
3455 
3456  const std::vector<std::pair<std::string, int> >& TopConfig::muonTriggers_Loose(const std::string& selection) const {
3457  std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >::const_iterator key = m_muonTriggers_Loose->find(
3458  selection);
3459  if (key != m_muonTriggers_Loose->end()) {
3460  return (*key).second;
3461  }
3462  return m_dummyTrigger;
3463  }
3464 
3465  const std::vector<std::pair<std::string, int> >& TopConfig::tauTriggers_Loose(const std::string& selection) const {
3466  std::unordered_map<std::string,
3467  std::vector<std::pair<std::string, int> > >::const_iterator key = m_tauTriggers_Loose->find(selection);
3468  if (key != m_tauTriggers_Loose->end()) {
3469  return (*key).second;
3470  }
3471  return m_dummyTrigger;
3472  }
3473 
3474  const std::vector<std::pair<std::string, int> >& TopConfig::photonTriggers_Loose(const std::string& selection) const {
3475  std::unordered_map<std::string,
3476  std::vector<std::pair<std::string, int> > >::const_iterator key = m_photonTriggers_Loose->find(selection);
3477  if (key != m_photonTriggers_Loose->end()) {
3478  return (*key).second;
3479  }
3480  return m_dummyTrigger;
3481  }
3482 
3485  top::TopPersistentSettings* TopConfig::createPersistentSettings() {
3486  top::TopPersistentSettings* out = new top::TopPersistentSettings();
3487 
3488  out->m_isMC = m_isMC;
3489  out->m_isAFII = m_isAFII;
3490  out->m_isDataOverlay = m_isDataOverlay;
3491  out->m_applyElectronInJetSubtraction = m_applyElectronInJetSubtraction;
3492  out->m_doOverlapRemovalOnLooseLeptonDef = m_doOverlapRemovalOnLooseLeptonDef;
3493  out->m_doKLFitter = m_doKLFitter;
3494  out->m_doPseudoTop = m_doPseudoTop;
3495 
3496  out->m_sgKeyTopSystematicEvents = m_sgKeyTopSystematicEvents;
3497  out->m_sgKeyTopSystematicEventsLoose = m_sgKeyTopSystematicEventsLoose;
3498 
3499  out->m_sgKeyEventInfo = m_sgKeyEventInfo;
3500  out->m_sgKeyPrimaryVertices = m_sgKeyPrimaryVertices;
3501  out->m_sgKeyPhotons = m_sgKeyPhotons;
3502  out->m_sgKeyElectrons = m_sgKeyElectrons;
3503  out->m_sgKeyFwdElectrons = m_sgKeyFwdElectrons;
3504  out->m_sgKeyMuons = m_sgKeyMuons;
3505  out->m_sgKeySoftMuons = m_sgKeySoftMuons;
3506  out->m_sgKeyTaus = m_sgKeyTaus;
3507  out->m_sgKeyJets = m_sgKeyJets;
3508  out->m_sgKeyLargeRJets = m_sgKeyLargeRJets;
3509  out->m_sgKeyTrackJets = m_sgKeyTrackJets;
3510  out->m_sgKeyTracks = m_sgKeyTracks;
3511  out->m_sgKeyMissingEt = m_sgKeyMissingEt;
3512  out->m_sgKeyMissingEtLoose = m_sgKeyMissingEtLoose;
3513 
3514  out->m_electronID = m_electronID;
3515  out->m_electronIDLoose = m_electronIDLoose;
3516  out->m_electronIsolation = m_electronIsolation;
3517  out->m_electronIsolationLoose = m_electronIsolationLoose;
3518  out->m_useElectronChargeIDSelection = m_useElectronChargeIDSelection;
3519  out->m_useEgammaLeakageCorrection = m_useEgammaLeakageCorrection;
3520  out->m_enablePromptLeptonImprovedVetoStudies = m_enablePromptLeptonImprovedVetoStudies;
3521 
3522  out->m_fwdElectronID = m_fwdElectronID;
3523 
3524  out->m_muonQuality = m_muonQuality;
3525  out->m_muonQualityLoose = m_muonQualityLoose;
3526  out->m_muonIsolation = m_muonIsolation;
3527  out->m_muonIsolationLoose = m_muonIsolationLoose;
3528 
3529  out->m_softmuonQuality = m_softmuonQuality;
3530 
3531  out->m_trackQuality = m_trackQuality;
3532 
3533  typedef std::unordered_map<std::size_t, std::string>::const_iterator Itr;
3534 
3535  for (const auto& btagWP : m_btagWP_caloJet)
3536  out->m_chosen_btaggingWP_caloJet.emplace_back(btagWP);
3537  for (const auto& btagWP : m_btagWP_trkJet)
3538  out->m_chosen_btaggingWP_trkJet.emplace_back(btagWP);
3539 
3540  for (Itr i = m_systSgKeyMapPhotons->begin(); i != m_systSgKeyMapPhotons->end(); ++i)
3541  out->m_systSgKeyMapPhotons.insert(std::make_pair((*i).first, (*i).second));
3542 
3543  for (Itr i = m_systSgKeyMapElectrons->begin(); i != m_systSgKeyMapElectrons->end(); ++i)
3544  out->m_systSgKeyMapElectrons.insert(std::make_pair((*i).first, (*i).second));
3545 
3546  for (const auto& i : *(m_systSgKeyMapFwdElectrons))
3547  out->m_systSgKeyMapFwdElectrons.insert(std::make_pair(i.first, i.second));
3548 
3549  for (Itr i = m_systSgKeyMapMuons->begin(); i != m_systSgKeyMapMuons->end(); ++i)
3550  out->m_systSgKeyMapMuons.insert(std::make_pair((*i).first, (*i).second));
3551 
3552  for (Itr i = m_systSgKeyMapSoftMuons->begin(); i != m_systSgKeyMapSoftMuons->end(); ++i)
3553  out->m_systSgKeyMapSoftMuons.insert(std::make_pair((*i).first, (*i).second));
3554 
3555  for (Itr i = m_systSgKeyMapTaus->begin(); i != m_systSgKeyMapTaus->end(); ++i)
3556  out->m_systSgKeyMapTaus.insert(std::make_pair((*i).first, (*i).second));
3557 
3558  for (Itr i = m_systSgKeyMapJets->begin(); i != m_systSgKeyMapJets->end(); ++i)
3559  out->m_systSgKeyMapJets.insert(std::make_pair((*i).first, (*i).second));
3560 
3561  for (Itr i = m_systSgKeyMapJets_electronInJetSubtraction->begin();
3562  i != m_systSgKeyMapJets_electronInJetSubtraction->end(); ++i)
3563  out->m_systSgKeyMapJets_electronInJetSubtraction.insert(std::make_pair((*i).first, (*i).second));
3564 
3565  for (Itr i = m_systSgKeyMapJetsLoose_electronInJetSubtraction->begin();
3566  i != m_systSgKeyMapJetsLoose_electronInJetSubtraction->end(); ++i)
3567  out->m_systSgKeyMapJetsLoose_electronInJetSubtraction.insert(std::make_pair((*i).first, (*i).second));
3568 
3569  for (Itr i = m_systSgKeyMapLargeRJets->begin(); i != m_systSgKeyMapLargeRJets->end(); ++i)
3570  out->m_systSgKeyMapLargeRJets.insert(std::make_pair((*i).first, (*i).second));
3571 
3572  for (Itr i = m_systSgKeyMapTrackJets->begin(); i != m_systSgKeyMapTrackJets->end(); ++i)
3573  out->m_systSgKeyMapTrackJets.insert(std::make_pair((*i).first, (*i).second));
3574 
3575  for (Itr i = m_systSgKeyMapTracks->begin(); i != m_systSgKeyMapTracks->end(); ++i)
3576  out->m_systSgKeyMapTracks.insert(std::make_pair((*i).first, (*i).second));
3577 
3578  for (Itr i = m_systSgKeyMapMissingET->begin(); i != m_systSgKeyMapMissingET->end(); ++i)
3579  out->m_systSgKeyMapMissingET.insert(std::make_pair((*i).first, (*i).second));
3580 
3581  for (Itr i = m_systSgKeyMapMissingETLoose->begin(); i != m_systSgKeyMapMissingETLoose->end(); ++i)
3582  out->m_systSgKeyMapMissingETLoose.insert(std::make_pair((*i).first, (*i).second));
3583 
3584  for (Itr i = m_systSgKeyMapKLFitter->begin(); i != m_systSgKeyMapKLFitter->end(); ++i)
3585  out->m_systSgKeyMapKLFitter.insert(std::make_pair((*i).first, (*i).second));
3586 
3587  for (Itr i = m_systSgKeyMapKLFitterLoose->begin(); i != m_systSgKeyMapKLFitterLoose->end(); ++i)
3588  out->m_systSgKeyMapKLFitterLoose.insert(std::make_pair((*i).first, (*i).second));
3589 
3590  for (Itr i = m_systSgKeyMapPseudoTop->begin(); i != m_systSgKeyMapPseudoTop->end(); ++i)
3591  out->m_systSgKeyMapPseudoTop.insert(std::make_pair((*i).first, (*i).second));
3592 
3593  for (Itr i = m_systSgKeyMapPseudoTopLoose->begin(); i != m_systSgKeyMapPseudoTopLoose->end(); ++i)
3594  out->m_systSgKeyMapPseudoTopLoose.insert(std::make_pair((*i).first, (*i).second));
3595 
3596  for (Itr i = m_systDecoKeyMapJetGhostTrack->begin(); i != m_systDecoKeyMapJetGhostTrack->end(); ++i)
3597  out->m_systDecoKeyMapJetGhostTrack.insert(std::make_pair((*i).first, (*i).second));
3598 
3599  for (Itr i = m_systPersistantAllTTreeNames->begin(); i != m_systPersistantAllTTreeNames->end(); ++i)
3600  out->m_systPersistantAllTTreeNames.insert(std::make_pair((*i).first, (*i).second));
3601 
3602  for (std::list<std::size_t>::const_iterator i = m_list_systHashAll->begin(); i != m_list_systHashAll->end(); ++i)
3603  out->m_list_systHashAll.push_back(*i);
3604 
3605  for (std::list<std::size_t>::const_iterator i = m_list_systHash_electronInJetSubtraction->begin();
3606  i != m_list_systHash_electronInJetSubtraction->end(); ++i)
3607  out->m_list_systHash_electronInJetSubtraction.push_back(*i);
3608 
3609  for (std::vector<std::string>::const_iterator i = m_allSelectionNames->begin(); i != m_allSelectionNames->end();
3610  ++i)
3611  out->m_allSelectionNames.push_back(*i);
3612 
3613  for (auto i : *m_allTriggers_Tight) {
3614  out->m_allTriggers_Tight.insert(i);
3615  }
3616  for (auto i : *m_electronTriggers_Tight) {
3617  out->m_electronTriggers_Tight.insert(i);
3618  }
3619  for (auto i : *m_muonTriggers_Tight) {
3620  out->m_muonTriggers_Tight.insert(i);
3621  }
3622  for (auto i : *m_tauTriggers_Tight) {
3623  out->m_tauTriggers_Tight.insert(i);
3624  }
3625  for (auto i : *m_photonTriggers_Tight) {
3626  out->m_photonTriggers_Tight.insert(i);
3627  }
3628 
3629  for (auto i : *m_allTriggers_Loose) {
3630  out->m_allTriggers_Loose.insert(i);
3631  }
3632  for (auto i : *m_electronTriggers_Loose) {
3633  out->m_electronTriggers_Loose.insert(i);
3634  }
3635  for (auto i : *m_muonTriggers_Loose) {
3636  out->m_muonTriggers_Loose.insert(i);
3637  }
3638  for (auto i : *m_tauTriggers_Loose) {
3639  out->m_tauTriggers_Loose.insert(i);
3640  }
3641  for (auto i : *m_photonTriggers_Loose) {
3642  out->m_photonTriggers_Loose.insert(i);
3643  }
3644 
3645  return out;
3646  }
3647 
3648  TopConfig::TopConfig(const top::TopPersistentSettings* settings) :
3649  // delegate to the default ctor - this is a nice C++11 feature, John likes this a lot
3650  TopConfig() {
3651  m_makeAllCPTools = false;
3652  m_isMC = settings->m_isMC;
3653  m_isAFII = settings->m_isAFII;
3654  m_isDataOverlay = settings->m_isDataOverlay;
3655  m_applyElectronInJetSubtraction = settings->m_applyElectronInJetSubtraction;
3656  m_doOverlapRemovalOnLooseLeptonDef = settings->m_doOverlapRemovalOnLooseLeptonDef;
3657  m_doKLFitter = settings->m_doKLFitter;
3658  m_doPseudoTop = settings->m_doPseudoTop;
3659 
3660  m_sgKeyTopSystematicEvents = settings->m_sgKeyTopSystematicEvents;
3661  m_sgKeyTopSystematicEventsLoose = settings->m_sgKeyTopSystematicEventsLoose;
3662 
3663  m_sgKeyEventInfo = settings->m_sgKeyEventInfo;
3664  m_sgKeyPrimaryVertices = settings->m_sgKeyPrimaryVertices;
3665  sgKeyPhotons(settings->m_sgKeyPhotons);
3666  sgKeyElectrons(settings->m_sgKeyElectrons);
3667  sgKeyFwdElectrons(settings->m_sgKeyFwdElectrons);
3668  sgKeyMuons(settings->m_sgKeyMuons);
3669  sgKeySoftMuons(settings->m_sgKeySoftMuons);
3670  sgKeyTaus(settings->m_sgKeyTaus);
3671  sgKeyJets(settings->m_sgKeyJets);
3672  sgKeyLargeRJets(settings->m_sgKeyLargeRJets);
3673  sgKeyTrackJets(settings->m_sgKeyTrackJets);
3674  sgKeyTracks(settings->m_sgKeyTracks);
3675  m_sgKeyMissingEt = settings->m_sgKeyMissingEt;
3676  m_sgKeyMissingEtLoose = settings->m_sgKeyMissingEtLoose;
3677 
3678  m_electronID = settings->m_electronID;
3679  m_electronIDLoose = settings->m_electronIDLoose;
3680  m_electronIsolation = settings->m_electronIsolation;
3681  m_electronIsolationLoose = settings->m_electronIsolationLoose;
3682  m_useElectronChargeIDSelection = settings->m_useElectronChargeIDSelection;
3683  m_useEgammaLeakageCorrection = settings->m_useEgammaLeakageCorrection;
3684  m_enablePromptLeptonImprovedVetoStudies = settings->m_enablePromptLeptonImprovedVetoStudies;
3685 
3686  m_fwdElectronID = settings->m_fwdElectronID;
3687 
3688  m_muonQuality = settings->m_muonQuality;
3689  m_muonQualityLoose = settings->m_muonQualityLoose;
3690  m_muonIsolation = settings->m_muonIsolation;
3691  m_muonIsolationLoose = settings->m_muonIsolationLoose;
3692 
3693  m_softmuonQuality = settings->m_softmuonQuality;
3694 
3695  typedef std::map<std::size_t, std::string>::const_iterator Itr;
3696 
3697  for (Itr i = settings->m_systSgKeyMapPhotons.begin(); i != settings->m_systSgKeyMapPhotons.end(); ++i)
3698  m_systSgKeyMapPhotons->insert(std::make_pair((*i).first, (*i).second));
3699 
3700  for (Itr i = settings->m_systSgKeyMapElectrons.begin(); i != settings->m_systSgKeyMapElectrons.end(); ++i)
3701  m_systSgKeyMapElectrons->insert(std::make_pair((*i).first, (*i).second));
3702 
3703  for (Itr i = settings->m_systSgKeyMapFwdElectrons.begin(); i != settings->m_systSgKeyMapFwdElectrons.end(); ++i)
3704  m_systSgKeyMapFwdElectrons->insert(std::make_pair((*i).first, (*i).second));
3705 
3706  for (Itr i = settings->m_systSgKeyMapMuons.begin(); i != settings->m_systSgKeyMapMuons.end(); ++i)
3707  m_systSgKeyMapMuons->insert(std::make_pair((*i).first, (*i).second));
3708 
3709  for (Itr i = settings->m_systSgKeyMapSoftMuons.begin(); i != settings->m_systSgKeyMapSoftMuons.end(); ++i)
3710  m_systSgKeyMapSoftMuons->insert(std::make_pair((*i).first, (*i).second));
3711 
3712  for (Itr i = settings->m_systSgKeyMapTaus.begin(); i != settings->m_systSgKeyMapTaus.end(); ++i)
3713  m_systSgKeyMapTaus->insert(std::make_pair((*i).first, (*i).second));
3714 
3715  for (Itr i = settings->m_systSgKeyMapJets.begin(); i != settings->m_systSgKeyMapJets.end(); ++i)
3716  m_systSgKeyMapJets->insert(std::make_pair((*i).first, (*i).second));
3717 
3718  for (Itr i = settings->m_systSgKeyMapJets_electronInJetSubtraction.begin();
3719  i != settings->m_systSgKeyMapJets_electronInJetSubtraction.end(); ++i)
3720  m_systSgKeyMapJets_electronInJetSubtraction->insert(std::make_pair((*i).first, (*i).second));
3721 
3722  for (Itr i = settings->m_systSgKeyMapJetsLoose_electronInJetSubtraction.begin();
3723  i != settings->m_systSgKeyMapJetsLoose_electronInJetSubtraction.end(); ++i)
3724  m_systSgKeyMapJetsLoose_electronInJetSubtraction->insert(std::make_pair((*i).first, (*i).second));
3725 
3726  for (Itr i = settings->m_systSgKeyMapLargeRJets.begin(); i != settings->m_systSgKeyMapLargeRJets.end(); ++i)
3727  m_systSgKeyMapLargeRJets->insert(std::make_pair((*i).first, (*i).second));
3728 
3729  for (Itr i = settings->m_systSgKeyMapTrackJets.begin(); i != settings->m_systSgKeyMapTrackJets.end(); ++i)
3730  m_systSgKeyMapTrackJets->insert(std::make_pair((*i).first, (*i).second));
3731 
3732  for (Itr i = settings->m_systSgKeyMapTracks.begin(); i != settings->m_systSgKeyMapTracks.end(); ++i)
3733  m_systSgKeyMapTracks->insert(std::make_pair((*i).first, (*i).second));
3734 
3735  for (Itr i = settings->m_systSgKeyMapMissingET.begin(); i != settings->m_systSgKeyMapMissingET.end(); ++i)
3736  m_systSgKeyMapMissingET->insert(std::make_pair((*i).first, (*i).second));
3737 
3738  for (Itr i = settings->m_systSgKeyMapMissingETLoose.begin(); i != settings->m_systSgKeyMapMissingETLoose.end(); ++i)
3739  m_systSgKeyMapMissingETLoose->insert(std::make_pair((*i).first, (*i).second));
3740 
3741  for (Itr i = settings->m_systSgKeyMapKLFitter.begin(); i != settings->m_systSgKeyMapKLFitter.end(); ++i)
3742  m_systSgKeyMapKLFitter->insert(std::make_pair((*i).first, (*i).second));
3743 
3744  for (Itr i = settings->m_systSgKeyMapKLFitterLoose.begin(); i != settings->m_systSgKeyMapKLFitterLoose.end(); ++i)
3745  m_systSgKeyMapKLFitterLoose->insert(std::make_pair((*i).first, (*i).second));
3746 
3747  for (Itr i = settings->m_systSgKeyMapPseudoTop.begin(); i != settings->m_systSgKeyMapPseudoTop.end(); ++i)
3748  m_systSgKeyMapPseudoTop->insert(std::make_pair((*i).first, (*i).second));
3749 
3750  for (Itr i = settings->m_systSgKeyMapPseudoTopLoose.begin(); i != settings->m_systSgKeyMapPseudoTopLoose.end(); ++i)
3751  m_systSgKeyMapPseudoTopLoose->insert(std::make_pair((*i).first, (*i).second));
3752 
3753  for (Itr i = settings->m_systDecoKeyMapJetGhostTrack.begin(); i != settings->m_systDecoKeyMapJetGhostTrack.end();
3754  ++i)
3755  m_systDecoKeyMapJetGhostTrack->insert(std::make_pair((*i).first, (*i).second));
3756 
3757  for (Itr i = settings->m_systPersistantAllTTreeNames.begin(); i != settings->m_systPersistantAllTTreeNames.end();
3758  ++i) {
3759  m_systPersistantAllTTreeNames->insert(std::make_pair((*i).first, (*i).second));
3760  m_systAllTTreeNames->insert(std::make_pair((*i).first, (*i).second));
3761  }
3762 
3763  for (std::vector<std::size_t>::const_iterator i = settings->m_list_systHashAll.begin();
3764  i != settings->m_list_systHashAll.end(); ++i)
3765  m_list_systHashAll->push_back(*i);
3766 
3767  for (std::vector<std::size_t>::const_iterator i = settings->m_list_systHash_electronInJetSubtraction.begin();
3768  i != settings->m_list_systHash_electronInJetSubtraction.end(); ++i)
3769  m_list_systHash_electronInJetSubtraction->push_back(*i);
3770 
3771  for (std::vector<std::string>::const_iterator i = settings->m_allSelectionNames.begin();
3772  i != settings->m_allSelectionNames.end(); ++i)
3773  m_allSelectionNames->push_back(*i);
3774 
3775  m_allTriggers_Tight = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
3776  m_electronTriggers_Tight = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
3777  m_muonTriggers_Tight = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
3778  m_tauTriggers_Tight = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
3779  m_photonTriggers_Tight = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
3780 
3781  m_allTriggers_Loose = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
3782  m_electronTriggers_Loose = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
3783  m_muonTriggers_Loose = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
3784  m_tauTriggers_Loose = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
3785  m_photonTriggers_Loose = std::make_shared<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > >();
3786 
3787  for (auto i : settings->m_allTriggers_Tight) {
3788  m_allTriggers_Tight->insert(i);
3789  }
3790  for (auto i : settings->m_electronTriggers_Tight) {
3791  m_electronTriggers_Tight->insert(i);
3792  }
3793  for (auto i : settings->m_muonTriggers_Tight) {
3794  m_muonTriggers_Tight->insert(i);
3795  }
3796  for (auto i : settings->m_tauTriggers_Tight) {
3797  m_tauTriggers_Tight->insert(i);
3798  }
3799  for (auto i : settings->m_photonTriggers_Tight) {
3800  m_photonTriggers_Tight->insert(i);
3801  }
3802 
3803  for (auto i : settings->m_allTriggers_Loose) {
3804  m_allTriggers_Loose->insert(i);
3805  }
3806  for (auto i : settings->m_electronTriggers_Loose) {
3807  m_electronTriggers_Loose->insert(i);
3808  }
3809  for (auto i : settings->m_muonTriggers_Loose) {
3810  m_muonTriggers_Loose->insert(i);
3811  }
3812  for (auto i : settings->m_tauTriggers_Loose) {
3813  m_tauTriggers_Loose->insert(i);
3814  }
3815  for (auto i : settings->m_photonTriggers_Loose) {
3816  m_photonTriggers_Loose->insert(i);
3817  }
3818 
3819  fixConfiguration();
3820  }
3821 
3822  // Place into a private function to allow use without replication of code
3823  void TopConfig::ReadIsAFII(top::ConfigurationSettings* const& settings) {
3824  if (settings->value("IsAFII") == "True") this->setIsAFII(true);
3825  else if (settings->value("IsAFII") == "False") this->setIsAFII(false);
3826  else if (settings->value("IsAFII") != " ") throw std::runtime_error(
3827  "TopConfig: option IsAFII must be either True or False");
3828  else if (this->isMC()) throw std::runtime_error("TopConfig: option IsAFII not set");
3829  }
3830 
3831  // Set up isDataOverlay
3832  void TopConfig::ReadIsDataOverlay(top::ConfigurationSettings* const& settings) {
3833  if (settings->value("IsDataOverlay") == "True") this->setIsDataOverlay(true);
3834  else if (settings->value("IsDataOverlay") == "False") this->setIsDataOverlay(false);
3835  else if (settings->value("IsDataOverlay") != " ") throw std::runtime_error(
3836  "TopConfig: option IsDataOverlay must be either True or False");
3837  }
3838 
3839  // Function to set the release series (this method may change so refactor)
3840  void TopConfig::setReleaseSeries() {
3841  // Method taken from TopCPTools
3842  std::string release_series = "";
3843  const char* rel_temp = std::getenv("ROOTCORE_RELEASE_SERIES");
3844  if (rel_temp) {
3845  release_series = std::string(rel_temp);
3846  } else {
3847  release_series = "";
3848  }
3849 
3850  if (release_series == "23") {
3851  m_release_series = 23; // 2.3
3852  } else if (release_series == "24") {
3853  m_release_series = 24; // 2.4 R20.7
3854  } else if (release_series == "25") {
3855  m_release_series = 25; // 2.6 R21
3856  } else {
3857  // Default to R21 because this build has moved away from ROOTCORE
3858  m_release_series = 25;
3859  }
3860  return;
3861  }
3862 
3863  // Function to return the year of data taking based on either run number (data) or random run number (MC)
3864  std::string TopConfig::getYear(unsigned int runnumber, const bool isMC) {
3865 
3866  if (isMC) {
3867  // mc16a - returning only 2015 but is really a mix of 15 + 16
3868  if (runnumber == 284500) return "2015";
3869 
3870  // mc16d
3871  if (runnumber == 300000) return "2017";
3872 
3873  // mc16e
3874  if (runnumber == 310000) return "2018";
3875 
3876  // Run 3 mc21a
3877  if (runnumber == 410000) return "2022";
3878 
3879  return "UNKNOWN";
3880  }
3881 
3882  // Set of runNumbers for data
3883  // 2015 : 266904 - 284484
3884  if (runnumber >= 266904 && runnumber <= 284484) return "2015";
3885 
3886  // 2016 : 296939 - 311481
3887  if (runnumber >= 296939 && runnumber <= 311481) return "2016";
3888 
3889  // 2017 : 324320 - 348835
3890  if (runnumber >= 324320 && runnumber <= 348835) return "2017";
3891 
3892  // 2018 : > 348835
3893  if (runnumber > 348835 && runnumber < 400000) return "2018";
3894 
3895  // Run 3: 2022
3896  if (runnumber > 410000 && runnumber < 999999) return "2022";
3897 
3898  return "UNKNOWN";
3899  }
3900 
3901  void TopConfig::SetTriggersToYear(const bool isMC) {
3902  if (m_year == "UNKNOWN") return;
3903 
3904  std::string year2("");
3905  if (isMC && m_year == "2015") year2 = "2016";
3906  if (isMC && m_year == "2016") year2 = "2015";
3907 
3908  auto removeYears = [](std::unordered_map<std::string,std::vector<std::pair<std::string, int> > >& trig, const std::string& year1, const std::string& year2) {
3909  auto itr = trig.begin();
3910  while (itr != trig.end()) {
3911  if ((*itr).first != year1 && (*itr).first != year2) {
3912  itr = trig.erase(itr);
3913  } else {
3914  itr++;
3915  }
3916  }
3917  };
3918 
3919  removeYears(m_trigGlobalConfiguration.trigger, m_year, year2);
3920  removeYears(m_trigGlobalConfiguration.trigger_loose, m_year, year2);
3921  }
3922 
3923  void TopConfig::setGlobalTriggerConfiguration(std::vector<std::string> electron_trigger_systematics,
3924  std::vector<std::string> muon_trigger_systematics,
3925  std::vector<std::string> photon_trigger_systematics,
3926  std::vector<std::string> electron_tool_names,
3927  std::vector<std::string> muon_tool_names,
3928  std::vector<std::string> photon_tool_names
3929  ) {
3930  m_trigGlobalConfiguration.electron_trigger_systematics = electron_trigger_systematics;
3931  m_trigGlobalConfiguration.muon_trigger_systematics = muon_trigger_systematics;
3932  m_trigGlobalConfiguration.photon_trigger_systematics = photon_trigger_systematics;
3933  m_trigGlobalConfiguration.electron_trigger_tool_names = electron_tool_names;
3934  m_trigGlobalConfiguration.muon_trigger_tool_names = muon_tool_names;
3935  m_trigGlobalConfiguration.photon_trigger_tool_names = photon_tool_names;
3936  m_trigGlobalConfiguration.isConfigured = true;
3937  return;
3938  }
3939 
3940 
3941 
3942  std::ostream& operator << (std::ostream& os, const TopConfig& config) {
3943  typedef std::shared_ptr<std::unordered_map<std::size_t, CP::SystematicSet> > map_t;
3944  typedef std::unordered_map<std::size_t, CP::SystematicSet>::const_iterator Itr;
3945 
3946  if (config.useJetGhostTrack()) {
3947  for (const auto& item : config.systematicsJetGhostTrack()) {
3948  os << " Jet Ghost Track Systematic\t\t :: " << item << " \n";
3949  }
3950  }
3951 
3952  os << "\n";
3953  os << "top::TopConfig has identified the following analysis release series : " << config.getReleaseSeries() << "\n";
3954  os << "top::TopConfig will evaluate the following systematics (saved as TTrees in your ntuple) \n";
3955  os << "A blank systematic means \"Nominal\" in xAOD. All Nominal calibrations go into the Nominal TTree. \n";
3956  os << "\n";
3957  if (config.usePhotons()) {
3958  map_t syst = config.systMapPhotons();
3959  for (Itr i = syst->begin(); i != syst->end(); ++i) {
3960  os << " Photon systematic\t :: " << (*i).second.name() << " \n";
3961  }
3962  }
3963 
3964  if (config.useElectrons()) {
3965  map_t syst = config.systMapElectrons();
3966  for (Itr i = syst->begin(); i != syst->end(); ++i) {
3967  os << " Electron systematic\t :: " << (*i).second.name() << " \n";
3968  }
3969  }
3970 
3971  if (config.useFwdElectrons()) {
3972  map_t syst = config.systMapFwdElectrons();
3973  for (Itr i = syst->begin(); i != syst->end(); ++i) {
3974  os << " Fwd Electron systematic\t :: " << (*i).second.name() << " \n";
3975  }
3976  }
3977 
3978  if (config.useMuons()) {
3979  map_t syst = config.systMapMuons();
3980  for (Itr i = syst->begin(); i != syst->end(); ++i) {
3981  os << " Muon systematic\t :: " << (*i).second.name() << " \n";
3982  }
3983  }
3984 
3985  if (config.useSoftMuons()) {
3986  map_t syst = config.systMapSoftMuons();
3987  for (Itr i = syst->begin(); i != syst->end(); ++i) {
3988  os << " Soft Muon systematic\t :: " << (*i).second.name() << " \n";
3989  }
3990  }
3991 
3992  if (config.useTaus()) {
3993  map_t syst = config.systMapTaus();
3994  for (Itr i = syst->begin(); i != syst->end(); ++i) {
3995  os << " Tau systematic\t :: " << (*i).second.name() << " \n";
3996  }
3997  }
3998 
3999  if (config.useJets()) {
4000  map_t syst = config.systMapJets();
4001  for (Itr i = syst->begin(); i != syst->end(); ++i) {
4002  os << " Jet systematic\t\t :: " << (*i).second.name() << " \n";
4003  }
4004  }
4005 
4006  if (config.useLargeRJets()) {
4007  map_t syst = config.systMapLargeRJets();
4008  for (Itr i = syst->begin(); i != syst->end(); ++i) {
4009  os << " Large-R Jet systematic\t\t :: " << (*i).second.name() << " \n";
4010  }
4011  }
4012 
4013  os << "\n";
4014  return os;
4015  }
4016 }
top::TopConfig::saveFailForwardJVTJets
virtual bool saveFailForwardJVTJets() const
Definition: TopConfig.h:1582
top::TopConfig::m_useVarRCJets
bool m_useVarRCJets
Definition: TopConfig.h:2206
top::TopConfig::m_systAllSgKeyMapTrackJetsTDS
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapTrackJetsTDS
Definition: TopConfig.h:2928
top::TopConfig::m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDSAux
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDSAux
Definition: TopConfig.h:2938
top::TopConfig::m_jetPtcut
float m_jetPtcut
Definition: TopConfig.h:2497
top::TopConfig::m_systDecoKeyMapJetGhostTrack
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systDecoKeyMapJetGhostTrack
Definition: TopConfig.h:2957
top::TopConfig::readFloatOption
float readFloatOption(top::ConfigurationSettings *const &settings, std::string in) const
Definition: TopConfig.cxx:1905
top::TopPersistentSettings::m_list_systHash_electronInJetSubtraction
std::vector< std::size_t > m_list_systHash_electronInJetSubtraction
Definition: TopPersistentSettings.h:106
top::TopConfig::sgKeyPseudoTopLoose
const std::string & sgKeyPseudoTopLoose(const std::size_t hash) const
Definition: TopConfig.cxx:3324
top::TopConfig::m_systAllSgKeyMapJets
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapJets
Definition: TopConfig.h:2901
top::TopConfig::photonTriggers_Tight
virtual void photonTriggers_Tight(std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)
Definition: TopConfig.h:481
top::TopConfig::RCJetEtacut
virtual float RCJetEtacut() const
Definition: TopConfig.h:1381
top::TopConfig::m_list_systHash_electronInJetSubtraction
std::shared_ptr< std::list< std::size_t > > m_list_systHash_electronInJetSubtraction
Definition: TopConfig.h:2866
python.AtlRunQueryAMI.period
period
Definition: AtlRunQueryAMI.py:225
top::TopConfig::sgKeyMuonsTDS
const std::string & sgKeyMuonsTDS(const std::size_t hash) const
Definition: TopConfig.cxx:3050
top::TopConfig::addLHAPDFResult
void addLHAPDFResult(const std::string &pdf_name, std::vector< float > sum_of_weights)
Definition: TopConfig.cxx:2248
top::TopConfig::m_systAllSgKeyMapTausTDSAux
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapTausTDSAux
Definition: TopConfig.h:2923
top::TopConfig::m_largeRJetSubstructureVariables
std::map< std::string, std::string > m_largeRJetSubstructureVariables
Definition: TopConfig.h:2535
top::TopConfig::m_systAllSgKeyMapSoftMuonsTDSAux
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapSoftMuonsTDSAux
Definition: TopConfig.h:2921
top::TopConfig::trigger
triggermap_t trigger
Definition: TopConfig.h:2782
top::TopConfig::decoKeyJetGhostTrack
virtual const std::string & decoKeyJetGhostTrack() const
Definition: TopConfig.h:605
top::TopConfig::fwdElectronBCIDCleaningMaxRun
virtual int fwdElectronBCIDCleaningMaxRun() const
Definition: TopConfig.h:942
top::TopConfig::m_systAllSgKeyMapJetsTDSAux
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapJetsTDSAux
Definition: TopConfig.h:2925
top::TopConfig::m_useSoftMuons
bool m_useSoftMuons
Definition: TopConfig.h:2199
top::ConfigurationSettings::value
const std::string & value(const std::string &key) const
The user wants to know the value for the specified key.
Definition: ConfigurationSettings.cxx:970
top::TopConfig::setForceRandomRunNumber
void setForceRandomRunNumber(const unsigned int randomRunNumber)
Definition: TopConfig.h:1988
top::TopConfig::m_systAllTTreeLooseIndex
std::shared_ptr< std::unordered_map< std::size_t, unsigned int > > m_systAllTTreeLooseIndex
Definition: TopConfig.h:2964
top::TopConfig::m_useTrackJets
bool m_useTrackJets
Definition: TopConfig.h:2204
top::TopConfig::m_useMuons
bool m_useMuons
Definition: TopConfig.h:2198
top::TopPersistentSettings
Definition: TopPersistentSettings.h:29
top::TopConfig::electronPtcut
virtual float electronPtcut() const
Definition: TopConfig.h:872
top::TopConfig::truth_jet_EtaCut
virtual float truth_jet_EtaCut() const
Definition: TopConfig.h:1857
top::TopConfig::m_systAllSgKeyMapFwdElectronsTDS
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapFwdElectronsTDS
Definition: TopConfig.h:2916
top::TopConfig::m_useAntiMuons
bool m_useAntiMuons
Definition: TopConfig.h:2200
top::TopConfig::m_systHashLargeRJets
std::shared_ptr< std::unordered_set< std::size_t > > m_systHashLargeRJets
Definition: TopConfig.h:2857
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
top::TopConfig::muonUseLowPt
virtual bool muonUseLowPt() const
Definition: TopConfig.h:1108
top::TopConfig::setFakesMMConfigIFF
void setFakesMMConfigIFF(const std::string &configIFF)
Definition: TopConfig.h:242
top::TopConfig::m_muonTriggers_Tight
std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > m_muonTriggers_Tight
Definition: TopConfig.h:2808
top::TopConfig::m_configFixed
bool m_configFixed
Definition: TopConfig.h:2182
algorithm
std::string algorithm
Definition: hcg.cxx:82
top::TopConfig::m_list_systHashAll
std::shared_ptr< std::list< std::size_t > > m_list_systHashAll
Definition: TopConfig.h:2863
top::TopConfig::m_pileup_reweighting
struct top::TopConfig::@217 m_pileup_reweighting
SGout2dot.alg
alg
Definition: SGout2dot.py:243
top::TopConfig::sgKeyFwdElectronsTDSAux
const std::string & sgKeyFwdElectronsTDSAux(const std::size_t hash) const
Definition: TopConfig.cxx:3025
get_generator_info.result
result
Definition: get_generator_info.py:21
top
TopConfig A simple configuration that is NOT a singleton.
Definition: AnalysisTrackingHelper.cxx:58
top::TopConfig::m_sgKeyEventInfo
std::string m_sgKeyEventInfo
Definition: TopConfig.h:2360
top::TopConfig::fwdElectronMaxEtacut
virtual float fwdElectronMaxEtacut() const
Definition: TopConfig.h:940
top::TopConfig::trackJetEtacut
virtual float trackJetEtacut() const
Definition: TopConfig.h:1351
max
#define max(a, b)
Definition: cfImp.cxx:41
top::TopConfig::sgKeyTausTDS
const std::string & sgKeyTausTDS(const std::size_t hash) const
Definition: TopConfig.cxx:3098
top::TopConfig::m_systAllSgKeyMapTracksTDS
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapTracksTDS
Definition: TopConfig.h:2930
top::TopConfig::truth_jet_largeR_PtCut
virtual float truth_jet_largeR_PtCut() const
Definition: TopConfig.h:1872
top::TopConfig::photonEtacut
virtual float photonEtacut() const
Definition: TopConfig.h:1730
top::TopConfig::m_sgKeyTruthPhotons
std::string m_sgKeyTruthPhotons
Definition: TopConfig.h:2377
top::TopConfig::m_useElectronChargeIDSelection
bool m_useElectronChargeIDSelection
Definition: TopConfig.h:2433
top::TopConfig::outputEvents
virtual const std::string & outputEvents() const
Definition: TopConfig.h:2017
top::TopConfig::m_allTriggers_Loose
std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > m_allTriggers_Loose
Definition: TopConfig.h:2811
top::TopConfig::jetCalibSequence
virtual const std::string & jetCalibSequence() const
Definition: TopConfig.h:1533
top::TopConfig::electronEfficiencySystematicModelEtBinning
virtual const std::string & electronEfficiencySystematicModelEtBinning()
Definition: TopConfig.h:844
top::TopPersistentSettings::m_electronTriggers_Tight
std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > m_electronTriggers_Tight
Definition: TopPersistentSettings.h:111
top::TopConfig::largeRJetUncertainties_NPModel
virtual const std::string & largeRJetUncertainties_NPModel() const
Definition: TopConfig.h:1333
top::TopConfig::setIsDataOverlay
void setIsDataOverlay(const bool value)
Definition: TopConfig.h:127
top::TopConfig::setNumberOfBootstrapReplicas
void setNumberOfBootstrapReplicas(const int value)
Definition: TopConfig.h:2129
top::TopConfig::m_systSgKeyMapTrackJets
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapTrackJets
Definition: TopConfig.h:2890
top::TopConfig::sgKeyTruthTaus
const std::string & sgKeyTruthTaus() const
Definition: TopConfig.h:595
top::TopConfig::m_systAllSgKeyMapSoftMuons
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapSoftMuons
Definition: TopConfig.h:2899
top::TopConfig::m_demandPriVtx
bool m_demandPriVtx
Definition: TopConfig.h:2232
top::TopConfig::sgKeyTrackJetsTDS
const std::string & sgKeyTrackJetsTDS(const std::size_t hash) const
Definition: TopConfig.cxx:3244
top::TopConfig::VarRCJetRho
virtual const std::string & VarRCJetRho() const
Definition: TopConfig.h:1441
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
top::TopConfig::photonTriggers_Loose
virtual void photonTriggers_Loose(std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)
Definition: TopConfig.h:516
top::TopConfig::truth_tau_PtCut
virtual float truth_tau_PtCut() const
Definition: TopConfig.h:1887
top::TopConfig::m_muonTriggers_Loose
std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > m_muonTriggers_Loose
Definition: TopConfig.h:2813
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
top::TopPersistentSettings::m_systSgKeyMapJetsLoose_electronInJetSubtraction
std::map< std::size_t, std::string > m_systSgKeyMapJetsLoose_electronInJetSubtraction
Definition: TopPersistentSettings.h:91
top::TopConfig::jetStoreTruthLabels
virtual bool jetStoreTruthLabels() const
Definition: TopConfig.h:1549
top::TopConfig::m_grlFile
std::vector< std::string > m_grlFile
Definition: TopConfig.h:2189
top::TopConfig::m_outputFileNEventAutoFlush
int m_outputFileNEventAutoFlush
Definition: TopConfig.h:2838
top::TopConfig::m_muonIsolation
std::string m_muonIsolation
Definition: TopConfig.h:2466
top::TopConfig::systematicsElectrons
virtual void systematicsElectrons(const std::list< CP::SystematicSet > &syst)
Definition: TopConfig.cxx:2310
top::TopConfig::bTag_eigen_C_trkJet
std::unordered_map< std::string, unsigned int > bTag_eigen_C_trkJet
Definition: TopConfig.h:2725
top::TopConfig::m_electronIDLooseDecoration
std::string m_electronIDLooseDecoration
Definition: TopConfig.h:2432
top::TopConfig::m_systAllSgKeyMapElectrons_electronInJetSubtractionTDS
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapElectrons_electronInJetSubtractionTDS
Definition: TopConfig.h:2933
top::TopConfig::sgKeyTracksTDSAux
const std::string & sgKeyTracksTDSAux(const std::size_t hash) const
Definition: TopConfig.cxx:3276
top::TopConfig::m_sgKeyTruthJets
std::string m_sgKeyTruthJets
Definition: TopConfig.h:2381
top::TopConfig::m_systSgKeyMapMET
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapMET
Definition: TopConfig.h:2892
top::TopConfig::m_sgKeyTruthMET
std::string m_sgKeyTruthMET
Definition: TopConfig.h:2383
top::TopConfig::m_doTightEvents
bool m_doTightEvents
Definition: TopConfig.h:2297
top::TopConfig::largeRJetUncertainties_JMR_NPModel
virtual const std::string & largeRJetUncertainties_JMR_NPModel() const
Definition: TopConfig.h:1334
top::TopConfig::m_electronIsolationLoose
std::string m_electronIsolationLoose
Definition: TopConfig.h:2424
top::TopConfig::largeRJetPtcut
virtual float largeRJetPtcut() const
Definition: TopConfig.h:1329
top::TopConfig::setUseBadBatmanCleaning
void setUseBadBatmanCleaning(const bool value)
Definition: TopConfig.h:2133
WriteCellNoiseToCool.src
src
Definition: WriteCellNoiseToCool.py:513
top::TopConfig::addBTagAlgo
void addBTagAlgo(const std::string &algorithm, const std::string &selectionToolName, bool trackJets=false)
Definition: TopConfig.cxx:2207
top::TopPersistentSettings::m_sgKeyTracks
std::string m_sgKeyTracks
Definition: TopPersistentSettings.h:56
top::TopPersistentSettings::m_sgKeyEventInfo
std::string m_sgKeyEventInfo
Definition: TopPersistentSettings.h:45
top::TopConfig::m_electronIDSFFile_path
std::string m_electronIDSFFile_path
Definition: TopConfig.h:2438
calibdata.modified
bool modified
Definition: calibdata.py:673
top::TopConfig::sgKeyElectronsTDSAux
const std::string & sgKeyElectronsTDSAux(const std::size_t hash) const
Definition: TopConfig.cxx:2979
top::TopConfig::m_sgKeyFwdElectrons
std::string m_sgKeyFwdElectrons
Definition: TopConfig.h:2364
index
Definition: index.py:1
top::TopConfig::m_btagWP_calib_trkJet
std::vector< std::string > m_btagWP_calib_trkJet
Definition: TopConfig.h:2694
top::TopConfig::m_systAllSgKeyMapPhotonsTDS
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapPhotonsTDS
Definition: TopConfig.h:2912
top::TopConfig::electronTriggers_Tight
virtual void electronTriggers_Tight(std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)
Definition: TopConfig.h:460
IsoCloseByCorrectionTest.WP
WP
Definition: IsoCloseByCorrectionTest.py:56
top::TopConfig::m_systAllSgKeyMapTrackJetsTDSAux
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapTrackJetsTDSAux
Definition: TopConfig.h:2929
top::TopConfig::setConfigSettings
void setConfigSettings(top::ConfigurationSettings *const &settings)
Definition: TopConfig.cxx:740
top::TopConfig::VarRCJetPtcut
virtual float VarRCJetPtcut() const
Definition: TopConfig.h:1437
top::TopConfig::softmuonUseLowPt
virtual bool softmuonUseLowPt() const
Definition: TopConfig.h:1221
top::TopConfig::ghostTracksVertexAssociation
virtual const std::string & ghostTracksVertexAssociation() const
Definition: TopConfig.h:1280
top::TopConfig::electronEfficiencySystematicModelToySeed
virtual const int & electronEfficiencySystematicModelToySeed()
Definition: TopConfig.h:851
top::TopConfig::setMCGeneratorWeights
void setMCGeneratorWeights()
Definition: TopConfig.h:341
top::TopConfig::electronIDLoose
virtual const std::string & electronIDLoose() const
Definition: TopConfig.h:870
top::TopConfig::m_systSgKeyMapJetsLoose_electronInJetSubtraction
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapJetsLoose_electronInJetSubtraction
Definition: TopConfig.h:2888
top::TopConfig::muonQualityLoose
virtual const std::string & muonQualityLoose() const
Definition: TopConfig.h:1106
top::TopConfig::isSystAll
bool isSystAll(const std::string &syst) const
Definition: TopConfig.cxx:2267
top::TopConfig::sgKeySoftMuonsTDS
const std::string & sgKeySoftMuonsTDS(const std::size_t hash) const
Definition: TopConfig.cxx:3074
top::TopConfig::m_lhapdf_options
struct top::TopConfig::@216 m_lhapdf_options
top::TopPersistentSettings::m_electronIsolation
std::string m_electronIsolation
Definition: TopPersistentSettings.h:62
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:14
top::TopConfig::systematicsJets
virtual void systematicsJets(const std::list< CP::SystematicSet > &syst)
Definition: TopConfig.cxx:2378
top::TopConfig::m_muonQuality
std::string m_muonQuality
Definition: TopConfig.h:2457
top::TopConfig::truth_jet_PtCut
virtual float truth_jet_PtCut() const
Definition: TopConfig.h:1856
top::TopConfig::m_doOverlapRemovalOnLooseLeptonDef
bool m_doOverlapRemovalOnLooseLeptonDef
Definition: TopConfig.h:2277
top::TopConfig::m_KLFitterJetSelectionMode
std::string m_KLFitterJetSelectionMode
Definition: TopConfig.h:2348
top::TopConfig::m_systAllSgKeyMapElectrons_electronInJetSubtraction
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapElectrons_electronInJetSubtraction
Definition: TopConfig.h:2907
top::TopConfig::m_allSelectionNames
std::shared_ptr< std::vector< std::string > > m_allSelectionNames
Definition: TopConfig.h:2803
top::TopConfig::m_sgKeyLargeRJets
std::string m_sgKeyLargeRJets
Definition: TopConfig.h:2369
top::TopConfig::m_fwdElectronID
std::string m_fwdElectronID
Definition: TopConfig.h:2449
top::TopConfig::m_systHashAll
std::shared_ptr< std::unordered_set< std::size_t > > m_systHashAll
Definition: TopConfig.h:2862
top::TopConfig::softmuonDRJetcutUseRapidity
virtual bool softmuonDRJetcutUseRapidity() const
Definition: TopConfig.h:1223
top::TopConfig::bTag_eigen_B_trkJet
std::unordered_map< std::string, unsigned int > bTag_eigen_B_trkJet
Definition: TopConfig.h:2722
top::tokenize
void tokenize(const std::string &input, Container &output, const std::string &delimiters=" ", bool trim_empty=false)
Tokenize an input string using a set of delimiters.
Definition: Tokenize.h:24
skel.it
it
Definition: skel.GENtoEVGEN.py:423
top::TopConfig::tauMuOLRLoose
virtual bool tauMuOLRLoose()
Definition: TopConfig.h:1700
top::TopPersistentSettings::m_muonIsolationLoose
std::string m_muonIsolationLoose
Definition: TopPersistentSettings.h:74
top::TopConfig::m_applyTTVACut
bool m_applyTTVACut
Definition: TopConfig.h:2230
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
top::TopConfig::largeRJetMasscut
virtual float largeRJetMasscut() const
Definition: TopConfig.h:1330
CP::SystematicSet
Class to wrap a set of SystematicVariations.
Definition: SystematicSet.h:31
top::TopConfig::m_year
std::string m_year
Definition: TopConfig.h:2988
top::TopConfig::m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDS
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapJetsLoose_electronInJetSubtractionTDS
Definition: TopConfig.h:2937
top::TopPersistentSettings::m_sgKeyPhotons
std::string m_sgKeyPhotons
Definition: TopPersistentSettings.h:47
top::TopConfig::systematicsPhotons
virtual void systematicsPhotons(const std::list< CP::SystematicSet > &syst)
Definition: TopConfig.cxx:2297
top::TopConfig::sgKeyTruthMET
const std::string & sgKeyTruthMET() const
Definition: TopConfig.h:598
top::TopConfig::jetUncertainties_QGHistPatterns
virtual const std::vector< std::string > & jetUncertainties_QGHistPatterns() const
Definition: TopConfig.h:1501
top::TopConfig::setGrlFile
void setGrlFile(const std::string &s)
Definition: TopConfig.cxx:1927
top::TopConfig::jetJMSOption
virtual const std::string & jetJMSOption() const
Definition: TopConfig.h:1517
top::TopConfig::sgKeyKLFitterLoose
const std::string & sgKeyKLFitterLoose(const std::size_t hash) const
Definition: TopConfig.cxx:3308
top::TopConfig::m_jetUncertainties_QGHistPatterns
std::vector< std::string > m_jetUncertainties_QGHistPatterns
Definition: TopConfig.h:2503
top::TopConfig::setFilterBranches
void setFilterBranches(const std::vector< std::string > &value)
Definition: TopConfig.h:135
top::TopConfig::m_systMapTrackJets
std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > > m_systMapTrackJets
Definition: TopConfig.h:2876
top::TopConfig::ReadIsDataOverlay
void ReadIsDataOverlay(top::ConfigurationSettings *const &settings)
Definition: TopConfig.cxx:3832
top::TopConfig::m_systSgKeyMapPseudoTopLoose
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapPseudoTopLoose
Definition: TopConfig.h:2952
top::TopConfig::sgKeyMissingEtLoose
virtual const std::string & sgKeyMissingEtLoose() const
Definition: TopConfig.h:587
top::TopConfig::m_useElectrons
bool m_useElectrons
Definition: TopConfig.h:2196
top::TopPersistentSettings::m_muonQuality
std::string m_muonQuality
Definition: TopPersistentSettings.h:71
top::TopConfig::m_makeAllCPTools
bool m_makeAllCPTools
Definition: TopConfig.h:2185
top::TopPersistentSettings::m_systSgKeyMapPhotons
std::map< std::size_t, std::string > m_systSgKeyMapPhotons
Definition: TopPersistentSettings.h:83
top::TopConfig::m_jetGhostTrackRunPeriods
std::vector< std::uint32_t > m_jetGhostTrackRunPeriods
Definition: TopConfig.h:2392
top::TopConfig::m_nominalSystName
std::string m_nominalSystName
Definition: TopConfig.h:2244
top::TopConfig::setFilterNominalBranches
void setFilterNominalBranches(const std::vector< std::string > &value)
Definition: TopConfig.h:167
top::TopConfig::METSignificance
virtual bool METSignificance() const
Definition: TopConfig.h:1610
top::TopPersistentSettings::m_systSgKeyMapKLFitter
std::map< std::size_t, std::string > m_systSgKeyMapKLFitter
Definition: TopPersistentSettings.h:96
top::TopConfig::m_electronIDSFFileLoose_path
std::string m_electronIDSFFileLoose_path
Definition: TopConfig.h:2439
top::TopConfig::m_sgKeySoftMuons
std::string m_sgKeySoftMuons
Definition: TopConfig.h:2366
top::TopConfig::m_muonCalibMode
std::string m_muonCalibMode
Definition: TopConfig.h:2473
top::TopConfig::isMC
bool isMC() const
Definition: TopConfig.h:110
top::TopConfig::m_isTruthDxAOD
bool m_isTruthDxAOD
Definition: TopConfig.h:2257
top::TopConfig::m_muonQualityLoose
std::string m_muonQualityLoose
Definition: TopConfig.h:2461
top::TopConfig::truth_softmuon_PtCut
virtual float truth_softmuon_PtCut() const
Definition: TopConfig.h:1810
top::TopConfig::muonSFCustomInputFolder
std::string const & muonSFCustomInputFolder() const
Definition: TopConfig.h:1126
top::TopConfig::m_treeFilter
std::shared_ptr< TreeFilter > m_treeFilter
Definition: TopConfig.h:2984
top::TopPersistentSettings::m_systSgKeyMapTaus
std::map< std::size_t, std::string > m_systSgKeyMapTaus
Definition: TopPersistentSettings.h:88
top::TopPersistentSettings::m_sgKeyMuons
std::string m_sgKeyMuons
Definition: TopPersistentSettings.h:50
top::TopPersistentSettings::m_systSgKeyMapMissingETLoose
std::map< std::size_t, std::string > m_systSgKeyMapMissingETLoose
Definition: TopPersistentSettings.h:95
top::TopConfig::setSaveBootstrapWeights
void setSaveBootstrapWeights(const bool value)
Definition: TopConfig.h:2127
top::TopConfig::setJVTWP
void setJVTWP(const std::string &value)
Definition: TopConfig.h:1567
top::TopConfig::bTag_eigen_light
std::unordered_map< std::string, unsigned int > bTag_eigen_light
Definition: TopConfig.h:2727
top::TopConfig::fwdElectronBCIDCleaningMinRun
virtual int fwdElectronBCIDCleaningMinRun() const
Definition: TopConfig.h:941
python.TrigTLAMonitorAlgorithm.triggers
triggers
Definition: TrigTLAMonitorAlgorithm.py:196
top::TopConfig::m_systHashTracks
std::shared_ptr< std::unordered_set< std::size_t > > m_systHashTracks
Definition: TopConfig.h:2859
top::TopConfig::m_nominalHashValue
std::size_t m_nominalHashValue
Definition: TopConfig.h:2848
top::TopConfig::setTDPPath
void setTDPPath(const std::string &s)
Definition: TopConfig.cxx:1942
top::TopConfig::jetUncertainties_NPModel
virtual const std::string & jetUncertainties_NPModel() const
Definition: TopConfig.h:1499
top::TopConfig::tauEleIDWPLoose
const std::string & tauEleIDWPLoose() const
Definition: TopConfig.h:1692
beamspotman.tokens
tokens
Definition: beamspotman.py:1284
top::TopConfig::muonUseMVALowPt
virtual bool muonUseMVALowPt() const
Definition: TopConfig.h:1107
top::TopPersistentSettings::m_allTriggers_Loose
std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > m_allTriggers_Loose
Definition: TopPersistentSettings.h:116
top::TopPersistentSettings::m_sgKeyTrackJets
std::string m_sgKeyTrackJets
Definition: TopPersistentSettings.h:55
top::TopConfig::m_KLFitterFailOnLessThanXJets
bool m_KLFitterFailOnLessThanXJets
Definition: TopConfig.h:2353
top::TopConfig::m_useRCJets
bool m_useRCJets
Definition: TopConfig.h:2205
top::TopConfig::sgKeyMCParticle
virtual const std::string & sgKeyMCParticle() const
Definition: TopConfig.h:591
top::TopConfig::muonMuonDoExtraSmearingHighPt
virtual bool muonMuonDoExtraSmearingHighPt() const
Definition: TopConfig.h:1121
top::TopConfig::muonTriggers_Tight
virtual void muonTriggers_Tight(std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)
Definition: TopConfig.h:467
top::TopConfig::m_softmuonQuality
std::string m_softmuonQuality
Definition: TopConfig.h:2487
top::TopConfig::truth_electron_PtCut
virtual float truth_electron_PtCut() const
Definition: TopConfig.h:1774
top::TopConfig::m_useVarRCJetSubstructure
bool m_useVarRCJetSubstructure
Definition: TopConfig.h:2568
top::TopConfig::m_systSgKeyMapSoftMuons
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapSoftMuons
Definition: TopConfig.h:2884
x
#define x
top::TopConfig::m_systMapMET
std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > > m_systMapMET
Definition: TopConfig.h:2878
top::TopConfig::m_systSgKeyMapJets_electronInJetSubtraction
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapJets_electronInJetSubtraction
Definition: TopConfig.h:2887
top::TopConfig::fwdElectronMinEtacut
virtual float fwdElectronMinEtacut() const
Definition: TopConfig.h:939
top::TopConfig::sgKeyTausTDSAux
const std::string & sgKeyTausTDSAux(const std::size_t hash) const
Definition: TopConfig.cxx:3106
top::TopConfig::muonMuonDoSmearing2stationHighPt
virtual bool muonMuonDoSmearing2stationHighPt() const
Definition: TopConfig.h:1120
top::TopConfig::m_useTruthMuons
bool m_useTruthMuons
Definition: TopConfig.h:2222
top::TopConfig::muon_trigger_systematics
std::vector< std::string > muon_trigger_systematics
Definition: TopConfig.h:2791
top::TopConfig::sgKeyElectronsTDS
const std::string & sgKeyElectronsTDS(const std::size_t hash) const
Definition: TopConfig.cxx:2959
top::TopConfig::tauJetConfigFileLoose
const std::string & tauJetConfigFileLoose()
Definition: TopConfig.h:1708
top::TopConfig::m_systSgKeyMapMuons
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapMuons
Definition: TopConfig.h:2883
top::TopConfig::m_doKLFitter
bool m_doKLFitter
Definition: TopConfig.h:2345
top::TopConfig::systematicsLargeRJets
virtual void systematicsLargeRJets(const std::list< CP::SystematicSet > &syst)
Definition: TopConfig.cxx:2394
top::TopConfig::m_useRCJetAdditionalSubstructure
bool m_useRCJetAdditionalSubstructure
Definition: TopConfig.h:2559
top::TopConfig
Definition: TopConfig.h:41
top::TopConfig::fwdElectronID
virtual const std::string & fwdElectronID() const
Definition: TopConfig.h:936
top::TopConfig::numberOfEventsToRun
virtual unsigned int numberOfEventsToRun() const
Definition: TopConfig.h:2028
top::TopConfig::sgKeyMuonsTDSAux
const std::string & sgKeyMuonsTDSAux(const std::size_t hash) const
Definition: TopConfig.cxx:3058
top::TopConfig::m_tauTriggers_Loose
std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > m_tauTriggers_Loose
Definition: TopConfig.h:2814
top::TopConfig::softmuonEtacut
virtual float softmuonEtacut() const
Definition: TopConfig.h:1218
top::TopPersistentSettings::m_photonTriggers_Loose
std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > m_photonTriggers_Loose
Definition: TopPersistentSettings.h:120
top::TopConfig::setUseEventLevelJetCleaningTool
void setUseEventLevelJetCleaningTool(const bool value)
Definition: TopConfig.h:2141
top::TopConfig::systematicsFwdElectrons
virtual void systematicsFwdElectrons(const std::list< CP::SystematicSet > &syst)
Definition: TopConfig.cxx:2326
top::TopConfig::m_useTruthParticles
bool m_useTruthParticles
Definition: TopConfig.h:2220
top::TopConfig::m_systAllSgKeyMapElectrons
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapElectrons
Definition: TopConfig.h:2896
top::TopConfig::allowSmallRJMSforAFII
virtual bool allowSmallRJMSforAFII() const
Definition: TopConfig.h:1541
top::TopConfig::sgKeyPhotonsTDSAux
const std::string & sgKeyPhotonsTDSAux(const std::size_t hash) const
Definition: TopConfig.cxx:2931
top::TopConfig::electronEfficiencySystematicModelEtaBinning
virtual const std::string & electronEfficiencySystematicModelEtaBinning()
Definition: TopConfig.h:841
config
Definition: PhysicsAnalysis/AnalysisCommon/AssociationUtils/python/config.py:1
top::TopConfig::RCJetPtcut
virtual float RCJetPtcut() const
Definition: TopConfig.h:1380
top::TopConfig::setReleaseSeries
void setReleaseSeries()
Definition: TopConfig.cxx:3840
top::TopConfig::m_systAllSgKeyMapPhotonsTDSAux
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapPhotonsTDSAux
Definition: TopConfig.h:2913
top::TopConfig::m_systAllSgKeyMapJets_electronInJetSubtraction
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapJets_electronInJetSubtraction
Definition: TopConfig.h:2908
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
top::TopConfig::m_systHashFwdElectrons
std::shared_ptr< std::unordered_set< std::size_t > > m_systHashFwdElectrons
Definition: TopConfig.h:2852
top::TopConfig::m_enablePromptLeptonImprovedVetoStudies
bool m_enablePromptLeptonImprovedVetoStudies
Definition: TopConfig.h:2435
top::TopConfig::m_btagAlgoWP_calib_caloJet
std::vector< std::pair< std::string, std::string > > m_btagAlgoWP_calib_caloJet
Definition: TopConfig.h:2691
top::TopConfig::m_KLFitterSaveAllPermutations
bool m_KLFitterSaveAllPermutations
Definition: TopConfig.h:2352
top::TopConfig::m_btagWP_calib_caloJet
std::vector< std::string > m_btagWP_calib_caloJet
Definition: TopConfig.h:2693
top::TopPersistentSettings::m_systSgKeyMapElectrons
std::map< std::size_t, std::string > m_systSgKeyMapElectrons
Definition: TopPersistentSettings.h:84
top::TopConfig::m_chosen_boostedJetTaggers
std::vector< std::pair< std::string, std::string > > m_chosen_boostedJetTaggers
Definition: TopConfig.h:2679
python.CreateTierZeroArgdict.pairs
pairs
Definition: CreateTierZeroArgdict.py:201
top::TopConfig::m_systSgKeyMapLargeRJets
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapLargeRJets
Definition: TopConfig.h:2889
top::TopConfig::jetEtacut
virtual float jetEtacut() const
Definition: TopConfig.h:1277
top::TopPersistentSettings::m_systSgKeyMapPseudoTopLoose
std::map< std::size_t, std::string > m_systSgKeyMapPseudoTopLoose
Definition: TopPersistentSettings.h:99
top::TopConfig::m_release_series
int m_release_series
Definition: TopConfig.h:2970
top::TopConfig::VarRCJetMaxRadius
virtual float VarRCJetMaxRadius() const
Definition: TopConfig.h:1440
top::TopConfig::m_systAllSgKeyMapLargeRJets
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapLargeRJets
Definition: TopConfig.h:2902
top::TopConfig::m_systMapPhotons
std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > > m_systMapPhotons
Definition: TopConfig.h:2868
top::TopConfig::m_boostedTaggerSFnames
std::unordered_map< std::string, std::string > m_boostedTaggerSFnames
Definition: TopConfig.h:2680
top::operator<<
std::ostream & operator<<(std::ostream &os, const SelectionConfigurationData &data)
Definition: ConfigurationSettings.cxx:1041
top::TopConfig::m_KLFitterTopMassFixed
bool m_KLFitterTopMassFixed
Definition: TopConfig.h:2351
top::TopConfig::setCalibBoostedJetTagger
void setCalibBoostedJetTagger(const std::string &WP, const std::string &SFname)
Definition: TopConfig.cxx:2203
top::TopConfig::m_useParticleFlowJets
bool m_useParticleFlowJets
Definition: TopConfig.h:2218
top::TopConfig::m_systSgKeyMapFwdElectrons
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapFwdElectrons
Definition: TopConfig.h:2882
top::TopConfig::truth_muon_PtCut
virtual float truth_muon_PtCut() const
Definition: TopConfig.h:1792
top::TopConfig::trackQuality
virtual const std::string & trackQuality() const
Definition: TopConfig.h:1373
top::TopConfig::m_systAllSgKeyMapJetsLoose_electronInJetSubtraction
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapJetsLoose_electronInJetSubtraction
Definition: TopConfig.h:2909
top::TopConfig::softmuonAdditionalTruthInfoDoVerbose
virtual bool softmuonAdditionalTruthInfoDoVerbose() const
Definition: TopConfig.h:1226
top::TopConfig::m_electronIsolationWPs
std::vector< std::string > m_electronIsolationWPs
Definition: TopConfig.h:2427
top::TopPersistentSettings::m_sgKeyLargeRJets
std::string m_sgKeyLargeRJets
Definition: TopPersistentSettings.h:54
PixelModuleFeMask_create_db.remove
string remove
Definition: PixelModuleFeMask_create_db.py:83
top::TopConfig::muonQuality
virtual const std::string & muonQuality() const
Definition: TopConfig.h:1105
top::TopConfig::m_btagAlgoWP_calib_trkJet
std::vector< std::pair< std::string, std::string > > m_btagAlgoWP_calib_trkJet
Definition: TopConfig.h:2692
top::TopConfig::setFakesMMIFFDebug
void setFakesMMIFFDebug()
Definition: TopConfig.h:244
runLayerRecalibration.branches
list branches
Definition: runLayerRecalibration.py:98
grl
Definition: ZLumiScripts/grid/grl.py:1
top::TopPersistentSettings::m_doPseudoTop
bool m_doPseudoTop
Definition: TopPersistentSettings.h:40
top::TopConfig::sgKeyTrackJetsTDSAux
const std::string & sgKeyTrackJetsTDSAux(const std::size_t hash) const
Definition: TopConfig.cxx:3252
top::TopConfig::enablePromptLeptonImprovedVetoStudies
bool enablePromptLeptonImprovedVetoStudies() const
Definition: TopConfig.h:884
top::TopConfig::m_systAllTTreeIndex
std::shared_ptr< std::unordered_map< std::size_t, unsigned int > > m_systAllTTreeIndex
Definition: TopConfig.h:2963
top::TopConfig::m_systAllSgKeyMapElectrons_electronInJetSubtractionTDSAux
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapElectrons_electronInJetSubtractionTDSAux
Definition: TopConfig.h:2934
top::TopPersistentSettings::m_sgKeyMissingEt
std::string m_sgKeyMissingEt
Definition: TopPersistentSettings.h:57
top::TopConfig::fixConfiguration
void fixConfiguration()
Definition: TopConfig.cxx:2480
top::TopConfig::m_systAllSgKeyMapElectronsTDSAux
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapElectronsTDSAux
Definition: TopConfig.h:2915
SampleXsection
Definition: SampleXsection.h:19
top::TopConfig::m_showerMCMCtranslator
std::unordered_map< std::string, std::string > m_showerMCMCtranslator
Definition: TopConfig.h:2986
top::TopConfig::m_doLooseSysts
bool m_doLooseSysts
Definition: TopConfig.h:2303
top::TopConfig::createPersistentSettings
top::TopPersistentSettings * createPersistentSettings()
– top::TopPersistentSettings allows us to take a snapshot of top::TopConfig –/// – and save it to a m...
Definition: TopConfig.cxx:3485
top::TopConfig::m_systAllSgKeyMapJets_electronInJetSubtractionTDSAux
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapJets_electronInJetSubtractionTDSAux
Definition: TopConfig.h:2936
top::TopConfig::m_btagAlgoWP_trkJet
std::vector< std::pair< std::string, std::string > > m_btagAlgoWP_trkJet
Definition: TopConfig.h:2685
top::TopConfig::m_jetUncertainties_QGFracFile
std::string m_jetUncertainties_QGFracFile
Definition: TopConfig.h:2502
top::TopConfig::sgKeyLargeRJetsTDS
const std::string & sgKeyLargeRJetsTDS(const std::size_t hash) const
Definition: TopConfig.cxx:3220
top::TopConfig::m_sgKeyMuons
std::string m_sgKeyMuons
Definition: TopConfig.h:2365
top::TopConfig::setTruthPDFInfo
void setTruthPDFInfo()
Definition: TopConfig.h:325
top::TopConfig::ReadIsAFII
void ReadIsAFII(top::ConfigurationSettings *const &settings)
Definition: TopConfig.cxx:3823
top::TopPersistentSettings::m_electronTriggers_Loose
std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > m_electronTriggers_Loose
Definition: TopPersistentSettings.h:117
top::TopConfig::sgKeyJets
virtual const std::string & sgKeyJets() const
Definition: TopConfig.h:582
top::TopConfig::m_bJSF
float m_bJSF
Definition: TopConfig.h:2575
top::TopConfig::photonIdentification
const std::string & photonIdentification()
Definition: TopConfig.h:1734
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
top::TopPersistentSettings::m_photonTriggers_Tight
std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > m_photonTriggers_Tight
Definition: TopPersistentSettings.h:114
top::TopConfig::m_electronTriggers_Loose
std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > m_electronTriggers_Loose
Definition: TopConfig.h:2812
top::TopConfig::m_systSgKeyMapTaus
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapTaus
Definition: TopConfig.h:2885
top::TopPersistentSettings::m_doKLFitter
bool m_doKLFitter
Definition: TopPersistentSettings.h:39
top::TopConfig::muonPtcut
virtual float muonPtcut() const
Definition: TopConfig.h:1101
top::TopConfig::sgKeyMissingEt
virtual const std::string & sgKeyMissingEt() const
Definition: TopConfig.h:586
top::TopConfig::m_tauTriggers_Tight
std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > m_tauTriggers_Tight
Definition: TopConfig.h:2809
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
top::TopConfig::sgKeyTruthJets
virtual const std::string & sgKeyTruthJets() const
Definition: TopConfig.h:596
top::TopConfig::m_systMapTaus
std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > > m_systMapTaus
Definition: TopConfig.h:2873
top::TopPersistentSettings::m_systSgKeyMapLargeRJets
std::map< std::size_t, std::string > m_systSgKeyMapLargeRJets
Definition: TopPersistentSettings.h:92
top::TopConfig::m_sgKeyMissingEt
std::string m_sgKeyMissingEt
Definition: TopConfig.h:2372
top::TopConfig::setBadBatmanCleaningMin
void setBadBatmanCleaningMin(const unsigned int value)
Definition: TopConfig.h:2135
top::TopConfig::m_muonIsolationLoose
std::string m_muonIsolationLoose
Definition: TopConfig.h:2467
top::TopConfig::m_electronID
std::string m_electronID
Definition: TopConfig.h:2418
top::TopConfig::m_useTruthMET
bool m_useTruthMET
Definition: TopConfig.h:2227
top::TopConfig::m_sgKeyTracks
std::string m_sgKeyTracks
Definition: TopConfig.h:2395
top::TopConfig::m_JSF
float m_JSF
Definition: TopConfig.h:2574
top::TopConfig::setApplyTightSFsInLooseTree
void setApplyTightSFsInLooseTree()
Definition: TopConfig.h:298
top::TopConfig::m_systSgKeyMapJets
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapJets
Definition: TopConfig.h:2886
lumiFormat.i
int i
Definition: lumiFormat.py:92
top::TopConfig::m_systAllSgKeyMapTracks
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapTracks
Definition: TopConfig.h:2904
top::TopConfig::sgKeyFwdElectronsStandAlone
virtual const std::string & sgKeyFwdElectronsStandAlone(const std::size_t hash) const
Definition: TopConfig.cxx:3034
top::TopConfig::m_systSgKeyMapPseudoTop
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapPseudoTop
Definition: TopConfig.h:2951
top::TopConfig::isRun3
bool isRun3() const
Definition: TopConfig.h:1990
top::TopConfig::systematicsTaus
virtual void systematicsTaus(const std::list< CP::SystematicSet > &syst)
Definition: TopConfig.cxx:2365
top::TopPersistentSettings::m_electronIDLoose
std::string m_electronIDLoose
Definition: TopPersistentSettings.h:61
top::TopConfig::jetEtaGhostTracks
virtual float jetEtaGhostTracks() const
Definition: TopConfig.h:1284
top::TopConfig::bTag_base_names_trkJet
std::unordered_map< std::string, std::set< std::string > > bTag_base_names_trkJet
Definition: TopConfig.h:2716
top::TopPersistentSettings::m_muonTriggers_Loose
std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > m_muonTriggers_Loose
Definition: TopPersistentSettings.h:118
top::TopConfig::m_bTagSystsExcludedFromEV
std::string m_bTagSystsExcludedFromEV
Definition: TopConfig.h:2699
top::TopConfig::photonIsolationLoose
const std::string & photonIsolationLoose()
Definition: TopConfig.h:1746
top::TopConfig::m_trigGlobalConfiguration
struct top::TopConfig::@218 m_trigGlobalConfiguration
top::TopConfig::setTruthBlockInfo
void setTruthBlockInfo()
Definition: TopConfig.h:317
top::TopConfig::m_systHashMET
std::shared_ptr< std::unordered_set< std::size_t > > m_systHashMET
Definition: TopConfig.h:2860
top::TopConfig::METSignifSoftTermParam
virtual const std::string & METSignifSoftTermParam() const
Definition: TopConfig.h:1609
top::TopConfig::allTriggers_Loose
virtual void allTriggers_Loose(std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)
Definition: TopConfig.h:488
top::TopConfig::tauTriggers_Loose
virtual void tauTriggers_Loose(std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)
Definition: TopConfig.h:509
top::TopConfig::doJVTinMET
virtual bool doJVTinMET() const
Definition: TopConfig.h:1557
top::TopConfig::m_systSgKeyMapKLFitterLoose
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapKLFitterLoose
Definition: TopConfig.h:2947
top::TopConfig::electronEfficiencySystematicModelNToys
virtual const int & electronEfficiencySystematicModelNToys()
Definition: TopConfig.h:847
top::TopConfig::tauTriggers_Tight
virtual void tauTriggers_Tight(std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)
Definition: TopConfig.h:474
top::TopConfig::m_useLargeRJets
bool m_useLargeRJets
Definition: TopConfig.h:2203
top::TopConfig::m_forceWeightIndex
bool m_forceWeightIndex
Definition: TopConfig.h:2330
top::TopConfig::sgKeyTracks
virtual const std::string & sgKeyTracks() const
Definition: TopConfig.h:585
top::TopConfig::jetJERSmearingModel
virtual const std::string & jetJERSmearingModel() const
Definition: TopConfig.h:1509
top::TopConfig::m_grlDir
std::string m_grlDir
Definition: TopConfig.h:2188
sel
sel
Definition: SUSYToolsTester.cxx:92
top::TopConfig::electronIsolationLoose
virtual const std::string & electronIsolationLoose() const
Definition: TopConfig.h:876
top::TopConfig::m_trackQuality
std::string m_trackQuality
Definition: TopConfig.h:2571
top::TopConfig::m_systMapFwdElectrons
std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > > m_systMapFwdElectrons
Definition: TopConfig.h:2870
top::nominal
@ nominal
Definition: ScaleFactorRetriever.h:29
top::TopConfig::m_useVarRCJetAdditionalSubstructure
bool m_useVarRCJetAdditionalSubstructure
Definition: TopConfig.h:2569
top::TopConfig::m_sgKeyMissingEtLoose
std::string m_sgKeyMissingEtLoose
Definition: TopConfig.h:2373
top::TopPersistentSettings::m_sgKeyElectrons
std::string m_sgKeyElectrons
Definition: TopPersistentSettings.h:48
top::TopConfig::m_systSgKeyMapMissingETLoose
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapMissingETLoose
Definition: TopConfig.h:2942
top::TopConfig::m_systSgKeyMapKLFitter
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapKLFitter
Definition: TopConfig.h:2946
top::TopConfig::runPeriodJetGhostTrack
virtual void runPeriodJetGhostTrack(const std::vector< std::uint32_t > &vect)
Definition: TopConfig.cxx:2164
top::TopConfig::m_btagWP_trkJet
std::vector< std::string > m_btagWP_trkJet
Definition: TopConfig.h:2688
top::TopConfig::setGrlDir
void setGrlDir(const std::string &s)
Definition: TopConfig.cxx:1920
top::TopConfig::muonIsolationSF
std::string const & muonIsolationSF() const
Definition: TopConfig.h:1116
top::TopPersistentSettings::m_tauTriggers_Loose
std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > m_tauTriggers_Loose
Definition: TopPersistentSettings.h:119
top::TopConfig::setOverlapRemovalOnLooseLeptonDef
void setOverlapRemovalOnLooseLeptonDef()
Definition: TopConfig.h:259
top::TopConfig::m_btagging_calibration_B
std::string m_btagging_calibration_B
Definition: TopConfig.h:2704
top::TopConfig::m_doPseudoTop
bool m_doPseudoTop
Definition: TopConfig.h:2356
top::TopConfig::numberOfEventsToSkip
virtual unsigned int numberOfEventsToSkip() const
Definition: TopConfig.h:2036
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
top::TopConfig::setFilterPartonLevelBranches
void setFilterPartonLevelBranches(const std::vector< std::string > &value)
Definition: TopConfig.h:143
top::TopConfig::m_systAllSgKeyMapPhotons
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapPhotons
Definition: TopConfig.h:2895
top::TopConfig::m_recomputeCPvars
bool m_recomputeCPvars
Definition: TopConfig.h:2237
top::TopConfig::m_jetGhostTrackSystematics
std::vector< std::string > m_jetGhostTrackSystematics
Definition: TopConfig.h:2391
top::TopConfig::muonUseMVALowPtLoose
virtual bool muonUseMVALowPtLoose() const
Definition: TopConfig.h:1110
top::TopConfig::runPeriodTrack
virtual void runPeriodTrack(const std::vector< std::uint32_t > &vect)
Definition: TopConfig.cxx:2170
top::TopConfig::m_allSystName
std::string m_allSystName
Definition: TopConfig.h:2245
top::TopConfig::m_KLFitterLH
std::string m_KLFitterLH
Definition: TopConfig.h:2350
top::TopConfig::truth_jet_largeR_EtaCut
virtual float truth_jet_largeR_EtaCut() const
Definition: TopConfig.h:1873
top::TopConfig::setBTaggingSFSysts
void setBTaggingSFSysts(std::string WP, const std::set< std::string > &btagging_SFs, bool isTrackJet=false)
Definition: TopConfig.cxx:2175
top::TopConfig::m_sgKeyKLFitter
std::string m_sgKeyKLFitter
Definition: TopConfig.h:2945
top::TopConfig::trackJetPtcut
virtual float trackJetPtcut() const
Definition: TopConfig.h:1350
top::TopConfig::m_systMapLargeRJets
std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > > m_systMapLargeRJets
Definition: TopConfig.h:2875
top::TopConfig::photonIsolation
const std::string & photonIsolation()
Definition: TopConfig.h:1742
top::TopConfig::softmuonQuality
virtual const std::string & softmuonQuality() const
Definition: TopConfig.h:1219
top::TopConfig::setParticleLevelOverlapRemovalMuJet
void setParticleLevelOverlapRemovalMuJet(bool value)
Definition: TopConfig.h:402
top::TopConfig::sgKeyTrackJets
virtual const std::string & sgKeyTrackJets() const
Definition: TopConfig.h:584
top::TopConfig::sgKeyJetsTDSAux
const std::string & sgKeyJetsTDSAux(const std::size_t hash, const bool useLooseLeptonJets) const
Definition: TopConfig.cxx:3174
top::TopConfig::systSgKeyMapJets
std::shared_ptr< std::unordered_map< std::size_t, std::string > > systSgKeyMapJets(const bool useLooseLeptonJets) const
Definition: TopConfig.cxx:3355
top::TopConfig::sgKeySoftMuonsTDSAux
const std::string & sgKeySoftMuonsTDSAux(const std::size_t hash) const
Definition: TopConfig.cxx:3082
top::TopConfig::m_useTruthTaus
bool m_useTruthTaus
Definition: TopConfig.h:2226
top::TopConfig::tauPtcut
virtual float tauPtcut() const
Definition: TopConfig.h:1672
top::TopConfig::m_btag_algos_trkJet
std::map< std::string, std::string > m_btag_algos_trkJet
Definition: TopConfig.h:2697
top::TopPersistentSettings::m_muonTriggers_Tight
std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > m_muonTriggers_Tight
Definition: TopPersistentSettings.h:112
top::TopConfig::m_systPersistantAllTTreeNames
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systPersistantAllTTreeNames
Definition: TopConfig.h:2961
top::TopConfig::electrond0Sigcut
virtual float electrond0Sigcut() const
Definition: TopConfig.h:873
top::TopConfig::sgKeyTruthPhotons
const std::string & sgKeyTruthPhotons() const
Definition: TopConfig.h:592
top::TopConfig::setIsAFII
void setIsAFII(const bool value)
Definition: TopConfig.h:119
top::TopConfig::muonForcePeriod
std::string const & muonForcePeriod() const
Definition: TopConfig.h:1144
top::TopConfig::sgKeyTruthElectrons
const std::string & sgKeyTruthElectrons() const
Definition: TopConfig.h:593
top::TopConfig::m_sgKeyTruthTaus
std::string m_sgKeyTruthTaus
Definition: TopConfig.h:2380
top::TopConfig::truth_photon_PtCut
virtual float truth_photon_PtCut() const
Definition: TopConfig.h:1838
top::TopConfig::m_systHashElectrons
std::shared_ptr< std::unordered_set< std::size_t > > m_systHashElectrons
Definition: TopConfig.h:2851
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
top::TopConfig::m_decoKeyJetGhostTrack
std::string m_decoKeyJetGhostTrack
Definition: TopConfig.h:2390
MsgCategory.h
top::TopConfig::bTag_named_systs_trkJet
std::unordered_map< std::string, std::set< std::string > > bTag_named_systs_trkJet
Definition: TopConfig.h:2719
top::TopConfig::m_outputFileBasketSizePrimitive
int m_outputFileBasketSizePrimitive
Definition: TopConfig.h:2839
top::TopPersistentSettings::m_fwdElectronID
std::string m_fwdElectronID
Definition: TopPersistentSettings.h:68
top::TopConfig::setFakesMMWeightsCalculationIFF
void setFakesMMWeightsCalculationIFF()
Definition: TopConfig.h:240
top::TopConfig::m_systMapElectrons
std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > > m_systMapElectrons
Definition: TopConfig.h:2869
top::TopConfig::m_useTaus
bool m_useTaus
Definition: TopConfig.h:2201
selection
std::string selection
Definition: fbtTestBasics.cxx:73
top::TopConfig::m_photonIsolationWPs
std::vector< std::string > m_photonIsolationWPs
Definition: TopConfig.h:2604
top::TopConfig::m_systSgKeyMapPhotons
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapPhotons
Definition: TopConfig.h:2880
top::TopConfig::m_dummyTrigger
std::vector< std::pair< std::string, int > > m_dummyTrigger
Definition: TopConfig.h:2816
WriteCalibToCool.swap
swap
Definition: WriteCalibToCool.py:94
top::TopConfig::sgKeyKLFitter
const std::string & sgKeyKLFitter(const std::size_t hash) const
Definition: TopConfig.cxx:3300
top::TopPersistentSettings::m_doOverlapRemovalOnLooseLeptonDef
bool m_doOverlapRemovalOnLooseLeptonDef
Definition: TopPersistentSettings.h:38
top::TopConfig::muonEtacut
virtual float muonEtacut() const
Definition: TopConfig.h:1102
top::TopConfig::m_btag_algos_caloJet
std::map< std::string, std::string > m_btag_algos_caloJet
Definition: TopConfig.h:2696
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
top::TopConfig::RCInputJetEtaMax
virtual float RCInputJetEtaMax() const
Definition: TopConfig.h:1383
top::TopConfig::m_electronIsolation
std::string m_electronIsolation
Definition: TopConfig.h:2423
top::TopConfig::m_systAllSgKeyMapMuons
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapMuons
Definition: TopConfig.h:2898
top::TopConfig::m_useTracks
bool m_useTracks
Definition: TopConfig.h:2213
top::TopPersistentSettings::m_muonQualityLoose
std::string m_muonQualityLoose
Definition: TopPersistentSettings.h:72
top::TopConfig::m_systAllSgKeyMapTausTDS
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapTausTDS
Definition: TopConfig.h:2922
top::TopConfig::muond0Sigcut
virtual float muond0Sigcut() const
Definition: TopConfig.h:1103
top::TopConfig::muonSFCustomInputFolderTrigger
std::string const & muonSFCustomInputFolderTrigger() const
Definition: TopConfig.h:1132
top::TopPersistentSettings::m_systPersistantAllTTreeNames
std::map< std::size_t, std::string > m_systPersistantAllTTreeNames
Definition: TopPersistentSettings.h:100
top::TopConfig::m_sgKeyTrackJets
std::string m_sgKeyTrackJets
Definition: TopConfig.h:2370
top::TopConfig::systematicsTrackJets
virtual void systematicsTrackJets(const std::list< CP::SystematicSet > &syst)
Definition: TopConfig.cxx:2407
top::TopConfig::RCJetTrimcut
virtual float RCJetTrimcut() const
Definition: TopConfig.h:1384
top::TopConfig::sgKeyPhotonsTDS
const std::string & sgKeyPhotonsTDS(const std::size_t hash) const
Definition: TopConfig.cxx:2923
top::TopConfig::m_btagWP_caloJet
std::vector< std::string > m_btagWP_caloJet
Definition: TopConfig.h:2687
top::TopConfig::m_sgKeyElectrons
std::string m_sgKeyElectrons
Definition: TopConfig.h:2363
top::TopConfig::muonUse2stationMuonsHighPt
virtual bool muonUse2stationMuonsHighPt() const
Definition: TopConfig.h:1109
DeMoScan.runnumber
runnumber
Definition: DeMoScan.py:266
top::TopConfig::m_systAllTTreeNames
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllTTreeNames
Definition: TopConfig.h:2960
top::TopConfig::sgKeyMuons
virtual const std::string & sgKeyMuons() const
Definition: TopConfig.h:579
top::TopConfig::m_systAllSgKeyMapTracksTDSAux
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapTracksTDSAux
Definition: TopConfig.h:2931
min
#define min(a, b)
Definition: cfImp.cxx:40
top::TopConfig::isSystNominal
bool isSystNominal(const std::string &syst) const
syst helper functions
Definition: TopConfig.cxx:2263
top::TopConfig::egammaSystematicModel
virtual const std::string & egammaSystematicModel()
Definition: TopConfig.h:839
ConfigurationSettings.h
top::TopConfig::trackEtacut
virtual float trackEtacut() const
Definition: TopConfig.h:1375
top::TopConfig::m_systHashJets
std::shared_ptr< std::unordered_set< std::size_t > > m_systHashJets
Definition: TopConfig.h:2856
top::TopConfig::m_sgKeyDummy
std::string m_sgKeyDummy
Definition: TopConfig.h:2359
top::TopConfig::jetPtGhostTracks
virtual float jetPtGhostTracks() const
Definition: TopConfig.h:1283
top::TopConfig::setParticleLevelOverlapRemovalElJet
void setParticleLevelOverlapRemovalElJet(bool value)
Definition: TopConfig.h:408
top::TopConfig::setTruthPDFInfoInNominalTrees
void setTruthPDFInfoInNominalTrees()
Definition: TopConfig.h:333
top::TopConfig::photon_trigger_systematics
std::vector< std::string > photon_trigger_systematics
Definition: TopConfig.h:2793
top::TopPersistentSettings::m_sgKeyJets
std::string m_sgKeyJets
Definition: TopPersistentSettings.h:53
top::TopConfig::m_btagAlgoWP_caloJet
std::vector< std::pair< std::string, std::string > > m_btagAlgoWP_caloJet
Definition: TopConfig.h:2684
top::TopConfig::m_electronIDLoose
std::string m_electronIDLoose
Definition: TopConfig.h:2419
top::TopConfig::m_sgKeyPhotons
std::string m_sgKeyPhotons
Definition: TopConfig.h:2362
top::TopPersistentSettings::m_sgKeySoftMuons
std::string m_sgKeySoftMuons
Definition: TopPersistentSettings.h:51
top::TopConfig::truth_photon_EtaCut
virtual float truth_photon_EtaCut() const
Definition: TopConfig.h:1839
top::TopConfig::muonIsolation
virtual const std::string & muonIsolation() const
Definition: TopConfig.h:1113
top::TopConfig::m_systHashTaus
std::shared_ptr< std::unordered_set< std::size_t > > m_systHashTaus
Definition: TopConfig.h:2855
top::TopConfig::sgKeyPhotons
virtual const std::string & sgKeyPhotons() const
Definition: TopConfig.h:576
top::TopConfig::allTriggers_Tight
virtual void allTriggers_Tight(std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)
Definition: TopConfig.h:453
top::TopConfig::m_systHashMuons
std::shared_ptr< std::unordered_set< std::size_t > > m_systHashMuons
Definition: TopConfig.h:2853
top::TopConfig::electronIsolationSFLoose
std::string const & electronIsolationSFLoose() const
Definition: TopConfig.h:879
top::TopConfig::setParticleLevelOverlapRemovalJetPhoton
void setParticleLevelOverlapRemovalJetPhoton(bool value)
Definition: TopConfig.h:414
top::TopConfig::setBadBatmanCleaningMax
void setBadBatmanCleaningMax(const unsigned int value)
Definition: TopConfig.h:2137
top::TopConfig::m_systMapJetGhostTrack
std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > > m_systMapJetGhostTrack
Definition: TopConfig.h:2955
top::TopConfig::m_useTruthLargeRJets
bool m_useTruthLargeRJets
Definition: TopConfig.h:2225
top::TopConfig::m_outputFileSetAutoFlushZero
bool m_outputFileSetAutoFlushZero
Definition: TopConfig.h:2836
Muon::nsw::unknown
@ unknown
Definition: NSWTriggerElink.h:36
top::TopConfig::m_systHash_electronInJetSubtraction
std::shared_ptr< std::unordered_set< std::size_t > > m_systHash_electronInJetSubtraction
Definition: TopConfig.h:2865
top::TopConfig::m_useFwdElectrons
bool m_useFwdElectrons
Definition: TopConfig.h:2197
top::TopConfig::sgKeyJetsStandAlone
virtual const std::string & sgKeyJetsStandAlone(const std::size_t hash) const
Definition: TopConfig.cxx:3204
top::TopConfig::m_sgKeyTruthLargeRJets
std::string m_sgKeyTruthLargeRJets
Definition: TopConfig.h:2382
top::TopConfig::bTag_eigen_B
std::unordered_map< std::string, unsigned int > bTag_eigen_B
Definition: TopConfig.h:2721
top::TopPersistentSettings::m_systSgKeyMapJets_electronInJetSubtraction
std::map< std::size_t, std::string > m_systSgKeyMapJets_electronInJetSubtraction
Definition: TopPersistentSettings.h:90
top::TopConfig::m_topDataPreparationPath
std::string m_topDataPreparationPath
Definition: TopConfig.h:2192
top::TopPersistentSettings::m_systSgKeyMapTracks
std::map< std::size_t, std::string > m_systSgKeyMapTracks
Definition: TopPersistentSettings.h:103
master.dictionary
dictionary
Definition: master.py:47
top::TopConfig::m_electronTriggers_Tight
std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > m_electronTriggers_Tight
Definition: TopConfig.h:2807
top::TopConfig::VarRCJetTrimcut
virtual float VarRCJetTrimcut() const
Definition: TopConfig.h:1439
top::TopConfig::muondeltaz0cut
virtual float muondeltaz0cut() const
Definition: TopConfig.h:1104
top::TopConfig::m_systAllSgKeyMapElectronsTDS
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapElectronsTDS
Definition: TopConfig.h:2914
top::TopConfig::m_useLooseObjectsInMETInLooseTree
bool m_useLooseObjectsInMETInLooseTree
Definition: TopConfig.h:2268
top::TopConfig::m_sgKeyTopSystematicEventsLoose
std::string m_sgKeyTopSystematicEventsLoose
Definition: TopConfig.h:2387
top::ConfigurationSettings::retrieve
void retrieve(std::string const &key, bool &value) const
The user wants to know the boolean value for the specified key.
Definition: ConfigurationSettings.cxx:1005
top::TopConfig::softmuonAdditionalTruthInfoCheckPartonOrigin
virtual bool softmuonAdditionalTruthInfoCheckPartonOrigin() const
Definition: TopConfig.h:1225
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
map_t
std::map< std::string, unsigned int > map_t
Definition: EMECSupportConstruction.cxx:227
top::TopConfig::m_sgKeyTruthElectrons
std::string m_sgKeyTruthElectrons
Definition: TopConfig.h:2378
top::TopPersistentSettings::m_sgKeyMissingEtLoose
std::string m_sgKeyMissingEtLoose
Definition: TopPersistentSettings.h:58
top::TopConfig::m_systMapTracks
std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > > m_systMapTracks
Definition: TopConfig.h:2877
top::TopPersistentSettings::m_allSelectionNames
std::vector< std::string > m_allSelectionNames
Definition: TopPersistentSettings.h:108
top::TopConfig::tauEtaRegions
const std::string & tauEtaRegions() const
Definition: TopConfig.h:1676
top::TopConfig::m_systHashPhotons
std::shared_ptr< std::unordered_set< std::size_t > > m_systHashPhotons
Definition: TopConfig.h:2850
top::TopConfig::m_doTightSysts
bool m_doTightSysts
Definition: TopConfig.h:2302
top::TopPersistentSettings::m_electronID
std::string m_electronID
Definition: TopPersistentSettings.h:60
top::TopConfig::m_systAllSgKeyMapFwdElectronsTDSAux
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapFwdElectronsTDSAux
Definition: TopConfig.h:2917
top::TopPersistentSettings::m_allTriggers_Tight
std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > m_allTriggers_Tight
Definition: TopPersistentSettings.h:110
top::TopConfig::m_systAllSgKeyMapJets_electronInJetSubtractionTDS
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapJets_electronInJetSubtractionTDS
Definition: TopConfig.h:2935
top::TopConfig::m_systAllSgKeyMapLargeRJetsTDS
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapLargeRJetsTDS
Definition: TopConfig.h:2926
top::TopConfig::setfJVTWP
void setfJVTWP(const std::string &value)
Definition: TopConfig.h:1585
top::TopConfig::setTopPartonLevel
void setTopPartonLevel(bool in)
Definition: TopConfig.h:384
top::TopPersistentSettings::m_electronIsolationLoose
std::string m_electronIsolationLoose
Definition: TopPersistentSettings.h:63
top::TopConfig::parse_bTagWPs
void parse_bTagWPs(const std::string &btagWPsettingString, std::vector< std::pair< std::string, std::string >> &btagAlgoWPlist, std::vector< std::string > &btagWPlist)
Definition: TopConfig.cxx:2216
top::TopConfig::largeRJetEtacut
virtual float largeRJetEtacut() const
Definition: TopConfig.h:1331
top::TopConfig::systematics
virtual const std::string & systematics() const
Definition: TopConfig.h:2050
top::TopConfig::m_trackRunPeriods
std::vector< std::uint32_t > m_trackRunPeriods
Definition: TopConfig.h:2397
top::TopConfig::setIsRun3
void setIsRun3(const bool isRun3)
Definition: TopConfig.h:1991
top::TopPersistentSettings::m_systSgKeyMapMissingET
std::map< std::size_t, std::string > m_systSgKeyMapMissingET
Definition: TopPersistentSettings.h:94
item
Definition: ItemListSvc.h:43
top::TopConfig::SetTriggersToYear
void SetTriggersToYear(const bool isMC)
Definition: TopConfig.cxx:3901
top::TopConfig::contains
bool contains(const std::set< std::string > &systList, const std::string &name) const
Definition: TopConfig.cxx:2292
top::TopConfig::m_nominalWeightNames
std::vector< std::string > m_nominalWeightNames
Definition: TopConfig.h:2327
top::TopConfig::setFilterParticleLevelBranches
void setFilterParticleLevelBranches(const std::vector< std::string > &value)
Definition: TopConfig.h:151
TopConfig.h
top::TopConfig::m_useLooseObjectsInMETInNominalTree
bool m_useLooseObjectsInMETInNominalTree
Definition: TopConfig.h:2269
top::TopConfig::dumpBtagSystsInSystTrees
virtual const bool & dumpBtagSystsInSystTrees()
Definition: TopConfig.h:688
top::TopConfig::m_systAllSgKeyMapSoftMuonsTDS
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapSoftMuonsTDS
Definition: TopConfig.h:2920
top::TopConfig::setApplyElectronInJetSubtraction
void setApplyElectronInJetSubtraction()
Definition: TopConfig.h:309
top::TopConfig::sgKeySoftMuons
virtual const std::string & sgKeySoftMuons() const
Definition: TopConfig.h:580
top::TopConfig::fwdElectronPtcut
virtual float fwdElectronPtcut() const
Definition: TopConfig.h:938
top::TopConfig::doLargeRPseudodataJER
virtual bool doLargeRPseudodataJER() const
Definition: TopConfig.h:1525
top::TopConfig::jetUncertainties_QGFracFile
virtual const std::string & jetUncertainties_QGFracFile() const
Definition: TopConfig.h:1500
top::TopPersistentSettings::m_systSgKeyMapFwdElectrons
std::map< std::size_t, std::string > m_systSgKeyMapFwdElectrons
Definition: TopPersistentSettings.h:85
top::TopConfig::truth_tau_EtaCut
virtual float truth_tau_EtaCut() const
Definition: TopConfig.h:1888
top::TopConfig::sgKeyTaus
virtual const std::string & sgKeyTaus() const
Definition: TopConfig.h:581
top::TopConfig::truth_photon_Origin
virtual const std::string & truth_photon_Origin() const
Definition: TopConfig.h:1840
top::TopConfig::setTopPartonHistory
void setTopPartonHistory()
Definition: TopConfig.h:368
top::TopConfig::m_systSgKeyMapElectrons
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapElectrons
Definition: TopConfig.h:2881
top::TopConfig::setMCGeneratorWeightsInNominalTrees
void setMCGeneratorWeightsInNominalTrees()
Definition: TopConfig.h:349
top::TopConfig::m_allTriggers_Tight
std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > m_allTriggers_Tight
Definition: TopConfig.h:2806
top::TopConfig::m_electronIDDecoration
std::string m_electronIDDecoration
Definition: TopConfig.h:2431
top::TopConfig::largeRJESJMSConfig
virtual const std::string & largeRJESJMSConfig() const
Definition: TopConfig.h:1336
top::TopPersistentSettings::m_systSgKeyMapSoftMuons
std::map< std::size_t, std::string > m_systSgKeyMapSoftMuons
Definition: TopPersistentSettings.h:87
top::TopConfig::m_saveOnlySelectedEvents
bool m_saveOnlySelectedEvents
Definition: TopConfig.h:2834
top::TopPersistentSettings::m_systSgKeyMapKLFitterLoose
std::map< std::size_t, std::string > m_systSgKeyMapKLFitterLoose
Definition: TopPersistentSettings.h:97
top::TopConfig::m_btagging_cdi_path
std::string m_btagging_cdi_path
Definition: TopConfig.h:2703
top::TopConfig::m_sgKeyPseudoTop
std::string m_sgKeyPseudoTop
Definition: TopConfig.h:2950
top::TopConfig::setFilterNominalLooseBranches
void setFilterNominalLooseBranches(const std::vector< std::string > &value)
Definition: TopConfig.h:159
top::TopConfig::removeElectronVetoLArCrack
void removeElectronVetoLArCrack()
Definition: TopConfig.h:767
top::TopConfig::ttreeIndex
unsigned int ttreeIndex(const std::size_t hash) const
Definition: TopConfig.cxx:3367
top::TopPersistentSettings::m_useElectronChargeIDSelection
bool m_useElectronChargeIDSelection
Definition: TopPersistentSettings.h:64
DeMoScan.index
string index
Definition: DeMoScan.py:362
top::TopConfig::m_writeMETBuiltWithLooseObjects
bool m_writeMETBuiltWithLooseObjects
Definition: TopConfig.h:2271
top::TopPersistentSettings::m_sgKeyFwdElectrons
std::string m_sgKeyFwdElectrons
Definition: TopPersistentSettings.h:49
top::TopConfig::m_systAllSgKeyMapLargeRJetsTDSAux
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapLargeRJetsTDSAux
Definition: TopConfig.h:2927
top::TopConfig::fwdElectronIDLoose
virtual const std::string & fwdElectronIDLoose() const
Definition: TopConfig.h:937
top::TopConfig::m_useJetGhostTrack
bool m_useJetGhostTrack
Definition: TopConfig.h:2211
top::TopPersistentSettings::m_sgKeyTopSystematicEventsLoose
std::string m_sgKeyTopSystematicEventsLoose
Definition: TopPersistentSettings.h:43
top::TopPersistentSettings::m_softmuonQuality
std::string m_softmuonQuality
Definition: TopPersistentSettings.h:76
top::TopConfig::sgKeyFwdElectrons
virtual const std::string & sgKeyFwdElectrons() const
Definition: TopConfig.h:578
top::TopConfig::softmuonAdditionalTruthInfo
virtual bool softmuonAdditionalTruthInfo() const
Definition: TopConfig.h:1224
top::TopConfig::m_sgKeyJets
std::string m_sgKeyJets
Definition: TopConfig.h:2368
top::TopConfig::photonPtcut
virtual float photonPtcut() const
Definition: TopConfig.h:1726
top::TopConfig::m_trigMatchElemRelink
bool m_trigMatchElemRelink
Definition: TopConfig.h:2819
top::TopConfig::sgKeyLargeRJetsTDSAux
const std::string & sgKeyLargeRJetsTDSAux(const std::size_t hash) const
Definition: TopConfig.cxx:3228
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
top::TopConfig::m_sgKeyTaus
std::string m_sgKeyTaus
Definition: TopConfig.h:2367
top::TopConfig::VarRCJetMassScale
virtual const std::string & VarRCJetMassScale() const
Definition: TopConfig.h:1442
top::TopConfig::m_outputFileBasketSizeVector
int m_outputFileBasketSizeVector
Definition: TopConfig.h:2840
SCT_ConditionsAlgorithms::CoveritySafe::getenv
std::string getenv(const std::string &variableName)
get an environment variable
Definition: SCT_ConditionsUtilities.cxx:17
top::TopConfig::RCInputJetPtMin
virtual float RCInputJetPtMin() const
Definition: TopConfig.h:1382
top::TopConfig::ttreeIndexLoose
unsigned int ttreeIndexLoose(const std::size_t hash) const
Definition: TopConfig.cxx:3380
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
top::TopConfig::setEleEleOverlapRemoval
void setEleEleOverlapRemoval()
Definition: TopConfig.h:287
top::TopPersistentSettings::m_systSgKeyMapPseudoTop
std::map< std::size_t, std::string > m_systSgKeyMapPseudoTop
Definition: TopPersistentSettings.h:98
top::TopConfig::muonBreakDownSystematics
virtual bool muonBreakDownSystematics()
Definition: TopConfig.h:1124
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
top::TopConfig::m_systMapMuons
std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > > m_systMapMuons
Definition: TopConfig.h:2871
top::TopConfig::bTag_base_names
std::unordered_map< std::string, std::set< std::string > > bTag_base_names
Definition: TopConfig.h:2715
DuplicateRemoval.h
top::TopConfig::muonTriggers_Loose
virtual void muonTriggers_Loose(std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)
Definition: TopConfig.h:502
top::TopConfig::setParticleLevelOverlapRemovalWithRapidity
void setParticleLevelOverlapRemovalWithRapidity(bool value)
Definition: TopConfig.h:420
top::TopConfig::m_sgKeyPrimaryVertices
std::string m_sgKeyPrimaryVertices
Definition: TopConfig.h:2361
top::TopConfig::sgKeyElectrons
virtual const std::string & sgKeyElectrons() const
Definition: TopConfig.h:577
top::TopConfig::softmuonDRJetcut
virtual float softmuonDRJetcut() const
Definition: TopConfig.h:1222
top::TopConfig::m_usePhotons
bool m_usePhotons
Definition: TopConfig.h:2195
Tokenize.h
top::TopPersistentSettings::m_useEgammaLeakageCorrection
bool m_useEgammaLeakageCorrection
Definition: TopPersistentSettings.h:65
top::TopPersistentSettings::m_muonIsolation
std::string m_muonIsolation
Definition: TopPersistentSettings.h:73
top::TopConfig::m_KLFitterTransferFunctionsPath
std::string m_KLFitterTransferFunctionsPath
Definition: TopConfig.h:2346
top::TopConfig::storePerJetBtagSFs
virtual const bool & storePerJetBtagSFs()
Definition: TopConfig.h:697
top::TopConfig::m_systMapJets
std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > > m_systMapJets
Definition: TopConfig.h:2874
top::TopConfig::systematicName
const std::string & systematicName(const std::size_t hash) const
Definition: TopConfig.cxx:3346
top::TopConfig::m_systHashTrackJets
std::shared_ptr< std::unordered_set< std::size_t > > m_systHashTrackJets
Definition: TopConfig.h:2858
top::TopConfig::m_sgKeyTruthMuons
std::string m_sgKeyTruthMuons
Definition: TopConfig.h:2379
top::TopConfig::m_isMC
bool m_isMC
Definition: TopConfig.h:2252
top::TopConfig::sgKeyTracksTDS
const std::string & sgKeyTracksTDS(const std::size_t hash) const
Definition: TopConfig.cxx:3268
top::TopConfig::sgKeyTruthLargeRJets
virtual const std::string & sgKeyTruthLargeRJets() const
Definition: TopConfig.h:597
top::TopConfig::muonUseLowPtLoose
virtual bool muonUseLowPtLoose() const
Definition: TopConfig.h:1111
top::TopConfig::electronIsolation
virtual const std::string & electronIsolation() const
Definition: TopConfig.h:875
top::TopConfig::sgKeyTruthMuons
const std::string & sgKeyTruthMuons() const
Definition: TopConfig.h:594
top::TopConfig::m_KLFitterBTaggingMethod
std::string m_KLFitterBTaggingMethod
Definition: TopConfig.h:2349
top::TopConfig::sgKeyElectronsStandAlone
virtual const std::string & sgKeyElectronsStandAlone(const std::size_t hash) const
Definition: TopConfig.cxx:2999
top::TopConfig::TopConfig
TopConfig()
m_tauJetID("SetMe"), m_tauJetIDBkg("SetMe"), m_tauEVetoID("SetMe"), m_tauVetoLArCrack(false),...
Definition: TopConfig.cxx:24
top::TopConfig::ghostTracksQuality
virtual const std::string & ghostTracksQuality() const
Definition: TopConfig.h:1281
top::remove_duplicates
void remove_duplicates(std::vector< T > &input)
Definition: DuplicateRemoval.h:15
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:569
top::TopConfig::doForwardJVTinMET
virtual bool doForwardJVTinMET() const
Definition: TopConfig.h:1575
top::TopPersistentSettings::m_isDataOverlay
bool m_isDataOverlay
Definition: TopPersistentSettings.h:36
top::TopConfig::tauJetIDWPLoose
const std::string & tauJetIDWPLoose() const
Definition: TopConfig.h:1684
top::TopConfig::electronID
virtual const std::string & electronID() const
Definition: TopConfig.h:869
top::TopConfig::useElectronChargeIDSelection
bool useElectronChargeIDSelection() const
Definition: TopConfig.h:882
top::TopConfig::m_doMultipleJES
bool m_doMultipleJES
Definition: TopConfig.h:2505
top::TopConfig::m_jetUncertainties_NPModel
std::string m_jetUncertainties_NPModel
Definition: TopConfig.h:2501
top::TopConfig::VarRCJetEtacut
virtual float VarRCJetEtacut() const
Definition: TopConfig.h:1438
top::TopConfig::systematicsMuons
virtual void systematicsMuons(const std::list< CP::SystematicSet > &syst)
Definition: TopConfig.cxx:2339
top::TopConfig::truth_photon_Isolation
virtual const std::string & truth_photon_Isolation() const
Definition: TopConfig.h:1841
top::TopConfig::m_systAllSgKeyMapMuonsTDS
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapMuonsTDS
Definition: TopConfig.h:2918
top::TopConfig::trackPtcut
virtual float trackPtcut() const
Definition: TopConfig.h:1374
EventInfoRead.isMC
isMC
Definition: EventInfoRead.py:11
top::TopConfig::muonUse2stationMuonsHighPtLoose
virtual bool muonUse2stationMuonsHighPtLoose() const
Definition: TopConfig.h:1112
top::TopConfig::electronTriggers_Loose
virtual void electronTriggers_Loose(std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > triggers)
Definition: TopConfig.h:495
top::TopConfig::m_sgKeyMCParticle
std::string m_sgKeyMCParticle
Definition: TopConfig.h:2376
top::TopConfig::electron_trigger_systematics
std::vector< std::string > electron_trigger_systematics
Definition: TopConfig.h:2789
top::TopPersistentSettings::m_isMC
bool m_isMC
Definition: TopPersistentSettings.h:34
top::TopConfig::useEgammaLeakageCorrection
bool useEgammaLeakageCorrection() const
Definition: TopConfig.h:883
top::TopConfig::m_photonTriggers_Tight
std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > m_photonTriggers_Tight
Definition: TopConfig.h:2810
top::TopPersistentSettings::m_systSgKeyMapJets
std::map< std::size_t, std::string > m_systSgKeyMapJets
Definition: TopPersistentSettings.h:89
top::TopConfig::m_isAFII
bool m_isAFII
Definition: TopConfig.h:2253
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
top::TopConfig::softmuonUseMVALowPt
virtual bool softmuonUseMVALowPt() const
Definition: TopConfig.h:1220
top::TopConfig::m_useTruthPhotons
bool m_useTruthPhotons
Definition: TopConfig.h:2223
top::TopConfig::m_muonIsolationWPs
std::vector< std::string > m_muonIsolationWPs
Definition: TopConfig.h:2470
top::TopConfig::truth_softmuon_EtaCut
virtual float truth_softmuon_EtaCut() const
Definition: TopConfig.h:1811
top::TopConfig::bTag_eigen_C
std::unordered_map< std::string, unsigned int > bTag_eigen_C
Definition: TopConfig.h:2724
top::TopConfig::m_systAllSgKeyMapJetsTDS
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapJetsTDS
Definition: TopConfig.h:2924
top::TopConfig::m_useEgammaLeakageCorrection
bool m_useEgammaLeakageCorrection
Definition: TopConfig.h:2434
top::TopPersistentSettings::m_systSgKeyMapMuons
std::map< std::size_t, std::string > m_systSgKeyMapMuons
Definition: TopPersistentSettings.h:86
calibdata.copy
bool copy
Definition: calibdata.py:27
top::TopConfig::electrondeltaz0cut
virtual float electrondeltaz0cut() const
Definition: TopConfig.h:874
top::TopConfig::getYear
const std::string & getYear()
Definition: TopConfig.h:2146
top::TopConfig::muonForceTrigger
std::string const & muonForceTrigger() const
Definition: TopConfig.h:1150
top::TopConfig::systematicsMET
virtual void systematicsMET(const std::list< CP::SystematicSet > &syst)
Definition: TopConfig.cxx:2420
top::TopPersistentSettings::m_sgKeyTaus
std::string m_sgKeyTaus
Definition: TopPersistentSettings.h:52
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:24
top::TopConfig::ghostTrackspT
virtual float ghostTrackspT() const
Definition: TopConfig.h:1279
top::TopConfig::setLargeJetOverlapRemoval
void setLargeJetOverlapRemoval()
Definition: TopConfig.h:278
top::TopConfig::m_useRCJetSubstructure
bool m_useRCJetSubstructure
Definition: TopConfig.h:2558
top::TopConfig::m_nominalWeightIndex
size_t m_nominalWeightIndex
Definition: TopConfig.h:2329
top::TopConfig::bTag_eigen_light_trkJet
std::unordered_map< std::string, unsigned int > bTag_eigen_light_trkJet
Definition: TopConfig.h:2728
top::TopConfig::electronEfficiencySystematicModel
virtual const std::string & electronEfficiencySystematicModel()
Definition: TopConfig.h:840
top::TopConfig::truth_muon_EtaCut
virtual float truth_muon_EtaCut() const
Definition: TopConfig.h:1793
top::TopConfig::m_systHashSoftMuons
std::shared_ptr< std::unordered_set< std::size_t > > m_systHashSoftMuons
Definition: TopConfig.h:2854
top::TopConfig::muonIsolationSFLoose
std::string const & muonIsolationSFLoose() const
Definition: TopConfig.h:1117
top::TopConfig::sgKeyPseudoTop
const std::string & sgKeyPseudoTop(const std::size_t hash) const
Definition: TopConfig.cxx:3316
top::TopConfig::getSystematicsList
bool getSystematicsList(const std::string &syst, std::set< std::string > &systList) const
Definition: TopConfig.cxx:2271
top::TopPersistentSettings::m_enablePromptLeptonImprovedVetoStudies
bool m_enablePromptLeptonImprovedVetoStudies
Definition: TopPersistentSettings.h:66
top::TopConfig::m_sgKeyTopSystematicEvents
std::string m_sgKeyTopSystematicEvents
Definition: TopConfig.h:2386
top::TopConfig::photonIdentificationLoose
const std::string & photonIdentificationLoose()
Definition: TopConfig.h:1738
top::TopPersistentSettings::m_list_systHashAll
std::vector< std::size_t > m_list_systHashAll
Definition: TopPersistentSettings.h:105
top::ConfigurationSettings
Hold the configuration information for the whole run.
Definition: ConfigurationSettings.h:21
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
top::TopConfig::m_outputEvents
std::string m_outputEvents
Definition: TopConfig.h:2833
top::TopConfig::bTag_named_systs
std::unordered_map< std::string, std::set< std::string > > bTag_named_systs
Definition: TopConfig.h:2718
top::TopConfig::m_btagging_calibration_C
std::string m_btagging_calibration_C
Definition: TopConfig.h:2705
top::TopConfig::m_applyElectronInJetSubtraction
bool m_applyElectronInJetSubtraction
Definition: TopConfig.h:2312
top::TopConfig::m_systMapSoftMuons
std::shared_ptr< std::unordered_map< std::size_t, CP::SystematicSet > > m_systMapSoftMuons
Definition: TopConfig.h:2872
top::TopConfig::outputFormat
virtual const std::string & outputFormat() const
Definition: TopConfig.h:2014
top::TopConfig::tauMuOLR
virtual bool tauMuOLR()
Definition: TopConfig.h:1696
top::TopConfig::muonIsolationLoose
virtual const std::string & muonIsolationLoose() const
Definition: TopConfig.h:1114
top::TopConfig::m_useTruthJets
bool m_useTruthJets
Definition: TopConfig.h:2224
top::TopConfig::largeRJetUncertaintiesConfigDir
virtual const std::string & largeRJetUncertaintiesConfigDir() const
Definition: TopConfig.h:1335
top::TopConfig::m_systSgKeyMapMissingET
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapMissingET
Definition: TopConfig.h:2941
top::TopConfig::setTopParticleLevel
void setTopParticleLevel(bool in)
Definition: TopConfig.h:392
top::TopPersistentSettings::m_isAFII
bool m_isAFII
Definition: TopPersistentSettings.h:35
top::TopConfig::systematicsJetGhostTrack
const std::vector< std::string > & systematicsJetGhostTrack() const
Definition: TopConfig.h:665
top::TopConfig::jetSubstructureName
virtual const std::string & jetSubstructureName() const
Definition: TopConfig.h:2078
top::TopConfig::muonForceYear
int muonForceYear() const
Definition: TopConfig.h:1138
top::TopConfig::saveFailJVTJets
virtual bool saveFailJVTJets() const
Definition: TopConfig.h:1564
top::TopConfig::m_useJets
bool m_useJets
Definition: TopConfig.h:2202
top::TopConfig::systematicsSoftMuons
virtual void systematicsSoftMuons(const std::list< CP::SystematicSet > &syst)
Definition: TopConfig.cxx:2352
top::TopConfig::m_systAllSgKeyMapFwdElectrons
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapFwdElectrons
Definition: TopConfig.h:2897
Trk::split
@ split
Definition: LayerMaterialProperties.h:38
top::TopConfig::tauJetIDWP
const std::string & tauJetIDWP() const
Definition: TopConfig.h:1680
top::TopConfig::METUncertaintiesConfigDir
virtual const std::string & METUncertaintiesConfigDir() const
Definition: TopConfig.h:1596
top::TopConfig::jetPtcut
virtual float jetPtcut() const
Definition: TopConfig.h:1276
top::TopConfig::m_jetPtGhostTracks
float m_jetPtGhostTracks
Definition: TopConfig.h:2499
top::TopConfig::m_muonSmearingSystematicModel
std::string m_muonSmearingSystematicModel
Definition: TopConfig.h:2474
top::TopConfig::sgKeyLargeRJets
virtual const std::string & sgKeyLargeRJets() const
Definition: TopConfig.h:583
top::TopConfig::m_KLFitterOutput
std::string m_KLFitterOutput
Definition: TopConfig.h:2347
top::TopPersistentSettings::m_tauTriggers_Tight
std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > m_tauTriggers_Tight
Definition: TopPersistentSettings.h:113
top::TopConfig::elTrigEffConfig
std::string const & elTrigEffConfig() const
Definition: TopConfig.h:886
top::TopConfig::m_photonTriggers_Loose
std::shared_ptr< std::unordered_map< std::string, std::vector< std::pair< std::string, int > > > > m_photonTriggers_Loose
Definition: TopConfig.h:2815
top::TopConfig::m_systSgKeyMapTracks
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systSgKeyMapTracks
Definition: TopConfig.h:2891
top::TopConfig::m_overlap_removal_procedure
std::string m_overlap_removal_procedure
Definition: TopConfig.h:2284
top::TopConfig::systematicsTracks
virtual void systematicsTracks(const std::list< CP::SystematicSet > &syst)
Definition: TopConfig.cxx:2460
top::TopPersistentSettings::m_systDecoKeyMapJetGhostTrack
std::map< std::size_t, std::string > m_systDecoKeyMapJetGhostTrack
Definition: TopPersistentSettings.h:102
top::TopConfig::electronIsolationSF
std::string const & electronIsolationSF() const
Definition: TopConfig.h:878
top::TopConfig::tauJetConfigFile
const std::string & tauJetConfigFile()
Definition: TopConfig.h:1704
top::TopConfig::setGlobalTriggerConfiguration
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 >)
Definition: TopConfig.cxx:3923
top::TopConfig::setMETJetSelectionWP
void setMETJetSelectionWP(const std::string &value)
Definition: TopConfig.h:1614
top::TopConfig::m_doLooseEvents
bool m_doLooseEvents
Definition: TopConfig.h:2299
top::TopConfig::m_useTruthElectrons
bool m_useTruthElectrons
Definition: TopConfig.h:2221
top::TopConfig::truth_electron_EtaCut
virtual float truth_electron_EtaCut() const
Definition: TopConfig.h:1775
top::TopConfig::sgKeyFwdElectronsTDS
const std::string & sgKeyFwdElectronsTDS(const std::size_t hash) const
Definition: TopConfig.cxx:3016
top::TopConfig::m_btagging_calibration_Light
std::string m_btagging_calibration_Light
Definition: TopConfig.h:2706
top::TopConfig::m_isDataOverlay
bool m_isDataOverlay
Definition: TopConfig.h:2254
top::TopConfig::RCJetRadius
virtual float RCJetRadius() const
Definition: TopConfig.h:1385
top::TopPersistentSettings::m_sgKeyTopSystematicEvents
std::string m_sgKeyTopSystematicEvents
Definition: TopPersistentSettings.h:42
top::TopPersistentSettings::m_sgKeyPrimaryVertices
std::string m_sgKeyPrimaryVertices
Definition: TopPersistentSettings.h:46
top::ConfigurationSettings::selections
const std::vector< SelectionConfigurationData > selections() const
Get all the data needed to configure the selections.
Definition: ConfigurationSettings.cxx:1001
top::TopConfig::m_egamma_calibration_model
std::string m_egamma_calibration_model
Definition: TopConfig.h:2710
top::TopConfig::m_systAllSgKeyMapTrackJets
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapTrackJets
Definition: TopConfig.h:2903
top::TopConfig::softmuonPtcut
virtual float softmuonPtcut() const
Definition: TopConfig.h:1217
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
top::TopConfig::m_systAllSgKeyMapTaus
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapTaus
Definition: TopConfig.h:2900
top::TopConfig::objectSelectionName
virtual const std::string & objectSelectionName() const
Definition: TopConfig.h:2006
top::TopPersistentSettings::m_applyElectronInJetSubtraction
bool m_applyElectronInJetSubtraction
Definition: TopPersistentSettings.h:37
top::TopConfig::m_systAllSgKeyMapMuonsTDSAux
std::shared_ptr< std::unordered_map< std::size_t, std::string > > m_systAllSgKeyMapMuonsTDSAux
Definition: TopConfig.h:2919
top::TopPersistentSettings::m_systSgKeyMapTrackJets
std::map< std::size_t, std::string > m_systSgKeyMapTrackJets
Definition: TopPersistentSettings.h:93
top::TopConfig::sgKeyJetsTDS
const std::string & sgKeyJetsTDS(const std::size_t hash, const bool useLooseLeptonJets) const
Definition: TopConfig.cxx:3144
top::TopConfig::tauEleIDWP
const std::string & tauEleIDWP() const
Definition: TopConfig.h:1688
Generated on Tue Jul 2 2024 21:29:29 for ATLAS Offline Software by   doxygen 1.8.18