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, run_dir=None, is_parallel=False):
v = None
template_common.validate_models(data, _SCHEMA)
v = template_common.flatten_data(data['models'], {})
v['outputDir'] = '"{}"'.format(run_dir) if run_dir else None
v['particlePeriod'] = _PARTICLE_PERIOD
v['particleFile'] = _PARTICLE_FILE
v['impactDensityCalculation'] = _generate_impact_density()
v['egunCurrentFile'] = _EGUN_CURRENT_FILE
v['conductorLatticeAndParticleScraper'] = _generate_lattice(data)
v['maxConductorVoltage'] = _max_conductor_voltage(data)
v['is3D'] = data.models.simulationGrid.simulation_mode == '3d'
if not v['is3D']:
v['simulationGrid_num_y'] = v['simulationGrid_num_x']
v['simulationGrid_channel_height'] = v['simulationGrid_channel_width']
template_name = ''
if 'report' not in data:
template_name = 'visualization'
elif data['report'] == 'animation':
if data['models']['simulation']['egun_mode'] == '1':
v['egunStatusFile'] = _EGUN_STATUS_FILE
template_name = 'egun'
else:
template_name = 'visualization'
else:
template_name = 'source-field'
return template_common.render_jinja(SIM_TYPE, v, 'base.py') \
+ template_common.render_jinja(SIM_TYPE, v, '{}.py'.format(template_name))
def _generate_parameters_file(data, run_dir=None, is_parallel=False):
_validate_data(data, _SCHEMA)
_scale_units(data)
v = template_common.flatten_data(data.models, PKDict())
r = data.report
report_model = data.models[r]
beamline = data.models.beamline
v.shadowOutputFile = _SHADOW_OUTPUT_FILE
if _has_zone_plate(beamline):
v.zonePlateMethods = template_common.render_jinja(
SIM_TYPE, v, 'zone_plate.py')
if v.simulation_sourceType == 'bendingMagnet':
v.bendingMagnetSettings = _generate_bending_magnet(data)
elif v.simulation_sourceType == 'geometricSource':
v.geometricSourceSettings = _generate_geometric_source(data)
elif v.simulation_sourceType == 'wiggler':
v.wigglerSettings = _generate_wiggler(data)
v.wigglerTrajectoryFilename = _WIGGLER_TRAJECTORY_FILENAME
v.wigglerTrajectoryInput = ''
if data.models.wiggler.b_from in ('1', '2'):
v.wigglerTrajectoryInput = _SIM_DATA.shadow_wiggler_file(
data.models.wiggler.trajFile)
elif v.simulation_sourceType == 'undulator':
v.undulatorSettings = template_common.render_jinja(
SIM_TYPE, v, 'undulator.py')
if r == 'initialIntensityReport':
v.distanceFromSource = beamline[
0].position if beamline else template_common.DEFAULT_INTENSITY_DISTANCE
elif r == 'beamStatisticsReport':
v.simulation_npoint = 10000
v.beamlineOptics = _generate_beamline_optics(data.models,
calc_beam_stats=True)
v.beamStatsFile = BEAM_STATS_FILE
assert v.simulation_sourceType in ('bendingMagnet', 'geometricSource',
'undulator')
if v.simulation_sourceType == 'geometricSource':
if v.geometricSource_f_color == '1':
v.photonEnergy = v.geometricSource_singleEnergyValue
else:
v.photonEnergy = (v.geometricSource_ph1 +
v.geometricSource_ph2) / 2
elif v.simulation_sourceType == 'undulator':
if v.undulator_select_energy == 'range':
v.photonEnergy = (v.undulator_emin + v.undulator_emax) / 2
else:
v.photonEnergy = v.undulator_photon_energy
elif v.simulation_sourceType == 'bendingMagnet':
v.photonEnergy = v.bendingMagnet_ph1
return template_common.render_jinja(SIM_TYPE, v, 'beam_statistics.py')
elif _SIM_DATA.is_watchpoint(r):
v.beamlineOptics = _generate_beamline_optics(
data.models, last_id=_SIM_DATA.watchpoint_id(r))
else:
v.distanceFromSource = report_model.distanceFromSource
return template_common.render_jinja(SIM_TYPE, v)
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):
v = template_common.flatten_data(data.models, {})
report = data.report if 'report' in data else ''
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':
return res + template_common.render_jinja(SIM_TYPE, v, 'twiss.py')
v['outputFile'] = _ZGOUBI_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):
_validate_data(data, _SCHEMA)
v = template_common.flatten_data(data['models'], {})
beamline_map = _build_beamline_map(data)
v['lattice'] = _generate_lattice(data, beamline_map, v)
v['diagnosticFilename'] = _BEAM_EVOLUTION_OUTPUT_FILENAME
res = template_common.render_jinja(SIM_TYPE, v, 'base.py')
report = data['report'] if 'report' in data else ''
if report == 'bunchReport' or report == 'twissReport' or report == 'twissReport2':
res += template_common.render_jinja(SIM_TYPE, v, 'twiss.py')
if report == 'bunchReport':
res += template_common.render_jinja(SIM_TYPE, v, 'bunch.py')
else:
res += template_common.render_jinja(SIM_TYPE, v, 'parameters.py')
return res
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_twiss_simulation(data, v):
max_id = elegant_lattice_importer.max_id(data)
sim = data['models']['simulation']
sim['simulationMode'] = 'serial'
run_setup = _find_first_command(data, 'run_setup') or {
'_id': max_id + 1,
'_type': 'run_setup',
'lattice': 'Lattice',
'p_central_mev': data['models']['bunch']['p_central_mev'],
}
run_setup['use_beamline'] = sim['activeBeamlineId']
twiss_output = _find_first_command(data, 'twiss_output') or {
'_id': max_id + 2,
'_type': 'twiss_output',
'filename': '1',
}
twiss_output['final_values_only'] = '0'
twiss_output['output_at_each_step'] = '0'
data['models']['commands'] = [
run_setup,
twiss_output,
]
filename_map = _build_filename_map(data)
beamline_map = _build_beamline_map(data)
v['lattice'] = generate_lattice(data, filename_map, beamline_map, v)
v['commands'] = _generate_commands(data, filename_map, beamline_map, v)
return template_common.render_jinja(SIM_TYPE, v)
def _generate_full_simulation(data, v):
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)
v['simulationMode'] = data['models']['simulation']['simulationMode']
return template_common.render_jinja(SIM_TYPE, v)
def _generate_bunch_simulation(data, v):
for f in _SCHEMA['model']['bunch']:
info = _SCHEMA['model']['bunch'][f]
if info[1] == 'RPNValue':
field = 'bunch_{}'.format(f)
v[field] = _format_rpn_value(v[field], is_command=True)
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
if v['bunchFile_sourceFile'] and v['bunchFile_sourceFile'] != 'None':
v['bunchInputFile'] = template_common.lib_file_name('bunchFile', 'sourceFile', v['bunchFile_sourceFile'])
v['bunchFileType'] = _sdds_beam_type_from_file(v['bunchInputFile'])
v['bunchOutputFile'] = _report_output_filename('bunchReport')
return template_common.render_jinja(SIM_TYPE, v, 'bunch.py')
def _generate_twiss_simulation(data, v):
max_id = elegant_lattice_importer.max_id(data)
sim = data['models']['simulation']
sim['simulationMode'] = 'serial'
run_setup = _find_first_command(data, 'run_setup') or {
'_id': max_id + 1,
'_type': 'run_setup',
'lattice': 'Lattice',
'p_central_mev': data['models']['bunch']['p_central_mev'],
}
run_setup['use_beamline'] = sim['activeBeamlineId']
twiss_output = _find_first_command(data, 'twiss_output') or {
'_id': max_id + 2,
'_type': 'twiss_output',
'filename': '1',
}
twiss_output['output_at_each_step'] = "0"
data['models']['commands'] = [
run_setup,
twiss_output,
]
filename_map = _build_filename_map(data)
beamline_map = _build_beamline_map(data)
v['lattice'] = generate_lattice(data, filename_map, beamline_map, v)
v['commands'] = _generate_commands(data, filename_map, beamline_map, v)
return template_common.render_jinja(SIM_TYPE, v)
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, run_dir=None, is_parallel=False):
_validate_data(data, simulation_db.get_schema(SIM_TYPE))
_convert_meters_to_centimeters(data['models'])
_convert_meters_to_centimeters(data['models']['beamline'])
v = template_common.flatten_data(data['models'], {})
r = data['report']
report_model = data['models'][r]
beamline = data['models']['beamline']
v['shadowOutputFile'] = _SHADOW_OUTPUT_FILE
if r == 'initialIntensityReport':
v['distanceFromSource'] = beamline[0]['position'] if len(beamline) else template_common.DEFAULT_INTENSITY_DISTANCE
elif template_common.is_watchpoint(r):
v['beamlineOptics'] = _generate_beamline_optics(data['models'], template_common.watchpoint_id(r))
else:
v['distanceFromSource'] = report_model['distanceFromSource']
if v['simulation_sourceType'] == 'bendingMagnet':
v['bendingMagnetSettings'] = _generate_bending_magnet(data)
elif v['simulation_sourceType'] == 'geometricSource':
v['geometricSourceSettings'] = _generate_geometric_source(data)
elif v['simulation_sourceType'] == 'wiggler':
v['wigglerSettings'] = _generate_wiggler(data)
v['wigglerTrajectoryFilename'] = _WIGGLER_TRAJECTOR_FILENAME
v['wigglerTrajectoryInput'] = ''
if data['models']['wiggler']['b_from'] in ('1', '2'):
v['wigglerTrajectoryInput'] = _wiggler_file(data['models']['wiggler']['trajFile'])
return template_common.render_jinja(SIM_TYPE, v)
def _generate_bunch_simulation(data, v):
for f in _SCHEMA['model']['bunch']:
info = _SCHEMA['model']['bunch'][f]
if info[1] == 'RPNValue':
field = 'bunch_{}'.format(f)
v[field] = _format_rpn_value(v[field], is_command=True)
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
if v['bunchFile_sourceFile'] and v['bunchFile_sourceFile'] != 'None':
v['bunchInputFile'] = template_common.lib_file_name(
'bunchFile', 'sourceFile', v['bunchFile_sourceFile'])
v['bunchFileType'] = _sdds_beam_type_from_file(v['bunchInputFile'])
v['bunchOutputFile'] = BUNCH_OUTPUT_FILE
return template_common.render_jinja(SIM_TYPE, v, 'bunch.py')
def _generate_parameters_file(data, run_dir=None, is_parallel=False):
_validate_data(data, _SCHEMA)
_scale_units(data)
v = template_common.flatten_data(data.models, PKDict())
r = data.report
report_model = data.models[r]
beamline = data.models.beamline
v.shadowOutputFile = _SHADOW_OUTPUT_FILE
if r == 'initialIntensityReport':
v.distanceFromSource = beamline[
0].position if beamline else template_common.DEFAULT_INTENSITY_DISTANCE
elif _SIM_DATA.is_watchpoint(r):
v.beamlineOptics = _generate_beamline_optics(
data.models, _SIM_DATA.watchpoint_id(r))
else:
v.distanceFromSource = report_model.distanceFromSource
if v.simulation_sourceType == 'bendingMagnet':
v.bendingMagnetSettings = _generate_bending_magnet(data)
elif v.simulation_sourceType == 'geometricSource':
v.geometricSourceSettings = _generate_geometric_source(data)
elif v.simulation_sourceType == 'wiggler':
v.wigglerSettings = _generate_wiggler(data)
v.wigglerTrajectoryFilename = _WIGGLER_TRAJECTORY_FILENAME
v.wigglerTrajectoryInput = ''
if data.models.wiggler.b_from in ('1', '2'):
v.wigglerTrajectoryInput = _SIM_DATA.shadow_wiggler_file(
data.models.wiggler.trajFile)
return 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, run_dir=None, is_parallel=False):
_validate_data(data, simulation_db.get_schema(SIM_TYPE))
_convert_meters_to_centimeters(data['models'])
_convert_meters_to_centimeters(data['models']['beamline'])
v = template_common.flatten_data(data['models'], {})
r = data['report']
report_model = data['models'][r]
beamline = data['models']['beamline']
v['shadowOutputFile'] = _SHADOW_OUTPUT_FILE
if r == 'initialIntensityReport':
v['distanceFromSource'] = beamline[0]['position'] if len(
beamline) else template_common.DEFAULT_INTENSITY_DISTANCE
elif _SIM_DATA.is_watchpoint(r):
v['beamlineOptics'] = _generate_beamline_optics(
data['models'], _SIM_DATA.watchpoint_id(r))
else:
v['distanceFromSource'] = report_model['distanceFromSource']
if v['simulation_sourceType'] == 'bendingMagnet':
v['bendingMagnetSettings'] = _generate_bending_magnet(data)
elif v['simulation_sourceType'] == 'geometricSource':
v['geometricSourceSettings'] = _generate_geometric_source(data)
elif v['simulation_sourceType'] == 'wiggler':
v['wigglerSettings'] = _generate_wiggler(data)
v['wigglerTrajectoryFilename'] = _WIGGLER_TRAJECTOR_FILENAME
v['wigglerTrajectoryInput'] = ''
if data['models']['wiggler']['b_from'] in ('1', '2'):
v['wigglerTrajectoryInput'] = _SIM_DATA.shadow_wiggler_file(
data.models.wiggler.trajFile)
return template_common.render_jinja(SIM_TYPE, v)
def _generate_full_simulation(data, v):
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)
v['simulationMode'] = data['models']['simulation']['simulationMode']
return 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):
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):
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 _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 _bunch_simulation(self):
d = self.data
v = self.jinja_env
for f in _SCHEMA.model.bunch:
info = _SCHEMA.model.bunch[f]
if info[1] == 'RPNValue':
field = f'bunch_{f}'
v[field] = _format_rpn_value(v[field], is_command=True)
longitudinal_method = int(d.models.bunch.longitudinalMethod)
# sigma s, sigma dp, dp s coupling
if longitudinal_method == 1:
v.update(
bunch_emit_z=0,
bunch_beta_z=0,
bunch_alpha_z=0,
)
# sigma s, sigma dp, alpha z
elif longitudinal_method == 2:
v.update(
bunch_emit_z=0,
bunch_beta_z=0,
bunch_dp_s_coupling=0,
)
# emit z, beta z, alpha z
elif longitudinal_method == 3:
v.update(
bunch_sigma_dp=0,
bunch_sigma_s=0,
bunch_dp_s_coupling=0,
)
if d.models.bunchSource.inputSource == 'sdds_beam':
v.update(
bunch_beta_x=5,
bunch_beta_y=5,
bunch_alpha_x=0,
)
if v.bunchFile_sourceFile and v.bunchFile_sourceFile != 'None':
v.bunchInputFile = self._input_file(
'bunchFile',
'sourceFile',
v.bunchFile_sourceFile,
)
v.bunchFileType = _sdds_beam_type_from_file(
self._abspath(v.bunchInputFile), )
if str(d.models.bunch.p_central_mev) == '0':
run_setup = LatticeUtil.find_first_command(d, 'run_setup')
if run_setup and run_setup.expand_for:
v.bunchExpandForFile = 'expand_for = "{}",'.format(
self._input_file(
'command_run_setup',
'expand_for',
run_setup.expand_for,
), )
v.bunchOutputFile = _report_output_filename('bunchReport')
return template_common.render_jinja(SIM_TYPE, v, 'bunch.py')
def _generate_parameters_file(data):
assert data['report'] == 'heightWeightReport', \
'unknown report: {}'.format(data['report'])
v = copy.deepcopy(data['models'], pkcollections.Dict())
v.input_name = INPUT_NAME
v.output_name = OUTPUT_NAME
return template_common.render_jinja(
SIM_TYPE,
v,
template_common.PARAMETERS_PYTHON_FILE,
)
def _generate_parameters_file(data):
_validate_data(data, _SCHEMA)
v = template_common.flatten_data(data['models'], {})
beamline_map = _build_beamline_map(data)
v['lattice'] = _generate_lattice(data, beamline_map, v)
v['bunchFileName'] = OUTPUT_FILE['bunchReport']
v['diagnosticFilename'] = OUTPUT_FILE['beamEvolutionAnimation']
v['twissFileName'] = OUTPUT_FILE['twissReport']
if data.models.bunch.distribution == 'file':
v['bunchFile'] = template_common.lib_file_name('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):
assert data['report'] == 'heightWeightReport', \
'unknown report: {}'.format(data['report'])
v = copy.deepcopy(data['models'], pkcollections.Dict())
v.input_name = INPUT_NAME
v.output_name = OUTPUT_NAME
return template_common.render_jinja(
SIM_TYPE,
v,
template_common.PARAMETERS_PYTHON_FILE,
)
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_full_simulation(data, v):
util = LatticeUtil(data, _SCHEMA)
if data.models.simulation.backtracking == '1':
_setup_backtracking(util)
filename_map = _build_filename_map_from_util(util)
v.update(
dict(
commands=_generate_commands(filename_map, util),
lattice=_generate_lattice(filename_map, util),
simulationMode=data.models.simulation.simulationMode,
))
return 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(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):
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 _full_simulation(self):
v = self.jinja_env
v.lattice = self._generate_lattice(
self.util,
self._code_var,
LatticeUtil.find_first_command(
self.util.data,
'track',
).line or self.util.select_beamline().id,
)
v.use_beamline = self.util.select_beamline().name
self._generate_commands_and_variables()
return template_common.render_jinja(SIM_TYPE, v, 'parameters.in')
def _generate_parameters_file(data, run_dir=None, is_parallel=False):
template_common.validate_models(data, _SCHEMA)
v = template_common.flatten_data(data['models'], {})
v['optionsCommand'] = _generate_options(data['models'])
v['solenoidCommand'] = _generate_solenoid(data['models'])
v['beamCommand'] = _generate_beam(data['models'])
v['currentCommand'] = _generate_current(data['models'])
v['chargeCommand'] = _generate_charge(data['models'])
if is_parallel:
v['latticeCommands'] = _generate_lattice(data['models'])
else:
v['latticeCommands'] = _DEFAULT_DRIFT_ELEMENT
return template_common.render_jinja(SIM_TYPE, v)
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, run_dir=None, is_parallel=False):
v = None
template_common.validate_models(data, simulation_db.get_schema(SIM_TYPE))
v = template_common.flatten_data(data['models'], {})
v['outputDir'] = '"{}"'.format(run_dir) if run_dir else None
v['particlePeriod'] = _PARTICLE_PERIOD
v['particleFile'] = _PARTICLE_FILE
v['impactDensityCalculation'] = _generate_impact_density()
v['egunCurrentFile'] = _EGUN_CURRENT_FILE
v['conductorLatticeAndParticleScraper'] = _generate_lattice(data)
template_name = ''
if 'report' not in data:
template_name = 'visualization'
elif data['report'] == 'animation':
if data['models']['simulation']['egun_mode'] == '1':
v['egunStatusFile'] = _EGUN_STATUS_FILE
template_name = 'egun'
else:
template_name = 'visualization'
else:
template_name = 'source-field'
return template_common.render_jinja(SIM_TYPE, v, 'base.py') \
+ template_common.render_jinja(SIM_TYPE, v, '{}.py'.format(template_name))
def generate_parameters_file(data, run_dir=None, is_parallel=False):
template_common.validate_models(data, _SCHEMA)
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 template_common.render_jinja(SIM_TYPE, v)
def _generate_parameters_file(data):
v = template_common.flatten_data(data.models, {})
report = data.report if 'report' in data else ''
v['particleDef'] = _generate_particle(data.models.particle)
v['beamlineElements'] = _generate_beamline_elements(report, data)
res = template_common.render_jinja(SIM_TYPE, v, 'base.py')
if 'twissReport' in report:
return res + template_common.render_jinja(SIM_TYPE, v, 'twiss.py')
if 'opticsReport' in report:
return res + template_common.render_jinja(SIM_TYPE, v, 'optics.py')
v['outputFile'] = _ZGOUBI_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)
