ATLAS Offline Software
Functions | Variables
python.FullCPAlgorithmsTest Namespace Reference

Functions

def makeTestSequenceBlocks (dataType, algSeq, forCompare, isPhyslite, geometry=None, autoconfigFromFlags=None, noSystematics=None, onlyNominalOR=False, forceEGammaFullSimConfig=False, returnConfigSeq=False)
 
def printSequenceAlgs (sequence)
 
def makeSequence (dataType, forCompare, noSystematics, yamlPath=None, hardCuts=False, isPhyslite=False, geometry=None, autoconfigFromFlags=None, onlyNominalOR=False, forceEGammaFullSimConfig=False)
 

Variables

dictionary triggerChainsPerYear
 
list triggerChains
 
dictionary tauTriggerChainsSF
 
dictionary exampleSelectionCuts
 
int electronMinPt = 10*GeV
 
 electronMaxEta = None
 
int photonMinPt = 10*GeV
 
 photonMaxEta = None
 
 muonMinPt = None
 
 muonMaxEta = None
 
 tauMinPt = None
 
 tauMaxEta = None
 
 jetMinPt = None
 
 jetMaxEta = None
 

Function Documentation

◆ makeSequence()

def python.FullCPAlgorithmsTest.makeSequence (   dataType,
  forCompare,
  noSystematics,
  yamlPath = None,
  hardCuts = False,
  isPhyslite = False,
  geometry = None,
  autoconfigFromFlags = None,
  onlyNominalOR = False,
  forceEGammaFullSimConfig = False 
)

Definition at line 479 of file FullCPAlgorithmsTest.py.

479 def makeSequence (dataType, forCompare, noSystematics,
480  yamlPath=None,
481  hardCuts = False, isPhyslite = False, geometry = None,
482  autoconfigFromFlags = None, onlyNominalOR = False,
483  forceEGammaFullSimConfig = False) :
484 
485  # do some harder cuts on all object types, this is mostly used for
486  # benchmarking
487  if hardCuts :
488  global electronMinPt
489  electronMinPt = 27*GeV
490  global photonMinPt
491  photonMinPt = 27*GeV
492  global muonMinPt
493  muonMinPt = 27*GeV
494  global tauMinPt
495  tauMinPt = 27*GeV
496  global jetMinPt
497  jetMinPt = 45*GeV
498 
499  algSeq = AlgSequence('AnalysisSequence')
500 
501  ca = None
502  if not yamlPath:
503  ca = makeTestSequenceBlocks (dataType, algSeq, forCompare=forCompare,
504  isPhyslite=isPhyslite,
505  geometry=geometry, onlyNominalOR=onlyNominalOR,
506  autoconfigFromFlags=autoconfigFromFlags,
507  noSystematics=noSystematics,
508  forceEGammaFullSimConfig=forceEGammaFullSimConfig)
509  else:
510  from AnalysisAlgorithmsConfig.ConfigText import makeSequence as makeSequenceText
511  ca = makeSequenceText(yamlPath, dataType, algSeq, geometry=geometry,
512  isPhyslite=isPhyslite,
513  autoconfigFromFlags=autoconfigFromFlags,
514  noSystematics=noSystematics)
515 
516  if ca is not None:
517  return ca
518  else:
519  return algSeq

◆ makeTestSequenceBlocks()

def python.FullCPAlgorithmsTest.makeTestSequenceBlocks (   dataType,
  algSeq,
  forCompare,
  isPhyslite,
  geometry = None,
  autoconfigFromFlags = None,
  noSystematics = None,
  onlyNominalOR = False,
  forceEGammaFullSimConfig = False,
  returnConfigSeq = False 
)

Definition at line 68 of file FullCPAlgorithmsTest.py.

68 def makeTestSequenceBlocks (dataType, algSeq, forCompare, isPhyslite,
69  geometry=None, autoconfigFromFlags=None, noSystematics=None,
70  onlyNominalOR=False, forceEGammaFullSimConfig=False,
71  returnConfigSeq=False) :
72 
73  vars = []
74  metVars = []
75 
76  # it seems the right containers are in the test input files so far
77  largeRJets = False
78  # there are no track jets in PHYSLITE, or in the sequence configuration
79  trackJets = not isPhyslite and not forCompare
80 
81  if autoconfigFromFlags is not None:
82  if geometry is None:
83  geometry = autoconfigFromFlags.GeoModel.Run
84 
85  configSeq = ConfigSequence ()
86 
87  outputContainers = {'mu_' : 'OutMuons',
88  'el_' : 'OutElectrons',
89  'ph_' : 'OutPhotons',
90  'tau_': 'OutTauJets',
91  'jet_': 'OutJets',
92  'met_': 'AnaMET',
93  '' : 'EventInfo'}
94 
95  # create factory object to build block configurations
96  from AnalysisAlgorithmsConfig.ConfigFactory import ConfigFactory
97  config = ConfigFactory()
98 
99  configSeq += config.makeConfig('CommonServices')
100  configSeq.setOptionValue('.systematicsHistogram', 'systematicsList')
101  if forCompare:
102  configSeq.setOptionValue('.filterSystematics', "^(?:(?!PseudoData).)*$")
103 
104  configSeq += config.makeConfig('PileupReweighting')
105 
106  # Skip events with no primary vertex,
107  # and perform loose jet cleaning
108  configSeq += config.makeConfig ('EventCleaning')
109  configSeq.setOptionValue ('.runEventCleaning', True)
110 
111  # Include, and then set up the jet analysis algorithm sequence:
112  configSeq += config.makeConfig( 'Jets',
113  containerName='AnaJets',
114  jetCollection='AntiKt4EMPFlowJets')
115  configSeq.setOptionValue ('.runJvtUpdate', False )
116  configSeq.setOptionValue ('.runNNJvtUpdate', True )
117  if not forCompare :
118  configSeq.setOptionValue ('.recalibratePhyslite', False)
119 
120  configSeq += config.makeConfig( 'Jets.JVT',
121  containerName='AnaJets' )
122 
123  # disabling flavor tagging for Run 4, as the configuration just
124  # refuses to work on that
125  if geometry is not LHCPeriod.Run4:
126 
127  btagger = "GN2v01"
128  btagWP = "FixedCutBEff_65"
129  configSeq += config.makeConfig( 'Jets.FlavourTagging',
130  containerName='AnaJets',
131  selectionName='ftag' )
132  configSeq.setOptionValue ('.noEffSF', True)
133  configSeq.setOptionValue ('.btagger', btagger)
134  configSeq.setOptionValue ('.btagWP', btagWP)
135 
136  if not forCompare:
137  btagWP = "Continuous"
138  configSeq += config.makeConfig( 'Jets.FlavourTagging',
139  containerName='AnaJets')
140  configSeq.setOptionValue ('.btagger', btagger)
141  configSeq.setOptionValue ('.btagWP', btagWP)
142  configSeq.setOptionValue ('.saveScores', 'All')
143 
144  configSeq += config.makeConfig( 'Jets.FlavourTaggingEventSF',
145  containerName='AnaJets.baselineJvt')
146  configSeq.setOptionValue ('.btagger', btagger)
147  configSeq.setOptionValue ('.btagWP', btagWP)
148 
149  if largeRJets :
150  configSeq += config.makeConfig( 'Jets',
151  containerName='AnaLargeRJets',
152  jetCollection='AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets' )
153  outputContainers['larger_jet_'] = 'OutLargeRJets'
154  if not forCompare :
155  configSeq.setOptionValue ('.recalibratePhyslite', False)
156 
157  if trackJets :
158  configSeq += config.makeConfig( 'Jets',
159  containerName='AnaTrackJets',
160  jetCollection='AntiKtVR30Rmax4Rmin02PV0TrackJets' )
161  outputContainers['track_jet_'] = 'OutTrackJets'
162 
163  configSeq += config.makeConfig ('Jets.PtEtaSelection',
164  containerName='AnaJets')
165  configSeq.setOptionValue ('.selectionDecoration', 'selectPtEta')
166  configSeq.setOptionValue ('.minPt', jetMinPt)
167  configSeq.setOptionValue ('.maxEta', jetMaxEta)
168  if largeRJets :
169  configSeq += config.makeConfig ('Jets.PtEtaSelection',
170  containerName='AnaLargeRJets')
171  configSeq.setOptionValue ('.selectionDecoration', 'selectPtEta')
172  configSeq.setOptionValue ('.minPt', jetMinPt)
173  configSeq.setOptionValue ('.maxEta', jetMaxEta)
174  if trackJets :
175  configSeq += config.makeConfig ('Jets.PtEtaSelection',
176  containerName='AnaTrackJets')
177  configSeq.setOptionValue ('.selectionDecoration', 'selectPtEta')
178  configSeq.setOptionValue ('.minPt', jetMinPt)
179  configSeq.setOptionValue ('.maxEta', jetMaxEta)
180 
181 
182  # Include, and then set up the electron analysis algorithm sequence:
183  likelihood = True
184  configSeq += config.makeConfig ('Electrons',
185  containerName='AnaElectrons' )
186  configSeq.setOptionValue ('.forceFullSimConfig', forceEGammaFullSimConfig)
187  if not forCompare :
188  configSeq.setOptionValue ('.recalibratePhyslite', False)
189  configSeq += config.makeConfig ('Electrons.WorkingPoint',
190  containerName='AnaElectrons',
191  selectionName='loose')
192  configSeq.setOptionValue ('.forceFullSimConfig', forceEGammaFullSimConfig)
193  if forCompare :
194  configSeq.setOptionValue ('.noEffSF', True)
195  else:
196  configSeq.setOptionValue ('.noEffSF', geometry is LHCPeriod.Run2)
197  if likelihood:
198  configSeq.setOptionValue ('.identificationWP', 'LooseBLayerLH')
199  else:
200  configSeq.setOptionValue ('.identificationWP', 'LooseDNN')
201  configSeq.setOptionValue ('.isolationWP', 'Loose_VarRad')
202  configSeq.setOptionValue ('.writeTrackD0Z0', True)
203 
204  configSeq += config.makeConfig ('Electrons.PtEtaSelection',
205  containerName='AnaElectrons')
206  configSeq.setOptionValue ('.selectionDecoration', 'selectPtEta')
207  configSeq.setOptionValue ('.minPt', electronMinPt)
208  configSeq.setOptionValue ('.maxEta', electronMaxEta)
209 
210 
211  # Include, and then set up the photon analysis algorithm sequence:
212  configSeq += config.makeConfig ('Photons',
213  containerName='AnaPhotons' )
214  configSeq.setOptionValue ('.forceFullSimConfig', forceEGammaFullSimConfig)
215  configSeq.setOptionValue ('.recomputeIsEM', False)
216  if not forCompare :
217  configSeq.setOptionValue ('.recalibratePhyslite', False)
218  configSeq += config.makeConfig ('Photons.WorkingPoint',
219  containerName='AnaPhotons',
220  selectionName='tight')
221  configSeq.setOptionValue ('.forceFullSimConfig', forceEGammaFullSimConfig)
222  if forCompare :
223  configSeq.setOptionValue ('.noEffSF', True)
224  configSeq.setOptionValue ('.qualityWP', 'Tight')
225  configSeq.setOptionValue ('.isolationWP', 'FixedCutTight')
226  configSeq.setOptionValue ('.recomputeIsEM', False)
227 
228  configSeq += config.makeConfig ('Photons.PtEtaSelection',
229  containerName='AnaPhotons')
230  configSeq.setOptionValue ('.selectionDecoration', 'selectPtEta')
231  configSeq.setOptionValue ('.minPt', photonMinPt)
232  configSeq.setOptionValue ('.maxEta', photonMaxEta)
233 
234 
235  # set up the muon analysis algorithm sequence:
236  configSeq += config.makeConfig ('Muons',
237  containerName='AnaMuons')
238  if not forCompare :
239  configSeq.setOptionValue ('.recalibratePhyslite', False)
240  configSeq += config.makeConfig ('Muons.WorkingPoint',
241  containerName='AnaMuons',
242  selectionName='medium')
243  configSeq.setOptionValue ('.quality', 'Medium')
244  configSeq.setOptionValue ('.isolation', 'Loose_VarRad')
245  if forCompare :
246  configSeq.setOptionValue ('.onlyRecoEffSF', True)
247  configSeq.setOptionValue ('.writeTrackD0Z0', True)
248 
249  # TODO: MCP should restore this when the recommendations for Tight WP exist in R23
250  # configSeq += config.makeConfig ('Muons.Selection', 'AnaMuons.tight')
251  # configSeq.setOptionValue ('.quality', 'Tight')
252  # configSeq.setOptionValue ('.isolation', 'Loose_VarRad')
253 
254  configSeq += config.makeConfig ('Muons.PtEtaSelection',
255  containerName='AnaMuons')
256  configSeq.setOptionValue ('.selectionDecoration', 'selectPtEta')
257  configSeq.setOptionValue ('.minPt', muonMinPt)
258  configSeq.setOptionValue ('.maxEta', muonMaxEta)
259 
260  # Include, and then set up the tau analysis algorithm sequence:
261  configSeq += config.makeConfig ('TauJets',
262  containerName='AnaTauJets')
263  configSeq += config.makeConfig ('TauJets.WorkingPoint',
264  containerName='AnaTauJets',
265  selectionName='tight')
266  configSeq.setOptionValue ('.quality', 'Tight')
267 
268  if not forCompare:
269  configSeq += config.makeConfig('TauJets.TriggerSF')
270  configSeq.setOptionValue('.containerName', 'AnaTauJets')
271  configSeq.setOptionValue('.tauID', 'Tight')
272  configSeq.setOptionValue('.triggerChainsPerYear', tauTriggerChainsSF)
273 
274  configSeq += config.makeConfig ('TauJets.PtEtaSelection',
275  containerName='AnaTauJets')
276  configSeq.setOptionValue ('.selectionDecoration', 'selectPtEta')
277  configSeq.setOptionValue ('.minPt', tauMinPt)
278  configSeq.setOptionValue ('.maxEta', tauMaxEta)
279 
280 
281  # Add systematic object links
282  configSeq += config.makeConfig('SystObjectLink', containerName='AnaJets')
283  if largeRJets:
284  configSeq += config.makeConfig('SystObjectLink', containerName='AnaLargeRJets')
285  if trackJets:
286  configSeq += config.makeConfig('SystObjectLink', containerName='AnaTrackJets')
287  configSeq += config.makeConfig('SystObjectLink', containerName='AnaElectrons')
288  configSeq += config.makeConfig('SystObjectLink', containerName='AnaPhotons')
289  configSeq += config.makeConfig('SystObjectLink', containerName='AnaMuons')
290  configSeq += config.makeConfig('SystObjectLink', containerName='AnaTauJets')
291 
292 
293  if dataType is not DataType.Data :
294  # Include, and then set up the generator analysis sequence:
295  configSeq += config.makeConfig( 'GeneratorLevelAnalysis')
296  configSeq.setOptionValue ('.saveCutBookkeepers', True)
297  configSeq.setOptionValue ('.runNumber', 284500)
298  configSeq.setOptionValue ('.cutBookkeepersSystematics', True)
299 
300 
301  # Include, and then set up the met analysis algorithm config:
302  configSeq += config.makeConfig ('MissingET',
303  containerName='AnaMET')
304  configSeq.setOptionValue ('.jets', 'AnaJets')
305  configSeq.setOptionValue ('.taus', 'AnaTauJets.tight')
306  configSeq.setOptionValue ('.electrons', 'AnaElectrons.loose')
307  configSeq.setOptionValue ('.photons', 'AnaPhotons.tight')
308  # Note that the configuration for the muons is not what you'd
309  # normally do. This is specifically here because this is a unit
310  # test and I wanted to make sure that selection expressions work.
311  # For an actual analysis that would just be `AnaMuons.medium`, but
312  # since `tight` is a strict subset of `medium` it doesn't matter
313  # if we do an "or" of the two.
314  # TODO: MCP should restore this when the recommendations for Tight WP exist in R23
315  # configSeq.setOptionValue ('.muons', 'AnaMuons.medium||tight')
316  configSeq.setOptionValue ('.muons', 'AnaMuons.medium')
317 
318 
319  # Include, and then set up the overlap analysis algorithm config:
320  configSeq += config.makeConfig( 'OverlapRemoval' )
321  configSeq.setOptionValue ('.electrons', 'AnaElectrons.loose')
322  configSeq.setOptionValue ('.photons', 'AnaPhotons.tight')
323  # TODO: MCP should restore this when the recommendations for Tight WP exist in R23
324  # configSeq.setOptionValue ('.muons', 'AnaMuons.medium||tight')
325  configSeq.setOptionValue ('.muons', 'AnaMuons.medium')
326  configSeq.setOptionValue ('.jets', 'AnaJets')
327  configSeq.setOptionValue ('.taus', 'AnaTauJets.tight')
328  configSeq.setOptionValue ('.inputLabel', 'preselectOR')
329  configSeq.setOptionValue ('.outputLabel', 'passesOR' )
330  configSeq.setOptionValue ('.nominalOnly', onlyNominalOR )
331  if not forCompare :
332  # ask to be added to the baseline selection for all objects, and to
333  # provide a preselection for the objects in subsequent algorithms
334  configSeq.setOptionValue ('.addToAllSelections', True)
335  configSeq.setOptionValue ('.addPreselection', True)
336 
337  # Include and set up a basic run of the event selection algorithm config:
338  if not forCompare and geometry is not LHCPeriod.Run4:
339  # configSeq += config.makeConfig( 'EventSelection', None )
340  # configSeq.setOptionValue ('.electrons', 'AnaElectrons.loose')
341  # configSeq.setOptionValue ('.muons', 'AnaMuons.medium')
342  # configSeq.setOptionValue ('.jets', 'AnaJets')
343  # configSeq.setOptionValue ('.met', 'AnaMET')
344  # configSeq.setOptionValue ('.selectionCutsDict', exampleSelectionCuts)
345  from EventSelectionAlgorithms.EventSelectionConfig import makeMultipleEventSelectionConfigs
346  makeMultipleEventSelectionConfigs(configSeq, electrons = 'AnaElectrons.loose', muons = 'AnaMuons.medium', jets = 'AnaJets',
347  met = 'AnaMET', btagDecoration = 'ftag_select_ftag',
348  selectionCutsDict = exampleSelectionCuts, noFilter = True)
349 
350 
351  # ObjectCutFlow blocks
352  configSeq += config.makeConfig ('ObjectCutFlow',
353  containerName='AnaJets',
354  selectionName='jvt')
355  configSeq += config.makeConfig ('ObjectCutFlow',
356  containerName='AnaElectrons',
357  selectionName='loose')
358  configSeq += config.makeConfig ('ObjectCutFlow',
359  containerName='AnaPhotons',
360  selectionName='tight')
361  configSeq += config.makeConfig ('ObjectCutFlow',
362  containerName='AnaMuons',
363  selectionName='medium')
364  configSeq += config.makeConfig ('ObjectCutFlow',
365  containerName='AnaTauJets',
366  selectionName='tight')
367 
368 
369  # Thinning blocks
370  configSeq += config.makeConfig ('Thinning',
371  containerName='AnaElectrons')
372  configSeq.setOptionValue ('.selectionName', 'loose')
373  configSeq.setOptionValue ('.outputName', 'OutElectrons')
374  configSeq += config.makeConfig ('Thinning',
375  containerName='AnaPhotons')
376  configSeq.setOptionValue ('.selectionName', 'tight')
377  configSeq.setOptionValue ('.outputName', 'OutPhotons')
378  configSeq += config.makeConfig ('Thinning',
379  containerName='AnaMuons')
380  configSeq.setOptionValue ('.selectionName', 'medium')
381  configSeq.setOptionValue ('.outputName', 'OutMuons')
382  configSeq += config.makeConfig ('Thinning',
383  containerName='AnaTauJets')
384  configSeq.setOptionValue ('.selectionName', 'tight')
385  configSeq.setOptionValue ('.outputName', 'OutTauJets')
386  configSeq += config.makeConfig ('Thinning',
387  containerName='AnaJets')
388  configSeq.setOptionValue ('.outputName', 'OutJets')
389  if largeRJets :
390  configSeq += config.makeConfig ('Thinning',
391  containerName='AnaLargeRJets')
392  configSeq.setOptionValue ('.outputName', 'OutLargeRJets')
393  if trackJets :
394  configSeq += config.makeConfig ('Thinning',
395  containerName='AnaTrackJets')
396  configSeq.setOptionValue ('.outputName', 'OutTrackJets')
397 
398  # disabling comparisons for triggers, because the config blocks do a
399  # lot more than the sequences. Also disabling for Run 3+4, as there is no SF yet
400  if not forCompare and geometry is LHCPeriod.Run2:
401  # Include, and then set up the trigger analysis sequence:
402  configSeq += config.makeConfig( 'Trigger' )
403  configSeq.setOptionValue ('.triggerChainsPerYear', triggerChainsPerYear )
404  configSeq.setOptionValue ('.noFilter', True )
405  configSeq.setOptionValue ('.electronID', 'Tight' )
406  configSeq.setOptionValue ('.electronIsol', 'Tight_VarRad')
407  configSeq.setOptionValue ('.photonIsol', 'TightCaloOnly')
408  configSeq.setOptionValue ('.muonID', 'Tight')
409  configSeq.setOptionValue ('.electrons', 'AnaElectrons' )
410  configSeq.setOptionValue ('.photons', 'AnaPhotons' )
411  configSeq.setOptionValue ('.muons', 'AnaMuons' )
412  configSeq.setOptionValue ('.taus', 'AnaTauJets' )
413  configSeq.setOptionValue ('.triggerMatchingChainsPerYear', triggerChainsPerYear)
414 
415  if not forCompare:
416  configSeq += config.makeConfig ('Bootstraps')
417  configSeq.setOptionValue ('.nReplicas', 2000 )
418  configSeq.setOptionValue ('.skipOnMC', False)
419 
420  # per-event lepton SF
421  if not forCompare:
422  configSeq += config.makeConfig ('LeptonSF')
423  if geometry is not LHCPeriod.Run2:
424  configSeq.setOptionValue ('.electrons', 'AnaElectrons.loose')
425  configSeq.setOptionValue ('.muons', 'AnaMuons.medium')
426  configSeq.setOptionValue ('.photons', 'AnaPhotons.tight')
427  configSeq.setOptionValue ('.lepton_postfix', 'nominal')
428 
429  configSeq += config.makeConfig ('Output')
430  configSeq.setOptionValue ('.treeName', 'analysis')
431  configSeq.setOptionValue ('.vars', vars)
432  configSeq.setOptionValue ('.metVars', metVars)
433  configSeq.setOptionValue ('.containers', outputContainers)
434  disable_commands = []
435  if forCompare:
436  disable_commands += [
437  'disable jet_select_baselineJvt.*',
438  'disable mu_select_medium.*',
439  'disable el_select_loose.*',
440  'disable ph_select_tight.*',
441  'disable tau_select_tight.*',
442  ]
443  configSeq.setOptionValue ('.commands', disable_commands)
444 
445  # return configSeq for unit test
446  if returnConfigSeq:
447  return configSeq
448 
449  configAccumulator = ConfigAccumulator (algSeq, dataType, isPhyslite, geometry, autoconfigFromFlags=autoconfigFromFlags, noSystematics=noSystematics)
450  configSeq.fullConfigure (configAccumulator)
451 
452  # order can change during fullConfigure
453  configSeq.printOptions()
454 
455  from AnaAlgorithm.DualUseConfig import isAthena, useComponentAccumulator
456  if isAthena and useComponentAccumulator:
457  return configAccumulator.CA
458  else:
459  return None
460 
461 
462 

◆ printSequenceAlgs()

def python.FullCPAlgorithmsTest.printSequenceAlgs (   sequence)
print the algorithms in the sequence without the sequence structure

This is mostly meant for easy comparison of different sequences
during configuration, particularly the sequences resulting from
the old sequence configuration and the new block configuration.
Those have different sequence structures in the output, but the
algorithms should essentially be configured the same way.

Definition at line 463 of file FullCPAlgorithmsTest.py.

463 def printSequenceAlgs (sequence) :
464  """print the algorithms in the sequence without the sequence structure
465 
466  This is mostly meant for easy comparison of different sequences
467  during configuration, particularly the sequences resulting from
468  the old sequence configuration and the new block configuration.
469  Those have different sequence structures in the output, but the
470  algorithms should essentially be configured the same way."""
471  if isinstance (sequence, AlgSequence) :
472  for alg in sequence :
473  printSequenceAlgs (alg)
474  else :
475  # assume this is an algorithm then
476  print (sequence)
477 
478 

Variable Documentation

◆ electronMaxEta

python.FullCPAlgorithmsTest.electronMaxEta = None

Definition at line 57 of file FullCPAlgorithmsTest.py.

◆ electronMinPt

int python.FullCPAlgorithmsTest.electronMinPt = 10*GeV

Definition at line 56 of file FullCPAlgorithmsTest.py.

◆ exampleSelectionCuts

dictionary python.FullCPAlgorithmsTest.exampleSelectionCuts
Initial value:
1 = {
2  'SUBcommon': ,
3  'ejets': ,
4  'mujets':
5 }

Definition at line 33 of file FullCPAlgorithmsTest.py.

◆ jetMaxEta

python.FullCPAlgorithmsTest.jetMaxEta = None

Definition at line 65 of file FullCPAlgorithmsTest.py.

◆ jetMinPt

python.FullCPAlgorithmsTest.jetMinPt = None

Definition at line 64 of file FullCPAlgorithmsTest.py.

◆ muonMaxEta

python.FullCPAlgorithmsTest.muonMaxEta = None

Definition at line 61 of file FullCPAlgorithmsTest.py.

◆ muonMinPt

python.FullCPAlgorithmsTest.muonMinPt = None

Definition at line 60 of file FullCPAlgorithmsTest.py.

◆ photonMaxEta

python.FullCPAlgorithmsTest.photonMaxEta = None

Definition at line 59 of file FullCPAlgorithmsTest.py.

◆ photonMinPt

int python.FullCPAlgorithmsTest.photonMinPt = 10*GeV

Definition at line 58 of file FullCPAlgorithmsTest.py.

◆ tauMaxEta

python.FullCPAlgorithmsTest.tauMaxEta = None

Definition at line 63 of file FullCPAlgorithmsTest.py.

◆ tauMinPt

python.FullCPAlgorithmsTest.tauMinPt = None

Definition at line 62 of file FullCPAlgorithmsTest.py.

◆ tauTriggerChainsSF

dictionary python.FullCPAlgorithmsTest.tauTriggerChainsSF
Initial value:
1 = {
2  '2015': ['HLT_tau25_medium1_tracktwo', 'HLT_tau35_medium1_tracktwo'],
3  '2016': ['HLT_tau25_medium1_tracktwo', 'HLT_tau35_medium1_tracktwo'],
4  '2017': ['HLT_tau25_medium1_tracktwo', 'HLT_tau35_medium1_tracktwo'],
5  '2018': ['HLT_tau25_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA', 'HLT_tau35_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA'],
6 }

Definition at line 25 of file FullCPAlgorithmsTest.py.

◆ triggerChains

list python.FullCPAlgorithmsTest.triggerChains
Initial value:
1 = [
2  'HLT_2mu14',
3  'HLT_mu20_mu8noL1',
4  'HLT_2e17_lhvloose_nod0'
5 ]

Definition at line 20 of file FullCPAlgorithmsTest.py.

◆ triggerChainsPerYear

dictionary python.FullCPAlgorithmsTest.triggerChainsPerYear
Initial value:
1 = {
2  '2015': ['HLT_e24_lhmedium_L1EM20VH || HLT_e60_lhmedium || HLT_e120_lhloose', 'HLT_mu20_iloose_L1MU15 || HLT_mu40', 'HLT_2g20_tight'],
3  '2016': ['HLT_e26_lhtight_nod0_ivarloose || HLT_e60_lhmedium_nod0 || HLT_e140_lhloose_nod0', 'HLT_mu26_ivarmedium || HLT_mu50', 'HLT_g35_loose_g25_loose'],
4  '2017': ['HLT_e26_lhtight_nod0_ivarloose || HLT_e60_lhmedium_nod0 || HLT_e140_lhloose_nod0', 'HLT_2g22_tight_L12EM15VHI', 'HLT_mu50'],
5  '2018': ['HLT_e26_lhtight_nod0_ivarloose || HLT_e60_lhmedium_nod0 || HLT_e140_lhloose_nod0', 'HLT_g35_medium_g25_medium_L12EM20VH', 'HLT_mu26_ivarmedium', 'HLT_2mu14'],
6  '2022': ['HLT_e26_lhtight_ivarloose_L1EM22VHI || HLT_e60_lhmedium_L1EM22VHI || HLT_e140_lhloose_L1EM22VHI'],
7  '2023': ['HLT_e26_lhtight_ivarloose_L1EM22VHI || HLT_e60_lhmedium_L1EM22VHI || HLT_e140_lhloose_L1EM22VHI'],
8 }

Definition at line 12 of file FullCPAlgorithmsTest.py.

python.AlgSequence.AlgSequence
AlgSequence
Definition: PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py:7
python.EventSelectionConfig.makeMultipleEventSelectionConfigs
def makeMultipleEventSelectionConfigs(seq, electrons=None, muons=None, jets=None, largeRjets=None, photons=None, taus=None, met=None, metTerm=None, btagDecoration=None, preselection=None, selectionCutsDict=None, noFilter=None, debugMode=None, cutFlowHistograms=None)
Definition: EventSelectionConfig.py:872
python.FullCPAlgorithmsTest.makeSequence
def makeSequence(dataType, forCompare, noSystematics, yamlPath=None, hardCuts=False, isPhyslite=False, geometry=None, autoconfigFromFlags=None, onlyNominalOR=False, forceEGammaFullSimConfig=False)
Definition: FullCPAlgorithmsTest.py:479
python.FullCPAlgorithmsTest.printSequenceAlgs
def printSequenceAlgs(sequence)
Definition: FullCPAlgorithmsTest.py:463
python.FullCPAlgorithmsTest.makeTestSequenceBlocks
def makeTestSequenceBlocks(dataType, algSeq, forCompare, isPhyslite, geometry=None, autoconfigFromFlags=None, noSystematics=None, onlyNominalOR=False, forceEGammaFullSimConfig=False, returnConfigSeq=False)
Definition: FullCPAlgorithmsTest.py:68