def create_loop_pickle(self, my_proc_list, model, pickle_file, energy, \
chosen_runner):
""" Create the pickle file for reference for the arguments here."""
# print "Creating loop pickle for chosen_runner=",chosen_runner
allowed_chosen_runners = ['ML4', 'ML5_opt', 'ML5_default']
if chosen_runner not in allowed_chosen_runners:
raise MadGraph5Error, 'The reference runner can only be in %s.'%\
allowed_chosen_runners
runner = None
if chosen_runner == 'ML5_opt':
runner = loop_me_comparator.LoopMG5Runner()
runner.setup(_mg5_path, optimized_output=True)
if chosen_runner == 'ML5_default':
runner = loop_me_comparator.LoopMG5Runner()
runner.setup(_mg5_path, optimized_output=False)
if chosen_runner == 'ML4':
runner = loop_me_comparator.LoopMG4Runner()
# Replace here the path of your ML4 installation
runner.setup(
'/Users/valentin/Documents/Work/aMC@NLO_v4/ML4ParrallelTest/NLOComp'
)
self.create_pickle(my_proc_list,pickle_file, runner, ref_runner=None, \
model=model,energy=energy)
# Clean up the runner only if it is not ML4
if chosen_runner != 'ML4':
runner.cleanup()
def compare_processes(self, my_proc_list = [], model = 'loop_sm-parallel_test',
pickle_file = "", energy = 2000, tolerance = 1e-06, filename = "",
chosen_runner = "ML5_opt"):
""" A helper function to compare processes.
Note that the chosen_runner is what runner should to create the reference
pickle if missing"""
# Print out progress if it is a run for an individual process
if len(my_proc_list)==1:
print "\n== %s =="%my_proc_list[0][0]
else:
print "\n== %s =="%filename
# Check if pickle exists, if not create it
if pickle_file!="" and not os.path.isfile(os.path.join(_pickle_path,pickle_file)):
print " => Computing reference evaluation with %s"%chosen_runner
self.create_loop_pickle(my_proc_list, model,
pickle_file, energy, chosen_runner)
print "\n => Done with %s evaluation"%chosen_runner
# Load the stored runner
if pickle_file != "":
stored_runner = me_comparator.PickleRunner.find_comparisons(
os.path.join(_pickle_path,pickle_file))[0]
# Create a MERunner object for MadLoop 5 optimized
ML5_opt = loop_me_comparator.LoopMG5Runner()
ML5_opt.setup(_mg5_path, optimized_output=True, temp_dir=filename)
# Create a MERunner object for MadLoop 5 default
ML5_default = loop_me_comparator.LoopMG5Runner()
ML5_default.setup(_mg5_path, optimized_output=False, temp_dir=filename)
# Create and setup a comparator
my_comp = loop_me_comparator.LoopMEComparator()
# Always put the saved run first if you use it, so that the corresponding PS
# points will be used.
if pickle_file != "":
my_comp.set_me_runners(stored_runner,ML5_opt,ML5_default)
else:
my_comp.set_me_runners(ML5_opt,ML5_default)
# Run the actual comparison
my_comp.run_comparison(my_proc_list,
model=model,
energy=energy)
# Print the output
my_comp.output_result(filename=os.path.join(_mg5_path,filename+'.log'))
# Assert that all process comparisons passed the tolerance cut
my_comp.assert_processes(self, tolerance)
# Do some cleanup
my_comp.cleanup()
def create_loop_pickle(my_proc_list, model, pickle_file, energy, \
chosen_runner):
""" Create the pickle file for reference for the arguments here."""
# print "Creating loop pickle for chosen_runner=",chosen_runner
allowed_chosen_runners = ['ML5_opt', 'ML5_default']
if chosen_runner not in allowed_chosen_runners:
raise MadGraph5Error, 'The reference runner can only be in %s.'%\
allowed_chosen_runners
runner = None
if chosen_runner == 'ML5_opt':
runner = loop_me_comparator.LoopMG5Runner()
runner.setup(_mg5_path, optimized_output=True)
if chosen_runner == 'ML5_default':
runner = loop_me_comparator.LoopMG5Runner()
runner.setup(_mg5_path, optimized_output=False)
create_pickle(my_proc_list,pickle_file, runner, ref_runner=None, \
model=model,energy=energy)
runner.cleanup()
# Load a saved run
#SavedRun = me_comparator.PickleRunner.find_comparisons(
# os.path.join(pickle_path,'ml5_parallel_test.pkl'))[0]
# Create a MERunner object for MadLoop 4
#ML4 = loop_me_comparator.LoopMG4Runner()
#ML4.setup('/Users/Spooner/Documents/PhD/MadFKS/ML4ParrallelTest/NLOComp')
# Create a MERunner object from Hard-Coded Reference value
HCRvalue = loop_me_comparator.LoopHardCodedRefRunner()
HCRvalue.setup(my_proc_list, my_res_list, model)
# Create a MERunner object for GoSam
#GoSam = loop_me_comparator.GoSamRunner()
# GoSam.setup('/Users/erdissshaw/Works/GoSam/gosam_dir')
# GoSam.setup('/Users/valentin/Documents/HEP_softs/GoSam/gosam-2.0.beta')
# Create a MERunner object for MadLoop 5 optimized
ML5_opt = loop_me_comparator.LoopMG5Runner()
ML5_opt.setup(mg5_path, optimized_output=True)
# Create a MERunner object for MadLoop 5 default
ML5_default = loop_me_comparator.LoopMG5Runner()
ML5_default.setup(mg5_path, optimized_output=False)
# Create a MERunner object for UFO-ALOHA-MG5
# my_mg5_ufo = me_comparator.MG5_UFO_Runner()
# my_mg5_ufo.setup(mg5_path, mg4_path)
# Create and setup a comparator
my_comp = loop_me_comparator.LoopMEComparator()
# Always put the saved run first if you use it, so that the corresponding PS
# points will be used
#my_comp.set_me_runners(ML5_opt,GoSam)
def compare_processes(self,
my_proc_list=[],
model='loop_sm-parallel_test',
pickle_file="",
energy=2000,
tolerance=3e-06,
filename="",
chosen_runner="ML5_opt",
compare_with=['ML5_opt', 'ML5_def']):
""" A helper function to compare processes.
Note that the chosen_runner is what runner should to create the reference
pickle if missing"""
# Print out progress if it is a run for an individual process
if len(my_proc_list) == 1:
print "\n== %s ==" % my_proc_list[0][0]
else:
print "\n== %s ==" % filename
# Check if pickle exists, if not create it
if pickle_file != "" and not os.path.isfile(
os.path.join(_pickle_path, pickle_file)):
print " => Computing reference evaluation with %s" % chosen_runner
self.create_loop_pickle(my_proc_list, model, pickle_file, energy,
chosen_runner)
print "\n => Done with %s evaluation" % chosen_runner
# Load the stored runner
if pickle_file != "":
stored_runner = me_comparator.PickleRunner.find_comparisons(
os.path.join(_pickle_path, pickle_file))[0]
# Create a MERunner object for MadLoop 5 optimized
ML5_opt = loop_me_comparator.LoopMG5Runner()
ML5_opt.setup(_mg5_path, optimized_output=True, temp_dir=filename)
MLCard = banner_mod.MadLoopParam(
os.path.join(_mg5_path, 'Template', 'loop_material', 'StandAlone',
'Cards', 'MadLoopParams.dat'))
MLredstr = MLCard['MLReductionLib'][0:1]
if MLredstr == "1":
# Create a MERunner object for MadLoop 5 default
ML5_default = loop_me_comparator.LoopMG5Runner()
ML5_default.setup(_mg5_path,
optimized_output=False,
temp_dir=filename)
# Create and setup a comparator
my_comp = loop_me_comparator.LoopMEComparator()
# Remove the default ML5 comparator if using TIR
to_compare_with = copy.copy(compare_with)
if MLredstr != '1':
try:
to_compare_with.pop(to_compare_with.index('ML5_def'))
except ValueError:
pass
runners_available = {
'ML5_opt': ML5_opt,
'ML5_def': ML5_opt,
'Stored': stored_runner
}
# Always put the saved run first if you use it, so that the corresponding PS
# points will be used.
runners_to_compare = []
if pickle_file != "":
runners_to_compare.append(stored_runner)
runners_to_compare.extend([runners_available[runner] for runner in \
to_compare_with])
if len(runners_to_compare) <= 1:
raise MadGraph5Error,\
""" Only one runner to compute the result with, so there is no possible comparison.
This is most likely due to the fact that you are running a TIR only comparison
and the reference pickle cannot be found."""
# Set the runners to include
my_comp.set_me_runners(*runners_to_compare)
# Run the actual comparison
my_comp.run_comparison(my_proc_list, model=model, energy=energy)
# Print the output
my_comp.output_result(filename=os.path.join(_mg5_path, filename +
'.log'))
# Assert that all process comparisons passed the tolerance cut
my_comp.assert_processes(self, tolerance)
# Do some cleanup
my_comp.cleanup()
def compare_processes(testInstance,
my_proc_list=[],
model='loop_qcd_qed_sm-parallel_test',
pickle_file="",
energy=2000,
tolerance=3e-06,
filename="",
chosen_runner="ML5_opt",
loop_induce=False,
mu_r=0.0):
""" A helper function to compare processes.
Note that the chosen_runner is what runner should to create the reference
pickle if missing"""
# Print out progress if it is a run for an individual process
if len(my_proc_list) == 1:
print "\n== %s %s ==" % (my_proc_list[0][0], my_proc_list[0][2])
else:
print "\n== %s ==" % filename
# Check if pickle exists, if not create it
if pickle_file != "" and not os.path.isfile(
os.path.join(_pickle_path, pickle_file)):
print " => Computing reference evaluation with %s" % chosen_runner
create_loop_pickle(my_proc_list, model, pickle_file, energy,
chosen_runner)
print "\n => Done with %s evaluation" % chosen_runner
# Load the stored runner
if pickle_file != "":
stored_runner = me_comparator.PickleRunner.find_comparisons(
os.path.join(_pickle_path, pickle_file))[0]
energy = stored_runner.energy
file = open(
os.path.join(_mg5_path, 'Template', 'loop_material', 'StandAlone',
'Cards', 'MadLoopParams.dat'), 'r')
# Check if the process has squared order constraints
has_sqso = any('^2' in key for proc in my_proc_list for key in \
proc[3].keys())
MLParams = file.read()
MLred = re.search(r'#MLReductionLib\n', MLParams)
MLredstr = MLParams[MLred.end():MLred.end() + 1]
if loop_induce and MLredstr != "1": return
# Create a MERunner object for MadLoop 5 optimized
# Open Loops is not avaiable for loop induced processes
if not loop_induce:
ML5_opt = loop_me_comparator.LoopMG5Runner()
ML5_opt.setup(_mg5_path, optimized_output=True, temp_dir=filename,\
mu_r=mu_r)
if MLredstr == "1" and not has_sqso:
# Create a MERunner object for MadLoop 5 default
ML5_default = loop_me_comparator.LoopMG5Runner()
ML5_default.setup(_mg5_path, optimized_output=False, temp_dir=filename,\
mu_r=mu_r)
# Create and setup a comparator
my_comp = loop_me_comparator.LoopMEComparator()
if MLredstr == "1" and not has_sqso:
# Always put the saved run first if you use it, so that the corresponding PS
# points will be used.
if pickle_file != "" and not loop_induce:
my_comp.set_me_runners(stored_runner, ML5_opt, ML5_default)
elif pickle_file != "" and loop_induce:
my_comp.set_me_runners(stored_runner, ML5_default)
elif pickle_file == "" and not loop_induce:
my_comp.set_me_runners(ML5_opt, ML5_default)
else:
raise MadGraph5Error, \
'Cannot find pickle_file for loop induced process.'
else:
if pickle_file != "":
my_comp.set_me_runners(stored_runner, ML5_opt)
else:
raise MadGraph5Error, "CANNOT find the stored result with TIR"
# Run the actual comparison
my_comp.run_comparison(my_proc_list, model=model, energy=energy)
# Print the output
my_comp.output_result(filename=os.path.join(_mg5_path,filename+'.log'),\
tolerance = tolerance)
# Assert that all process comparisons passed the tolerance cut
my_comp.assert_processes(testInstance, tolerance)
# Do some cleanup
my_comp.cleanup()