def _generate_parameters_file(data):
res, v = template_common.generate_parameters_file(data)
report = data.report if 'report' in data else ''
if report == 'tunesReport':
return template_common.render_jinja(SIM_TYPE, v, TUNES_INPUT_FILE)
v['zgoubiCommandFile'] = _ZGOUBI_COMMAND_FILE
v['particleDef'] = _generate_particle(data.models.particle)
v['beamlineElements'] = _generate_beamline_elements(report, data)
v['bunchCoordinates'] = data.models.bunch.coordinates
res += template_common.render_jinja(SIM_TYPE, v, 'base.py')
if 'twissReport' in report or 'opticsReport' in report or report == 'twissSummaryReport':
v['fitYRange'] = [-10, 10]
if v['bunch_method'] == 'OBJET2.1':
y = v['bunchCoordinates'][0]['Y']
if y != 0:
# within 20% on either side of particle 0
v['fitYRange'] = [
min(v['fitYRange'][0], y * 80),
max(v['fitYRange'][1], y * 120)
]
return res + template_common.render_jinja(SIM_TYPE, v, 'twiss.py')
v['outputFile'] = _ZGOUBI_FAI_DATA_FILE
res += template_common.render_jinja(SIM_TYPE, v, 'bunch.py')
if 'bunchReport' in report:
return res + template_common.render_jinja(SIM_TYPE, v,
'bunch-report.py')
return res + template_common.render_jinja(SIM_TYPE, v)
def _generate_parameters_file(data):
bunch = data.models.bunch
zgoubi_importer.MODEL_UNITS.scale_to_native('bunch', bunch)
for f in ('FNAME', 'FNAME2', 'FNAME3'):
if bunch[f]:
bunch[f] = _SIM_DATA.lib_file_name_with_model_field(
'bunch', f, bunch[f])
res, v = template_common.generate_parameters_file(data)
report = data.report if 'report' in data else ''
if report == 'tunesReport':
return template_common.render_jinja(SIM_TYPE, v, TUNES_INPUT_FILE)
v.zgoubiCommandFile = _ZGOUBI_COMMAND_FILE
v.particleDef = _generate_particle(data.models.particle)
v.beamlineElements = _generate_beamline_elements(report, data)
v.bunchCoordinates = bunch.coordinates
res += template_common.render_jinja(SIM_TYPE, v, 'base.py')
if 'twissReport' in report or 'opticsReport' in report or report == 'twissSummaryReport':
v.fitYRange = [-10, 10]
if v.bunch_method == 'OBJET2.1':
y = v.bunchCoordinates[0].Y
if y != 0:
# within 20% on either side of particle 0
v.fitYRange = [
min(v.fitYRange[0], y * 80),
max(v.fitYRange[1], y * 120)
]
return res + template_common.render_jinja(SIM_TYPE, v, 'twiss.py')
v.outputFile = _ZGOUBI_FAI_DATA_FILE
res += template_common.render_jinja(SIM_TYPE, v, 'bunch.py')
if 'bunchReport' in report:
return res + template_common.render_jinja(SIM_TYPE, v,
'bunch-report.py')
return res + template_common.render_jinja(SIM_TYPE, v)
def _generate_parameters_file(run_dir, data):
report = data.get('report', None)
if report and report != 'epicsServerAnimation':
return ''
#template_common.validate_models(data, simulation_db.get_schema(SIM_TYPE))
# copy model values into beamline elements
kicker_values = []
count = 0
for idx in range(len(data.models.elements)):
el = data.models.elements[idx]
key = '{}{}'.format(el.type, el._id)
if key in data.models:
data.models.elements[idx] = data.models[key]
el = data.models.elements[idx]
if el.type == 'KICKER':
kicker_values += [el.hkick, el.vkick]
count += 1
el.hkick = '{' + 'sr_epics_corrector{}_HCurrent'.format(
count) + '}'
el.vkick = '{' + 'sr_epics_corrector{}_VCurrent'.format(
count) + '}'
if run_dir:
numpy.save(str(run_dir.join(CURRENT_FILE)),
numpy.array([CURRENT_FIELDS, kicker_values]))
res, v = template_common.generate_parameters_file(data)
from sirepo.template import elegant
#TODO(pjm): calling private template.elegant._build_beamline_map()
data.models.commands = []
v['currentFile'] = CURRENT_FILE
v['fodoLattice'] = elegant.webcon_generate_lattice(data)
v['BPM_FIELDS'] = BPM_FIELDS
v['CURRENT_FIELDS'] = CURRENT_FIELDS
return res + template_common.render_jinja(SIM_TYPE, v)
def _generate_parameters_file(data):
if data.report == 'animation':
beamline = data.models.beamline
data.models.crystal = _get_crystal(data)
res, v = template_common.generate_parameters_file(data)
v.leftMirrorFocusingError = beamline[0].focusingError
v.rightMirrorFocusingError = beamline[-1].focusingError
v.summaryCSV = _SUMMARY_CSV_FILE
v.initialLaserFile = _INITIAL_LASER_FILE
v.finalLaserFile = _FINAL_LASER_FILE
return res + template_common.render_jinja(SIM_TYPE, v)
if data.report == 'crystalAnimation':
res, v = template_common.generate_parameters_file(data)
v.crystalCSV = _CRYSTAL_CSV_FILE
return res + template_common.render_jinja(SIM_TYPE, v, 'crystal.py')
assert False, 'invalid param report: {}'.format(data.report)
def _generate_parameters_file(data):
res, v = template_common.generate_parameters_file(data)
v.report = re.sub(r'\d+$', '', data.get('report', ''))
if v.report in _INITIAL_REPORTS:
# these reports do not require running madx first
v.initialTwissParameters = _get_initial_twiss_params(data)
v.numParticles = data.models.simulation.numberOfParticles
v.particleFile = simulation_db.simulation_dir(SIM_TYPE, data.simulationId) \
.join(data.report).join('ptc_particles.txt')
res = template_common.render_jinja(SIM_TYPE, v, 'bunch.py')
return res
util = LatticeUtil(data, _SCHEMA)
filename_map = _build_filename_map_from_util(util)
report = data.get('report', '')
code_var = _code_var(data.models.rpnVariables)
v.twissOutputFilename = _TWISS_OUTPUT_FILE
v.lattice = _generate_lattice(filename_map, util)
v.variables = _generate_variables(code_var, data)
v.useBeamline = util.select_beamline().name
if report == 'twissReport':
v.twissOutputFilename = _TWISS_OUTPUT_FILE
return template_common.render_jinja(SIM_TYPE, v, 'twiss.madx')
_add_commands(data, util)
v.commands = _generate_commands(filename_map, util)
v.hasTwiss = bool(util.find_first_command(data, 'twiss'))
if not v.hasTwiss:
v.twissOutputFilename = _TWISS_OUTPUT_FILE
return template_common.render_jinja(SIM_TYPE, v, 'parameters.madx')
def _generate_parameters_file(data):
report = data.get('report', '')
if report == 'elegantAnimation':
return _generate_elegant_simulation(data)
res, v = template_common.generate_parameters_file(data)
res += 'from __future__ import absolute_import, division, print_function\n'
infile = _SIM_DATA.rcscon_filename(data, 'files', 'inputs')
outfile = _SIM_DATA.rcscon_filename(data, 'files', 'outputs')
v.pkupdate(
inputsFileName=infile,
outputsFileName=outfile,
layerImplementationNames=_layer_implementation_list(data),
neuralNetLayers=data.models.neuralNet.layers,
inputDim=data.models.files.inputsCount,
).pkupdate(_OUTPUT_FILE)
if 'mlModelGraph' in report:
res += template_common.render_jinja(SIM_TYPE, v, 'build-model.py')
res += template_common.render_jinja(SIM_TYPE, v, 'graph.py')
return res
res += template_common.render_jinja(SIM_TYPE, v, 'scale.py')
if 'fileColumnReport' in report or report == 'partitionSelectionReport':
return res
v.hasTrainingAndTesting = v.partition_section0 == 'train_and_test' \
or v.partition_section1 == 'train_and_test' \
or v.partition_section2 == 'train_and_test'
res += template_common.render_jinja(SIM_TYPE, v, 'partition.py')
if 'partitionAnimation' in report:
res += template_common.render_jinja(SIM_TYPE, v, 'save-partition.py')
return res
res += template_common.render_jinja(SIM_TYPE, v, 'build-model.py')
res += template_common.render_jinja(SIM_TYPE, v, 'train.py')
return res
def _generate_parameters_file(data):
report = data.get('report', '')
res, v = template_common.generate_parameters_file(data)
beamline = data.models.beamline
v.leftMirrorFocusingError = beamline[0].focusingError
v.rightMirrorFocusingError = beamline[-1].focusingError
return res + template_common.render_jinja(SIM_TYPE, v)
def _generate_parameters_file(data):
res, v = template_common.generate_parameters_file(data)
_generate_madx(v, data)
v.optimizerTargets = data.models.optimizerSettings.targets
v.summaryCSV = _SUMMARY_CSV_FILE
if data.get('report') == 'initialMonitorPositionsReport':
v.optimizerSettings_method = 'runOnce'
return res + template_common.render_jinja(SIM_TYPE, v)
def _generate_parameters_file(data):
res, v = template_common.generate_parameters_file(data)
util = LatticeUtil(data, _SCHEMA)
code_var = _code_var(data.models.rpnVariables)
v.lattice = _generate_lattice(util)
v.variables = _generate_variables(code_var, data)
if data.models.simulation.visualizationBeamlineId:
v.useBeamline = util.id_map[data.models.simulation.visualizationBeamlineId].name
return template_common.render_jinja(SIM_TYPE, v, 'parameters.madx')
def sim(self, full=True):
d = self.data
r, v = template_common.generate_parameters_file(d)
v.rpn_variables = generate_variables(d)
self.jinja_env = v
if full:
return r + self._full_simulation()
if d.get('report', '') == 'twissReport':
return r + self._twiss_simulation()
return r + self._bunch_simulation()
def generate_parameters_file(data, is_parallel=False):
_validate_data(data, _SCHEMA)
res, v = template_common.generate_parameters_file(data)
v.rpn_variables = _generate_variables(data)
if is_parallel:
return res + _generate_full_simulation(data, v)
if data.get('report', '') == 'twissReport':
return res + _generate_twiss_simulation(data, v)
return res + _generate_bunch_simulation(data, v)
def _generate_parameters_file(data):
report = data.get('report', '')
res, v = template_common.generate_parameters_file(data)
sim_id = data.get('simulationId', data.models.simulation.simulationId)
g = data.models.geometry
v['dmpFile'] = _dmp_file(sim_id)
if 'dmpImportFile' in data.models.simulation:
v['dmpImportFile'] = simulation_db.simulation_lib_dir(SIM_TYPE).join(
f'{_SCHEMA.constants.radiaDmpFileType}.{data.models.simulation.dmpImportFile}'
)
v['isExample'] = data.models.simulation.get('isExample', False)
v.objects = g.get('objects', [])
# read in h-m curves if applicable
for o in v.objects:
o.h_m_curve = _read_h_m_file(o.materialFile) if \
o.get('material', None) and o.material == 'custom' and \
o.get('materialFile', None) and o.materialFile else None
v['geomName'] = g.name
disp = data.models.magnetDisplay
v_type = disp.viewType
f_type = None
if v_type not in VIEW_TYPES:
raise ValueError('Invalid view {} ({})'.format(v_type, VIEW_TYPES))
v['viewType'] = v_type
v['dataFile'] = _geom_file(sim_id)
if v_type == _SCHEMA.constants.viewTypeFields:
f_type = disp.fieldType
if f_type not in radia_tk.FIELD_TYPES:
raise ValueError(
'Invalid field {} ({})'.format(f_type, radia_tk.FIELD_TYPES)
)
v['fieldType'] = f_type
v['fieldPoints'] = _build_field_points(data.models.fieldPaths.get('paths', []))
if 'solver' in report:
v['doSolve'] = True
s = data.models.solver
v['solvePrec'] = s.precision
v['solveMaxIter'] = s.maxIterations
v['solveMethod'] = s.method
if 'reset' in report:
radia_tk.reset()
data.report = 'geometry'
return _generate_parameters_file(data)
v['h5ObjPath'] = _geom_h5_path(_SCHEMA.constants.viewTypeObjects)
v['h5FieldPath'] = _geom_h5_path(_SCHEMA.constants.viewTypeFields, f_type)
return template_common.render_jinja(
SIM_TYPE,
v,
GEOM_PYTHON_FILE,
)
def _generate_parameters_file(data):
res, v = template_common.generate_parameters_file(data)
util = LatticeUtil(data, _SCHEMA)
v.update(
dict(
lattice=_generate_lattice(util),
use_beamline=util.select_beamline().name,
commands=_generate_commands(util),
))
report = data.get('report', '')
if report == 'twissReport':
return template_common.render_jinja(SIM_TYPE, v, 'twiss.in')
return template_common.render_jinja(SIM_TYPE, v, 'parameters.in')
def generate_parameters_file(data, is_parallel=False):
template_common.validate_models(data, _SCHEMA)
res, v = template_common.generate_parameters_file(data)
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 res + template_common.render_jinja(SIM_TYPE, v)
def _generate_parameters_file(data):
v = None
template_common.validate_models(data, _SCHEMA)
res, v = template_common.generate_parameters_file(data)
v['particlePeriod'] = _PARTICLE_PERIOD
v['particleFile'] = _PARTICLE_FILE
v['potentialFile'] = _POTENTIAL_FILE
v['stepSize'] = COMPARISON_STEP_SIZE
v['densityFile'] = _DENSITY_FILE
v['egunCurrentFile'] = _EGUN_CURRENT_FILE
v['estimateFile'] = _FIELD_ESTIMATE_FILE
v['conductors'] = _prepare_conductors(data)
v['maxConductorVoltage'] = _max_conductor_voltage(data)
v['is3D'] = _SIM_DATA.warpvnd_is_3d(data)
v['anode'] = _prepare_anode(data)
v['saveIntercept'] = v['anode']['isReflector']
for c in data.models.conductors:
if c.conductor_type.type == 'stl':
# if any conductor is STL then don't save the intercept
v['saveIntercept'] = False
v['polyFile'] = _SIM_DATA.lib_file_abspath(
_stl_polygon_file(c.conductor_type.name),
)
break
if c.conductor_type.isReflector:
v['saveIntercept'] = True
if not v['is3D']:
v['simulationGrid_num_y'] = v['simulationGrid_num_x']
v['simulationGrid_channel_height'] = v['simulationGrid_channel_width']
if 'report' not in data:
data['report'] = 'animation'
v['isOptimize'] = data['report'] == 'optimizerAnimation'
if v['isOptimize']:
_replace_optimize_variables(data, v)
res = _render_jinja('base', v)
if data['report'] == 'animation':
if data['models']['simulation']['egun_mode'] == '1':
v['egunStatusFile'] = _EGUN_STATUS_FILE
res += _render_jinja('egun', v)
else:
res += _render_jinja('visualization', v)
res += _render_jinja('impact-density', v)
elif data['report'] == 'optimizerAnimation':
res += _render_jinja('parameters-optimize', v)
else:
res += _render_jinja('source-field', v)
return res, v
def _generate_elegant_simulation(data):
vars_by_name = PKDict({x.name: x.value for x in data.models.rpnVariables})
for m in ('elegantAnimation', 'latticeSettings', 'rfcSettings'):
for f in data.models[m]:
vars_by_name[f] = data.models[m][f]
data.models.rpnVariables = [
PKDict(name=n, value=v) for n, v in vars_by_name.items()
]
res, v = template_common.generate_parameters_file(data)
from sirepo.template import elegant
#TODO(pjm): don't call private functions
v.rpn_variables = elegant._generate_variables(data)
data.models.simulation.update(
PKDict(
backtracking='0',
simulationMode='serial',
))
return elegant._generate_full_simulation(data, v)
def _generate_parameters_file(data):
report = data.get('report', '')
res, v = template_common.generate_parameters_file(data)
sim_id = data.simulationId
g = data.models.geometry
v['dmpFile'] = _dmp_file(sim_id)
v['isExample'] = data.models.simulation.get('isExample', False)
v['objects'] = g.get('objects', [])
v['geomName'] = g.name
disp = data.models.magnetDisplay
v_type = disp.viewType
f_type = None
if v_type not in VIEW_TYPES:
raise ValueError('Invalid view {} ({})'.format(v_type, VIEW_TYPES))
v['viewType'] = v_type
v['dataFile'] = _geom_file(sim_id)
if v_type == VIEW_TYPE_FIELD:
f_type = disp.fieldType
if f_type not in radia_tk.FIELD_TYPES:
raise ValueError('Invalid field {} ({})'.format(
f_type, radia_tk.FIELD_TYPES))
v['fieldType'] = f_type
v['fieldPoints'] = _build_field_points(
data.models.fieldPaths.get('paths', []))
if 'solver' in report:
v['doSolve'] = True
s = data.models.solver
v['solvePrec'] = s.precision
v['solveMaxIter'] = s.maxIterations
v['solveMethod'] = s.method
if 'reset' in report:
radia_tk.reset()
data.report = 'geometry'
return _generate_parameters_file(data)
v['h5ObjPath'] = _geom_h5_path(VIEW_TYPE_OBJ)
v['h5FieldPath'] = _geom_h5_path(VIEW_TYPE_FIELD, f_type)
return template_common.render_jinja(
SIM_TYPE,
v,
GEOM_PYTHON_FILE,
)
def _generate_parameters_file(data):
res, v = template_common.generate_parameters_file(data)
util = LatticeUtil(data, _SCHEMA)
filename_map = _build_filename_map_from_util(util)
report = data.get('report', '')
v.twissOutputFilename = _TWISS_OUTPUT_FILE
v.lattice = _generate_lattice(filename_map, util)
v.variables = code_var(
data.models.rpnVariables).generate_variables(_generate_variable)
v.useBeamline = util.select_beamline().name
if report == 'twissReport' or _is_report('bunchReport', report):
v.twissOutputFilename = _TWISS_OUTPUT_FILE
return template_common.render_jinja(SIM_TYPE, v, 'twiss.madx')
_add_commands(data, util)
v.commands = _generate_commands(filename_map, util)
v.hasTwiss = bool(util.find_first_command(data, 'twiss'))
if not v.hasTwiss:
v.twissOutputFilename = _TWISS_OUTPUT_FILE
return template_common.render_jinja(SIM_TYPE, v, 'parameters.madx')
def _generate_parameters_file(data):
res, v = template_common.generate_parameters_file(data)
util = LatticeUtil(data, _SCHEMA)
code_var = _code_var(data.models.rpnVariables)
report = data.get('report', '')
if 'bunchReport' in report:
# keep only first distribution and beam in command list
beam = LatticeUtil.find_first_command(data, 'beam')
distribution = LatticeUtil.find_first_command(data, 'distribution')
v.beamName = beam.name
v.distributionName = distribution.name
# these need to get set to default or distribution won't generate in 1 step
# for emitted distributions
distribution.nbin = 0
distribution.emissionsteps = 1
data.models.commands = [
LatticeUtil.find_first_command(data, 'option'),
beam,
distribution,
]
else:
if report == 'twissReport':
beamline_id = util.select_beamline().id
else:
beamline_id = LatticeUtil.find_first_command(
util.data, 'track').line or util.select_beamline().id
v.lattice = _generate_lattice(util, code_var, beamline_id)
v.use_beamline = util.select_beamline().name
v.update(
dict(
variables=_generate_variables(code_var, data),
header_commands=_generate_commands(util, True),
commands=_generate_commands(util, False),
))
if 'bunchReport' in report:
return template_common.render_jinja(SIM_TYPE, v, 'bunch.in')
if report == 'twissReport':
v.twiss_file_name = _TWISS_FILE_NAME
return template_common.render_jinja(SIM_TYPE, v, 'twiss.in')
return template_common.render_jinja(SIM_TYPE, v, 'parameters.in')
def _generate_parameters_file(data):
report = data.get('report', '')
res, v = template_common.generate_parameters_file(data)
v.dataFile = _filename(data.models.dataFile.file)
v.pkupdate(
layerImplementationNames=_layer_implementation_list(data),
neuralNetLayers=data.models.neuralNet.layers,
inputDim=data.models.columnInfo.inputOutput.count('input'),
).pkupdate(_OUTPUT_FILE)
v.columnTypes = '[' + ','.join(
["'" + v + "'" for v in data.models.columnInfo.inputOutput]) + ']'
res += template_common.render_jinja(SIM_TYPE, v, 'scale.py')
if 'fileColumnReport' in report or report == 'partitionSelectionReport':
return res
v.hasTrainingAndTesting = v.partition_section0 == 'train_and_test' \
or v.partition_section1 == 'train_and_test' \
or v.partition_section2 == 'train_and_test'
res += template_common.render_jinja(SIM_TYPE, v, 'partition.py')
if 'partitionColumnReport' in report:
res += template_common.render_jinja(SIM_TYPE, v, 'save-partition.py')
return res
if data.models.dataFile.appMode == 'classification':
res += template_common.render_jinja(SIM_TYPE, v,
'classification-base.py')
d = PKDict(
decisionTree='decision-tree',
knn='knn',
linearSvc='linear-svc',
logisticRegression='logistic-regression',
)
return res + template_common.render_jinja(
SIM_TYPE,
v,
f'{d[data.models.classificationAnimation.classifier]}.py',
)
res += template_common.render_jinja(SIM_TYPE, v, 'build-model.py')
res += template_common.render_jinja(SIM_TYPE, v, 'train.py')
return res
def _generate_parameters_file(data):
_validate_data(data, _SCHEMA)
res, v = template_common.generate_parameters_file(data)
util = LatticeUtil(data, _SCHEMA)
v.update({
'lattice': _generate_lattice(data, util),
'use_beamline': util.select_beamline().name.lower(),
'bunchFileName': OUTPUT_FILE.bunchReport,
'diagnosticFilename': OUTPUT_FILE.beamEvolutionAnimation,
'twissFileName': OUTPUT_FILE.twissReport,
})
if data.models.bunch.distribution == 'file':
v.bunchFile = _SIM_DATA.lib_file_name_with_model_field('bunch', 'particleFile', data.models.bunch.particleFile)
v.bunch = template_common.render_jinja(SIM_TYPE, v, 'bunch.py')
res += template_common.render_jinja(SIM_TYPE, v, 'base.py')
report = data.report if 'report' in data else ''
if 'bunchReport' in report or 'twissReport' in report:
res += template_common.render_jinja(SIM_TYPE, v, 'twiss.py')
if 'bunchReport' in report:
res += template_common.render_jinja(SIM_TYPE, v, 'bunch-report.py')
else:
res += template_common.render_jinja(SIM_TYPE, v, 'parameters.py')
return res
def _generate_parameters_file(data):
report = data.get('report', '')
res, v = template_common.generate_parameters_file(data)
v.dataFile = _filename(data.models.dataFile.file)
v.update(_OUTPUT_FILE).update(
layerImplementationNames=_layer_implementation_list(data),
neuralNetLayers=data.models.neuralNet.layers,
inputDim=data.models.columnInfo.inputOutput.count('input'),
)
v.columnTypes = '[' + ','.join([ "'" + v + "'" for v in data.models.columnInfo.inputOutput]) + ']'
res += template_common.render_jinja(SIM_TYPE, v, 'scale.py')
if 'fileColumnReport' in report or report == 'partitionSelectionReport':
return res
v.hasTrainingAndTesting = v.partition_section0 == 'train_and_test' \
or v.partition_section1 == 'train_and_test' \
or v.partition_section2 == 'train_and_test'
res += template_common.render_jinja(SIM_TYPE, v, 'partition.py')
if 'partitionColumnReport' in report:
res += template_common.render_jinja(SIM_TYPE, v, 'save-partition.py')
return res
res += template_common.render_jinja(SIM_TYPE, v, 'build-model.py')
res += template_common.render_jinja(SIM_TYPE, v, 'train.py')
return res
def _generate_parameters_file(data, is_parallel, for_export):
import jinja2
report = data.get('report', '')
rpt_out = f'{_REPORT_RES_MAP.get(report, report)}'
res, v = template_common.generate_parameters_file(data)
if rpt_out in _POST_SIM_REPORTS:
return res
v.doSolve = False
v.doReset = False
v.isParallel = is_parallel
sim_id = data.get('simulationId', data.models.simulation.simulationId)
g = data.models.geometry
v.dmpOutputFile = _DMP_FILE if for_export else _dmp_file(sim_id)
if 'dmpImportFile' in data.models.simulation:
v.dmpImportFile = data.models.simulation.dmpImportFile if for_export else \
simulation_db.simulation_lib_dir(SIM_TYPE).join(
f'{_SCHEMA.constants.radiaDmpFileType}.{data.models.simulation.dmpImportFile}'
)
v.isExample = data.models.simulation.get('isExample', False) and \
data.models.simulation.name in radia_examples.EXAMPLES
v.exampleName = data.models.simulation.get('exampleName', None)
v.is_raw = v.exampleName in _SCHEMA.constants.rawExamples
v.magnetType = data.models.simulation.get('magnetType', 'freehand')
wd, hd, bd = _geom_directions(
data.models.simulation.beamAxis,
data.models.hybridUndulator.gapAxis if v.magnetType == 'undulator' else 'y'
)
v.width_dir = wd.tolist()
v.height_dir = hd.tolist()
v.beam_dir = bd.tolist()
if v.magnetType == 'undulator':
_update_geom_from_undulator(g, data.models.hybridUndulator, data.models.simulation.beamAxis)
v.objects = g.get('objects', [])
_validate_objects(v.objects)
# read in h-m curves if applicable
for o in v.objects:
o.h_m_curve = _read_h_m_file(o.materialFile) if \
o.get('material', None) and o.material == 'custom' and \
o.get('materialFile', None) and o.materialFile else None
v.geomName = g.name
disp = data.models.magnetDisplay
v_type = disp.viewType
# for rendering conveneince
v.VIEW_TYPE_OBJ = _SCHEMA.constants.viewTypeObjects
v.VIEW_TYPE_FIELD = _SCHEMA.constants.viewTypeFields
v.FIELD_TYPE_MAG_M = radia_util.FIELD_TYPE_MAG_M
v.POINT_FIELD_TYPES = radia_util.POINT_FIELD_TYPES
v.INTEGRABLE_FIELD_TYPES = radia_util.INTEGRABLE_FIELD_TYPES
f_type = None
if v_type not in VIEW_TYPES:
raise ValueError('Invalid view {} ({})'.format(v_type, VIEW_TYPES))
v.viewType = v_type
v.dataFile = _GEOM_FILE if for_export else _get_res_file(sim_id, f'{rpt_out}.h5', run_dir=rpt_out)
if v_type == _SCHEMA.constants.viewTypeFields:
f_type = disp.fieldType
if f_type not in radia_util.FIELD_TYPES:
raise ValueError(
'Invalid field {} ({})'.format(f_type, radia_util.FIELD_TYPES)
)
v.fieldType = f_type
v.fieldPaths = data.models.fieldPaths.get('paths', [])
v.fieldPoints = _build_field_points(data.models.fieldPaths.get('paths', []))
v.kickMap = data.models.get('kickMapReport', None)
if 'solver' in report or for_export:
v.doSolve = True
v.gId = _get_g_id(sim_id)
s = data.models.solver
v.solvePrec = s.precision
v.solveMaxIter = s.maxIterations
v.solveMethod = s.method
if 'reset' in report:
v.doReset = True
v.h5FieldPath = _geom_h5_path(_SCHEMA.constants.viewTypeFields, f_type)
v.h5KickMapPath = _H5_PATH_KICK_MAP
v.h5ObjPath = _geom_h5_path(_SCHEMA.constants.viewTypeObjects)
v.h5SolutionPath = _H5_PATH_SOLUTION
v.h5IdMapPath = _H5_PATH_ID_MAP
j_file = RADIA_EXPORT_FILE if for_export else f'{rpt_out}.py'
return template_common.render_jinja(
SIM_TYPE,
v,
j_file,
jinja_env=PKDict(loader=jinja2.PackageLoader('sirepo', 'template'))
)
