def run(cfg_dir):
"""Run code in ``cfg_dir``
Args:
cfg_dir (str): directory to run code in
"""
template = sirepo.template.import_module(pkinspect.module_basename(run))
with pkio.save_chdir(cfg_dir):
_run_code()
data = simulation_db.read_json(template_common.INPUT_BASE_NAME)
data_file = template.open_data_file(py.path.local())
model = data['models'][data['report']]
if data['report'] == 'laserPreviewReport':
field = model['field']
coordinate = model['coordinate']
mode = model['mode']
if mode != 'all':
mode = int(mode)
res = template.extract_field_report(field, coordinate, mode, data_file)
elif data['report'] == 'beamPreviewReport':
res = template.extract_particle_report(
model,
'beam',
cfg_dir,
data_file,
)
simulation_db.write_result(res)
def prepare_simulation(data, run_dir):
"""Create and install files, update parameters, and generate command.
Copies files into the simulation directory (``run_dir``)
Updates the parameters in ``data`` and save.
Generate the pkcli command.
Args:
data (dict): report and model parameters
run_dir (py.path.local): dir simulation will be run in
Returns:
list, py.path: pkcli command, simulation directory
"""
import sirepo.sim_data
sim_type = data.simulationType
template = sirepo.template.import_module(data)
s = sirepo.sim_data.get_class(sim_type)
s.lib_files_to_run_dir(data, run_dir)
update_rsmanifest(data)
write_json(run_dir.join(template_common.INPUT_BASE_NAME), data)
#TODO(robnagler) encapsulate in template
is_p = s.is_parallel(data)
template.write_parameters(
data,
run_dir=run_dir,
is_parallel=is_p,
)
cmd = [
pkinspect.root_package(template),
pkinspect.module_basename(template),
'run-background' if is_p else 'run',
str(run_dir),
]
return cmd, run_dir
def test_module_basename():
p1 = pkunit.import_module_from_data_dir('p1')
assert pkinspect.module_basename(p1) == 'p1'
m1 = pkunit.import_module_from_data_dir('p1.m1')
assert pkinspect.module_basename(m1) == 'm1'
assert pkinspect.module_basename(m1.C) == 'm1'
assert pkinspect.module_basename(m1.C()) == 'm1'
assert pkinspect.module_basename(m1) == 'm1'
assert pkinspect.module_basename(m1.C) == 'm1'
assert pkinspect.module_basename(m1.C()) == 'm1'
p2 = pkunit.import_module_from_data_dir('p1.p2')
assert pkinspect.module_basename(p2) == 'p2'
m2 = pkunit.import_module_from_data_dir('p1.p2.m2')
assert pkinspect.module_basename(m2) == 'm2'
def test_module_basename():
p1 = pkunit.import_module_from_data_dir('p1')
assert pkinspect.module_basename(p1) == 'p1'
m1 = pkunit.import_module_from_data_dir('p1.m1')
assert pkinspect.module_basename(m1) == 'm1'
assert pkinspect.module_basename(m1.C) == 'm1'
assert pkinspect.module_basename(m1.C()) == 'm1'
assert pkinspect.module_basename(m1) == 'm1'
assert pkinspect.module_basename(m1.C) == 'm1'
assert pkinspect.module_basename(m1.C()) == 'm1'
p2 = pkunit.import_module_from_data_dir('p1.p2')
assert pkinspect.module_basename(p2) == 'p2'
m2 = pkunit.import_module_from_data_dir('p1.p2.m2')
assert pkinspect.module_basename(m2) == 'm2'
def template_globals(sim_type=None):
"""Initializer for templates
Usage::
_SIM_DATA, SIM_TYPE, _SCHEMA = sirepo.sim_data.template_globals()
Args:
sim_type (str): simulation type [calling module's basename]
Returns:
(class, str, object): SimData class, simulation type, and schema
"""
c = get_class(sim_type or pkinspect.module_basename(pkinspect.caller_module()))
return c, c.sim_type(), c.schema()
def _display_name(e):
"""Lookup display_name for enum
Args:
e (Enum): what to look up
Returns:
str: display name for `e`
"""
f = pkinspect.module_basename(e)
if f not in _display_name_cache:
# Name collisions avoided because this is a radtrack namespace
_display_name_cache[f] = pkyaml.load_resource(f)
return _display_name_cache[f][e.__class__.__name__][e.name]
def prepare_simulation(data, tmp_dir=None):
"""Create and install files, update parameters, and generate command.
Copies files into the simulation directory (``run_dir``), or (if
specified) a ``tmp_dir``.
Updates the parameters in ``data`` and save.
Generate the pkcli command to pass to task runner.
Args:
data (dict): report and model parameters
tmp_dir (py.path.local):
Returns:
list, py.path: pkcli command, simulation directory
"""
if tmp_dir is None:
# This is the legacy (pre-runner-daemon) code path
run_dir = simulation_run_dir(data, remove_dir=True)
#TODO(robnagler) create a lock_dir -- what node/pid/thread to use?
# probably can only do with celery.
pkio.mkdir_parent(run_dir)
out_dir = run_dir
# Only done on the legacy path, because the runner daemon owns the
# status file.
write_status('pending', out_dir)
else:
# This is the runner-daemon code path -- tmp_dir is always given, as a
# new temporary directory we have to create.
run_dir = simulation_run_dir(data)
pkio.mkdir_parent(tmp_dir)
out_dir = tmp_dir
sim_type = data['simulationType']
sid = parse_sid(data)
template = sirepo.template.import_module(data)
template_common.copy_lib_files(data, None, out_dir)
write_json(out_dir.join(template_common.INPUT_BASE_NAME), data)
#TODO(robnagler) encapsulate in template
is_p = is_parallel(data)
template.write_parameters(
data,
run_dir=out_dir,
is_parallel=is_p,
)
cmd = [
pkinspect.root_package(template),
pkinspect.module_basename(template),
'run-background' if is_p else 'run',
str(run_dir),
]
return cmd, run_dir
def prepare_simulation(data, run_dir=None):
"""Create and install files, update parameters, and generate command.
Copies files into the simulation directory (``run_dir``)
Updates the parameters in ``data`` and save.
Generate the pkcli command to pass to task runner.
Args:
data (dict): report and model parameters
run_dir (py.path.local): defaults to `simulation_run_dir`
Returns:
list, py.path: pkcli command, simulation directory
"""
import sirepo.sim_data
if run_dir is None:
# This is the legacy (pre-runner-daemon) code path
run_dir = simulation_run_dir(data, remove_dir=True)
#TODO(robnagler) create a lock_dir -- what node/pid/thread to use?
# probably can only do with celery.
pkio.mkdir_parent(run_dir)
write_status('pending', run_dir)
sim_type = data.simulationType
template = sirepo.template.import_module(data)
s = sirepo.sim_data.get_class(sim_type)
s.lib_files_to_run_dir(data, run_dir)
update_rsmanifest(data)
write_json(run_dir.join(template_common.INPUT_BASE_NAME), data)
#TODO(robnagler) encapsulate in template
is_p = s.is_parallel(data)
template.write_parameters(
data,
run_dir=run_dir,
is_parallel=is_p,
)
cmd = [
pkinspect.root_package(template),
pkinspect.module_basename(template),
'run-background' if is_p else 'run',
str(run_dir),
]
return cmd, run_dir
def run(cfg_dir):
"""Run code in ``cfg_dir``
Args:
cfg_dir (str): directory to run code in
"""
template = sirepo.template.import_module(pkinspect.module_basename(run))
with pkio.save_chdir(cfg_dir):
_run_code()
a = PKDict(
# see template.warppba.open_data_file (opens last frame)
frameIndex=None,
run_dir=pkio.py_path(cfg_dir),
sim_in=simulation_db.read_json(template_common.INPUT_BASE_NAME),
)
a.frameReport = a.sim_in.report
a.update(a.sim_in.models[a.frameReport])
if a.frameReport == 'laserPreviewReport':
res = template.sim_frame_fieldAnimation(a)
elif a.frameReport == 'beamPreviewReport':
res = template.sim_frame_beamAnimation(a)
simulation_db.write_result(res)
def prepare_simulation(data):
"""Create and install files, update parameters, and generate command.
Copies files into the simulation directory (``run_dir``).
Updates the parameters in ``data`` and save.
Generate the pkcli command to pass to task runner.
Args:
data (dict): report and model parameters
Returns:
list, py.path: pkcli command, simulation directory
"""
run_dir = simulation_run_dir(data, remove_dir=True)
#TODO(robnagler) create a lock_dir -- what node/pid/thread to use?
# probably can only do with celery.
pkio.mkdir_parent(run_dir)
write_status('pending', run_dir)
sim_type = data['simulationType']
sid = parse_sid(data)
template = sirepo.template.import_module(data)
template_common.copy_lib_files(data, None, run_dir)
write_json(run_dir.join(template_common.INPUT_BASE_NAME), data)
#TODO(robnagler) encapsulate in template
is_p = is_parallel(data)
template.write_parameters(
data,
run_dir=run_dir,
is_parallel=is_p,
)
cmd = [
pkinspect.root_package(template),
pkinspect.module_basename(template),
'run-background' if is_p else 'run',
str(run_dir),
]
return cmd, run_dir
def prepare_simulation(data):
"""Create and install files, update parameters, and generate command.
Copies files into the simulation directory (``run_dir``).
Updates the parameters in ``data`` and save.
Generate the pkcli command to pass to task runner.
Args:
data (dict): report and model parameters
Returns:
list, py.path: pkcli command, simulation directory
"""
run_dir = simulation_run_dir(data, remove_dir=True)
#TODO(robnagler) create a lock_dir -- what node/pid/thread to use?
# probably can only do with celery.
pkio.mkdir_parent(run_dir)
write_status('pending', run_dir)
sim_type = data['simulationType']
sid = parse_sid(data)
template = sirepo.template.import_module(data)
template_common.copy_lib_files(data, None, run_dir)
write_json(run_dir.join(template_common.INPUT_BASE_NAME), data)
#TODO(robnagler) encapsulate in template
is_p = is_parallel(data)
template.write_parameters(
data,
run_dir=run_dir,
is_parallel=is_p,
)
cmd = [
pkinspect.root_package(template),
pkinspect.module_basename(template),
'run-background' if is_p else 'run',
str(run_dir),
]
return cmd, run_dir
def sim_type(cls):
return cls._memoize(pkinspect.module_basename(cls))
