ATLAS Offline Software
Functions
python.EGAM11 Namespace Reference

Functions

def EGAM11SkimmingToolCfg (flags)
 
def EGAM11ZeeMassTool1Cfg (flags)
 
def EGAM11ZeeMassTool2Cfg (flags)
 
def EGAM11ZeeMassTool3Cfg (flags)
 
def EGAM11ZegMassToolCfg (flags)
 
def EGAM11KernelCfg (flags, name="EGAM11Kernel", **kwargs)
 
def EGAM11Cfg (flags)
 

Function Documentation

◆ EGAM11Cfg()

def python.EGAM11.EGAM11Cfg (   flags)

Definition at line 571 of file EGAM11.py.

571 def EGAM11Cfg(flags):
572  acc = ComponentAccumulator()
573 
574  # configure skimming/thinning/augmentation tools
575  acc.merge(
577  flags,
578  name="EGAM11Kernel",
579  StreamName="StreamDAOD_EGAM11",
580  TriggerListsHelper=None,
581  )
582  )
583 
584  # configure slimming
585  from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
586  from xAODMetaDataCnv.InfileMetaDataConfig import SetupMetaDataForStreamCfg
587  from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
588 
589  EGAM11SlimmingHelper = SlimmingHelper(
590  "EGAM11SlimmingHelper",
591  NamesAndTypes=flags.Input.TypedCollections,
592  flags=flags,
593  )
594 
595  # ------------------------------------------
596  # containers for which we save all variables
597  # -------------------------------------------
598 
599  # baseline
600  EGAM11SlimmingHelper.AllVariables = [
601  "Electrons",
602  "GSFTrackParticles",
603  "egammaClusters",
604  "CaloCalTopoClusters",
605  ]
606 
607  # on MC we also add:
608  if flags.Input.isMC:
609  EGAM11SlimmingHelper.AllVariables += [
610  "TruthEvents",
611  "TruthParticles",
612  "TruthVertices",
613  "egammaTruthParticles",
614  ]
615 
616  # -------------------------------------------
617  # containers that we slim
618  # -------------------------------------------
619 
620  # first add variables from smart-slimming
621  # adding only also those for which we add all variables since
622  # the XXXCPContent.py files also bring in some extra variables
623  # for other collections
624  EGAM11SlimmingHelper.SmartCollections = [
625  "Electrons",
626  "Photons",
627  "Muons",
628  "TauJets",
629  "PrimaryVertices",
630  "InDetTrackParticles",
631  "AntiKt4EMTopoJets",
632  ]
633  if flags.Input.isMC:
634  EGAM11SlimmingHelper.SmartCollections += [
635  "AntiKt4TruthJets",
636  "AntiKt4TruthDressedWZJets",
637  ]
638 
639  # then add extra variables:
640 
641  # muons
642  EGAM11SlimmingHelper.ExtraVariables += [
643  "Muons.ptcone20.ptcone30.ptcone40.etcone20.etcone30.etcone40"
644  ]
645 
646  # conversion vertices
647  EGAM11SlimmingHelper.ExtraVariables += [
648  "GSFConversionVertices.x.y.z.px.py.pz.pt1.pt2.etaAtCalo.phiAtCalo",
649  "GSFConversionVertices.trackParticleLinks",
650  ]
651 
652  # primary vertices
653  EGAM11SlimmingHelper.ExtraVariables += ["PrimaryVertices.sumPt2"]
654 
655  # track jets
656  EGAM11SlimmingHelper.ExtraVariables += [
657  "AntiKt4PV0TrackJets.pt.eta.phi.e.m.btaggingLink.constituentLinks"
658  ]
659 
660  # energy density
661  EGAM11SlimmingHelper.ExtraVariables += [
662  "TopoClusterIsoCentralEventShape.Density",
663  "TopoClusterIsoForwardEventShape.Density",
664  ]
665 
666  # photons: detailed shower shape variables
667  EGAM11SlimmingHelper.ExtraVariables += PhotonsCPDetailedContent
668 
669  # truth
670  if flags.Input.isMC:
671  EGAM11SlimmingHelper.ExtraVariables += [
672  "MuonTruthParticles.e.px.py.pz.status.pdgId.truthOrigin.truthType"
673  ]
674 
675  EGAM11SlimmingHelper.ExtraVariables += [
676  "Photons.truthOrigin.truthType.truthParticleLink"
677  ]
678 
679  # Add event info
680  if flags.Derivation.Egamma.doEventInfoSlimming:
681  EGAM11SlimmingHelper.SmartCollections.append("EventInfo")
682  else:
683  EGAM11SlimmingHelper.AllVariables += ["EventInfo"]
684 
685  # Add HIEventShape and CaloSums variables for heavy ions
686  EGAM11SlimmingHelper.AllVariables += ["HIEventShape"]
687  EGAM11SlimmingHelper.AllVariables += ["CaloSums"]
688 
689  # Add full CellContainer
690  EGAM11SlimmingHelper.StaticContent = [
691  "CaloCellContainer#AllCalo",
692  "CaloClusterCellLinkContainer#egammaClusters_links",
693  ]
694 
695  EGAM11ItemList = EGAM11SlimmingHelper.GetItemList()
696  acc.merge(
698  flags,
699  "DAOD_EGAM11",
700  ItemList=EGAM11ItemList,
701  AcceptAlgs=["EGAM11Kernel"],
702  )
703  )
704  acc.merge(
706  flags,
707  "DAOD_EGAM11",
708  AcceptAlgs=["EGAM11Kernel"],
709  createMetadata=[
710  MetadataCategory.CutFlowMetaData,
711  MetadataCategory.TruthMetaData,
712  ],
713  )
714  )
715 
716  return acc

◆ EGAM11KernelCfg()

def python.EGAM11.EGAM11KernelCfg (   flags,
  name = "EGAM11Kernel",
**  kwargs 
)
Configure the derivation framework driving algorithm (kernel)
for EGAM11

Definition at line 204 of file EGAM11.py.

204 def EGAM11KernelCfg(flags, name="EGAM11Kernel", **kwargs):
205  """Configure the derivation framework driving algorithm (kernel)
206  for EGAM11"""
207  acc = ComponentAccumulator()
208 
209  # Schedule extra jets collections
210  from JetRecConfig.StandardSmallRJets import AntiKt4PV0Track, AntiKt4EMTopo
211  from JetRecConfig.JetRecConfig import JetRecCfg
212 
213  jetList = [AntiKt4PV0Track, AntiKt4EMTopo]
214  for jd in jetList:
215  acc.merge(JetRecCfg(flags, jd))
216 
217  # Common augmentations
218  # cannot use PhysCommon sequence because
219  # - no triggers
220  # - no TauJets
221  # so we have to use a modified version here
222  from DerivationFrameworkInDet.InDetCommonConfig import InDetCommonCfg
223  from DerivationFrameworkMuons.MuonsCommonConfig import MuonsCommonCfg
224  from DerivationFrameworkEGamma.EGammaCommonConfig import EGammaCommonCfg
225 
226  TrackingFlags = flags.Tracking
227  acc.merge(
229  flags,
230  DoVertexFinding=TrackingFlags.doVertexFinding,
231  AddPseudoTracks=TrackingFlags.doPseudoTracking,
232  DecoLRTTTVA=False,
233  DoR3LargeD0=flags.Tracking.doLargeD0,
234  StoreSeparateLargeD0Container=TrackingFlags.storeSeparateLargeD0Container,
235  MergeLRT=False,
236  )
237  )
238  acc.merge(MuonsCommonCfg(flags))
239  acc.merge(EGammaCommonCfg(flags))
240 
241  # jet cleaning
242  # standard way in PhysCommon is
243  # - calculate tau ID (needed for default jet OR)
244  # - decorate jets with overlap removal
245  # - do event cleaning
246  # but taus are missing in HI derivations so need to do differently
247 
248  # Decorate if jet passed JVT criteria
249  from JetJvtEfficiency.JetJvtEfficiencyToolConfig import getJvtEffToolCfg
250 
251  algName = "DFJet_EventCleaning_passJvtAlg"
252  passJvtTool = acc.popToolsAndMerge(getJvtEffToolCfg(flags, "AntiKt4EMTopo"))
253  passJvtTool.PassJVTKey = "AntiKt4EMTopoJets.DFCommonJets_passJvt"
254  acc.addEventAlgo(
255  CompFactory.JetDecorationAlg(
256  algName, JetContainer="AntiKt4EMTopoJets", Decorators=[passJvtTool]
257  )
258  )
259 
260  # Decorate if jet passes OR and save decoration DFCommonJets_passOR
261  # Use modified OR that does not check overlaps with tauls
262  from AssociationUtils.AssociationUtilsConfig import OverlapRemovalToolCfg
263 
264  outputLabel = "DFCommonJets_passOR"
265  bJetLabel = "" # default
266  tauLabel = "" # workaround for missing taus
267  tauKey = "" # workaround for missing taus
268  orTool = acc.popToolsAndMerge(
270  flags, outputLabel=outputLabel, bJetLabel=bJetLabel, doTaus=False
271  )
272  )
273  algOR = CompFactory.OverlapRemovalGenUseAlg(
274  "OverlapRemovalGenUseAlg",
275  OverlapLabel=outputLabel,
276  OverlapRemovalTool=orTool,
277  TauKey=tauKey,
278  TauLabel=tauLabel,
279  BJetLabel=bJetLabel,
280  )
281  acc.addEventAlgo(algOR)
282 
283  # Do the cleaning
284  from JetSelectorTools.JetSelectorToolsConfig import (
285  EventCleaningToolCfg,
286  JetCleaningToolCfg,
287  )
288 
289  workingPoints = ["Loose"]
290  prefix = "DFCommonJets_"
291 
292  for wp in workingPoints:
293  cleaningLevel = wp + "Bad"
294  # LLP WPs have a slightly different name format
295  if "LLP" in wp:
296  cleaningLevel = wp.replace("LLP", "BadLLP")
297 
298  jetCleaningTool = acc.popToolsAndMerge(
300  flags,
301  "JetCleaningTool_" + cleaningLevel,
302  "AntiKt4EMTopoJets",
303  cleaningLevel,
304  False,
305  )
306  )
307  acc.addPublicTool(jetCleaningTool)
308 
309  ecTool = acc.popToolsAndMerge(
310  EventCleaningToolCfg(flags, "EventCleaningTool_" + wp, cleaningLevel)
311  )
312  ecTool.JetCleanPrefix = prefix
313  ecTool.JetContainer = "AntiKt4EMTopoJets"
314  ecTool.JetCleaningTool = jetCleaningTool
315  acc.addPublicTool(ecTool)
316 
317  # Alg to calculate event-level and jet-level cleaning variables
318  # Only store event-level flags for Loose* WPs
319  eventCleanAlg = CompFactory.EventCleaningTestAlg(
320  "EventCleaningTestAlg_" + wp,
321  EventCleaningTool=ecTool,
322  JetCollectionName="AntiKt4EMTopoJets",
323  EventCleanPrefix=prefix,
324  CleaningLevel=cleaningLevel,
325  doEvent=("Loose" in wp),
326  )
327  acc.addEventAlgo(eventCleanAlg)
328 
329  # EGAM11 augmentations
330  augmentationTools = []
331 
332  # ====================================================================
333  # ee and egamma invariant masses
334  # ====================================================================
335  EGAM11ZeeMassTool1 = acc.popToolsAndMerge(EGAM11ZeeMassTool1Cfg(flags))
336  acc.addPublicTool(EGAM11ZeeMassTool1)
337  augmentationTools.append(EGAM11ZeeMassTool1)
338 
339  EGAM11ZeeMassTool2 = acc.popToolsAndMerge(EGAM11ZeeMassTool2Cfg(flags))
340  acc.addPublicTool(EGAM11ZeeMassTool2)
341  augmentationTools.append(EGAM11ZeeMassTool2)
342 
343  EGAM11ZeeMassTool3 = acc.popToolsAndMerge(EGAM11ZeeMassTool3Cfg(flags))
344  acc.addPublicTool(EGAM11ZeeMassTool3)
345  augmentationTools.append(EGAM11ZeeMassTool3)
346 
347  EGAM11ZegMassTool = acc.popToolsAndMerge(EGAM11ZegMassToolCfg(flags))
348  acc.addPublicTool(EGAM11ZegMassTool)
349  augmentationTools.append(EGAM11ZegMassTool)
350 
351  # thinning tools
352  thinningTools = []
353  streamName = kwargs["StreamName"]
354 
355  # Track thinning
356  if flags.Derivation.Egamma.doTrackThinning:
357  from DerivationFrameworkInDet.InDetToolsConfig import (
358  TrackParticleThinningCfg,
359  MuonTrackParticleThinningCfg,
360  TauTrackParticleThinningCfg,
361  )
362 
363  TrackThinningKeepElectronTracks = True
364  TrackThinningKeepPhotonTracks = True
365  TrackThinningKeepAllElectronTracks = True
366  TrackThinningKeepJetTracks = False
367  TrackThinningKeepMuonTracks = False
368  TrackThinningKeepTauTracks = False
369  TrackThinningKeepPVTracks = True
370 
371  # Tracks associated with Electrons
372  if TrackThinningKeepElectronTracks:
373  EGAM11ElectronTPThinningTool = (
374  CompFactory.DerivationFramework.EgammaTrackParticleThinning(
375  name="EGAM11ElectronTPThinningTool",
376  StreamName=streamName,
377  SGKey="Electrons",
378  GSFTrackParticlesKey="GSFTrackParticles",
379  InDetTrackParticlesKey="InDetTrackParticles",
380  SelectionString="Electrons.pt > 0*GeV",
381  BestMatchOnly=True,
382  ConeSize=0.3,
383  )
384  )
385  acc.addPublicTool(EGAM11ElectronTPThinningTool)
386  thinningTools.append(EGAM11ElectronTPThinningTool)
387 
388  # Tracks associated with Electrons (all tracks, large cone, for track
389  # isolation studies of the selected electrons)
390  if TrackThinningKeepAllElectronTracks:
391  EGAM11ElectronTPThinningTool2 = (
392  CompFactory.DerivationFramework.EgammaTrackParticleThinning(
393  name="EGAM11ElectronTPThinningTool2",
394  StreamName=streamName,
395  SGKey="Electrons",
396  GSFTrackParticlesKey="GSFTrackParticles",
397  InDetTrackParticlesKey="InDetTrackParticles",
398  SelectionString="Electrons.pt > 4*GeV",
399  BestMatchOnly=False,
400  ConeSize=0.6,
401  )
402  )
403  acc.addPublicTool(EGAM11ElectronTPThinningTool2)
404  thinningTools.append(EGAM11ElectronTPThinningTool2)
405 
406  # Tracks associated with Photons
407  if TrackThinningKeepPhotonTracks:
408  EGAM11PhotonTPThinningTool = (
409  CompFactory.DerivationFramework.EgammaTrackParticleThinning(
410  name="EGAM11PhotonTPThinningTool",
411  StreamName=streamName,
412  SGKey="Photons",
413  GSFTrackParticlesKey="GSFTrackParticles",
414  InDetTrackParticlesKey="InDetTrackParticles",
415  GSFConversionVerticesKey="GSFConversionVertices",
416  SelectionString="Photons.pt > 0*GeV",
417  BestMatchOnly=True,
418  ConeSize=0.3,
419  )
420  )
421  acc.addPublicTool(EGAM11PhotonTPThinningTool)
422  thinningTools.append(EGAM11PhotonTPThinningTool)
423 
424  # Tracks associated with Jets
425  if TrackThinningKeepJetTracks:
426  EGAM11JetTPThinningTool = (
427  CompFactory.DerivationFramework.JetTrackParticleThinning(
428  name="EGAM11JetTPThinningTool",
429  StreamName=streamName,
430  JetKey="AntiKt4EMTopoJets",
431  InDetTrackParticlesKey="InDetTrackParticles",
432  )
433  )
434  acc.addPublicTool(EGAM11JetTPThinningTool)
435  thinningTools.append(EGAM11JetTPThinningTool)
436 
437  # Tracks associated with Muons
438  if TrackThinningKeepMuonTracks:
439  EGAM11MuonTPThinningTool = acc.getPrimaryAndMerge(
441  flags,
442  name="EGAM11MuonTPThinningTool",
443  StreamName=streamName,
444  MuonKey="Muons",
445  InDetTrackParticlesKey="InDetTrackParticles",
446  )
447  )
448  thinningTools.append(EGAM11MuonTPThinningTool)
449 
450  # Tracks associated with Taus
451  if TrackThinningKeepTauTracks:
452  EGAM11TauTPThinningTool = acc.getPrimaryAndMerge(
454  flags,
455  name="EGAM11TauTPThinningTool",
456  StreamName=streamName,
457  TauKey="TauJets",
458  ConeSize=0.6,
459  InDetTrackParticlesKey="InDetTrackParticles",
460  DoTauTracksThinning=True,
461  TauTracksKey="TauTracks",
462  )
463  )
464  thinningTools.append(EGAM11TauTPThinningTool)
465 
466  # Tracks from primary vertex
467  thinning_expression = " && ".join(
468  [
469  "(InDetTrackParticles.DFCommonTightPrimary)",
470  "(abs(DFCommonInDetTrackZ0AtPV)*sin(InDetTrackParticles.theta)<3*mm)",
471  "(InDetTrackParticles.pt>10*GeV)",
472  ]
473  )
474  if TrackThinningKeepPVTracks:
475  EGAM11TPThinningTool = acc.getPrimaryAndMerge(
477  flags,
478  name="EGAM11TPThinningTool",
479  StreamName=streamName,
480  SelectionString=thinning_expression,
481  InDetTrackParticlesKey="InDetTrackParticles",
482  )
483  )
484  thinningTools.append(EGAM11TPThinningTool)
485 
486  # keep topoclusters around electrons
487  from DerivationFrameworkCalo.DerivationFrameworkCaloConfig import (
488  CaloClusterThinningCfg,
489  )
490 
491  EGAM11CCTCThinningTool = acc.getPrimaryAndMerge(
493  flags,
494  name="EGAM11CCTCThinningTool",
495  StreamName=streamName,
496  SGKey="Electrons",
497  SelectionString="Electrons.pt>4*GeV",
498  TopoClCollectionSGKey="CaloCalTopoClusters",
499  ConeSize=0.5,
500  )
501  )
502  thinningTools.append(EGAM11CCTCThinningTool)
503 
504  # truth thinning
505  if flags.Input.isMC:
506  # W, Z and Higgs
507  truth_cond_WZH = " && ".join(
508  ["(abs(TruthParticles.pdgId) >= 23)", "(abs(TruthParticles.pdgId) <= 25)"]
509  )
510  # Leptons
511  truth_cond_lep = " && ".join(
512  ["(abs(TruthParticles.pdgId) >= 11)", "(abs(TruthParticles.pdgId) <= 16)"]
513  )
514  # Top quark
515  truth_cond_top = "(abs(TruthParticles.pdgId) == 6)"
516  # Photon
517  truth_cond_gam = " && ".join(
518  ["(abs(TruthParticles.pdgId) == 22)", "(TruthParticles.pt > 1*GeV)"]
519  )
520  # stable particles
521  truth_cond_finalState = " && ".join(
522  ["(TruthParticles.status == 1)", "(TruthParticles.barcode < 200000)"]
523  )
524  truth_expression = (
525  "( "
526  + truth_cond_WZH
527  + " ) || "
528  + "( "
529  + truth_cond_lep
530  + " ) || "
531  + "( "
532  + truth_cond_top
533  + " ) || "
534  + "( "
535  + truth_cond_gam
536  + " ) || "
537  + "( "
538  + truth_cond_finalState
539  + " )"
540  )
541  print("EGAM11 truth thinning expression: ", truth_expression)
542 
543  EGAM11TruthThinningTool = CompFactory.DerivationFramework.GenericTruthThinning(
544  name="EGAM11TruthThinningTool",
545  StreamName=streamName,
546  ParticleSelectionString=truth_expression,
547  PreserveDescendants=False,
548  PreserveGeneratorDescendants=True,
549  PreserveAncestors=True,
550  )
551  acc.addPublicTool(EGAM11TruthThinningTool)
552  thinningTools.append(EGAM11TruthThinningTool)
553 
554  # skimming
555  skimmingTool = acc.popToolsAndMerge(EGAM11SkimmingToolCfg(flags))
556  acc.addPublicTool(skimmingTool)
557 
558  # setup the kernel
559  acc.addEventAlgo(
560  CompFactory.DerivationFramework.DerivationKernel(
561  name,
562  SkimmingTools=[skimmingTool],
563  AugmentationTools=augmentationTools,
564  ThinningTools=thinningTools,
565  )
566  )
567 
568  return acc
569 
570 

◆ EGAM11SkimmingToolCfg()

def python.EGAM11.EGAM11SkimmingToolCfg (   flags)
Configure the EGAM11 skimming tool

Definition at line 21 of file EGAM11.py.

21 def EGAM11SkimmingToolCfg(flags):
22  """Configure the EGAM11 skimming tool"""
23  acc = ComponentAccumulator()
24 
25  expression = " || ".join(
26  [
27  "(count( EGAM11_DiElectronMass1 > 50.0*GeV ) >= 1)",
28  "(count( EGAM11_DiElectronMass2 > 50.0*GeV ) >= 1)",
29  "(count( EGAM11_DiElectronMass3 > 50.0*GeV ) >= 1)",
30  "(count( EGAM11_ElectronPhotonMass > 50.0*GeV )>=1)",
31  ]
32  )
33  print("EGAM11 skimming expression: ", expression)
34 
35  acc.setPrivateTools(
36  CompFactory.DerivationFramework.xAODStringSkimmingTool(
37  name="EGAM11SkimmingTool", expression=expression, TrigDecisionTool=""
38  )
39  )
40 
41  return acc
42 
43 

◆ EGAM11ZeeMassTool1Cfg()

def python.EGAM11.EGAM11ZeeMassTool1Cfg (   flags)
Configure the EGAM11 ee invariant mass augmentation tool 1

Definition at line 44 of file EGAM11.py.

44 def EGAM11ZeeMassTool1Cfg(flags):
45  """Configure the EGAM11 ee invariant mass augmentation tool 1"""
46  acc = ComponentAccumulator()
47 
48  # ====================================================================
49  # 1. di-electron invariant mass for events passing the Z->ee
50  # selection for the e-gamma calibration
51  #
52  # 1 tight e, central, pT>25 GeV
53  # 1 medium e, pT>20 GeV
54  # opposite-sign
55  # mee>50 GeV (cut applied in skimming step later)
56  # ====================================================================
57 
58  requirement_tag = " && ".join(
59  ["(Electrons.DFCommonElectronsLHTight)", "(Electrons.pt > 24.5*GeV)"]
60  )
61 
62  requirement_probe = " && ".join(
63  ["(Electrons.DFCommonElectronsLHMedium)", "(Electrons.pt > 19.5*GeV)"]
64  )
65 
66  acc.setPrivateTools(
67  CompFactory.DerivationFramework.EGInvariantMassTool(
68  name="EGAM11_ZEEMassTool1",
69  Object1Requirements=requirement_tag,
70  Object2Requirements=requirement_probe,
71  StoreGateEntryName="EGAM11_DiElectronMass1",
72  Mass1Hypothesis=0.511 * MeV,
73  Mass2Hypothesis=0.511 * MeV,
74  Container1Name="Electrons",
75  Container2Name="Electrons",
76  CheckCharge=True,
77  DoTransverseMass=False,
78  MinDeltaR=0.0,
79  )
80  )
81 
82  return acc
83 
84 

◆ EGAM11ZeeMassTool2Cfg()

def python.EGAM11.EGAM11ZeeMassTool2Cfg (   flags)
Configure the EGAM11 ee invariant mass augmentation tool 2

Definition at line 85 of file EGAM11.py.

85 def EGAM11ZeeMassTool2Cfg(flags):
86  """Configure the EGAM11 ee invariant mass augmentation tool 2"""
87  acc = ComponentAccumulator()
88 
89  # ====================================================================
90  # 2. di-electron invariant mass for events passing the Z->e selection
91  # for the e-gamma calibration
92  #
93  # 2 medium e, central, pT>20 GeV
94  # opposite-sign
95  # mee>50 GeV (cut applied in skimming step later)
96  # ====================================================================
97 
98  requirement = " && ".join(
99  ["(Electrons.DFCommonElectronsLHMedium)", "(Electrons.pt > 19.5*GeV)"]
100  )
101 
102  acc.setPrivateTools(
103  CompFactory.DerivationFramework.EGInvariantMassTool(
104  name="EGAM11_ZEEMassTool2",
105  Object1Requirements=requirement,
106  Object2Requirements=requirement,
107  StoreGateEntryName="EGAM11_DiElectronMass2",
108  Mass1Hypothesis=0.511 * MeV,
109  Mass2Hypothesis=0.511 * MeV,
110  Container1Name="Electrons",
111  Container2Name="Electrons",
112  CheckCharge=True,
113  DoTransverseMass=False,
114  MinDeltaR=0.0,
115  )
116  )
117 
118  return acc
119 
120 

◆ EGAM11ZeeMassTool3Cfg()

def python.EGAM11.EGAM11ZeeMassTool3Cfg (   flags)
Configure the EGAM11 ee invariant mass augmentation tool 3

Definition at line 121 of file EGAM11.py.

121 def EGAM11ZeeMassTool3Cfg(flags):
122  """Configure the EGAM11 ee invariant mass augmentation tool 3"""
123  acc = ComponentAccumulator()
124 
125  # ====================================================================
126  # 3. di-electron invariant mass for events passing the Z->ee
127  # selection for the e efficiencies with tag and probe.
128  #
129  # 1 tight e, central, pT>25 GeV
130  # 1 e, central, pT>4 GeV
131  # opposite-sign + same-sign
132  # mee>50 GeV (cut applied in skimming step later)
133  # ====================================================================
134 
135  requirement_tag = " && ".join(
136  ["(Electrons.DFCommonElectronsLHMedium)", "(Electrons.pt > 24.5*GeV)"]
137  )
138 
139  requirement_probe = "Electrons.pt > 4*GeV"
140 
141  acc.setPrivateTools(
142  CompFactory.DerivationFramework.EGInvariantMassTool(
143  name="EGAM11_ZEEMassTool3",
144  Object1Requirements=requirement_tag,
145  Object2Requirements=requirement_probe,
146  StoreGateEntryName="EGAM11_DiElectronMass3",
147  Mass1Hypothesis=0.511 * MeV,
148  Mass2Hypothesis=0.511 * MeV,
149  Container1Name="Electrons",
150  Container2Name="Electrons",
151  CheckCharge=False,
152  DoTransverseMass=False,
153  MinDeltaR=0.0,
154  )
155  )
156 
157  return acc
158 
159 

◆ EGAM11ZegMassToolCfg()

def python.EGAM11.EGAM11ZegMassToolCfg (   flags)
Configure the EGAM11 e+photon mass augmentation tool

Definition at line 160 of file EGAM11.py.

160 def EGAM11ZegMassToolCfg(flags):
161  """Configure the EGAM11 e+photon mass augmentation tool"""
162  acc = ComponentAccumulator()
163 
164  # ====================================================================
165  # 4. Z->eg selection for reco SF (central)
166  # for tag and probe
167  #
168  # 1 tight e, central, pT>25 GeV
169  # note: use medium instead of tight for early data upon electron
170  # group request
171  # 1 gamma, pT>15 GeV, central
172  # opposite sign + same sign
173  # mey>50 GeV (cut applied in skimming step later)
174  # ====================================================================
175 
176  requirement_tag = " && ".join(
177  ["(Electrons.DFCommonElectronsLHMedium)", "(Electrons.pt > 24.5*GeV)"]
178  )
179 
180  requirement_probe = "DFCommonPhotons_et > 14.5*GeV"
181 
182  acc.setPrivateTools(
183  CompFactory.DerivationFramework.EGInvariantMassTool(
184  name="EGAM11_ZEGMassTool",
185  Object1Requirements=requirement_tag,
186  Object2Requirements=requirement_probe,
187  StoreGateEntryName="EGAM11_ElectronPhotonMass",
188  Mass1Hypothesis=0.511 * MeV,
189  Mass2Hypothesis=0.511 * MeV,
190  Container1Name="Electrons",
191  Container2Name="Photons",
192  Pt2BranchName="DFCommonPhotons_et",
193  Eta2BranchName="DFCommonPhotons_eta",
194  Phi2BranchName="DFCommonPhotons_phi",
195  CheckCharge=False,
196  DoTransverseMass=False,
197  MinDeltaR=0.0,
198  )
199  )
200  return acc
201 
202 
203 # Main algorithm config
AssociationUtilsConfig.OverlapRemovalToolCfg
def OverlapRemovalToolCfg(ConfigFlags, masterName='OverlapRemovalTool', inputLabel='selected', outputLabel='overlaps', bJetLabel='', maxElePtForBJetAwareOR=100. *1000, boostedLeptons=False, outputPassValue=False, linkOverlapObjects=False, doEleEleOR=False, doElectrons=True, doMuons=True, doJets=True, doTaus=True, doPhotons=True, doFatJets=False, **kwargs)
Definition: AssociationUtilsConfig.py:5
DerivationFrameworkCaloConfig.CaloClusterThinningCfg
def CaloClusterThinningCfg(flags, **kwargs)
Definition: DerivationFrameworkCaloConfig.py:98
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
python.JetSelectorToolsConfig.EventCleaningToolCfg
def EventCleaningToolCfg(ConfigFlags, name, cleaningLevel)
Definition: JetSelectorToolsConfig.py:14
python.OutputStreamConfig.OutputStreamCfg
def OutputStreamCfg(flags, streamName, ItemList=[], MetadataItemList=[], disableEventTag=False, trigNavThinningSvc=None, takeItemsFromInput=False, extendProvenanceRecord=True, AcceptAlgs=[], HelperTools=[])
Definition: OutputStreamConfig.py:12
python.JetSelectorToolsConfig.JetCleaningToolCfg
def JetCleaningToolCfg(ConfigFlags, name, jetdef, cleaningLevel, useDecorations)
Definition: JetSelectorToolsConfig.py:6
python.InDetToolsConfig.TrackParticleThinningCfg
def TrackParticleThinningCfg(flags, name, **kwargs)
Definition: InDetToolsConfig.py:458
python.EGAM11.EGAM11ZeeMassTool1Cfg
def EGAM11ZeeMassTool1Cfg(flags)
Definition: EGAM11.py:44
python.EGammaCommonConfig.EGammaCommonCfg
def EGammaCommonCfg(ConfigFlags)
Definition: EGammaCommonConfig.py:15
python.EGAM11.EGAM11SkimmingToolCfg
def EGAM11SkimmingToolCfg(flags)
Definition: EGAM11.py:21
python.JetRecConfig.JetRecCfg
def JetRecCfg(flags, jetdef, returnConfiguredDef=False)
Top level functions returning ComponentAccumulator out of JetDefinition.
Definition: JetRecConfig.py:36
python.MuonsCommonConfig.MuonsCommonCfg
def MuonsCommonCfg(flags, suff="")
Definition: MuonsCommonConfig.py:13
python.EGAM11.EGAM11Cfg
def EGAM11Cfg(flags)
Definition: EGAM11.py:571
python.InDetToolsConfig.MuonTrackParticleThinningCfg
def MuonTrackParticleThinningCfg(flags, name, **kwargs)
Definition: InDetToolsConfig.py:528
python.InDetToolsConfig.TauTrackParticleThinningCfg
def TauTrackParticleThinningCfg(flags, name, **kwargs)
Definition: InDetToolsConfig.py:539
print
void print(char *figname, TCanvas *c1)
Definition: TRTCalib_StrawStatusPlots.cxx:25
python.EGAM11.EGAM11ZeeMassTool2Cfg
def EGAM11ZeeMassTool2Cfg(flags)
Definition: EGAM11.py:85
TCS::join
std::string join(const std::vector< std::string > &v, const char c=',')
Definition: Trigger/TrigT1/L1Topo/L1TopoCommon/Root/StringUtils.cxx:10
python.EGAM11.EGAM11ZeeMassTool3Cfg
def EGAM11ZeeMassTool3Cfg(flags)
Definition: EGAM11.py:121
python.InDetCommonConfig.InDetCommonCfg
def InDetCommonCfg(flags, **kwargs)
Definition: InDetCommonConfig.py:16
python.JetJvtEfficiencyToolConfig.getJvtEffToolCfg
def getJvtEffToolCfg(flags, jetalg)
Definition: JetJvtEfficiencyToolConfig.py:17
InfileMetaDataConfig.SetupMetaDataForStreamCfg
def SetupMetaDataForStreamCfg(flags, streamName="", AcceptAlgs=None, createMetadata=None, propagateMetadataFromInput=True, *args, **kwargs)
Definition: InfileMetaDataConfig.py:222
python.EGAM11.EGAM11KernelCfg
def EGAM11KernelCfg(flags, name="EGAM11Kernel", **kwargs)
Definition: EGAM11.py:204
SlimmingHelper
Definition: SlimmingHelper.py:1
python.EGAM11.EGAM11ZegMassToolCfg
def EGAM11ZegMassToolCfg(flags)
Definition: EGAM11.py:160