def get_simulation_frame(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
if data['modelName'] in ('beamEvolutionAnimation',
'coolingRatesAnimation'):
args = template_common.parse_animation_args(
data,
{
'1': ['x', 'y1', 'y2', 'y3', 'startTime'],
'': ['y1', 'y2', 'y3', 'startTime'],
},
)
return _extract_evolution_plot(args, run_dir)
elif data['modelName'] == 'particleAnimation':
args = template_common.parse_animation_args(
data,
{
'1': ['x', 'y', 'histogramBins', 'startTime'],
'': [
'x', 'y', 'histogramBins', 'plotRangeType',
'horizontalSize', 'horizontalOffset', 'verticalSize',
'verticalOffset', 'isRunning', 'startTime'
],
},
)
return _extract_particle_plot(args, run_dir, frame_index)
raise RuntimeError('unknown animation model: {}'.format(data['modelName']))
def get_simulation_frame(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
if data['modelName'] == 'beamAnimation':
args = template_common.parse_animation_args(
data,
{
'1': ['reportType', 'histogramBins', 'startTime'],
'': ['reportType', 'histogramBins', 'plotRangeType', 'horizontalSize', 'horizontalOffset', 'verticalSize', 'verticalOffset', 'isRunning', 'startTime'],
},
)
return extract_beam_report(args, run_dir, frame_index)
elif data['modelName'] == 'beamHistogramAnimation':
args = template_common.parse_animation_args(
data,
{'': ['reportType', 'histogramBins', 'startTime']},
)
return extract_beam_histrogram(args, run_dir, frame_index)
elif data['modelName'] == 'particleAnimation':
args = template_common.parse_animation_args(
data,
{'': ['reportType', 'renderCount', 'startTime']},
)
return extract_particle_report(args, run_dir)
elif data['modelName'] == 'parameterAnimation':
args = template_common.parse_animation_args(
data,
{'': ['reportType', 'startTime']},
)
return extract_parameter_report(args, run_dir)
raise RuntimeError('unknown animation model: {}'.format(data['modelName']))
def get_simulation_frame(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
if data['modelName'] == 'currentAnimation':
data_file = open_data_file(run_dir, data['modelName'], frame_index)
return _extract_current(model_data, data_file)
if data['modelName'] == 'fieldAnimation':
args = template_common.parse_animation_args(
data, {'': ['field', 'startTime']})
data_file = open_data_file(run_dir, data['modelName'], frame_index)
return _extract_field(args.field, model_data, data_file)
if data['modelName'] == 'particleAnimation' or data[
'modelName'] == 'particle3d':
args = template_common.parse_animation_args(
data, {'': ['renderCount', 'startTime']})
return _extract_particle(run_dir, model_data, int(args.renderCount))
if data['modelName'] == 'egunCurrentAnimation':
return _extract_egun_current(model_data,
run_dir.join(_EGUN_CURRENT_FILE),
frame_index)
if data['modelName'] == 'impactDensityAnimation':
return _extract_impact_density(run_dir, model_data)
if data['modelName'] == 'optimizerAnimation':
args = template_common.parse_animation_args(data, {'': ['x', 'y']})
return _extract_optimization_results(run_dir, model_data, args)
raise RuntimeError('{}: unknown simulation frame model'.format(
data['modelName']))
def get_simulation_frame(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
data_file = open_data_file(run_dir, frame_index)
if data['modelName'] == 'fieldAnimation':
args = template_common.parse_animation_args(
data,
{'': ['field', 'coordinate', 'mode', 'startTime']},
)
return _field_animation(args, data_file)
if data['modelName'] == 'particleAnimation':
args = template_common.parse_animation_args(
data,
{
'': [
'x', 'y', 'histogramBins', 'xMin', 'xMax', 'yMin', 'yMax',
'zMin', 'zMax', 'uxMin', 'uxMax', 'uyMin', 'uyMax',
'uzMin', 'uzMax', 'startTime'
]
},
)
return extract_particle_report(args, 'electrons', run_dir, data_file)
if data['modelName'] == 'beamAnimation':
args = template_common.parse_animation_args(
data,
{'': ['x', 'y', 'histogramBins', 'startTime']},
)
return extract_particle_report(args, 'beam', run_dir, data_file)
raise RuntimeError('{}: unknown simulation frame model'.format(
data['modelName']))
def get_simulation_frame(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
if data['modelName'] == 'beamEvolutionAnimation':
args = template_common.parse_animation_args(
data,
{
'1': ['x', 'y1', 'y2', 'y3', 'startTime'],
'': ['y1', 'y2', 'y3', 'startTime'],
},
)
return _extract_evolution_plot(args, run_dir)
if data['modelName'] == 'bunchAnimation':
args = template_common.parse_animation_args(
data,
{
'1': ['x', 'y', 'histogramBins', 'startTime'],
'': ['x', 'y', 'histogramBins', 'plotRangeType', 'horizontalSize', 'horizontalOffset', 'verticalSize', 'verticalOffset', 'isRunning', 'startTime'],
},
)
return _extract_bunch_plot(args, frame_index, run_dir)
if data['modelName'] == 'turnComparisonAnimation':
args = template_common.parse_animation_args(
data,
{
'': ['y', 'turn1', 'turn2', 'startTime'],
},
)
return _extract_turn_comparison_plot(args, run_dir, model_data.models.simulationSettings.turn_count)
raise RuntimeError('unknown animation model: {}'.format(data['modelName']))
def get_simulation_frame(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
if data['modelName'] == 'beamEvolutionAnimation':
args = template_common.parse_animation_args(
data,
{
'1': ['x', 'y1', 'y2', 'y3', 'startTime'],
'': ['y1', 'y2', 'y3', 'startTime'],
},
)
return _extract_evolution_plot(args, run_dir)
if data['modelName'] == 'bunchAnimation':
args = template_common.parse_animation_args(
data,
{
'1': ['x', 'y', 'histogramBins', 'startTime'],
'': [
'x', 'y', 'histogramBins', 'plotRangeType',
'horizontalSize', 'horizontalOffset', 'verticalSize',
'verticalOffset', 'isRunning', 'startTime'
],
},
)
return _extract_bunch_plot(args, frame_index, run_dir)
if data['modelName'] == 'turnComparisonAnimation':
args = template_common.parse_animation_args(
data,
{
'': ['y', 'turn1', 'turn2', 'startTime'],
},
)
return _extract_turn_comparison_plot(
args, run_dir, model_data.models.simulationSettings.turn_count)
raise RuntimeError('unknown animation model: {}'.format(data['modelName']))
def _extract_animation(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
report = template_common.parse_animation_args(
data,
{
'1': ['x', 'y', 'histogramBins', 'startTime'],
'2': [
'x', 'y', 'histogramBins', 'plotRangeType', 'horizontalSize',
'horizontalOffset', 'verticalSize', 'verticalOffset',
'isRunning', 'startTime'
],
'': [
'x', 'y', 'histogramBins', 'plotRangeType', 'horizontalSize',
'horizontalOffset', 'verticalSize', 'verticalOffset',
'isRunning', 'showAllFrames', 'particleNumber', 'startTime'
],
},
)
is_frame_0 = False
# fieldRange is store on the bunchAnimation
model = model_data.models.bunchAnimation
if data['modelName'] == 'energyAnimation':
model.update(model_data.models.energyAnimation)
frame_index += 1
else:
# bunchAnimations
# remap frame 0 to use initial "o" values from frame 1
if frame_index == 0:
is_frame_0 = True
for f in ('x', 'y'):
report[f] = _initial_phase_field(report[f])
frame_index = 1
model.update(report)
col_names, all_rows = _read_data_file(run_dir.join(_ZGOUBI_DATA_FILE))
ipasses = _ipasses_for_data(col_names, all_rows)
ipass = int(ipasses[frame_index - 1])
rows = []
ipass_index = int(col_names.index('IPASS'))
let_index = int(col_names.index('LET'))
let_search = "'{}'".format(report['particleNumber'])
count = 0
for row in all_rows:
if report['showAllFrames'] == '1':
if model_data.models.bunch.method == 'OBJET2.1' and report[
'particleNumber'] != 'all':
if row[let_index] != let_search:
continue
rows.append(row)
elif int(row[ipass_index]) == ipass:
rows.append(row)
if report['showAllFrames'] == '1':
title = 'All Frames'
if model_data.models.bunch.method == 'OBJET2.1' and report[
'particleNumber'] != 'all':
title += ', Particle {}'.format(report['particleNumber'])
else:
title = 'Initial Distribution' if is_frame_0 else 'Pass {}'.format(
ipass)
return _extract_bunch_data(model, col_names, rows, title)
def _extract_evolution_plot(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
args = template_common.parse_animation_args(
data,
{
'': ['y1', 'y2', 'y3', 'startTime'],
},
)
datfile = np.loadtxt(str(run_dir.join(_GRID_EVOLUTION_FILE)))
stride = 20
x = datfile[::stride, 0]
plots = []
for plot in _PLOT_COLUMNS[model_data.models.simulation.get(
'flashType', 'RTFlame')]:
plots.append({
'name': plot[0],
'label': plot[0],
'points': datfile[::stride, plot[1]].tolist(),
})
return {
'title': '',
'x_range': [min(x), max(x)],
'y_label': '',
'x_label': 'time [s]',
'x_points': x.tolist(),
'plots': plots,
'y_range': template_common.compute_plot_color_and_range(plots),
}
def get_simulation_frame(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
frame_data = template_common.parse_animation_args(
data,
{
'1': ['x', 'y', 'histogramBins', 'xFileId', 'startTime'],
'2':
['x', 'y', 'histogramBins', 'xFileId', 'yFileId', 'startTime'],
'3': [
'x', 'y1', 'y2', 'y3', 'histogramBins', 'xFileId', 'y2FileId',
'y3FileId', 'startTime'
],
'4':
['x', 'y1', 'y2', 'y3', 'histogramBins', 'xFileId', 'startTime'],
'': [
'x', 'y1', 'y2', 'y3', 'histogramBins', 'xFileId',
'plotRangeType', 'horizontalSize', 'horizontalOffset',
'verticalSize', 'verticalOffset', 'startTime'
],
},
)
page_count = 0
for info in _output_info(run_dir):
if info['modelKey'] == data['modelName']:
page_count = info['pageCount']
frame_data['fieldRange'] = info['fieldRange']
frame_data['y'] = frame_data['y1']
return extract_report_data(
_file_name_from_id(frame_data.xFileId, model_data, run_dir),
frame_data,
frame_index,
page_count=page_count,
)
def _extract_bunch_animation(run_dir, data, model_data):
# KEX, Do-1, Yo, To, Zo, Po, So, to, D-1, Y, T, Z, P, S, time, SXo, SYo, SZo, modSo, SX, SY, SZ, modS, ENEKI, ENERG, IT, IREP, SORT, M, Q, G, tau, unused, RET, DPR, PS, BORO, IPASS, NOEL, KLEY, LABEL1, LABEL2, LET
# int, float, cm, mrd, cm, mrd, cm, mu_s, float, cm, mrd, cm, mrd, cm, mu_s, float,float,float, float, float,float,float,float, MeV, MeV, int, int, cm, MeV/c2, C, float, float, float, float, float, float, kG.cm, int, int, string, string, string, string
#TODO(pjm): extract units from datafile
frame_index = int(data['frameIndex'])
report = template_common.parse_animation_args(
data,
{'': ['x', 'y', 'histogramBins', 'startTime']},
)
is_frame_0 = False
# remap frame 0 to use initial "o" values from frame 1
if frame_index == 0:
is_frame_0 = True
for f in ('x', 'y'):
v = report[f]
report[f] = _INITIAL_PHASE_MAP.get(v, '{}o'.format(v))
frame_index = 1
col_names, all_rows = read_data_file(run_dir.join(_ZGOUBI_DATA_FILE))
rows = []
ipass_index = int(col_names.index('IPASS'))
for row in all_rows:
if int(row[ipass_index]) == frame_index:
rows.append(row)
return _extract_bunch_data(
report, col_names, rows, 'Initial Distribution'
if is_frame_0 else 'Pass {}'.format(frame_index))
def get_simulation_frame(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
if data['modelName'] == 'currentAnimation':
data_file = open_data_file(run_dir, data['modelName'], frame_index)
return _extract_current(model_data, data_file)
if data['modelName'] == 'fieldAnimation':
args = template_common.parse_animation_args(data, {'': ['field', 'startTime']})
data_file = open_data_file(run_dir, data['modelName'], frame_index)
return _extract_field(args.field, model_data, data_file)
if data['modelName'] == 'particleAnimation' or data['modelName'] == 'particle3d':
args = template_common.parse_animation_args(data, {'': ['renderCount', 'startTime']})
return _extract_particle(run_dir, model_data, int(args.renderCount))
if data['modelName'] == 'egunCurrentAnimation':
return _extract_egun_current(model_data, run_dir.join(_EGUN_CURRENT_FILE), frame_index)
if data['modelName'] == 'impactDensityAnimation':
return _extract_impact_density(run_dir, model_data)
raise RuntimeError('{}: unknown simulation frame model'.format(data['modelName']))
def get_simulation_frame(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
data_file = open_data_file(run_dir, frame_index)
if data['modelName'] == 'fieldAnimation':
args = template_common.parse_animation_args(
data,
{'': ['field', 'coordinate', 'mode', 'startTime']},
)
return _field_animation(args, data_file)
if data['modelName'] == 'particleAnimation':
args = template_common.parse_animation_args(
data,
{'': ['x', 'y', 'histogramBins', 'xMin', 'xMax', 'yMin', 'yMax', 'zMin', 'zMax', 'uxMin', 'uxMax', 'uyMin', 'uyMax', 'uzMin', 'uzMax', 'startTime']},
)
return extract_particle_report(args, 'electrons', run_dir, data_file)
if data['modelName'] == 'beamAnimation':
args = template_common.parse_animation_args(
data,
{'': ['x', 'y', 'histogramBins', 'startTime']},
)
return extract_particle_report(args, 'beam', run_dir, data_file)
raise RuntimeError('{}: unknown simulation frame model'.format(data['modelName']))
def get_simulation_frame(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
frame_data = template_common.parse_animation_args(
data,
{
'1': ['x', 'y', 'histogramBins', 'xFileId', 'startTime'],
'': ['x', 'y', 'histogramBins', 'xFileId', 'yFileId', 'startTime'],
},
)
if frame_data.version <= 1:
frame_data.yFileId = frame_data.xFileId
xFileId = frame_data.xFileId.split(_FILE_ID_SEP)
yFileId = frame_data.yFileId.split(_FILE_ID_SEP)
xFilename = _get_filename_for_element_id(xFileId, model_data)
yFilename = _get_filename_for_element_id(yFileId, model_data)
return extract_report_data(
str(run_dir.join(xFilename)),
str(run_dir.join(yFilename)),
frame_data,
frame_index,
)
def get_simulation_frame(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
frame_data = template_common.parse_animation_args(
data,
{
'1': ['x', 'y', 'histogramBins', 'xFileId', 'startTime'],
'2': ['x', 'y', 'histogramBins', 'xFileId', 'yFileId', 'startTime'],
'3': ['x', 'y1', 'y2', 'y3', 'histogramBins', 'xFileId', 'y2FileId', 'y3FileId', 'startTime'],
'': ['x', 'y1', 'y2', 'y3', 'histogramBins', 'xFileId', 'startTime'],
},
)
page_count = 0
for info in _output_info(run_dir):
if info['modelKey'] == data['modelName']:
page_count = info['pageCount']
return extract_report_data(
_file_name_from_id(frame_data.xFileId, model_data, run_dir),
frame_data,
frame_index,
page_count=page_count,
)
def get_simulation_frame(run_dir, data, model_data):
frame_index = int(data['frameIndex'])
frame_data = template_common.parse_animation_args(
data,
{
'1': ['x', 'y', 'histogramBins', 'xFileId', 'startTime'],
'2':
['x', 'y', 'histogramBins', 'xFileId', 'yFileId', 'startTime'],
'': [
'x', 'y1', 'y2', 'y3', 'histogramBins', 'xFileId', 'y2FileId',
'y3FileId', 'startTime'
],
},
)
return extract_report_data(
_file_name_from_id(frame_data.xFileId, model_data, run_dir),
_file_name_from_id(frame_data.y2FileId, model_data, run_dir),
_file_name_from_id(frame_data.y3FileId, model_data, run_dir),
frame_data,
frame_index,
)
def _extract_bunch_animation(run_dir, data, model_data):
# KEX, Do-1, Yo, To, Zo, Po, So, to, D-1, Y, T, Z, P, S, time, SXo, SYo, SZo, modSo, SX, SY, SZ, modS, ENEKI, ENERG, IT, IREP, SORT, M, Q, G, tau, unused, RET, DPR, PS, BORO, IPASS, NOEL, KLEY, LABEL1, LABEL2, LET
# int, float, cm, mrd, cm, mrd, cm, mu_s, float, cm, mrd, cm, mrd, cm, mu_s, float,float,float, float, float,float,float,float, MeV, MeV, int, int, cm, MeV/c2, C, float, float, float, float, float, float, kG.cm, int, int, string, string, string, string
#TODO(pjm): extract units from datafile
frame_index = int(data['frameIndex'])
report = template_common.parse_animation_args(
data,
{'': ['x', 'y', 'histogramBins', 'startTime']},
)
is_frame_0 = False
# remap frame 0 to use initial "o" values from frame 1
if frame_index == 0:
is_frame_0 = True
for f in ('x', 'y'):
v = report[f]
report[f] = _INITIAL_PHASE_MAP.get(v, '{}o'.format(v))
frame_index = 1
col_names, all_rows = read_data_file(run_dir.join(_ZGOUBI_DATA_FILE))
rows = []
ipass_index = int(col_names.index('IPASS'))
for row in all_rows:
if int(row[ipass_index]) == frame_index:
rows.append(row)
return _extract_bunch_data(report, col_names, rows, 'Initial Distribution' if is_frame_0 else 'Pass {}'.format(frame_index))
def _extract_meshed_plot(run_dir, data):
frame_index = int(data['frameIndex'])
report = template_common.parse_animation_args(
data,
{'': ['var', 'startTime']},
)
field = report['var']
filename = _h5_file_list(run_dir)[frame_index]
with h5py.File(filename) as f:
params = _parameters(f)
node_type = f['node type']
bounding_box = f['bounding box']
xdomain = [params['xmin'], params['xmax']]
ydomain = [params['ymin'], params['ymax']]
size = _cell_size(f, params['lrefine_max'])
dim = (
_rounded_int((ydomain[1] - ydomain[0]) / size[1]) * params['nyb'],
_rounded_int((xdomain[1] - xdomain[0]) / size[0]) * params['nxb'],
)
grid = np.zeros(dim)
values = f[field]
amr_grid = []
for i in xrange(len(node_type)):
if node_type[i] == 1:
bounds = bounding_box[i]
_apply_to_grid(grid, values[i, 0], bounds, size, xdomain,
ydomain)
amr_grid.append([
(bounds[0] / 100).tolist(),
(bounds[1] / 100).tolist(),
])
# imgplot = plt.imshow(grid, extent=[xdomain[0], xdomain[1], ydomain[1], ydomain[0]], cmap='PiYG')
aspect_ratio = float(params['nblocky']) / params['nblockx']
time_units = 's'
if params['time'] != 0:
if params['time'] < 1e-6:
params['time'] *= 1e9
time_units = 'ns'
elif params['time'] < 1e-3:
params['time'] *= 1e6
time_units = 'µs'
elif params['time'] < 1:
params['time'] *= 1e3
time_units = 'ms'
return {
'x_range': [xdomain[0] / 100, xdomain[1] / 100,
len(grid[0])],
'y_range': [ydomain[0] / 100, ydomain[1] / 100,
len(grid)],
'x_label':
'x [m]',
'y_label':
'y [m]',
'title':
'{}'.format(field),
'subtitle':
'Time: {:.1f} [{}], Plot {}'.format(params['time'], time_units,
frame_index + 1),
'aspectRatio':
aspect_ratio,
'z_matrix':
grid.tolist(),
'amr_grid':
amr_grid,
'summaryData': {
'aspectRatio': aspect_ratio,
},
}
