def generate_parameters_file(data, is_parallel=False):
_validate_data(data, _SCHEMA)
v = template_common.flatten_data(data["models"], {})
longitudinal_method = int(data["models"]["bunch"]["longitudinalMethod"])
# sigma s, sigma dp, dp s coupling
if longitudinal_method == 1:
v["bunch_emit_z"] = 0
v["bunch_beta_z"] = 0
v["bunch_alpha_z"] = 0
# sigma s, sigma dp, alpha z
elif longitudinal_method == 2:
v["bunch_emit_z"] = 0
v["bunch_beta_z"] = 0
v["bunch_dp_s_coupling"] = 0
# emit z, beta z, alpha z
elif longitudinal_method == 3:
v["bunch_sigma_dp"] = 0
v["bunch_sigma_s"] = 0
v["bunch_dp_s_coupling"] = 0
if data["models"]["bunchSource"]["inputSource"] == "sdds_beam":
v["bunch_beta_x"] = 5
v["bunch_beta_y"] = 5
v["bunch_alpha_x"] = 0
v["bunch_alpha_x"] = 0
v["rpn_variables"] = _generate_variables(data)
if is_parallel:
filename_map = _build_filename_map(data)
beamline_map = _build_beamline_map(data)
v["commands"] = _generate_commands(data, filename_map, beamline_map, v)
v["lattice"] = generate_lattice(data, filename_map, beamline_map, v)
return pkjinja.render_resource("elegant.py", v)
return pkjinja.render_resource("elegant_bunch.py", v)
def uwsgi():
"""Starts UWSGI server"""
db_dir =_db_dir()
run_dir = _run_dir()
with pkio.save_chdir(run_dir):
values = dict(pkcollections.map_items(cfg))
# uwsgi.py must be first, because referenced by uwsgi.yml
for f in ('uwsgi.py', 'uwsgi.yml'):
output = run_dir.join(f)
values[f.replace('.', '_')] = str(output)
pkjinja.render_resource(f, values, output=output)
cmd = ['uwsgi', '--yaml=' + values['uwsgi_yml']]
subprocess.check_call(cmd)
def uwsgi():
"""Starts UWSGI server"""
run_dir = _run_dir()
with pkio.save_chdir(run_dir):
values = dict(pkcollections.map_items(cfg))
values['logto'] = None if pkconfig.channel_in('dev') else str(run_dir.join('uwsgi.log'))
# uwsgi.py must be first, because values['uwsgi_py'] referenced by uwsgi.yml
for f in ('uwsgi.py', 'uwsgi.yml'):
output = run_dir.join(f)
values[f.replace('.', '_')] = str(output)
pkjinja.render_resource(f, values, output=output)
cmd = ['uwsgi', '--yaml=' + values['uwsgi_yml']]
pksubprocess.check_call_with_signals(cmd)
def generate_parameters_file(data, schema, run_dir=None, run_async=False):
if 'report' in data and (re.search('watchpointReport', data['report']) or data['report'] == 'sourceIntensityReport'):
# render the watchpoint report settings in the initialIntensityReport template slot
data['models']['initialIntensityReport'] = data['models'][data['report']].copy()
_validate_data(data, schema)
last_id = None
if 'report' in data:
m = re.search('watchpointReport(\d+)', data['report'])
if m:
last_id = int(m.group(1))
if int(data['models']['simulation']['samplingMethod']) == 2:
data['models']['simulation']['sampleFactor'] = 0
v = template_common.flatten_data(data['models'], {})
v['beamlineOptics'] = _generate_beamline_optics(data['models'], last_id)
if 'report' in data and 'distanceFromSource' in data['models'][data['report']]:
position = data['models'][data['report']]['distanceFromSource']
else:
position = _get_first_element_position(data)
v['beamlineFirstElementPosition'] = position
# initial drift = 1/2 undulator length + 2 periods
source_type = data['models']['simulation']['sourceType']
drift = 0
if source_type == 'u':
drift = -0.5 * data['models']['undulator']['length'] - 2 * data['models']['undulator']['period']
else:
#TODO(pjm): allow this to be set in UI?
drift = 0
v['electronBeamInitialDrift'] = drift
# 1: auto-undulator 2: auto-wiggler
v['energyCalculationMethod'] = 1 if source_type == 'u' else 2
v['userDefinedElectronBeam'] = 1
if 'isReadOnly' in data['models']['electronBeam'] and data['models']['electronBeam']['isReadOnly']:
v['userDefinedElectronBeam'] = 0
return pkjinja.render_resource('srw.py', v)
def _create_html(zip_path, data):
"""Convert zip to html data
Args:
zip_path (py.path): what to embed
data (dict): simulation db
Returns:
py.path, str: file and mime type
"""
from pykern import pkjinja
from pykern import pkcollections
from sirepo import uri_router
from sirepo import simulation_db
import py.path
import copy
# Use same tmp directory
fp = py.path.local(zip_path.dirname).join(zip_path.purebasename) + '.html'
values = pkcollections.Dict(data=data)
values.uri = uri_router.uri_for_api('importArchive', external=False)
values.server = uri_router.uri_for_api('importArchive')[:-len(values.uri)]
sc = simulation_db.SCHEMA_COMMON
values.appLongName = sc.appInfo[data.simulationType].longName
values.appShortName = sc.appInfo[data.simulationType].shortName
values.productLongName = sc.productInfo.longName
values.productShortName = sc.productInfo.shortName
values.zip = zip_path.read().encode('base64')
with open(str(fp), 'wb') as f:
fp.write(pkjinja.render_resource('archive.html', values))
return fp, 'text/html'
def nginx_proxy():
"""Starts nginx in container.
Used for development only.
"""
assert pkconfig.channel_in('dev')
run_dir = _run_dir().join('nginx_proxy').ensure(dir=True)
with pkio.save_chdir(run_dir):
f = run_dir.join('default.conf')
values = dict(pkcollections.map_items(cfg))
pkjinja.render_resource('nginx_proxy.conf', values, output=f)
cmd = [
'docker',
'run',
'--net=host',
'--rm',
'--volume={}:/etc/nginx/conf.d/default.conf'.format(f),
'nginx',
]
pksubprocess.check_call_with_signals(cmd)
def uwsgi():
"""Starts UWSGI server"""
in_dev = pkconfig.channel_in('dev')
if in_dev:
from sirepo import server, runner
# uwsgi doesn't pass signals right so can't use _Background
if not issubclass(server.cfg.job_queue, runner.Celery):
pkcli.command_error('uwsgi only works if sirepo.server.cfg.job_queue=_Celery')
db_dir =_db_dir()
run_dir = _run_dir()
with pkio.save_chdir(run_dir):
values = dict(pkcollections.map_items(cfg))
values['logto'] = None if in_dev else str(run_dir.join('uwsgi.log'))
# uwsgi.py must be first, because values['uwsgi_py'] referenced by uwsgi.yml
for f in ('uwsgi.py', 'uwsgi.yml'):
output = run_dir.join(f)
values[f.replace('.', '_')] = str(output)
pkjinja.render_resource(f, values, output=output)
cmd = ['uwsgi', '--yaml=' + values['uwsgi_yml']]
pksubprocess.check_call_with_signals(cmd)
def generate_parameters_file(data, run_dir=None, is_parallel=False):
_validate_data(data, simulation_db.get_schema(_SIMULATION_TYPE))
v = template_common.flatten_data(data['models'], {})
v['outputDir'] = '"{}"'.format(run_dir) if run_dir else None
v['isAnimationView'] = is_parallel
v['incSteps'] = 50
v['diagnosticPeriod'] = 50
if data['models']['simulation']['sourceType'] == 'electronBeam':
v['useBeam'] = 1
v['useLaser'] = 0
else:
v['useBeam'] = 0
v['useLaser'] = 1
if data['models']['electronBeam']['beamRadiusMethod'] == 'a':
v['electronBeam_transverseEmittance'] = 0
return pkjinja.render_resource('warp.py', v)
def render(out):
v = {'k1': 'v1'}
return pkjinja.render_resource('t1', v, out)
def generate_parameters_file(data, schema, run_dir=None, run_async=False):
_validate_data(data, schema)
v = template_common.flatten_data(data['models'], {})
return pkjinja.render_resource('elegant.py', v)
def generate_parameters_file(data, schema, run_dir=None, run_async=False):
_validate_data(data, schema)
v = template_common.flatten_data(data['models'], {})
return pkjinja.render_resource('elegant.py', v)
def create_cli_function(function_name, parameters, config):
"""The function creates the content of the CLI functions with the input from JSON config.
Args:
function_name (str): name of the function.
parameters (dict): dictionary with the parameters of the arguments (default value, help info, type).
config (dict): dictionary with the parameters (descriptions, used class name, returns, parameters (optional)).
Returns:
str: resulted function represented as a string.
"""
# argh_decorators:
argh_args = ''
argh_kwargs = ''
for key in sorted(parameters.keys()):
if parameters[key]['default'] is None:
if parameters[key]['type'] in [list, tuple]:
argh_args += "@argh.arg('{}', nargs='*', type={})\n".format(
key, parameters[key]['element_type'].__name__)
else:
argh_args += "@argh.arg('{}', type={})\n".format(
key, parameters[key]['type'].__name__)
else:
if parameters[key]['type'] in [list, tuple]:
argh_kwargs += "@argh.arg('--{}', nargs='+', type={})\n".format(
key, parameters[key]['element_type'].__name__)
if 'choices' in parameters[key]:
argh_kwargs += "@argh.arg('--{}', choices=[{}])\n".format(
key, ', '.join([
"\'{}\'".format(x)
for x in parameters[key]['choices'].keys()
]))
argh_decorators = '{}{}'.format(argh_args, argh_kwargs)
# function_arguments:
str_args = ''
str_kwargs = ''
for key in sorted(parameters.keys()):
a = parameters[key]['default']
if parameters[key]['default'] is None:
str_args += ' {},\n'.format(key)
continue
if parameters[key]['type'] == str:
a = "\'{}\'".format(parameters[key]['default'])
str_kwargs += ' {}={},\n'.format(key, a)
function_arguments = '\n{}{}'.format(str_args, str_kwargs)
# descriptions:
description_short = config['description_short']
description_long = config['description_long']
# arguments_description:
arguments_description = ''
for key in sorted(parameters.keys()):
format_str = ' {} ({}): {}.\n'
format_values = [
key,
parameters[key]['type'].__name__,
parameters[key]['help'],
]
if 'choices' in parameters[key]:
format_str = ' {} ({}): {} ({}).\n'
choices_str = ''
comma = ', '
for i, choices_key in enumerate(
sorted(parameters[key]['choices'].keys())):
if i == len(parameters[key]['choices'].keys()) - 1:
comma = ''
choices_str += "``{}`` - {}{}".format(
choices_key, parameters[key]['choices'][choices_key],
comma)
format_values.append(choices_str)
arguments_description += format_str.format(*format_values)
# class_name:
class_name = config['class_name']
# class_arguments:
class_arguments = ''
for key in sorted(parameters.keys()):
class_arguments += ' {}={},\n'.format(key, key)
# return_dict
return_dict = ''
if type(config['returns']) == list:
for r in config['returns']:
return_dict += " '{}': c.{},\n".format(r, r)
return_dict = '{{\n{} }}'.format(return_dict)
else:
return_dict = config['returns']
v = {
'argh_decorators': argh_decorators,
'function_name': function_name,
'function_arguments': function_arguments,
'description_short': description_short,
'description_long': description_long,
'arguments_description': arguments_description,
'class_name': class_name,
'class_arguments': class_arguments,
'return_dict': return_dict,
}
return pkjinja.render_resource('cli_function', v)
def generate_parameters_file(data, schema, run_dir=None, run_async=False):
_validate_data(data, schema)
v = template_common.flatten_data(data['models'], {})
v['outputDir'] = '"{}"'.format(run_dir) if run_dir else None
v['enablePlasma'] = 1
return pkjinja.render_resource('warp.py', v)
def create_cli_function(function_name, parameters, config):
"""The function creates the content of the CLI functions with the input from JSON config.
Args:
function_name (str): name of the function.
parameters (dict): dictionary with the parameters of the arguments (default value, help info, type).
config (dict): dictionary with the parameters (descriptions, used class name, returns, parameters (optional)).
Returns:
str: resulted function represented as a string.
"""
# argh_decorators:
argh_args = ''
argh_kwargs = ''
for key in sorted(parameters.keys()):
if parameters[key]['default'] is None:
if parameters[key]['type'] in [list, tuple]:
argh_args += "@argh.arg('{}', nargs='*', type={})\n".format(key,
parameters[key]['element_type'].__name__)
else:
argh_args += "@argh.arg('{}', type={})\n".format(key, parameters[key]['type'].__name__)
else:
if parameters[key]['type'] in [list, tuple]:
argh_kwargs += "@argh.arg('--{}', nargs='+', type={})\n".format(key, parameters[key][
'element_type'].__name__)
if 'choices' in parameters[key]:
argh_kwargs += "@argh.arg('--{}', choices=[{}])\n".format(
key,
', '.join(["\'{}\'".format(x) for x in parameters[key]['choices'].keys()])
)
argh_decorators = '{}{}'.format(argh_args, argh_kwargs)
# function_arguments:
str_args = ''
str_kwargs = ''
for key in sorted(parameters.keys()):
a = parameters[key]['default']
if parameters[key]['default'] is None:
str_args += ' {},\n'.format(key)
continue
if parameters[key]['type'] == str:
a = "\'{}\'".format(parameters[key]['default'])
str_kwargs += ' {}={},\n'.format(key, a)
function_arguments = '\n{}{}'.format(str_args, str_kwargs)
# descriptions:
description_short = config['description_short']
description_long = config['description_long']
# arguments_description:
arguments_description = ''
for key in sorted(parameters.keys()):
format_str = ' {} ({}): {}.\n'
format_values = [
key,
parameters[key]['type'].__name__,
parameters[key]['help'],
]
if 'choices' in parameters[key]:
format_str = ' {} ({}): {} ({}).\n'
choices_str = ''
comma = ', '
for i, choices_key in enumerate(sorted(parameters[key]['choices'].keys())):
if i == len(parameters[key]['choices'].keys()) - 1:
comma = ''
choices_str += "``{}`` - {}{}".format(choices_key, parameters[key]['choices'][choices_key], comma)
format_values.append(choices_str)
arguments_description += format_str.format(*format_values)
# class_name:
class_name = config['class_name']
# class_arguments:
class_arguments = ''
for key in sorted(parameters.keys()):
class_arguments += ' {}={},\n'.format(key, key)
# return_dict
return_dict = ''
if type(config['returns']) == list:
for r in config['returns']:
return_dict += " '{}': c.{},\n".format(r, r)
return_dict = '{{\n{} }}'.format(return_dict)
else:
return_dict = config['returns']
v = {
'argh_decorators': argh_decorators,
'function_name': function_name,
'function_arguments': function_arguments,
'description_short': description_short,
'description_long': description_long,
'arguments_description': arguments_description,
'class_name': class_name,
'class_arguments': class_arguments,
'return_dict': return_dict,
}
return pkjinja.render_resource('cli_function', v)
def generate_parameters_file(data, schema, run_dir=None, run_async=False):
_validate_data(data, schema)
v = template_common.flatten_data(data['models'], {})
v['outputDir'] = '"{}"'.format(run_dir) if run_dir else None
v['enablePlasma'] = 1
return pkjinja.render_resource('warp.py', v)
def render(out):
v = {'k1': 'v1'}
return pkjinja.render_resource('t1', v, out)
