ATLAS Offline Software
Functions
MonopoleConfig Namespace Reference

Functions

def load_files_for_monopole_scenario (MASS, GCHARGE)
 
def load_files_for_qball_scenario (MASS, CHARGE)
 
def load_files_for_fcp_scenario (MASS, CHARGE, X, Y)
 
def load_files_for_dyon_scenario (MASS, CHARGE, GCHARGE)
 
def MonopolePhysicsToolCfg (flags, name="MonopolePhysicsTool", **kwargs)
 
def G4mplEqMagElectricFieldToolCfg (flags, name="G4mplEqMagElectricField", **kwargs)
 
def fcpPreInclude (flags)
 
def fcpCfg (flags)
 
def QballPreInclude (flags)
 
def QballCfg (flags)
 
def DyonPreInclude (flags)
 
def DyonCfg (flags)
 
def MonopolePreInclude (flags)
 
def MonopoleCfg (flags)
 
def Monopole_VerboseSelectorCfg (flags, name="G4UA::VerboseSelectorTool", **kwargs)
 

Function Documentation

◆ DyonCfg()

def MonopoleConfig.DyonCfg (   flags)

Definition at line 261 of file MonopoleConfig.py.

261 def DyonCfg(flags):
262  result = ComponentAccumulator()
263  if flags.Common.ProductionStep == ProductionStep.Simulation:
264  from G4AtlasServices.G4AtlasServicesConfig import PhysicsListSvcCfg
265  result.merge(PhysicsListSvcCfg(flags))
266 
267  simdict = flags.Input.SpecialConfiguration
268  assert "MASS" in simdict
269  assert "CHARGE" in simdict
270  assert "GCHARGE" in simdict
271  load_files_for_dyon_scenario(simdict["MASS"], simdict["CHARGE"], simdict["GCHARGE"])
272  pdgcodes = eval(simdict['InteractingPDGCodes']) if 'InteractingPDGCodes' in simdict else []
273  from ExtraParticles.PDGHelpers import updateExtraParticleAcceptList
274  updateExtraParticleAcceptList('G4particle_acceptlist_ExtraParticles.txt', pdgcodes)
275 
276  if flags.Common.ProductionStep == ProductionStep.Simulation:
277  from GaudiKernel.GaudiHandles import PrivateToolHandleArray
278  physicsOptions = PrivateToolHandleArray([ result.popToolsAndMerge(MonopolePhysicsToolCfg(flags)) ])
279  result.getService("PhysicsListSvc").PhysOption = physicsOptions + result.getService("PhysicsListSvc").PhysOption
280  return result
281 
282 

◆ DyonPreInclude()

def MonopoleConfig.DyonPreInclude (   flags)

Definition at line 243 of file MonopoleConfig.py.

243 def DyonPreInclude(flags):
244  if flags.Common.ProductionStep == ProductionStep.Simulation:
245  # add monopole-specific configuration for looper killer
246  flags.Sim.OptionalUserActionList += ['G4UserActions.G4UserActionsConfig.MonopoleLooperKillerToolCfg']
247  # add default HIP killer
248  flags.Sim.OptionalUserActionList += ['G4UserActions.G4UserActionsConfig.HIPKillerToolCfg']
249  flags.Sim.G4Stepper = 'ClassicalRK4'
250  flags.Sim.G4EquationOfMotion = "G4mplEqMagElectricField" #Monopole Equation of Motion
251  flags.Sim.TightMuonStepping = False
252  simdict = flags.Input.SpecialConfiguration
253  if "InteractingPDGCodes" not in simdict:
254  assert "CHARGE" in simdict
255  CODE=4110000+int(float(simdict["CHARGE"])*10)
256  CODE2=4120000+int(float(simdict["CHARGE"])*10)
257  simdict['InteractingPDGCodes'] = str([CODE,-1*CODE,CODE2,-1*CODE2])
258  flags.Input.SpecialConfiguration = simdict
259 
260 

◆ fcpCfg()

def MonopoleConfig.fcpCfg (   flags)

Definition at line 181 of file MonopoleConfig.py.

181 def fcpCfg(flags):
182  result = ComponentAccumulator()
183  if flags.Common.ProductionStep == ProductionStep.Simulation:
184  from G4AtlasServices.G4AtlasServicesConfig import PhysicsListSvcCfg
185  result.merge(PhysicsListSvcCfg(flags))
186 
187  simdict = flags.Input.SpecialConfiguration
188  load_files_for_fcp_scenario(simdict["MASS"], simdict["CHARGE"], simdict["X"], simdict["Y"])
189  pdgcodes = eval(simdict['InteractingPDGCodes']) if 'InteractingPDGCodes' in simdict else []
190  from ExtraParticles.PDGHelpers import updateExtraParticleAcceptList
191  updateExtraParticleAcceptList('G4particle_acceptlist_ExtraParticles.txt', pdgcodes)
192 
193  if flags.Common.ProductionStep == ProductionStep.Simulation:
194  physicsOptions = [ result.popToolsAndMerge(MonopolePhysicsToolCfg(flags)) ]
195  result.getService("PhysicsListSvc").PhysOption += physicsOptions
196  # add monopole-specific configuration for looper killer
197  #simFlags.OptionalUserActionList.addAction('G4UA::MonopoleLooperKillerTool') #FIXME missing functionality
198  # add default HIP killer
199  #simFlags.OptionalUserActionList.addAction('G4UA::HIPKillerTool') #FIXME missing functionality
200 
201  return result
202 
203 

◆ fcpPreInclude()

def MonopoleConfig.fcpPreInclude (   flags)

Definition at line 165 of file MonopoleConfig.py.

165 def fcpPreInclude(flags):
166  simdict = flags.Input.SpecialConfiguration
167  if flags.Common.ProductionStep == ProductionStep.Simulation:
168  # add monopole-specific configuration for looper killer
169  flags.Sim.OptionalUserActionList += ['G4UserActions.G4UserActionsConfig.MonopoleLooperKillerToolCfg']
170  # add default HIP killer
171  flags.Sim.OptionalUserActionList += ['G4UserActions.G4UserActionsConfig.HIPKillerToolCfg']
172  if "InteractingPDGCodes" not in simdict: #FIXME This code would ideally update the ConfigFlag itself
173  assert "CHARGE" in simdict
174  assert "X" in simdict
175  assert "Y" in simdict
176  CODE=int(20000000)+int(simdict["X"])*1000+int(simdict["Y"])*10
177  simdict['InteractingPDGCodes'] = str([CODE,-1*CODE])
178  flags.Input.SpecialConfiguration = simdict
179 
180 

◆ G4mplEqMagElectricFieldToolCfg()

def MonopoleConfig.G4mplEqMagElectricFieldToolCfg (   flags,
  name = "G4mplEqMagElectricField",
**  kwargs 
)

Definition at line 159 of file MonopoleConfig.py.

159 def G4mplEqMagElectricFieldToolCfg(flags, name="G4mplEqMagElectricField", **kwargs):
160  result = ComponentAccumulator()
161  result.setPrivateTools( CompFactory.G4mplEqMagElectricFieldTool(name, **kwargs) )
162  return result
163 
164 

◆ load_files_for_dyon_scenario()

def MonopoleConfig.load_files_for_dyon_scenario (   MASS,
  CHARGE,
  GCHARGE 
)

Definition at line 104 of file MonopoleConfig.py.

104 def load_files_for_dyon_scenario(MASS, CHARGE, GCHARGE):
105  CODE=4110000+int(CHARGE)*10
106  CODE2=4120000+int(CHARGE)*10
107  if getPDGTABLE('PDGTABLE.MeV'):
108  ALINE1="M {code} {intmass}.E+03 +0.0E+00 -0.0E+00 DyonSS 0".format(code=CODE,intmass=int(MASS)) #Dyon magnetic and electric charges are the same sign
109  ALINE2="W {code} 0.E+00 +0.0E+00 -0.0E+00 DyonSS 0".format(code=CODE)
110  ALINE3="M {code2} {intmass}.E+03 +0.0E+00 -0.0E+00 DyonOS 0".format(code2=CODE2,intmass=int(MASS)) #Dyon magnetic and electric charges are opposite signs
111  ALINE4="W {code2} 0.E+00 +0.0E+00 -0.0E+00 DyonOS 0".format(code2=CODE2)
112 
113 
114  BLINE1="{code} {intmass}.00 {fcharge} {gcharge} # DyonSS".format(code=CODE, intmass=int(MASS), fcharge=float(CHARGE), gcharge=GCHARGE)
115  BLINE2="-{code} {intmass}.00 -{fcharge} -{gcharge} # DyonSSBar".format(code=CODE, intmass=int(MASS), fcharge=float(CHARGE), gcharge=GCHARGE)
116  BLINE3="{code2} {intmass}.00 -{fcharge} {gcharge} # DyonOS".format(code2=CODE2, intmass=int(MASS), fcharge=float(CHARGE), gcharge=GCHARGE)
117  BLINE4="-{code2} {intmass}.00 {fcharge} -{gcharge} # DyonOSBar".format(code2=CODE2, intmass=int(MASS), fcharge=float(CHARGE), gcharge=GCHARGE)
118 
119  f=open('PDGTABLE.MeV','a')
120  f.writelines(str(ALINE1))
121  f.writelines('\n')
122  f.writelines(str(ALINE2))
123  f.writelines('\n')
124  f.writelines(str(ALINE3))
125  f.writelines('\n')
126  f.writelines(str(ALINE4))
127  f.writelines('\n')
128  f.close()
129  partmod = os.path.isfile('particles.txt')
130  if partmod is True:
131  os.remove('particles.txt')
132  f=open('particles.txt','w')
133  f.writelines(str(BLINE1))
134  f.writelines('\n')
135  f.writelines(str(BLINE2))
136  f.writelines('\n')
137  f.writelines(str(BLINE3))
138  f.writelines('\n')
139  f.writelines(str(BLINE4))
140  f.writelines('\n')
141  f.close()
142 
143  del ALINE1
144  del ALINE2
145  del ALINE3
146  del ALINE4
147  del BLINE1
148  del BLINE2
149  del BLINE3
150  del BLINE4
151 
152 

◆ load_files_for_fcp_scenario()

def MonopoleConfig.load_files_for_fcp_scenario (   MASS,
  CHARGE,
  X,
  Y 
)

Definition at line 74 of file MonopoleConfig.py.

74 def load_files_for_fcp_scenario(MASS, CHARGE, X, Y):
75  CODE=int(20000000)+int(X)*1000+int(Y)*10
76  print("Trying to load %s, %s for particle with code %s" % (X, Y, CODE))
77 
78  pdgLine1="M {code} {intmass}.E+03 +0.0E+00 -0.0E+00 fcp +\n".format(code=CODE,intmass=int(MASS))
79  pdgLine2="W {code} 0.E+00 +0.0E+00 -0.0E+00 fcp +\n".format(code=CODE)
80  particleLine1="{code} {intmass}.00 {fcharge} 0.0 # fcp\n".format(code=CODE,intmass=int(MASS), fcharge=float(CHARGE))
81  particleLine2="-{code} {intmass}.00 -{fcharge} 0.0 # fcpBar\n".format(code=CODE,intmass=int(MASS), fcharge=float(CHARGE))
82 
83  # retreive the PDGTABLE file
84  if getPDGTABLE('PDGTABLE.MeV'):
85  f=open('PDGTABLE.MeV','a')
86  f.writelines(str(pdgLine1))
87  f.writelines(str(pdgLine2))
88  f.close()
89  partmod = os.path.isfile('particles.txt')
90  if partmod is True:
91  os.remove('particles.txt')
92  f=open('particles.txt','w')
93  f.writelines(str(particleLine1))
94  f.writelines(str(particleLine2))
95  f.close()
96 
97  del pdgLine1
98  del pdgLine2
99  del particleLine1
100  del particleLine2
101 
102 
103 @AccumulatorCache

◆ load_files_for_monopole_scenario()

def MonopoleConfig.load_files_for_monopole_scenario (   MASS,
  GCHARGE 
)

Definition at line 12 of file MonopoleConfig.py.

12 def load_files_for_monopole_scenario(MASS, GCHARGE):
13  if getPDGTABLE('PDGTABLE.MeV'):
14  ALINE1="M 4110000 {intmass}.E+03 +0.0E+00 -0.0E+00 Monopole 0".format(intmass=int(MASS))
15  ALINE2="W 4110000 0.E+00 +0.0E+00 -0.0E+00 Monopole 0"
16  BLINE1="4110000 {intmass}.00 0.0 {gcharge} # Monopole".format(intmass=int(MASS), gcharge=GCHARGE)
17  BLINE2="-4110000 {intmass}.00 0.0 -{gcharge} # MonopoleBar".format(intmass=int(MASS), gcharge=GCHARGE)
18 
19  f=open('PDGTABLE.MeV','a')
20  f.writelines(str(ALINE1))
21  f.writelines('\n')
22  f.writelines(str(ALINE2))
23  f.writelines('\n')
24  f.close()
25  partmod = os.path.isfile('particles.txt')
26  if partmod is True:
27  os.remove('particles.txt')
28  f=open('particles.txt','w')
29  f.writelines(str(BLINE1))
30  f.writelines('\n')
31  f.writelines(str(BLINE2))
32  f.writelines('\n')
33  f.close()
34 
35  del ALINE1
36  del ALINE2
37  del BLINE1
38  del BLINE2
39 
40 
41 @AccumulatorCache

◆ load_files_for_qball_scenario()

def MonopoleConfig.load_files_for_qball_scenario (   MASS,
  CHARGE 
)

Definition at line 42 of file MonopoleConfig.py.

42 def load_files_for_qball_scenario(MASS, CHARGE):
43  if getPDGTABLE('PDGTABLE.MeV'):
44  CODE=10000000+int(float(CHARGE)*100)
45 
46  ALINE1="M {code} {intmass}.E+03 +0.0E+00 -0.0E+00 Qball +".format(code=CODE,intmass=int(MASS))
47  ALINE2="W {code} 0.E+00 +0.0E+00 -0.0E+00 Qball +".format(code=CODE)
48  BLINE1="{code} {intmass}.00 {charge} 0.0 # Qball".format(code=CODE,intmass=int(MASS), charge=CHARGE)
49  BLINE2="-{code} {intmass}.00 -{charge} 0.0 # QballBar".format(code=CODE,intmass=int(MASS), charge=CHARGE)
50 
51  f=open('PDGTABLE.MeV','a')
52  f.writelines(str(ALINE1))
53  f.writelines('\n')
54  f.writelines(str(ALINE2))
55  f.writelines('\n')
56  f.close()
57  partmod = os.path.isfile('particles.txt')
58  if partmod is True:
59  os.remove('particles.txt')
60  f=open('particles.txt','w')
61  f.writelines(str(BLINE1))
62  f.writelines('\n')
63  f.writelines(str(BLINE2))
64  f.writelines('\n')
65  f.close()
66 
67  del ALINE1
68  del ALINE2
69  del BLINE1
70  del BLINE2
71 
72 
73 @AccumulatorCache

◆ Monopole_VerboseSelectorCfg()

def MonopoleConfig.Monopole_VerboseSelectorCfg (   flags,
  name = "G4UA::VerboseSelectorTool",
**  kwargs 
)

Definition at line 319 of file MonopoleConfig.py.

319 def Monopole_VerboseSelectorCfg(flags, name="G4UA::VerboseSelectorTool", **kwargs): kwargs.setdefault('TargetEvent',1)
320  kwargs.setdefault('VerboseLevel',1)
321  kwargs.setdefault('TargetPdgIDs',
322  [
323  -4110000,4110000 #Monopoles
324  ])
325  from G4DebuggingTools.G4DebuggingToolsConfig import VerboseSelectorToolCfg
326  return VerboseSelectorToolCfg(flags, name, **kwargs)
327 

◆ MonopoleCfg()

def MonopoleConfig.MonopoleCfg (   flags)

Definition at line 298 of file MonopoleConfig.py.

298 def MonopoleCfg(flags):
299  result = ComponentAccumulator()
300  if flags.Common.ProductionStep == ProductionStep.Simulation:
301  from G4AtlasServices.G4AtlasServicesConfig import PhysicsListSvcCfg
302  result.merge(PhysicsListSvcCfg(flags))
303 
304  simdict = flags.Input.SpecialConfiguration
305  assert "MASS" in simdict
306  assert "GCHARGE" in simdict
307  load_files_for_monopole_scenario(simdict["MASS"], simdict["GCHARGE"])
308  pdgcodes = eval(simdict['InteractingPDGCodes']) if 'InteractingPDGCodes' in simdict else []
309  from ExtraParticles.PDGHelpers import updateExtraParticleAcceptList
310  updateExtraParticleAcceptList('G4particle_acceptlist_ExtraParticles.txt', pdgcodes)
311 
312  if flags.Common.ProductionStep == ProductionStep.Simulation:
313  from GaudiKernel.GaudiHandles import PrivateToolHandleArray
314  physicsOptions = PrivateToolHandleArray([ result.popToolsAndMerge(MonopolePhysicsToolCfg(flags)) ])
315  result.getService("PhysicsListSvc").PhysOption = physicsOptions + result.getService("PhysicsListSvc").PhysOption
316  return result
317 
318 

◆ MonopolePhysicsToolCfg()

def MonopoleConfig.MonopolePhysicsToolCfg (   flags,
  name = "MonopolePhysicsTool",
**  kwargs 
)

Definition at line 153 of file MonopoleConfig.py.

153 def MonopolePhysicsToolCfg(flags, name="MonopolePhysicsTool", **kwargs):
154  result = ComponentAccumulator()
155  result.setPrivateTools( CompFactory.MonopolePhysicsTool(name, **kwargs) )
156  return result
157 
158 

◆ MonopolePreInclude()

def MonopoleConfig.MonopolePreInclude (   flags)

Definition at line 283 of file MonopoleConfig.py.

283 def MonopolePreInclude(flags):
284  if flags.Common.ProductionStep == ProductionStep.Simulation:
285  # add monopole-specific configuration for looper killer
286  flags.Sim.OptionalUserActionList += ['G4UserActions.G4UserActionsConfig.MonopoleLooperKillerToolCfg']
287  # add default HIP killer
288  flags.Sim.OptionalUserActionList += ['G4UserActions.G4UserActionsConfig.HIPKillerToolCfg']
289  flags.Sim.G4Stepper = 'ClassicalRK4'
290  flags.Sim.G4EquationOfMotion = "G4mplEqMagElectricField" #Monopole Equation of Motion
291  flags.Sim.TightMuonStepping = False
292  simdict = flags.Input.SpecialConfiguration
293  if "InteractingPDGCodes" not in simdict:
294  simdict['InteractingPDGCodes'] = str([4110000,-4110000])
295  flags.Input.SpecialConfiguration = simdict
296 
297 

◆ QballCfg()

def MonopoleConfig.QballCfg (   flags)

Definition at line 218 of file MonopoleConfig.py.

218 def QballCfg(flags):
219  result = ComponentAccumulator()
220  simdict = flags.Input.SpecialConfiguration
221  if flags.Common.ProductionStep == ProductionStep.Simulation:
222  from G4AtlasServices.G4AtlasServicesConfig import PhysicsListSvcCfg
223  result.merge(PhysicsListSvcCfg(flags))
224  if "InteractingPDGCodes" not in simdict:
225  assert "CHARGE" in simdict
226  CODE=10000000+int(float(simdict["CHARGE"])*100)
227  simdict['InteractingPDGCodes'] = str([CODE,-1*CODE])
228 
229  assert "MASS" in simdict
230  assert "CHARGE" in simdict
231  load_files_for_qball_scenario(simdict["MASS"], simdict["CHARGE"])
232  pdgcodes = eval(simdict['InteractingPDGCodes']) if 'InteractingPDGCodes' in simdict else []
233  from ExtraParticles.PDGHelpers import updateExtraParticleAcceptList
234  updateExtraParticleAcceptList('G4particle_acceptlist_ExtraParticles.txt', pdgcodes)
235 
236  if flags.Common.ProductionStep == ProductionStep.Simulation:
237  physicsOptions = [ result.popToolsAndMerge(MonopolePhysicsToolCfg(flags)) ]
238  result.getService("PhysicsListSvc").PhysOption += physicsOptions
239 
240  return result
241 
242 

◆ QballPreInclude()

def MonopoleConfig.QballPreInclude (   flags)

Definition at line 204 of file MonopoleConfig.py.

204 def QballPreInclude(flags):
205  simdict = flags.Input.SpecialConfiguration
206  if flags.Common.ProductionStep == ProductionStep.Simulation:
207  # add monopole-specific configuration for looper killer
208  flags.Sim.OptionalUserActionList += ['G4UserActions.G4UserActionsConfig.MonopoleLooperKillerToolCfg']
209  # add default HIP killer
210  flags.Sim.OptionalUserActionList += ['G4UserActions.G4UserActionsConfig.HIPKillerToolCfg']
211  if "InteractingPDGCodes" not in simdict:
212  assert "CHARGE" in simdict
213  CODE=10000000+int(float(simdict["CHARGE"])*100)
214  simdict['InteractingPDGCodes'] = str([CODE,-1*CODE])
215  flags.Input.SpecialConfiguration = simdict
216 
217 
PDGHelpers.updateExtraParticleAcceptList
def updateExtraParticleAcceptList(listName='G4particle_acceptlist_ExtraParticles.txt', pdgcodes=[])
Definition: PDGHelpers.py:57
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
MonopoleConfig.DyonPreInclude
def DyonPreInclude(flags)
Definition: MonopoleConfig.py:243
python.G4DebuggingToolsConfig.VerboseSelectorToolCfg
def VerboseSelectorToolCfg(flags, name="G4UA::VerboseSelectorTool", **kwargs)
Definition: G4DebuggingToolsConfig.py:9
vtune_athena.format
format
Definition: vtune_athena.py:14
MonopoleConfig.fcpCfg
def fcpCfg(flags)
Definition: MonopoleConfig.py:181
MonopoleConfig.MonopolePreInclude
def MonopolePreInclude(flags)
Definition: MonopoleConfig.py:283
PDGHelpers.getPDGTABLE
def getPDGTABLE(table)
Definition: PDGHelpers.py:37
MonopoleConfig.G4mplEqMagElectricFieldToolCfg
def G4mplEqMagElectricFieldToolCfg(flags, name="G4mplEqMagElectricField", **kwargs)
Definition: MonopoleConfig.py:159
MonopoleConfig.QballPreInclude
def QballPreInclude(flags)
Definition: MonopoleConfig.py:204
MonopoleConfig.load_files_for_dyon_scenario
def load_files_for_dyon_scenario(MASS, CHARGE, GCHARGE)
Definition: MonopoleConfig.py:104
MonopoleConfig.load_files_for_monopole_scenario
def load_files_for_monopole_scenario(MASS, GCHARGE)
Definition: MonopoleConfig.py:12
MonopoleConfig.DyonCfg
def DyonCfg(flags)
Definition: MonopoleConfig.py:261
print
void print(char *figname, TCanvas *c1)
Definition: TRTCalib_StrawStatusPlots.cxx:25
MonopoleConfig.MonopoleCfg
def MonopoleCfg(flags)
Definition: MonopoleConfig.py:298
MonopoleConfig.MonopolePhysicsToolCfg
def MonopolePhysicsToolCfg(flags, name="MonopolePhysicsTool", **kwargs)
Definition: MonopoleConfig.py:153
G4AtlasServicesConfig.PhysicsListSvcCfg
def PhysicsListSvcCfg(flags, name="PhysicsListSvc", **kwargs)
Definition: G4AtlasServicesConfig.py:14
Trk::open
@ open
Definition: BinningType.h:40
MonopoleConfig.load_files_for_qball_scenario
def load_files_for_qball_scenario(MASS, CHARGE)
Definition: MonopoleConfig.py:42
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
MonopoleConfig.fcpPreInclude
def fcpPreInclude(flags)
Definition: MonopoleConfig.py:165
str
Definition: BTagTrackIpAccessor.cxx:11
MonopoleConfig.Monopole_VerboseSelectorCfg
def Monopole_VerboseSelectorCfg(flags, name="G4UA::VerboseSelectorTool", **kwargs)
Definition: MonopoleConfig.py:319
MonopoleConfig.QballCfg
def QballCfg(flags)
Definition: MonopoleConfig.py:218
MonopoleConfig.load_files_for_fcp_scenario
def load_files_for_fcp_scenario(MASS, CHARGE, X, Y)
Definition: MonopoleConfig.py:74
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
Generated on Tue Sep 2 2025 22:16:55 for ATLAS Offline Software by   doxygen 1.8.18