ATLAS Offline Software
Functions | Variables
SleptonsConfig Namespace Reference

Functions

def get_and_fix_PDGTABLE_GMSB (replace)
 
def load_files_for_GMSB_scenario (simdict)
 
def get_and_fix_PDGTABLE_sleptons (flags, replace)
 
def load_files_for_sleptonLLP_scenario (flags)
 
def SleptonsPhysicsToolCfg (flags, name="SleptonsPhysicsTool", **kwargs)
 
def AllSleptonsPhysicsToolCfg (flags, name="AllSleptonsPhysicsTool", **kwargs)
 
def SElectronRPlusToElectronGravitinoCfg (flags, name="SElectronRPlusToElectronGravitino", **kwargs)
 Gravitino Options. More...
 
def SElectronRMinusToElectronGravitinoCfg (flags, name="SElectronRMinusToElectronGravitino", **kwargs)
 
def SMuonRPlusToMuonGravitinoCfg (flags, name="SMuonRPlusToMuonGravitino", **kwargs)
 
def SMuonRMinusToMuonGravitinoCfg (flags, name="SMuonRMinusToMuonGravitino", **kwargs)
 
def STauLPlusToTauGravitinoCfg (flags, name="STauLPlusToTauGravitino", **kwargs)
 
def STauLMinusToTauGravitinoCfg (flags, name="STauLMinusToTauGravitino", **kwargs)
 
def SElectronLPlusToElectronGravitinoCfg (flags, name="SElectronLPlusToElectronGravitino", **kwargs)
 
def SElectronLMinusToElectronGravitinoCfg (flags, name="SElectronLMinusToElectronGravitino", **kwargs)
 
def SMuonLPlusToMuonGravitinoCfg (flags, name="SMuonLPlusToMuonGravitino", **kwargs)
 
def SMuonLMinusToMuonGravitinoCfg (flags, name="SMuonLMinusToMuonGravitino", **kwargs)
 
def STauRPlusToTauGravitinoCfg (flags, name="STauRPlusToTauGravitino", **kwargs)
 
def STauRMinusToTauGravitinoCfg (flags, name="STauRMinusToTauGravitino", **kwargs)
 
def STauRMinusToTauNeutralinoCfg (flags, name="STauRMinusToTauNeutralino", **kwargs)
 Neutralino-Stau. More...
 
def STauRPlusToTauNeutralinoCfg (flags, name="STauRPlusToTauNeutralino", **kwargs)
 
def STauLMinusToTauNeutralinoCfg (flags, name="STauLMinusToTauNeutralino", **kwargs)
 
def STauLPlusToTauNeutralinoCfg (flags, name="STauLPlusToTauNeutralino", **kwargs)
 
def STauRMinusToPionMinusNeutralinoCfg (flags, name="STauRMinusToPionMinusNeutralino", **kwargs)
 Neutralino-Stau Off shell tau Stau-Neutralino Pion Neutrino. More...
 
def STauRPlusToPionPlusNeutralinoCfg (flags, name="STauRPlusToPionPlusNeutralino", **kwargs)
 
def STauLMinusToPionMinusNeutralinoCfg (flags, name="STauLMinusToPionMinusNeutralino", **kwargs)
 
def STauLPlusToPionPlusNeutralinoCfg (flags, name="STauLPlusToPionPlusNeutralino", **kwargs)
 
def STauRMinusToRhoMinusNeutralinoCfg (flags, name="STauRMinusToRhoMinusNeutralino", **kwargs)
 Neutralino-Stau Off shell tau Stau-Neutralino Muon Neutrino. More...
 
def STauRPlusToRhoPlusNeutralinoCfg (flags, name="STauRPlusToRhoPlusNeutralino", **kwargs)
 
def STauLMinusToRhoMinusNeutralinoCfg (flags, name="STauLMinusToRhoMinusNeutralino", **kwargs)
 
def STauLPlusToRhoPlusNeutralinoCfg (flags, name="STauLPlusToRhoPlusNeutralino", **kwargs)
 
def STauRMinusToEMinusNeutralinoCfg (flags, name="STauRMinusToEMinusNeutralino", **kwargs)
 Neutralino-Stau Off shell tau Stau-Neutralino Electron Neutrino. More...
 
def STauRPlusToEPlusNeutralinoCfg (flags, name="STauRPlusToEPlusNeutralino", **kwargs)
 
def STauLMinusToEMinusNeutralinoCfg (flags, name="STauLMinusToEMinusNeutralino", **kwargs)
 
def STauLPlusToEPlusNeutralinoCfg (flags, name="STauLPlusToEPlusNeutralino", **kwargs)
 
def STauRMinusToMuMinusNeutralinoCfg (flags, name="STauRMinusToMuMinusNeutralino", **kwargs)
 Neutralino-Stau Off shell tau Stau-Neutralino Muon Neutrino. More...
 
def STauRPlusToMuPlusNeutralinoCfg (flags, name="STauRPlusToMuPlusNeutralino", **kwargs)
 
def STauLMinusToMuMinusNeutralinoCfg (flags, name="STauLMinusToMuMinusNeutralino", **kwargs)
 
def STauLPlusToMuPlusNeutralinoCfg (flags, name="STauLPlusToMuPlusNeutralino", **kwargs)
 
def STauRMinusToa1MinusNeutralinoCfg (flags, name="STauRMinusToa1MinusNeutralino", **kwargs)
 Neutralino-Stau Off shell tau Stau-Neutralino Pseuddo-Vector a1(1260) meson Neutrino. More...
 
def STauRPlusToa1PlusNeutralinoCfg (flags, name="STauRPlusToa1PlusNeutralino", **kwargs)
 
def STauLMinusToa1MinusNeutralinoCfg (flags, name="STauLMinusToa1MinusNeutralino", **kwargs)
 
def STauLPlusToa1PlusNeutralinoCfg (flags, name="STauLPlusToa1PlusNeutralino", **kwargs)
 
def SElectronRPlusToElectronNeutralinoCfg (flags, name="SElectronRPlusToElectronNeutralino", **kwargs)
 Neutralino Selectron. More...
 
def SElectronRMinusToElectronNeutralinoCfg (flags, name="SElectronRMinusToElectronNeutralino", **kwargs)
 
def SElectronLPlusToElectronNeutralinoCfg (flags, name="SElectronLPlusToElectronNeutralino", **kwargs)
 
def SElectronLMinusToElectronNeutralinoCfg (flags, name="SElectronLMinusToElectronNeutralino", **kwargs)
 
def SMuonLPlusToMuonNeutralinoCfg (flags, name="SMuonLPlusToMuonNeutralino", **kwargs)
 Neutralino SMuon. More...
 
def SMuonLMinusToMuonNeutralinoCfg (flags, name="SMuonLMinusToMuonNeutralino", **kwargs)
 
def SMuonRPlusToMuonNeutralinoCfg (flags, name="SMuonRPlusToMuonNeutralino", **kwargs)
 
def SMuonRMinusToMuonNeutralinoCfg (flags, name="SMuonRMinusToMuonNeutralino", **kwargs)
 
def SleptonsLLPCfg (flags)
 
def GMSB_Cfg (flags)
 
def GMSB_VerboseSelectorCfg (flags, name="G4UA::VerboseSelectorTool", **kwargs)
 
def SleptonsLLP_VerboseSelectorCfg (flags, name="G4UA::VerboseSelectorTool", **kwargs)
 

Variables

int Mass_a1Meson = 1260.
 

Function Documentation

◆ AllSleptonsPhysicsToolCfg()

def SleptonsConfig.AllSleptonsPhysicsToolCfg (   flags,
  name = "AllSleptonsPhysicsTool",
**  kwargs 
)

Definition at line 246 of file SleptonsConfig.py.

246 def AllSleptonsPhysicsToolCfg(flags, name="AllSleptonsPhysicsTool", **kwargs):
247  result = ComponentAccumulator()
248  if "GMSBStau" in flags.Input.SpecialConfiguration or "coannihilationStau" in flags.Input.SpecialConfiguration:
249  StauMass = None
250  StauLifetime = None
251  if "GMSBStau" in flags.Input.SpecialConfiguration: # Check for GMSBStau key word in job options. If found set Stau values.
252  StauMass = eval(flags.Input.SpecialConfiguration.get("GMSBStau", "None"))
253  StauLifetime = eval(flags.Input.SpecialConfiguration.get("GMSBStauTime", "None"))
254  elif "coannihilationStau" in flags.Input.SpecialConfiguration: # Check for coannihilationStau key word in evgen special configs. This is an option that is normally put in the event gen job options file.
255  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
256  StauLifetime = eval(flags.Input.SpecialConfiguration.get("coannihilationStauTime", "None"))
257 
258  kwargs.setdefault("G4STau1MinusMass", StauMass)
259  kwargs.setdefault("G4STau1MinusPDGCode", 1000015)
260  kwargs.setdefault("G4STau1MinusStable", False)
261  kwargs.setdefault("G4STau1MinusLifetime", StauLifetime)
262 
263  kwargs.setdefault("G4STau1PlusMass", StauMass)
264  kwargs.setdefault("G4STau1PlusPDGCode", -1000015)
265  kwargs.setdefault("G4STau1PlusStable", False)
266  kwargs.setdefault("G4STau1PlusLifetime", StauLifetime)
267 
268  kwargs.setdefault("G4STau2MinusMass", StauMass)
269  kwargs.setdefault("G4STau2MinusPDGCode", 2000015)
270  kwargs.setdefault("G4STau2MinusStable", False)
271  kwargs.setdefault("G4STau2MinusLifetime", StauLifetime)
272 
273  kwargs.setdefault("G4STau2PlusMass", StauMass)
274  kwargs.setdefault("G4STau2PlusPDGCode", -2000015)
275  kwargs.setdefault("G4STau2PlusStable", False)
276  kwargs.setdefault("G4STau2PlusLifetime", StauLifetime)
277 
278  if "GMSBSlepton" in flags.Input.SpecialConfiguration:
279  GMSBSlepton = eval(flags.Input.SpecialConfiguration.get("GMSBSlepton", "None"))
280  GMSBSleptonTime = eval(flags.Input.SpecialConfiguration.get("GMSBSleptonTime", "None"))
281 
282  kwargs.setdefault("G4SElectronLMinusMass", GMSBSlepton)
283  kwargs.setdefault("G4SElectronLMinusPDGCode", 1000011)
284  kwargs.setdefault("G4SElectronLMinusStable", False)
285  kwargs.setdefault("G4SElectronLMinusLifetime", GMSBSleptonTime)
286 
287  kwargs.setdefault("G4SElectronLPlusMass", GMSBSlepton)
288  kwargs.setdefault("G4SElectronLPlusPDGCode", -1000011)
289  kwargs.setdefault("G4SElectronLPlusStable", False)
290  kwargs.setdefault("G4SElectronLPlusLifetime", GMSBSleptonTime)
291 
292  kwargs.setdefault("G4SMuonLMinusMass", GMSBSlepton)
293  kwargs.setdefault("G4SMuonLMinusPDGCode", 1000013)
294  kwargs.setdefault("G4SMuonLMinusStable", False)
295  kwargs.setdefault("G4SMuonLMinusLifetime", GMSBSleptonTime)
296 
297  kwargs.setdefault("G4SMuonLPlusMass", GMSBSlepton)
298  kwargs.setdefault("G4SMuonLPlusPDGCode", -1000013)
299  kwargs.setdefault("G4SMuonLPlusStable", False)
300  kwargs.setdefault("G4SMuonLPlusLifetime", GMSBSleptonTime)
301 
302  kwargs.setdefault("G4SElectronRMinusMass", GMSBSlepton)
303  kwargs.setdefault("G4SElectronRMinusPDGCode", 2000011)
304  kwargs.setdefault("G4SElectronRMinusStable", False)
305  kwargs.setdefault("G4SElectronRMinusLifetime", GMSBSleptonTime)
306 
307  kwargs.setdefault("G4SElectronRPlusMass", GMSBSlepton)
308  kwargs.setdefault("G4SElectronRPlusPDGCode", -2000011)
309  kwargs.setdefault("G4SElectronRPlusStable", False)
310  kwargs.setdefault("G4SElectronRPlusLifetime", GMSBSleptonTime)
311 
312  kwargs.setdefault("G4SMuonRMinusMass", GMSBSlepton)
313  kwargs.setdefault("G4SMuonRMinusPDGCode", 2000013)
314  kwargs.setdefault("G4SMuonRMinusStable", False)
315  kwargs.setdefault("G4SMuonRMinusLifetime", GMSBSleptonTime)
316 
317  kwargs.setdefault("G4SMuonRPlusMass", GMSBSlepton)
318  kwargs.setdefault("G4SMuonRPlusPDGCode", -2000013)
319  kwargs.setdefault("G4SMuonRPlusStable", False)
320  kwargs.setdefault("G4SMuonRPlusLifetime", GMSBSleptonTime)
321  result.setPrivateTools( CompFactory.SleptonsPhysicsTool(name, **kwargs) )
322  return result
323 
324 

◆ get_and_fix_PDGTABLE_GMSB()

def SleptonsConfig.get_and_fix_PDGTABLE_GMSB (   replace)

Definition at line 28 of file SleptonsConfig.py.

28 def get_and_fix_PDGTABLE_GMSB(replace):
29 
30  # Download generic PDGTABLE (overwrite existing one if it exists)
31  from ExtraParticles.PDGHelpers import getPDGTABLE
32  if getPDGTABLE('PDGTABLE.MeV'):
33  shutil.move('PDGTABLE.MeV', 'PDGTABLE.MeV.org')
34 
35  # an example line to illustrate the fixed format, see PDGTABLE.MeV for more details
36  # M 1000022 0.E+00 +0.0E+00 -0.0E+00 ~chi(0,1) 0
37 
38  lines = open('PDGTABLE.MeV.org').readlines()
39  for pdgid,mass,name,charge in replace:
40  if not re.search(r'[MW]\s+'+str(pdgid)+r'\s+\S+', ''.join(lines)):
41  lines.append('M' + str(pdgid).rjust(8) +''.ljust(26) +
42  ('%11.5E' % mass).ljust(15) +
43  '+0.0E+00'.ljust(9) + '-0.0E+00'.ljust(9) +
44  name.strip() + ''.ljust(6) + charge.strip()+''.rjust(20-len(name.strip())) + '\n')
45  lines.append('W' + str(pdgid).rjust(8) +''.ljust(26) +
46  '0.E+00'.ljust(15) + '+0.0E+00'.ljust(9) + '-0.0E+00'.ljust(9) +
47  name.strip() + ''.ljust(6) + charge.strip()+''.rjust(20-len(name.strip())) + '\n')
48  else:
49  from past.builtins import xrange # Temporary workaround for python3 compatibility use range in CA-based config
50  for i in xrange(len(lines)):
51  if re.search(r'M\s+'+str(pdgid)+r'\s+\S+', lines[i]):
52  l = lines[i]
53  lines[i] = l[0:35] + ('%11.5E' % mass).ljust(14) + l[49:]
54 
55  update = open('PDGTABLE.MeV', 'w')
56  update.write(''.join(lines))
57  update.close()
58 
59  print ('modified PDGTABLE\n%s\n' % ''.join(lines))
60  sys.stdout.flush()
61 
62 
63 @AccumulatorCache

◆ get_and_fix_PDGTABLE_sleptons()

def SleptonsConfig.get_and_fix_PDGTABLE_sleptons (   flags,
  replace 
)

Definition at line 137 of file SleptonsConfig.py.

137 def get_and_fix_PDGTABLE_sleptons(flags, replace):
138 
139  # Download generic PDGTABLE (do not overwrite existing one if it exists, use existing one instead)
140  from ExtraParticles.PDGHelpers import getPDGTABLE
141  if getPDGTABLE('PDGTABLE.MeV'):
142  shutil.move('PDGTABLE.MeV', 'PDGTABLE.MeV.org')
143 
144  # an example line to illustrate the fixed format, see PDGTABLE.MeV for more details
145  # M 1000022 0.E+00 +0.0E+00 -0.0E+00 ~chi(0,1) 0
146 
147  lines = open('PDGTABLE.MeV.org').readlines()
148  for pdgid,mass,name,charge in replace:
149  if not re.search(r'[MW]\s+'+str(pdgid)+r'\s+\S+', ''.join(lines)):
150  lines.append('M' + str(pdgid).rjust(8) +''.ljust(26) +
151  ('%11.5E' % mass).ljust(15) +
152  '+0.0E+00'.ljust(9) + '-0.0E+00'.ljust(9) +
153  name.strip() + ''.ljust(6) + charge.strip()+''.rjust(20-len(name.strip())) + '\n')
154  lines.append('W' + str(pdgid).rjust(8) +''.ljust(26) +
155  '0.E+00'.ljust(15) + '+0.0E+00'.ljust(9) + '-0.0E+00'.ljust(9) +
156  name.strip() + ''.ljust(6) + charge.strip()+''.rjust(20-len(name.strip())) + '\n')
157  else:
158  from past.builtins import xrange # Temporary workaround for python3 compatibility use range in CA-based config
159  for i in xrange(len(lines)):
160  if re.search(r'M\s+'+str(pdgid)+r'\s+\S+', lines[i]):
161  l = lines[i]
162  lines[i] = l[0:35] + ('%11.5E' % mass).ljust(14) + l[49:]
163 
164  update = open('PDGTABLE.MeV', 'w')
165  update.write(''.join(lines))
166  update.close()
167 
168  print('modified PDGTABLE\n%s\n' % ''.join(lines))
169  sys.stdout.flush()
170 
171 

◆ GMSB_Cfg()

def SleptonsConfig.GMSB_Cfg (   flags)

Definition at line 937 of file SleptonsConfig.py.

937 def GMSB_Cfg(flags):
938  result = ComponentAccumulator()
939  if flags.Common.ProductionStep == ProductionStep.Simulation:
940  from G4AtlasServices.G4AtlasServicesConfig import PhysicsListSvcCfg
941  result.merge(PhysicsListSvcCfg(flags))
942 
943  simdict = flags.Input.SpecialConfiguration
944  assert "GMSBIndex" in simdict
945  load_files_for_GMSB_scenario(simdict)
946 
947  if flags.Common.ProductionStep == ProductionStep.Simulation:
948  from Gauginos.GauginosConfig import GauginosPhysicsToolCfg, NeutralinoToPhotonGravitinoCfg
949  GMSBIndex = int(simdict["GMSBIndex"])
950  physicsOptions = []
951  if GMSBIndex == 1: # generic neutralino to photon scenario
952  physicsOptions = [ result.popToolsAndMerge(GauginosPhysicsToolCfg(flags)) ]
953  physicsOptions += [ result.popToolsAndMerge(NeutralinoToPhotonGravitinoCfg(flags)) ]
954  elif GMSBIndex == 2 or GMSBIndex == 3 or GMSBIndex == 4: # generic stau scenario
955  physicsOptions = [ result.popToolsAndMerge(SleptonsPhysicsToolCfg(flags)) ]
956  else:
957  print ('GMSBIndex %i not supported' % GMSBIndex)
958  raise
959  del GMSBIndex
960  result.getService("PhysicsListSvc").PhysOption += physicsOptions
961  return result
962 
963 

◆ GMSB_VerboseSelectorCfg()

def SleptonsConfig.GMSB_VerboseSelectorCfg (   flags,
  name = "G4UA::VerboseSelectorTool",
**  kwargs 
)

Definition at line 964 of file SleptonsConfig.py.

964 def GMSB_VerboseSelectorCfg(flags, name="G4UA::VerboseSelectorTool", **kwargs): kwargs.setdefault('TargetEvent',1)
965  kwargs.setdefault('VerboseLevel',1)
966  kwargs.setdefault('TargetPdgIDs',
967  [
968  -1000001,1000001, # ~d(L)
969  -1000002,1000002, # ~u(L)
970  -1000003,1000003, # ~s(L)
971  -1000004,1000004, # ~c(L)
972  -1000005,1000005, # ~b(1)
973  -1000006,1000006, # ~t(1)
974  -1000011,1000011, # ~e(L)
975  -1000013,1000013, # ~mu(L)'
976  -1000015,1000015, # ~tau(L)
977  -2000001,2000001, # ~d(R)
978  -2000002,2000002, # ~u(R)
979  -2000003,2000003, # ~s(R)
980  -2000004,2000004, # ~c(R)
981  -2000005,2000005, # ~b(2)
982  -2000006,2000006, # ~t(2)
983  -2000011,2000011, # ~e(R)
984  -2000013,2000013, # ~mu(R)'
985  -2000015,2000015, # ~tau(R)
986  1000021, # ~g
987  1000022, # ~chi(0,1)
988  1000023, # ~chi(0,2)
989  -1000024,1000024, # ~chi(+,1)
990  1000025, # ~chi(0,3)
991  1000035, # ~chi(0,4)
992  -1000037,1000037, # ~chi(+,2)
993  1000039 # ~G
994  ])
995  from G4DebuggingTools.G4DebuggingToolsConfig import VerboseSelectorToolCfg
996  return VerboseSelectorToolCfg(flags, name, **kwargs)
997 
998 
999 

◆ load_files_for_GMSB_scenario()

def SleptonsConfig.load_files_for_GMSB_scenario (   simdict)

Definition at line 64 of file SleptonsConfig.py.

64 def load_files_for_GMSB_scenario(simdict):
65 
66  GMSBIndex = int(simdict["GMSBIndex"])
67  pdgcodes = []
68  if GMSBIndex == 1:
69  get_and_fix_PDGTABLE_GMSB([
70  (1000022, eval(simdict["GMSBNeutralino"]), '~chi(0,1)', '0'),
71  (1000039, eval(simdict.get("GMSBGravitino",'0')), '~G', '0')
72  ])
73  pdgcodes += [1000022,1000039]
74  elif GMSBIndex == 2:
75  m_stau = eval(simdict["GMSBStau"])
76  m_slepton = eval(simdict["GMSBSlepton"])
77  get_and_fix_PDGTABLE_GMSB([
78  (1000015, m_stau, '~tau(L)', '-'),
79  (2000011, m_slepton, '~e(R)', '-'),
80  (2000013, m_slepton, '~mu(R)', '-')
81  ])
82  pdgcodes += [-1000015,1000015,-2000011,2000011,-2000013,2000013]
83  elif GMSBIndex == 3:
84  m_stau = eval(simdict["GMSBStau"])
85  m_slepton = eval(simdict["GMSBSlepton"])
86  m_squark = eval(simdict["SQUARKMASS"])
87  m_neutralino = eval(simdict["NEUTRALINOMASS"])
88  m_gluino = eval(simdict["GLUINOMASS"])
89  get_and_fix_PDGTABLE_GMSB([
90  (1000001, m_squark, '~d(L)', '-1/3'), (2000001, m_squark, '~d(R)', '-1/3'),
91  (1000002, m_squark, '~u(L)', '+2/3'), (2000002, m_squark, '~u(R)', '+2/3'),
92  (1000003, 1.00E+04, '~s(L)', '-1/3'), (2000003, 1.00E+04, '~s(R)', '-1/3'),
93  (1000004, 1.00E+04, '~c(L)', '+2/3'), (2000004, 1.00E+04, '~c(R)', '+2/3'),
94  (1000005, 1.00E+04, '~b(1)', '-1/3'), (2000005, 1.00E+04, '~b(2)', '-1/3'),
95  (1000006, 1.00E+04, '~t(1)', '+2/3'), (2000006, 1.00E+04, '~t(2)', '+2/3'),
96  (1000011, 2.50E+02, '~e(L)', '-'), (2000011, m_slepton, '~e(R)', '-'),
97  (1000012, 1.00E+04, '~nu(e,L)', '0'),
98  (1000013, 2.50E+02, '~mu(L)', '-'), (2000013, m_slepton, '~mu(R)', '-'),
99  (1000014, 1.00E+04, '~nu(e,L)', '0'),
100  (1000015, m_stau, '~tau(L)', '-'), (2000015, 2.50E+02, '~tau(R)', '-'),
101  (1000016, 1.00E+04, '~nu(tau,L)', '0'),
102  (1000021, m_gluino, '~g', '0'),
103  (1000022, m_neutralino, '~chi(0,1)', '0'),
104  (1000023, 1.00E+04, '~chi(0,2)', '0'),
105  (1000024, 1.00E+04, '~chi(+,1)', '+'),
106  (1000025, -1.00E+04, '~chi(0,3)', '0'),
107  (1000035, 1.00E+04, '~chi(0,4)', '0'),
108  (1000037, 1.00E+04, '~chi(+,2)', '+')
109  ])
110  pdgcodes += [
111  -1000001,1000001,-2000001,2000001,
112  -1000002,1000002,-2000002,2000002,
113  -1000003,1000003,-2000003,2000003,
114  -1000004,1000004,-2000004,2000004,
115  -1000005,1000005,-2000005,2000005,
116  -1000006,1000006,-2000006,2000006,
117  -1000011,1000011,-2000011,2000011,
118  -1000013,1000013,-2000013,2000013,
119  -1000015,1000015,-2000015,2000015,
120  1000012,1000014,1000016,1000021,1000022,1000023,
121  -1000024,1000024,1000025,1000035,-1000037,1000037]
122 
123  elif GMSBIndex == 4:
124  get_and_fix_PDGTABLE_GMSB([
125  (1000015, m_stau, '~tau(L)', '-')
126  ])
127  pdgcodes += [-1000015,1000015]
128 
129  else:
130  print ('GMSBIndex %i not supported' % GMSBIndex)
131  raise
132  from ExtraParticles.PDGHelpers import updateExtraParticleAcceptList
133  updateExtraParticleAcceptList('G4particle_acceptlist_ExtraParticles.txt', pdgcodes)
134 
135 
136 @AccumulatorCache

◆ load_files_for_sleptonLLP_scenario()

def SleptonsConfig.load_files_for_sleptonLLP_scenario (   flags)

Definition at line 172 of file SleptonsConfig.py.

172 def load_files_for_sleptonLLP_scenario(flags):
173  simdict = flags.Input.SpecialConfiguration
174  pdgcodes = []
175  if "GMSBSlepton" in simdict:
176  get_and_fix_PDGTABLE_sleptons(flags, [
177  (2000011, eval(simdict.get("GMSBSlepton",'0')), '~e(R)', '-'),
178  (2000013, eval(simdict.get("GMSBSlepton",'0')), '~mu(R)', '-'),
179  (1000011, eval(simdict.get("GMSBSlepton",'0')), '~e(L)', '-'),
180  (1000013, eval(simdict.get("GMSBSlepton",'0')), '~mu(L)', '-'),
181  ])
182  pdgcodes += [-2000011,2000011,-2000013,2000013,-1000011,1000011,-1000013,1000013]
183  if "GMSBStau" in simdict:
184  get_and_fix_PDGTABLE_sleptons(flags, [
185  (2000015, eval(simdict.get("GMSBStau",'0')), '~tau(R)', '-'),
186  (1000015, eval(simdict.get("GMSBStau",'0')), '~tau(L)', '-'),
187  ])
188  pdgcodes += [-2000015,2000015,-1000015,1000015]
189  if "GMSBGravitino" in simdict:
190  get_and_fix_PDGTABLE_sleptons(flags, [
191  (1000039, eval(simdict.get("GMSBGravitino",'0')), '~G', '0'),
192  ])
193  pdgcodes += [1000039]
194  if "coannihilationStau" in simdict:
195  get_and_fix_PDGTABLE_sleptons([
196  (2000015, eval(simdict.get("coannihilationStau",'0')), '~tau(R)', '-'),
197  (1000015, eval(simdict.get("coannihilationStau",'0')), '~tau(L)', '-'),
198  ])
199  pdgcodes += [-2000015,2000015,-1000015,1000015]
200  if "coannihilationSlepton" in simdict:
201  get_and_fix_PDGTABLE_sleptons([
202  (2000011, eval(simdict.get("coannihilationSlepton", '0')), '~e(R)', '-'),
203  (2000013, eval(simdict.get("coannihilationSlepton", '0')), '~mu(R)', '-'),
204  (1000011, eval(simdict.get("coannihilationSlepton", '0')), '~e(L)', '-'),
205  (1000013, eval(simdict.get("coannihilationSlepton", '0')), '~mu(L)', '-'),
206  ])
207  pdgcodes += [-2000011, 2000011, -2000013, 2000013, -1000011, 1000011, -1000013, 1000013]
208  if "coannihilationNeutralino" in simdict:
209  get_and_fix_PDGTABLE_sleptons([
210  (1000022, eval(simdict.get("coannihilationNeutralino", '0')), '~chi(0,1)', '0'),
211  ])
212  pdgcodes += [1000022]
213 
214  from ExtraParticles.PDGHelpers import updateExtraParticleAcceptList
215  updateExtraParticleAcceptList('G4particle_acceptlist_ExtraParticles.txt', pdgcodes)
216 
217 

◆ SElectronLMinusToElectronGravitinoCfg()

def SleptonsConfig.SElectronLMinusToElectronGravitinoCfg (   flags,
  name = "SElectronLMinusToElectronGravitino",
**  kwargs 
)

Definition at line 389 of file SleptonsConfig.py.

389 def SElectronLMinusToElectronGravitinoCfg(flags, name="SElectronLMinusToElectronGravitino", **kwargs):
390  result = ComponentAccumulator()
391  kwargs.setdefault("ParticleName","s_e_minus_L")
392  kwargs.setdefault("BR", 1.0) # Branching Ratio
393  kwargs.setdefault("Daughters","s_G,e-")
394  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
395  return result
396 
397 

◆ SElectronLMinusToElectronNeutralinoCfg()

def SleptonsConfig.SElectronLMinusToElectronNeutralinoCfg (   flags,
  name = "SElectronLMinusToElectronNeutralino",
**  kwargs 
)

Definition at line 819 of file SleptonsConfig.py.

819 def SElectronLMinusToElectronNeutralinoCfg(flags, name="SElectronLMinusToElectronNeutralino", **kwargs):
820  result = ComponentAccumulator()
821  kwargs.setdefault("ParticleName","s_e_minus_L")
822  kwargs.setdefault("BR", 1.0) # Branching Ratio
823  kwargs.setdefault("Daughters","s_chi_0_1,e-")
824  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
825  return result
826 
827 

◆ SElectronLPlusToElectronGravitinoCfg()

def SleptonsConfig.SElectronLPlusToElectronGravitinoCfg (   flags,
  name = "SElectronLPlusToElectronGravitino",
**  kwargs 
)

Definition at line 380 of file SleptonsConfig.py.

380 def SElectronLPlusToElectronGravitinoCfg(flags, name="SElectronLPlusToElectronGravitino", **kwargs):
381  result = ComponentAccumulator()
382  kwargs.setdefault("ParticleName","s_e_plus_L")
383  kwargs.setdefault("BR", 1.0) # Branching Ratio
384  kwargs.setdefault("Daughters","s_G,e+")
385  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
386  return result
387 
388 

◆ SElectronLPlusToElectronNeutralinoCfg()

def SleptonsConfig.SElectronLPlusToElectronNeutralinoCfg (   flags,
  name = "SElectronLPlusToElectronNeutralino",
**  kwargs 
)

Definition at line 810 of file SleptonsConfig.py.

810 def SElectronLPlusToElectronNeutralinoCfg(flags, name="SElectronLPlusToElectronNeutralino", **kwargs):
811  result = ComponentAccumulator()
812  kwargs.setdefault("ParticleName","s_e_plus_L")
813  kwargs.setdefault("BR", 1.0) # Branching Ratio
814  kwargs.setdefault("Daughters","s_chi_0_1,e+")
815  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
816  return result
817 
818 

◆ SElectronRMinusToElectronGravitinoCfg()

def SleptonsConfig.SElectronRMinusToElectronGravitinoCfg (   flags,
  name = "SElectronRMinusToElectronGravitino",
**  kwargs 
)

Definition at line 335 of file SleptonsConfig.py.

335 def SElectronRMinusToElectronGravitinoCfg(flags, name="SElectronRMinusToElectronGravitino", **kwargs):
336  result = ComponentAccumulator()
337  kwargs.setdefault("ParticleName","s_e_minus_R")
338  kwargs.setdefault("BR", 1.0) # Branching Ratio
339  kwargs.setdefault("Daughters","s_G,e-")
340  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
341  return result
342 
343 

◆ SElectronRMinusToElectronNeutralinoCfg()

def SleptonsConfig.SElectronRMinusToElectronNeutralinoCfg (   flags,
  name = "SElectronRMinusToElectronNeutralino",
**  kwargs 
)

Definition at line 801 of file SleptonsConfig.py.

801 def SElectronRMinusToElectronNeutralinoCfg(flags, name="SElectronRMinusToElectronNeutralino", **kwargs):
802  result = ComponentAccumulator()
803  kwargs.setdefault("ParticleName","s_e_minus_R")
804  kwargs.setdefault("BR", 1.0) # Branching Ratio
805  kwargs.setdefault("Daughters","s_chi_0_1,e-")
806  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
807  return result
808 
809 

◆ SElectronRPlusToElectronGravitinoCfg()

def SleptonsConfig.SElectronRPlusToElectronGravitinoCfg (   flags,
  name = "SElectronRPlusToElectronGravitino",
**  kwargs 
)

Gravitino Options.

Definition at line 326 of file SleptonsConfig.py.

326 def SElectronRPlusToElectronGravitinoCfg(flags, name="SElectronRPlusToElectronGravitino", **kwargs):
327  result = ComponentAccumulator()
328  kwargs.setdefault("ParticleName","s_e_plus_R")
329  kwargs.setdefault("BR", 1.0) # Branching Ratio
330  kwargs.setdefault("Daughters","s_G,e+")
331  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
332  return result
333 
334 

◆ SElectronRPlusToElectronNeutralinoCfg()

def SleptonsConfig.SElectronRPlusToElectronNeutralinoCfg (   flags,
  name = "SElectronRPlusToElectronNeutralino",
**  kwargs 
)

Neutralino Selectron.

Definition at line 792 of file SleptonsConfig.py.

792 def SElectronRPlusToElectronNeutralinoCfg(flags, name="SElectronRPlusToElectronNeutralino", **kwargs):
793  result = ComponentAccumulator()
794  kwargs.setdefault("ParticleName","s_e_plus_R")
795  kwargs.setdefault("BR", 1.0) # Branching Ratio
796  kwargs.setdefault("Daughters","s_chi_0_1,e+")
797  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
798  return result
799 
800 

◆ SleptonsLLP_VerboseSelectorCfg()

def SleptonsConfig.SleptonsLLP_VerboseSelectorCfg (   flags,
  name = "G4UA::VerboseSelectorTool",
**  kwargs 
)

Definition at line 1000 of file SleptonsConfig.py.

1000 def SleptonsLLP_VerboseSelectorCfg(flags, name="G4UA::VerboseSelectorTool", **kwargs):
1001  kwargs.setdefault('TargetEvent',1)
1002  kwargs.setdefault('VerboseLevel',1)
1003  kwargs.setdefault('TargetPdgIDs',
1004  [
1005  -1000001,1000001, # ~d(L)
1006  -1000002,1000002, # ~u(L)
1007  -1000003,1000003, # ~s(L)
1008  -1000004,1000004, # ~c(L)
1009  -1000005,1000005, # ~b(1)
1010  -1000006,1000006, # ~t(1)
1011  -1000011,1000011, # ~e(L)
1012  -1000013,1000013, # ~mu(L)'
1013  -1000015,1000015, # ~tau(L)
1014  -2000001,2000001, # ~d(R)
1015  -2000002,2000002, # ~u(R)
1016  -2000003,2000003, # ~s(R)
1017  -2000004,2000004, # ~c(R)
1018  -2000005,2000005, # ~b(2)
1019  -2000006,2000006, # ~t(2)
1020  -2000011,2000011, # ~e(R)
1021  -2000013,2000013, # ~mu(R)'
1022  -2000015,2000015, # ~tau(R)
1023  1000021, # ~g
1024  1000022, # ~chi(0,1)
1025  1000023, # ~chi(0,2)
1026  -1000024,1000024, # ~chi(+,1)
1027  1000025, # ~chi(0,3)
1028  1000035, # ~chi(0,4)
1029  -1000037,1000037, # ~chi(+,2)
1030  1000039 # ~G
1031  ])
1032  from G4DebuggingTools.G4DebuggingToolsConfig import VerboseSelectorToolCfg
1033  return VerboseSelectorToolCfg(flags, name, **kwargs)

◆ SleptonsLLPCfg()

def SleptonsConfig.SleptonsLLPCfg (   flags)

Definition at line 865 of file SleptonsConfig.py.

865 def SleptonsLLPCfg(flags):
866  result = ComponentAccumulator()
867  load_files_for_sleptonLLP_scenario(flags)
868 
869  if flags.Common.ProductionStep == ProductionStep.Simulation:
870  from G4AtlasServices.G4AtlasServicesConfig import PhysicsListSvcCfg
871  from Gauginos.GauginosConfig import GauginosPhysicsToolCfg
872  result.merge(PhysicsListSvcCfg(flags))
873  physicsOptions = [ result.popToolsAndMerge(GauginosPhysicsToolCfg(flags)) ]
874  physicsOptions += [ result.popToolsAndMerge(AllSleptonsPhysicsToolCfg(flags)) ]
875  # Slepton decays from SleptonsConfig
876  if "GMSBSlepton" in flags.Input.SpecialConfiguration:
877  physicsOptions += [ result.popToolsAndMerge(SElectronRPlusToElectronGravitinoCfg(flags)) ]
878  physicsOptions += [ result.popToolsAndMerge(SElectronLPlusToElectronGravitinoCfg(flags)) ]
879  physicsOptions += [ result.popToolsAndMerge(SElectronRMinusToElectronGravitinoCfg(flags)) ]
880  physicsOptions += [ result.popToolsAndMerge(SElectronLMinusToElectronGravitinoCfg(flags)) ]
881  physicsOptions += [ result.popToolsAndMerge(SMuonRPlusToMuonGravitinoCfg(flags)) ]
882  physicsOptions += [ result.popToolsAndMerge(SMuonLPlusToMuonGravitinoCfg(flags)) ]
883  physicsOptions += [ result.popToolsAndMerge(SMuonRMinusToMuonGravitinoCfg(flags)) ]
884  physicsOptions += [ result.popToolsAndMerge(SMuonLMinusToMuonGravitinoCfg(flags)) ]
885  if "GMSBStau" in flags.Input.SpecialConfiguration:
886  physicsOptions += [ result.popToolsAndMerge(STauRPlusToTauGravitinoCfg(flags)) ]
887  physicsOptions += [ result.popToolsAndMerge(STauLPlusToTauGravitinoCfg(flags)) ]
888  physicsOptions += [ result.popToolsAndMerge(STauRMinusToTauGravitinoCfg(flags)) ]
889  physicsOptions += [ result.popToolsAndMerge(STauLMinusToTauGravitinoCfg(flags)) ]
890  if "coannihilationStau" in flags.Input.SpecialConfiguration:
891  MassStau = eval(flags.Input.SpecialConfiguration.get("coannihilationStau",'0'))
892  MassNeutralino = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino",'0'))
893  MassTau = 1776. # MeV
894  if MassStau > MassNeutralino + MassTau:
895  physicsOptions += [ result.popToolsAndMerge(STauRPlusToTauNeutralinoCfg(flags)) ]
896  physicsOptions += [ result.popToolsAndMerge(STauLPlusToTauNeutralinoCfg(flags)) ]
897  physicsOptions += [ result.popToolsAndMerge(STauRMinusToTauNeutralinoCfg(flags)) ]
898  physicsOptions += [ result.popToolsAndMerge(STauLMinusToTauNeutralinoCfg(flags)) ]
899  else:
901  if (abs(MassStau-MassNeutralino - 300) > .05 and abs(MassStau-MassNeutralino - 1700) > 0.05):
902  print('Warning: Branching ratios are wrong. Mass splitting of stau neutralino %s currently has no available values.' % (MassStau - MassNeutralino))
903  physicsOptions += [ result.popToolsAndMerge(STauRMinusToPionMinusNeutralinoCfg(flags)) ]
904  physicsOptions += [ result.popToolsAndMerge(STauRPlusToPionPlusNeutralinoCfg(flags)) ]
905  physicsOptions += [ result.popToolsAndMerge(STauLMinusToPionMinusNeutralinoCfg(flags)) ]
906  physicsOptions += [ result.popToolsAndMerge(STauLPlusToPionPlusNeutralinoCfg(flags)) ]
907  physicsOptions += [ result.popToolsAndMerge(STauRMinusToRhoMinusNeutralinoCfg(flags)) ]
908  physicsOptions += [ result.popToolsAndMerge(STauRPlusToRhoPlusNeutralinoCfg(flags)) ]
909  physicsOptions += [ result.popToolsAndMerge(STauLMinusToRhoMinusNeutralinoCfg(flags)) ]
910  physicsOptions += [ result.popToolsAndMerge(STauLPlusToRhoPlusNeutralinoCfg(flags)) ]
911  physicsOptions += [ result.popToolsAndMerge(STauRMinusToEMinusNeutralinoCfg(flags)) ]
912  physicsOptions += [ result.popToolsAndMerge(STauRPlusToEPlusNeutralinoCfg(flags)) ]
913  physicsOptions += [ result.popToolsAndMerge(STauLMinusToEMinusNeutralinoCfg(flags)) ]
914  physicsOptions += [ result.popToolsAndMerge(STauLPlusToEPlusNeutralinoCfg(flags)) ]
915  physicsOptions += [ result.popToolsAndMerge(STauRMinusToMuMinusNeutralinoCfg(flags)) ]
916  physicsOptions += [ result.popToolsAndMerge(STauRPlusToMuPlusNeutralinoCfg(flags)) ]
917  physicsOptions += [ result.popToolsAndMerge(STauLMinusToMuMinusNeutralinoCfg(flags)) ]
918  physicsOptions += [ result.popToolsAndMerge(STauLPlusToMuPlusNeutralinoCfg(flags)) ]
919  physicsOptions += [ result.popToolsAndMerge(STauRMinusToa1MinusNeutralinoCfg(flags)) ]
920  physicsOptions += [ result.popToolsAndMerge(STauRPlusToa1PlusNeutralinoCfg(flags)) ]
921  physicsOptions += [ result.popToolsAndMerge(STauLMinusToa1MinusNeutralinoCfg(flags)) ]
922  physicsOptions += [ result.popToolsAndMerge(STauLPlusToa1PlusNeutralinoCfg(flags)) ]
923  if "coannihilationSlepton" in flags.Input.SpecialConfiguration:
924  physicsOptions += [ result.popToolsAndMerge(SElectronRPlusToElectronNeutralinoCfg(flags)) ]
925  physicsOptions += [ result.popToolsAndMerge(SElectronLPlusToElectronNeutralinoCfg(flags)) ]
926  physicsOptions += [ result.popToolsAndMerge(SElectronRMinusToElectronNeutralinoCfg(flags)) ]
927  physicsOptions += [ result.popToolsAndMerge(SElectronLMinusToElectronNeutralinoCfg(flags)) ]
928  physicsOptions += [ result.popToolsAndMerge(SMuonRPlusToMuonNeutralinoCfg(flags)) ]
929  physicsOptions += [ result.popToolsAndMerge(SMuonLPlusToMuonNeutralinoCfg(flags)) ]
930  physicsOptions += [ result.popToolsAndMerge(SMuonRMinusToMuonNeutralinoCfg(flags)) ]
931  physicsOptions += [ result.popToolsAndMerge(SMuonLMinusToMuonNeutralinoCfg(flags)) ]
932 
933  result.getService("PhysicsListSvc").PhysOption += physicsOptions
934  return result
935 
936 

◆ SleptonsPhysicsToolCfg()

def SleptonsConfig.SleptonsPhysicsToolCfg (   flags,
  name = "SleptonsPhysicsTool",
**  kwargs 
)

Definition at line 218 of file SleptonsConfig.py.

218 def SleptonsPhysicsToolCfg(flags, name="SleptonsPhysicsTool", **kwargs):
219  result = ComponentAccumulator()
220  if "GMSBStau" in flags.Input.SpecialConfiguration or "coannihilationStau" in flags.Input.SpecialConfiguration:
221  StauMass = None
222  if "GMSBStau" in flags.Input.SpecialConfiguration:
223  StauMass = eval(flags.Input.SpecialConfiguration.get("GMSBStau", "None"))
224  kwargs.setdefault("G4STau1MinusMass", StauMass)
225  kwargs.setdefault("G4STau1PlusMass", StauMass)
226  # TODO Check whether G4STau2(Plus/Minus)Mass should also be set here
227  elif "coannihilationStau" in flags.Input.SpecialConfiguration:
228  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
229  kwargs.setdefault("G4STau1MinusMass", StauMass)
230  kwargs.setdefault("G4STau1PlusMass", StauMass)
231  kwargs.setdefault("G4STau2MinusMass", StauMass)
232  kwargs.setdefault("G4STau2PlusMass", StauMass)
233 
234  if "GMSBSlepton" in flags.Input.SpecialConfiguration:
235  GMSBSlepton = eval(flags.Input.SpecialConfiguration.get("GMSBSlepton", "None"))
236 
237  kwargs.setdefault("G4SElectronRMinusMass", GMSBSlepton)
238  kwargs.setdefault("G4SElectronRPlusMass", GMSBSlepton)
239  kwargs.setdefault("G4SMuonRMinusMass", GMSBSlepton)
240  kwargs.setdefault("G4SMuonRPlusMass", GMSBSlepton)
241 
242  result.setPrivateTools( CompFactory.SleptonsPhysicsTool(name, **kwargs) )
243  return result
244 
245 

◆ SMuonLMinusToMuonGravitinoCfg()

def SleptonsConfig.SMuonLMinusToMuonGravitinoCfg (   flags,
  name = "SMuonLMinusToMuonGravitino",
**  kwargs 
)

Definition at line 407 of file SleptonsConfig.py.

407 def SMuonLMinusToMuonGravitinoCfg(flags, name="SMuonLMinusToMuonGravitino", **kwargs):
408  result = ComponentAccumulator()
409  kwargs.setdefault("ParticleName","s_mu_minus_L")
410  kwargs.setdefault("BR", 1.0) # Branching Ratio
411  kwargs.setdefault("Daughters","s_G,mu-")
412  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
413  return result
414 
415 

◆ SMuonLMinusToMuonNeutralinoCfg()

def SleptonsConfig.SMuonLMinusToMuonNeutralinoCfg (   flags,
  name = "SMuonLMinusToMuonNeutralino",
**  kwargs 
)

Definition at line 838 of file SleptonsConfig.py.

838 def SMuonLMinusToMuonNeutralinoCfg(flags, name="SMuonLMinusToMuonNeutralino", **kwargs):
839  result = ComponentAccumulator()
840  kwargs.setdefault("ParticleName","s_mu_minus_L")
841  kwargs.setdefault("BR", 1.0) # Branching Ratio
842  kwargs.setdefault("Daughters","s_chi_0_1,mu-")
843  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
844  return result
845 
846 

◆ SMuonLPlusToMuonGravitinoCfg()

def SleptonsConfig.SMuonLPlusToMuonGravitinoCfg (   flags,
  name = "SMuonLPlusToMuonGravitino",
**  kwargs 
)

Definition at line 398 of file SleptonsConfig.py.

398 def SMuonLPlusToMuonGravitinoCfg(flags, name="SMuonLPlusToMuonGravitino", **kwargs):
399  result = ComponentAccumulator()
400  kwargs.setdefault("ParticleName","s_mu_plus_L")
401  kwargs.setdefault("BR", 1.0) # Branching Ratio
402  kwargs.setdefault("Daughters","s_G,mu+")
403  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
404  return result
405 
406 

◆ SMuonLPlusToMuonNeutralinoCfg()

def SleptonsConfig.SMuonLPlusToMuonNeutralinoCfg (   flags,
  name = "SMuonLPlusToMuonNeutralino",
**  kwargs 
)

Neutralino SMuon.

Definition at line 829 of file SleptonsConfig.py.

829 def SMuonLPlusToMuonNeutralinoCfg(flags, name="SMuonLPlusToMuonNeutralino", **kwargs):
830  result = ComponentAccumulator()
831  kwargs.setdefault("ParticleName","s_mu_plus_L")
832  kwargs.setdefault("BR", 1.0) # Branching Ratio
833  kwargs.setdefault("Daughters","s_chi_0_1,mu+")
834  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
835  return result
836 
837 

◆ SMuonRMinusToMuonGravitinoCfg()

def SleptonsConfig.SMuonRMinusToMuonGravitinoCfg (   flags,
  name = "SMuonRMinusToMuonGravitino",
**  kwargs 
)

Definition at line 353 of file SleptonsConfig.py.

353 def SMuonRMinusToMuonGravitinoCfg(flags, name="SMuonRMinusToMuonGravitino", **kwargs):
354  result = ComponentAccumulator()
355  kwargs.setdefault("ParticleName","s_mu_minus_R")
356  kwargs.setdefault("BR", 1.0) # Branching Ratio
357  kwargs.setdefault("Daughters","s_G,mu-")
358  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
359  return result
360 
361 

◆ SMuonRMinusToMuonNeutralinoCfg()

def SleptonsConfig.SMuonRMinusToMuonNeutralinoCfg (   flags,
  name = "SMuonRMinusToMuonNeutralino",
**  kwargs 
)

Definition at line 856 of file SleptonsConfig.py.

856 def SMuonRMinusToMuonNeutralinoCfg(flags, name="SMuonRMinusToMuonNeutralino", **kwargs):
857  result = ComponentAccumulator()
858  kwargs.setdefault("ParticleName","s_mu_minus_R")
859  kwargs.setdefault("BR", 1.0) # Branching Ratio
860  kwargs.setdefault("Daughters","s_chi_0_1,mu-")
861  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
862  return result
863 
864 

◆ SMuonRPlusToMuonGravitinoCfg()

def SleptonsConfig.SMuonRPlusToMuonGravitinoCfg (   flags,
  name = "SMuonRPlusToMuonGravitino",
**  kwargs 
)

Definition at line 344 of file SleptonsConfig.py.

344 def SMuonRPlusToMuonGravitinoCfg(flags, name="SMuonRPlusToMuonGravitino", **kwargs):
345  result = ComponentAccumulator()
346  kwargs.setdefault("ParticleName","s_mu_plus_R")
347  kwargs.setdefault("BR", 1.0) # Branching Ratio
348  kwargs.setdefault("Daughters","s_G,mu+")
349  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
350  return result
351 
352 

◆ SMuonRPlusToMuonNeutralinoCfg()

def SleptonsConfig.SMuonRPlusToMuonNeutralinoCfg (   flags,
  name = "SMuonRPlusToMuonNeutralino",
**  kwargs 
)

Definition at line 847 of file SleptonsConfig.py.

847 def SMuonRPlusToMuonNeutralinoCfg(flags, name="SMuonRPlusToMuonNeutralino", **kwargs):
848  result = ComponentAccumulator()
849  kwargs.setdefault("ParticleName","s_mu_plus_R")
850  kwargs.setdefault("BR", 1.0) # Branching Ratio
851  kwargs.setdefault("Daughters","s_chi_0_1,mu+")
852  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
853  return result
854 
855 

◆ STauLMinusToa1MinusNeutralinoCfg()

def SleptonsConfig.STauLMinusToa1MinusNeutralinoCfg (   flags,
  name = "STauLMinusToa1MinusNeutralino",
**  kwargs 
)

Definition at line 761 of file SleptonsConfig.py.

761 def STauLMinusToa1MinusNeutralinoCfg(flags, name="STauLMinusToa1MinusNeutralino", **kwargs):
762  result = ComponentAccumulator()
763  BR = 0
764  # coannihilation Neutralino and Stau masses
765  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
766  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
767  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
768  BR = .15
769  kwargs.setdefault("ParticleName","s_tau_minus_1")
770  kwargs.setdefault("BR", BR) # Branching Ratio
771  kwargs.setdefault("Daughters","s_chi_0_1,a1(1260)-,nu_tau")
772  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
773  return result
774 
775 

◆ STauLMinusToEMinusNeutralinoCfg()

def SleptonsConfig.STauLMinusToEMinusNeutralinoCfg (   flags,
  name = "STauLMinusToEMinusNeutralino",
**  kwargs 
)

Definition at line 633 of file SleptonsConfig.py.

633 def STauLMinusToEMinusNeutralinoCfg(flags, name="STauLMinusToEMinusNeutralino", **kwargs):
634  result = ComponentAccumulator()
635  BR = .07
636  # coannihilation Neutralino and Stau masses
637  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
638  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
639  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
640  BR = .19
641  kwargs.setdefault("ParticleName","s_tau_minus_1")
642  kwargs.setdefault("BR", BR) # Branching Ratio
643  kwargs.setdefault("Daughters","s_chi_0_1,e-,nu_tau,anti_nu_e")
644  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
645  return result
646 
647 

◆ STauLMinusToMuMinusNeutralinoCfg()

def SleptonsConfig.STauLMinusToMuMinusNeutralinoCfg (   flags,
  name = "STauLMinusToMuMinusNeutralino",
**  kwargs 
)

Definition at line 697 of file SleptonsConfig.py.

697 def STauLMinusToMuMinusNeutralinoCfg(flags, name="STauLMinusToMuMinusNeutralino", **kwargs):
698  result = ComponentAccumulator()
699  BR = .03
700  # coannihilation Neutralino and Stau masses
701  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
702  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
703  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
704  BR = .18
705  kwargs.setdefault("ParticleName","s_tau_minus_1")
706  kwargs.setdefault("BR", BR) # Branching Ratio
707  kwargs.setdefault("Daughters","s_chi_0_1,mu-,nu_tau,anti_nu_mu")
708  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
709  return result
710 
711 

◆ STauLMinusToPionMinusNeutralinoCfg()

def SleptonsConfig.STauLMinusToPionMinusNeutralinoCfg (   flags,
  name = "STauLMinusToPionMinusNeutralino",
**  kwargs 
)

Definition at line 505 of file SleptonsConfig.py.

505 def STauLMinusToPionMinusNeutralinoCfg(flags, name="STauLMinusToPionMinusNeutralino", **kwargs):
506  result = ComponentAccumulator()
507  BR = .9
508  # coannihilation Neutralino and Stau masses
509  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
510  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
511  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
512  BR = .15
513  kwargs.setdefault("ParticleName","s_tau_minus_1")
514  kwargs.setdefault("BR", BR) # Branching Ratio
515  kwargs.setdefault("Daughters","s_chi_0_1,pi-,nu_tau")
516  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
517  return result
518 
519 

◆ STauLMinusToRhoMinusNeutralinoCfg()

def SleptonsConfig.STauLMinusToRhoMinusNeutralinoCfg (   flags,
  name = "STauLMinusToRhoMinusNeutralino",
**  kwargs 
)

Definition at line 569 of file SleptonsConfig.py.

569 def STauLMinusToRhoMinusNeutralinoCfg(flags, name="STauLMinusToRhoMinusNeutralino", **kwargs):
570  result = ComponentAccumulator()
571  BR = 0.0
572  # coannihilation Neutralino and Stau masses
573  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
574  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
575  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
576  BR = .33
577  kwargs.setdefault("ParticleName","s_tau_minus_1")
578  kwargs.setdefault("BR", BR) # Branching Ratio
579  kwargs.setdefault("Daughters","s_chi_0_1,rho-,nu_tau")
580  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
581  return result
582 
583 

◆ STauLMinusToTauGravitinoCfg()

def SleptonsConfig.STauLMinusToTauGravitinoCfg (   flags,
  name = "STauLMinusToTauGravitino",
**  kwargs 
)

Definition at line 371 of file SleptonsConfig.py.

371 def STauLMinusToTauGravitinoCfg(flags, name="STauLMinusToTauGravitino", **kwargs):
372  result = ComponentAccumulator()
373  kwargs.setdefault("ParticleName","s_tau_minus_1")
374  kwargs.setdefault("BR", 1.0) # Branching Ratio
375  kwargs.setdefault("Daughters","s_G,tau-")
376  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
377  return result
378 
379 

◆ STauLMinusToTauNeutralinoCfg()

def SleptonsConfig.STauLMinusToTauNeutralinoCfg (   flags,
  name = "STauLMinusToTauNeutralino",
**  kwargs 
)

Definition at line 453 of file SleptonsConfig.py.

453 def STauLMinusToTauNeutralinoCfg(flags, name="STauLMinusToTauNeutralino", **kwargs):
454  result = ComponentAccumulator()
455  kwargs.setdefault("ParticleName","s_tau_minus_1")
456  kwargs.setdefault("BR", 1.0) # Branching Ratio
457  kwargs.setdefault("Daughters","s_chi_0_1,tau-")
458  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
459  return result
460 
461 

◆ STauLPlusToa1PlusNeutralinoCfg()

def SleptonsConfig.STauLPlusToa1PlusNeutralinoCfg (   flags,
  name = "STauLPlusToa1PlusNeutralino",
**  kwargs 
)

Definition at line 776 of file SleptonsConfig.py.

776 def STauLPlusToa1PlusNeutralinoCfg(flags, name="STauLPlusToa1PlusNeutralino", **kwargs):
777  result = ComponentAccumulator()
778  BR = 0
779  # coannihilation Neutralino and Stau masses
780  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
781  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
782  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
783  BR = .15
784  kwargs.setdefault("ParticleName","s_tau_plus_1")
785  kwargs.setdefault("BR", BR) # Branching Ratio
786  kwargs.setdefault("Daughters","s_chi_0_1,a1(1260)+,anti_nu_tau")
787  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
788  return result
789 
790 

◆ STauLPlusToEPlusNeutralinoCfg()

def SleptonsConfig.STauLPlusToEPlusNeutralinoCfg (   flags,
  name = "STauLPlusToEPlusNeutralino",
**  kwargs 
)

Definition at line 648 of file SleptonsConfig.py.

648 def STauLPlusToEPlusNeutralinoCfg(flags, name="STauLPlusToEPlusNeutralino", **kwargs):
649  result = ComponentAccumulator()
650  BR = .07
651  # coannihilation Neutralino and Stau masses
652  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
653  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
654  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
655  BR = .03
656  kwargs.setdefault("ParticleName","s_tau_plus_1")
657  kwargs.setdefault("BR", BR) # Branching Ratio
658  kwargs.setdefault("Daughters","s_chi_0_1,e+,anti_nu_tau,nu_e")
659  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
660  return result
661 
662 

◆ STauLPlusToMuPlusNeutralinoCfg()

def SleptonsConfig.STauLPlusToMuPlusNeutralinoCfg (   flags,
  name = "STauLPlusToMuPlusNeutralino",
**  kwargs 
)

Definition at line 712 of file SleptonsConfig.py.

712 def STauLPlusToMuPlusNeutralinoCfg(flags, name="STauLPlusToMuPlusNeutralino", **kwargs):
713  result = ComponentAccumulator()
714  BR = .03
715  # coannihilation Neutralino and Stau masses
716  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
717  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
718  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
719  BR = .18
720  kwargs.setdefault("ParticleName","s_tau_plus_1")
721  kwargs.setdefault("BR", BR) # Branching Ratio
722  kwargs.setdefault("Daughters","s_chi_0_1,mu+,anti_nu_tau,nu_mu")
723  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
724  return result
725 
726 

◆ STauLPlusToPionPlusNeutralinoCfg()

def SleptonsConfig.STauLPlusToPionPlusNeutralinoCfg (   flags,
  name = "STauLPlusToPionPlusNeutralino",
**  kwargs 
)

Definition at line 520 of file SleptonsConfig.py.

520 def STauLPlusToPionPlusNeutralinoCfg(flags, name="STauLPlusToPionPlusNeutralino", **kwargs):
521  result = ComponentAccumulator()
522  BR = .9
523  # coannihilation Neutralino and Stau masses
524  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
525  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
526  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
527  BR = .15
528  kwargs.setdefault("ParticleName","s_tau_plus_1")
529  kwargs.setdefault("BR", BR) # Branching Ratio
530  kwargs.setdefault("Daughters","s_chi_0_1,pi+,anti_nu_tau")
531  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
532  return result
533 
534 

◆ STauLPlusToRhoPlusNeutralinoCfg()

def SleptonsConfig.STauLPlusToRhoPlusNeutralinoCfg (   flags,
  name = "STauLPlusToRhoPlusNeutralino",
**  kwargs 
)

Definition at line 584 of file SleptonsConfig.py.

584 def STauLPlusToRhoPlusNeutralinoCfg(flags, name="STauLPlusToRhoPlusNeutralino", **kwargs):
585  result = ComponentAccumulator()
586  BR = 0.0
587  # coannihilation Neutralino and Stau masses
588  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
589  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
590  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
591  BR = .33
592  kwargs.setdefault("ParticleName","s_tau_plus_1")
593  kwargs.setdefault("BR", BR) # Branching Ratio
594  kwargs.setdefault("Daughters","s_chi_0_1,rho+,anti_nu_tau")
595  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
596  return result
597 
598 

◆ STauLPlusToTauGravitinoCfg()

def SleptonsConfig.STauLPlusToTauGravitinoCfg (   flags,
  name = "STauLPlusToTauGravitino",
**  kwargs 
)

Definition at line 362 of file SleptonsConfig.py.

362 def STauLPlusToTauGravitinoCfg(flags, name="STauLPlusToTauGravitino", **kwargs):
363  result = ComponentAccumulator()
364  kwargs.setdefault("ParticleName","s_tau_plus_1")
365  kwargs.setdefault("BR", 1.0) # Branching Ratio
366  kwargs.setdefault("Daughters","s_G,tau+")
367  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
368  return result
369 
370 

◆ STauLPlusToTauNeutralinoCfg()

def SleptonsConfig.STauLPlusToTauNeutralinoCfg (   flags,
  name = "STauLPlusToTauNeutralino",
**  kwargs 
)

Definition at line 462 of file SleptonsConfig.py.

462 def STauLPlusToTauNeutralinoCfg(flags, name="STauLPlusToTauNeutralino", **kwargs):
463  result = ComponentAccumulator()
464  kwargs.setdefault("ParticleName","s_tau_plus_1")
465  kwargs.setdefault("BR", 1.0) # Branching Ratio
466  kwargs.setdefault("Daughters","s_chi_0_1,tau+")
467  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
468  return result
469 
470 

◆ STauRMinusToa1MinusNeutralinoCfg()

def SleptonsConfig.STauRMinusToa1MinusNeutralinoCfg (   flags,
  name = "STauRMinusToa1MinusNeutralino",
**  kwargs 
)

Neutralino-Stau Off shell tau Stau-Neutralino Pseuddo-Vector a1(1260) meson Neutrino.

Definition at line 731 of file SleptonsConfig.py.

731 def STauRMinusToa1MinusNeutralinoCfg(flags, name="STauRMinusToa1MinusNeutralino", **kwargs):
732  result = ComponentAccumulator()
733  BR = 0
734  # coannihilation Neutralino and Stau masses
735  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
736  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
737  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
738  BR = .15
739  kwargs.setdefault("ParticleName","s_tau_minus_2")
740  kwargs.setdefault("BR", BR) # Branching Ratio
741  kwargs.setdefault("Daughters","s_chi_0_1,a1(1260)-,nu_tau")
742  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
743  return result
744 
745 

◆ STauRMinusToEMinusNeutralinoCfg()

def SleptonsConfig.STauRMinusToEMinusNeutralinoCfg (   flags,
  name = "STauRMinusToEMinusNeutralino",
**  kwargs 
)

Neutralino-Stau Off shell tau Stau-Neutralino Electron Neutrino.

Definition at line 603 of file SleptonsConfig.py.

603 def STauRMinusToEMinusNeutralinoCfg(flags, name="STauRMinusToEMinusNeutralino", **kwargs):
604  result = ComponentAccumulator()
605  BR = .07
606  # coannihilation Neutralino and Stau masses
607  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
608  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
609  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
610  BR = .19
611  kwargs.setdefault("ParticleName","s_tau_minus_2")
612  kwargs.setdefault("BR", BR) # Branching Ratio
613  kwargs.setdefault("Daughters","s_chi_0_1,e-,nu_tau,anti_nu_e")
614  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
615  return result
616 
617 

◆ STauRMinusToMuMinusNeutralinoCfg()

def SleptonsConfig.STauRMinusToMuMinusNeutralinoCfg (   flags,
  name = "STauRMinusToMuMinusNeutralino",
**  kwargs 
)

Neutralino-Stau Off shell tau Stau-Neutralino Muon Neutrino.

Definition at line 667 of file SleptonsConfig.py.

667 def STauRMinusToMuMinusNeutralinoCfg(flags, name="STauRMinusToMuMinusNeutralino", **kwargs):
668  result = ComponentAccumulator()
669  BR = .03
670  # coannihilation Neutralino and Stau masses
671  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
672  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
673  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
674  BR = .18
675  kwargs.setdefault("ParticleName","s_tau_minus_2")
676  kwargs.setdefault("BR", BR) # Branching Ratio
677  kwargs.setdefault("Daughters","s_chi_0_1,mu-,nu_tau,anti_nu_mu")
678  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
679  return result
680 
681 

◆ STauRMinusToPionMinusNeutralinoCfg()

def SleptonsConfig.STauRMinusToPionMinusNeutralinoCfg (   flags,
  name = "STauRMinusToPionMinusNeutralino",
**  kwargs 
)

Neutralino-Stau Off shell tau Stau-Neutralino Pion Neutrino.

Definition at line 475 of file SleptonsConfig.py.

475 def STauRMinusToPionMinusNeutralinoCfg(flags, name="STauRMinusToPionMinusNeutralino", **kwargs):
476  result = ComponentAccumulator()
477  BR = .9
478  # coannihilation Neutralino and Stau masses
479  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
480  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
481  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
482  BR = .15
483  kwargs.setdefault("ParticleName","s_tau_minus_2")
484  kwargs.setdefault("BR", BR) # Branching Ratio
485  kwargs.setdefault("Daughters","s_chi_0_1,pi-,nu_tau")
486  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
487  return result
488 
489 

◆ STauRMinusToRhoMinusNeutralinoCfg()

def SleptonsConfig.STauRMinusToRhoMinusNeutralinoCfg (   flags,
  name = "STauRMinusToRhoMinusNeutralino",
**  kwargs 
)

Neutralino-Stau Off shell tau Stau-Neutralino Muon Neutrino.

Definition at line 539 of file SleptonsConfig.py.

539 def STauRMinusToRhoMinusNeutralinoCfg(flags, name="STauRMinusToRhoMinusNeutralino", **kwargs):
540  result = ComponentAccumulator()
541  BR = 0.0
542  # coannihilation Neutralino and Stau masses
543  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
544  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
545  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
546  BR = .33
547  kwargs.setdefault("ParticleName","s_tau_minus_2")
548  kwargs.setdefault("BR", BR) # Branching Ratio
549  kwargs.setdefault("Daughters","s_chi_0_1,rho-,nu_tau")
550  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
551  return result
552 
553 

◆ STauRMinusToTauGravitinoCfg()

def SleptonsConfig.STauRMinusToTauGravitinoCfg (   flags,
  name = "STauRMinusToTauGravitino",
**  kwargs 
)

Definition at line 425 of file SleptonsConfig.py.

425 def STauRMinusToTauGravitinoCfg(flags, name="STauRMinusToTauGravitino", **kwargs):
426  result = ComponentAccumulator()
427  kwargs.setdefault("ParticleName","s_tau_minus_2")
428  kwargs.setdefault("BR", 1.0) # Branching Ratio
429  kwargs.setdefault("Daughters","s_G,tau-")
430  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
431  return result
432 
433 

◆ STauRMinusToTauNeutralinoCfg()

def SleptonsConfig.STauRMinusToTauNeutralinoCfg (   flags,
  name = "STauRMinusToTauNeutralino",
**  kwargs 
)

Neutralino-Stau.

Definition at line 435 of file SleptonsConfig.py.

435 def STauRMinusToTauNeutralinoCfg(flags, name="STauRMinusToTauNeutralino", **kwargs):
436  result = ComponentAccumulator()
437  kwargs.setdefault("ParticleName","s_tau_minus_2")
438  kwargs.setdefault("BR", 1.0) # Branching Ratio
439  kwargs.setdefault("Daughters","s_chi_0_1,tau-")
440  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
441  return result
442 
443 

◆ STauRPlusToa1PlusNeutralinoCfg()

def SleptonsConfig.STauRPlusToa1PlusNeutralinoCfg (   flags,
  name = "STauRPlusToa1PlusNeutralino",
**  kwargs 
)

Definition at line 746 of file SleptonsConfig.py.

746 def STauRPlusToa1PlusNeutralinoCfg(flags, name="STauRPlusToa1PlusNeutralino", **kwargs):
747  result = ComponentAccumulator()
748  BR = 0
749  # coannihilation Neutralino and Stau masses
750  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
751  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
752  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
753  BR = .15
754  kwargs.setdefault("ParticleName","s_tau_plus_2")
755  kwargs.setdefault("BR", BR) # Branching Ratio
756  kwargs.setdefault("Daughters","s_chi_0_1,a1(1260)+,anti_nu_tau")
757  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
758  return result
759 
760 

◆ STauRPlusToEPlusNeutralinoCfg()

def SleptonsConfig.STauRPlusToEPlusNeutralinoCfg (   flags,
  name = "STauRPlusToEPlusNeutralino",
**  kwargs 
)

Definition at line 618 of file SleptonsConfig.py.

618 def STauRPlusToEPlusNeutralinoCfg(flags, name="STauRPlusToEPlusNeutralino", **kwargs):
619  result = ComponentAccumulator()
620  BR = .07
621  # coannihilation Neutralino and Stau masses
622  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
623  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
624  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
625  BR = .19
626  kwargs.setdefault("ParticleName","s_tau_plus_2")
627  kwargs.setdefault("BR", BR) # Branching Ratio
628  kwargs.setdefault("Daughters","s_chi_0_1,e+,anti_nu_tau,nu_e")
629  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
630  return result
631 
632 

◆ STauRPlusToMuPlusNeutralinoCfg()

def SleptonsConfig.STauRPlusToMuPlusNeutralinoCfg (   flags,
  name = "STauRPlusToMuPlusNeutralino",
**  kwargs 
)

Definition at line 682 of file SleptonsConfig.py.

682 def STauRPlusToMuPlusNeutralinoCfg(flags, name="STauRPlusToMuPlusNeutralino", **kwargs):
683  result = ComponentAccumulator()
684  BR = .03
685  # coannihilation Neutralino and Stau masses
686  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
687  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
688  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
689  BR = .18
690  kwargs.setdefault("ParticleName","s_tau_plus_2")
691  kwargs.setdefault("BR", BR) # Branching Ratio
692  kwargs.setdefault("Daughters","s_chi_0_1,mu+,anti_nu_tau,nu_mu")
693  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
694  return result
695 
696 

◆ STauRPlusToPionPlusNeutralinoCfg()

def SleptonsConfig.STauRPlusToPionPlusNeutralinoCfg (   flags,
  name = "STauRPlusToPionPlusNeutralino",
**  kwargs 
)

Definition at line 490 of file SleptonsConfig.py.

490 def STauRPlusToPionPlusNeutralinoCfg(flags, name="STauRPlusToPionPlusNeutralino", **kwargs):
491  result = ComponentAccumulator()
492  BR = .9
493  # coannihilation Neutralino and Stau masses
494  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
495  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
496  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
497  BR = .15
498  kwargs.setdefault("ParticleName","s_tau_plus_2")
499  kwargs.setdefault("BR", BR) # Branching Ratio
500  kwargs.setdefault("Daughters","s_chi_0_1,pi+,anti_nu_tau")
501  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
502  return result
503 
504 

◆ STauRPlusToRhoPlusNeutralinoCfg()

def SleptonsConfig.STauRPlusToRhoPlusNeutralinoCfg (   flags,
  name = "STauRPlusToRhoPlusNeutralino",
**  kwargs 
)

Definition at line 554 of file SleptonsConfig.py.

554 def STauRPlusToRhoPlusNeutralinoCfg(flags, name="STauRPlusToRhoPlusNeutralino", **kwargs):
555  result = ComponentAccumulator()
556  BR = 0.0
557  # coannihilation Neutralino and Stau masses
558  NeutralinoMass = eval(flags.Input.SpecialConfiguration.get("coannihilationNeutralino", "None"))
559  StauMass = eval(flags.Input.SpecialConfiguration.get("coannihilationStau", "None"))
560  if NeutralinoMass is not None and StauMass is not None and StauMass - Mass_a1Meson > NeutralinoMass:
561  BR = .33
562  kwargs.setdefault("ParticleName","s_tau_plus_2")
563  kwargs.setdefault("BR", BR) # Branching Ratio
564  kwargs.setdefault("Daughters","s_chi_0_1,rho+,anti_nu_tau")
565  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
566  return result
567 
568 

◆ STauRPlusToTauGravitinoCfg()

def SleptonsConfig.STauRPlusToTauGravitinoCfg (   flags,
  name = "STauRPlusToTauGravitino",
**  kwargs 
)

Definition at line 416 of file SleptonsConfig.py.

416 def STauRPlusToTauGravitinoCfg(flags, name="STauRPlusToTauGravitino", **kwargs):
417  result = ComponentAccumulator()
418  kwargs.setdefault("ParticleName","s_tau_plus_2")
419  kwargs.setdefault("BR", 1.0) # Branching Ratio
420  kwargs.setdefault("Daughters","s_G,tau+")
421  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
422  return result
423 
424 

◆ STauRPlusToTauNeutralinoCfg()

def SleptonsConfig.STauRPlusToTauNeutralinoCfg (   flags,
  name = "STauRPlusToTauNeutralino",
**  kwargs 
)

Definition at line 444 of file SleptonsConfig.py.

444 def STauRPlusToTauNeutralinoCfg(flags, name="STauRPlusToTauNeutralino", **kwargs):
445  result = ComponentAccumulator()
446  kwargs.setdefault("ParticleName","s_tau_plus_2")
447  kwargs.setdefault("BR", 1.0) # Branching Ratio
448  kwargs.setdefault("Daughters","s_chi_0_1,tau+")
449  result.setPrivateTools( CompFactory.AddPhysicsDecayTool(name, **kwargs) )
450  return result
451 
452 

Variable Documentation

◆ Mass_a1Meson

int SleptonsConfig.Mass_a1Meson = 1260.

Definition at line 25 of file SleptonsConfig.py.

xrange
void xrange(TH1 *h, bool symmetric)
Definition: computils.cxx:515
SleptonsConfig.GMSB_Cfg
def GMSB_Cfg(flags)
Definition: SleptonsConfig.py:937
PDGHelpers.updateExtraParticleAcceptList
def updateExtraParticleAcceptList(listName='G4particle_acceptlist_ExtraParticles.txt', pdgcodes=[])
Definition: PDGHelpers.py:57
SleptonsConfig.STauRMinusToa1MinusNeutralinoCfg
def STauRMinusToa1MinusNeutralinoCfg(flags, name="STauRMinusToa1MinusNeutralino", **kwargs)
Neutralino-Stau Off shell tau Stau-Neutralino Pseuddo-Vector a1(1260) meson Neutrino.
Definition: SleptonsConfig.py:731
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
SleptonsConfig.STauRPlusToEPlusNeutralinoCfg
def STauRPlusToEPlusNeutralinoCfg(flags, name="STauRPlusToEPlusNeutralino", **kwargs)
Definition: SleptonsConfig.py:618
python.G4DebuggingToolsConfig.VerboseSelectorToolCfg
def VerboseSelectorToolCfg(flags, name="G4UA::VerboseSelectorTool", **kwargs)
Definition: G4DebuggingToolsConfig.py:8
SleptonsConfig.STauLMinusToRhoMinusNeutralinoCfg
def STauLMinusToRhoMinusNeutralinoCfg(flags, name="STauLMinusToRhoMinusNeutralino", **kwargs)
Definition: SleptonsConfig.py:569
SleptonsConfig.SleptonsPhysicsToolCfg
def SleptonsPhysicsToolCfg(flags, name="SleptonsPhysicsTool", **kwargs)
Definition: SleptonsConfig.py:218
SleptonsConfig.STauRMinusToTauNeutralinoCfg
def STauRMinusToTauNeutralinoCfg(flags, name="STauRMinusToTauNeutralino", **kwargs)
Neutralino-Stau.
Definition: SleptonsConfig.py:435
GauginosConfig.GauginosPhysicsToolCfg
def GauginosPhysicsToolCfg(flags, name="GauginosPhysicsTool", **kwargs)
Definition: GauginosConfig.py:8
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
SleptonsConfig.STauLPlusToTauNeutralinoCfg
def STauLPlusToTauNeutralinoCfg(flags, name="STauLPlusToTauNeutralino", **kwargs)
Definition: SleptonsConfig.py:462
PDGHelpers.getPDGTABLE
def getPDGTABLE(table)
Definition: PDGHelpers.py:37
SleptonsConfig.STauLMinusToTauGravitinoCfg
def STauLMinusToTauGravitinoCfg(flags, name="STauLMinusToTauGravitino", **kwargs)
Definition: SleptonsConfig.py:371
SleptonsConfig.SElectronRPlusToElectronNeutralinoCfg
def SElectronRPlusToElectronNeutralinoCfg(flags, name="SElectronRPlusToElectronNeutralino", **kwargs)
Neutralino Selectron.
Definition: SleptonsConfig.py:792
SleptonsConfig.SElectronLPlusToElectronGravitinoCfg
def SElectronLPlusToElectronGravitinoCfg(flags, name="SElectronLPlusToElectronGravitino", **kwargs)
Definition: SleptonsConfig.py:380
SleptonsConfig.SMuonRMinusToMuonNeutralinoCfg
def SMuonRMinusToMuonNeutralinoCfg(flags, name="SMuonRMinusToMuonNeutralino", **kwargs)
Definition: SleptonsConfig.py:856
SleptonsConfig.get_and_fix_PDGTABLE_sleptons
def get_and_fix_PDGTABLE_sleptons(flags, replace)
Definition: SleptonsConfig.py:137
SleptonsConfig.SleptonsLLP_VerboseSelectorCfg
def SleptonsLLP_VerboseSelectorCfg(flags, name="G4UA::VerboseSelectorTool", **kwargs)
Definition: SleptonsConfig.py:1000
SleptonsConfig.get_and_fix_PDGTABLE_GMSB
def get_and_fix_PDGTABLE_GMSB(replace)
Definition: SleptonsConfig.py:28
SleptonsConfig.STauLMinusToEMinusNeutralinoCfg
def STauLMinusToEMinusNeutralinoCfg(flags, name="STauLMinusToEMinusNeutralino", **kwargs)
Definition: SleptonsConfig.py:633
SleptonsConfig.SMuonLPlusToMuonNeutralinoCfg
def SMuonLPlusToMuonNeutralinoCfg(flags, name="SMuonLPlusToMuonNeutralino", **kwargs)
Neutralino SMuon.
Definition: SleptonsConfig.py:829
SleptonsConfig.STauRMinusToRhoMinusNeutralinoCfg
def STauRMinusToRhoMinusNeutralinoCfg(flags, name="STauRMinusToRhoMinusNeutralino", **kwargs)
Neutralino-Stau Off shell tau Stau-Neutralino Muon Neutrino.
Definition: SleptonsConfig.py:539
SleptonsConfig.STauRMinusToEMinusNeutralinoCfg
def STauRMinusToEMinusNeutralinoCfg(flags, name="STauRMinusToEMinusNeutralino", **kwargs)
Neutralino-Stau Off shell tau Stau-Neutralino Electron Neutrino.
Definition: SleptonsConfig.py:603
SleptonsConfig.SElectronLPlusToElectronNeutralinoCfg
def SElectronLPlusToElectronNeutralinoCfg(flags, name="SElectronLPlusToElectronNeutralino", **kwargs)
Definition: SleptonsConfig.py:810
SleptonsConfig.load_files_for_GMSB_scenario
def load_files_for_GMSB_scenario(simdict)
Definition: SleptonsConfig.py:64
SleptonsConfig.STauLMinusToTauNeutralinoCfg
def STauLMinusToTauNeutralinoCfg(flags, name="STauLMinusToTauNeutralino", **kwargs)
Definition: SleptonsConfig.py:453
SleptonsConfig.STauRMinusToPionMinusNeutralinoCfg
def STauRMinusToPionMinusNeutralinoCfg(flags, name="STauRMinusToPionMinusNeutralino", **kwargs)
Neutralino-Stau Off shell tau Stau-Neutralino Pion Neutrino.
Definition: SleptonsConfig.py:475
SleptonsConfig.SMuonRMinusToMuonGravitinoCfg
def SMuonRMinusToMuonGravitinoCfg(flags, name="SMuonRMinusToMuonGravitino", **kwargs)
Definition: SleptonsConfig.py:353
SleptonsConfig.SElectronLMinusToElectronGravitinoCfg
def SElectronLMinusToElectronGravitinoCfg(flags, name="SElectronLMinusToElectronGravitino", **kwargs)
Definition: SleptonsConfig.py:389
SleptonsConfig.STauRPlusToMuPlusNeutralinoCfg
def STauRPlusToMuPlusNeutralinoCfg(flags, name="STauRPlusToMuPlusNeutralino", **kwargs)
Definition: SleptonsConfig.py:682
SleptonsConfig.STauLPlusToMuPlusNeutralinoCfg
def STauLPlusToMuPlusNeutralinoCfg(flags, name="STauLPlusToMuPlusNeutralino", **kwargs)
Definition: SleptonsConfig.py:712
SleptonsConfig.STauLMinusToa1MinusNeutralinoCfg
def STauLMinusToa1MinusNeutralinoCfg(flags, name="STauLMinusToa1MinusNeutralino", **kwargs)
Definition: SleptonsConfig.py:761
SleptonsConfig.SElectronRPlusToElectronGravitinoCfg
def SElectronRPlusToElectronGravitinoCfg(flags, name="SElectronRPlusToElectronGravitino", **kwargs)
Gravitino Options.
Definition: SleptonsConfig.py:326
SleptonsConfig.STauRPlusToTauNeutralinoCfg
def STauRPlusToTauNeutralinoCfg(flags, name="STauRPlusToTauNeutralino", **kwargs)
Definition: SleptonsConfig.py:444
SleptonsConfig.STauLPlusToa1PlusNeutralinoCfg
def STauLPlusToa1PlusNeutralinoCfg(flags, name="STauLPlusToa1PlusNeutralino", **kwargs)
Definition: SleptonsConfig.py:776
SleptonsConfig.SElectronRMinusToElectronNeutralinoCfg
def SElectronRMinusToElectronNeutralinoCfg(flags, name="SElectronRMinusToElectronNeutralino", **kwargs)
Definition: SleptonsConfig.py:801
SleptonsConfig.SMuonRPlusToMuonGravitinoCfg
def SMuonRPlusToMuonGravitinoCfg(flags, name="SMuonRPlusToMuonGravitino", **kwargs)
Definition: SleptonsConfig.py:344
SleptonsConfig.SElectronLMinusToElectronNeutralinoCfg
def SElectronLMinusToElectronNeutralinoCfg(flags, name="SElectronLMinusToElectronNeutralino", **kwargs)
Definition: SleptonsConfig.py:819
SleptonsConfig.SleptonsLLPCfg
def SleptonsLLPCfg(flags)
Definition: SleptonsConfig.py:865
TCS::join
std::string join(const std::vector< std::string > &v, const char c=',')
Definition: Trigger/TrigT1/L1Topo/L1TopoCommon/Root/StringUtils.cxx:10
SleptonsConfig.STauRMinusToMuMinusNeutralinoCfg
def STauRMinusToMuMinusNeutralinoCfg(flags, name="STauRMinusToMuMinusNeutralino", **kwargs)
Neutralino-Stau Off shell tau Stau-Neutralino Muon Neutrino.
Definition: SleptonsConfig.py:667
SleptonsConfig.SMuonLMinusToMuonNeutralinoCfg
def SMuonLMinusToMuonNeutralinoCfg(flags, name="SMuonLMinusToMuonNeutralino", **kwargs)
Definition: SleptonsConfig.py:838
G4AtlasServicesConfig.PhysicsListSvcCfg
def PhysicsListSvcCfg(flags, name="PhysicsListSvc", **kwargs)
Definition: G4AtlasServicesConfig.py:22
SleptonsConfig.AllSleptonsPhysicsToolCfg
def AllSleptonsPhysicsToolCfg(flags, name="AllSleptonsPhysicsTool", **kwargs)
Definition: SleptonsConfig.py:246
SleptonsConfig.SElectronRMinusToElectronGravitinoCfg
def SElectronRMinusToElectronGravitinoCfg(flags, name="SElectronRMinusToElectronGravitino", **kwargs)
Definition: SleptonsConfig.py:335
Trk::open
@ open
Definition: BinningType.h:40
SleptonsConfig.STauRPlusToTauGravitinoCfg
def STauRPlusToTauGravitinoCfg(flags, name="STauRPlusToTauGravitino", **kwargs)
Definition: SleptonsConfig.py:416
GauginosConfig.NeutralinoToPhotonGravitinoCfg
def NeutralinoToPhotonGravitinoCfg(flags, name="NeutralinoToPhotonGravitino", **kwargs)
Definition: GauginosConfig.py:31
SleptonsConfig.STauLPlusToPionPlusNeutralinoCfg
def STauLPlusToPionPlusNeutralinoCfg(flags, name="STauLPlusToPionPlusNeutralino", **kwargs)
Definition: SleptonsConfig.py:520
SleptonsConfig.SMuonLMinusToMuonGravitinoCfg
def SMuonLMinusToMuonGravitinoCfg(flags, name="SMuonLMinusToMuonGravitino", **kwargs)
Definition: SleptonsConfig.py:407
SleptonsConfig.STauLPlusToTauGravitinoCfg
def STauLPlusToTauGravitinoCfg(flags, name="STauLPlusToTauGravitino", **kwargs)
Definition: SleptonsConfig.py:362
SleptonsConfig.STauLMinusToPionMinusNeutralinoCfg
def STauLMinusToPionMinusNeutralinoCfg(flags, name="STauLMinusToPionMinusNeutralino", **kwargs)
Definition: SleptonsConfig.py:505
SleptonsConfig.load_files_for_sleptonLLP_scenario
def load_files_for_sleptonLLP_scenario(flags)
Definition: SleptonsConfig.py:172
SleptonsConfig.SMuonRPlusToMuonNeutralinoCfg
def SMuonRPlusToMuonNeutralinoCfg(flags, name="SMuonRPlusToMuonNeutralino", **kwargs)
Definition: SleptonsConfig.py:847
SleptonsConfig.GMSB_VerboseSelectorCfg
def GMSB_VerboseSelectorCfg(flags, name="G4UA::VerboseSelectorTool", **kwargs)
Definition: SleptonsConfig.py:964
SleptonsConfig.STauRPlusToa1PlusNeutralinoCfg
def STauRPlusToa1PlusNeutralinoCfg(flags, name="STauRPlusToa1PlusNeutralino", **kwargs)
Definition: SleptonsConfig.py:746
str
Definition: BTagTrackIpAccessor.cxx:11
dbg::print
void print(std::FILE *stream, std::format_string< Args... > fmt, Args &&... args)
Definition: SGImplSvc.cxx:70
SleptonsConfig.STauRPlusToRhoPlusNeutralinoCfg
def STauRPlusToRhoPlusNeutralinoCfg(flags, name="STauRPlusToRhoPlusNeutralino", **kwargs)
Definition: SleptonsConfig.py:554
SleptonsConfig.STauRMinusToTauGravitinoCfg
def STauRMinusToTauGravitinoCfg(flags, name="STauRMinusToTauGravitino", **kwargs)
Definition: SleptonsConfig.py:425
SleptonsConfig.SMuonLPlusToMuonGravitinoCfg
def SMuonLPlusToMuonGravitinoCfg(flags, name="SMuonLPlusToMuonGravitino", **kwargs)
Definition: SleptonsConfig.py:398
SleptonsConfig.STauLMinusToMuMinusNeutralinoCfg
def STauLMinusToMuMinusNeutralinoCfg(flags, name="STauLMinusToMuMinusNeutralino", **kwargs)
Definition: SleptonsConfig.py:697
SleptonsConfig.STauRPlusToPionPlusNeutralinoCfg
def STauRPlusToPionPlusNeutralinoCfg(flags, name="STauRPlusToPionPlusNeutralino", **kwargs)
Definition: SleptonsConfig.py:490
SleptonsConfig.STauLPlusToRhoPlusNeutralinoCfg
def STauLPlusToRhoPlusNeutralinoCfg(flags, name="STauLPlusToRhoPlusNeutralino", **kwargs)
Definition: SleptonsConfig.py:584
SleptonsConfig.STauLPlusToEPlusNeutralinoCfg
def STauLPlusToEPlusNeutralinoCfg(flags, name="STauLPlusToEPlusNeutralino", **kwargs)
Definition: SleptonsConfig.py:648
Generated on Fri Oct 4 2024 22:27:24 for ATLAS Offline Software by   doxygen 1.8.18