506 lines
18 KiB

from dolfin import *
import dolfin
import argparse
from common import inout
import numpy as np
import sys
# import ruamel.yaml as yaml
from pathlib import Path
import csv
import shutil
# parameters['allow_extrapolation'] = True
# careful with this option... can give nonsensical results outside
if '2017' in dolfin.__version__:
class MPI(MPI):
comm_world = MPI.comm_world
def solution_function_space(options):
''' Create function space to read in solution checkpoints, as specified in
options (dict): Options dictionary (from input file)
FunctionSpace: Solution checkpoint function space
mesh, _, _ = inout.read_mesh(options['mesh'])
if 'fluid' in options:
if options['fem']['velocity_space'].lower() == 'p2':
Evel = VectorElement('P', mesh.ufl_cell(), 2)
elif options['fem']['velocity_space'].lower() == 'p1':
Evel = VectorElement('P', mesh.ufl_cell(), 1)
raise Exception('Velocity space {} not yet implemented!'.format(
elif 'material' in options:
if options['incompressibility']['mixed_formulation']:
raise Exception('Only compressible hyperelasticity data is '
'supported here, for simplicity')
deg = options['solver']['fe_degree']
Evel = VectorElement('P', mesh.ufl_cell(), deg)
V = FunctionSpace(mesh, Evel)
return V
def measurement_function_spaces(options):
''' Create function space for measurements, as specified in
options (dict): Options dictionary (from input file)
list((Vector)FunctionSpace): list of function spaces on measurement
mesh, scalar if measurements are scalar, else VectorFunctionSpace
list(VectorFunctionSpace): if scalar measurements, a list of
corresponding VectorFunctionSpace for interpolation, else empty
measurement_lst = options['estimation']['measurements']
if not isinstance(measurement_lst, list):
measurement_lst = [measurement_lst]
meshes = [meas['mesh'] for meas in measurement_lst]
if 'fe_degree' in options['estimation']['measurements'][0]:
degree = options['estimation']['measurements'][0]['fe_degree']
degree = 1
for measurement in measurement_lst[1:]:
if not degree == measurement['fe_degree']:
raise Exception('fe_degree must the the same for all '
if degree in (1, 2):
element_family = 'P'
elif degree == 0:
element_family = 'DG'
raise Exception('Unsupported measurement FE degree: {}'
scalar = [False]*len(measurement_lst)
for i, measurement in enumerate(measurement_lst):
if 'velocity_direction' in measurement:
direction = measurement['velocity_direction']
if direction and None not in direction and sum(direction) > 0:
scalar[i] = True
V = []
V_aux = []
for scal, file in zip(scalar, meshes):
mesh, _, _ = inout.read_mesh(file)
if scal:
V.append(FunctionSpace(mesh, element_family, degree))
# 1. interpolate velocity vector onto measurement grid (V_aux)
# 2. perform component projection in the measurement space
# ---> need to store both scalar and vector spaces
V_aux.append(VectorFunctionSpace(mesh, element_family, degree))
V.append(VectorFunctionSpace(mesh, element_family, degree))
return V, V_aux
def find_checkpoints(options):
''' Find all checkpoints of a simulation from configuration in options
options (dict): Options dictionary (from YAML input file)
list: List of found checkpoint indices
list: List of found checkpoint times
list: List of found checkpoint files
if MPI.rank(MPI.comm_world) > 0:
chkpt_root = options['io']['write_path'] + '/checkpoint/{i}/u.h5'
indices = options['estimation']['measurements'][0]['indices']
if not indices:
path_all = list(Path().glob(chkpt_root.format(i='*')))
indices = sorted(int(str(s).split('/')[-2]) for s in path_all)
# dt_meas = options['timemarching']['checkpoint_dt']
# times = np.concatenate(([options['timemarching']['dt']],
# dt_meas*np.array(indices[1:])))
dt = options['timemarching']['dt']
times = dt*np.array(indices)
print('indices: \n')
print('\t', indices)
print('times: \n')
print('\t', times)
files = [chkpt_root.format(i=i) for i in indices]
# check if all files are found
for f in files:
if not Path(f).is_file():
raise FileNotFoundError(f)
return indices, times, files
def generate(options, seed_lst, print_norms=False):
''' Generate measurements.
options (dict): Options dictionary (from input file)
seed_lst (list): list of random seeds
print_norms (bool): switch for printing norms of measurements
V = solution_function_space(options)
ndim = V.mesh().topology().dim()
u = Function(V)
V_meas_lst, V_aux_lst = measurement_function_spaces(options)
u_meas_lst = [Function(V_meas, name='measurement') for V_meas in
u_meas_cpy = [Function(V_meas, name='measurement') for V_meas in
LI = LagrangeInterpolator
if V_aux_lst:
u_aux_lst = [Function(V_aux) for V_aux in V_aux_lst]
comp_assigner = [FunctionAssigner([V]*ndim, V_aux) for V, V_aux in
zip(V_meas_lst, V_aux_lst)]
measurement_lst = options['estimation']['measurements']
noise_sd = [meas['noise_stddev'] for meas in measurement_lst]
# if 'project' in options['estimation']['measurements']:
# project_switch = bool(options['estimation']['measurements']
# ['project'])
# else:
# project_switch = False
project_switch = False
indices, times, files = find_checkpoints(options)
outfile_root_lst = [meas['file_root'] for meas in measurement_lst]
xdmf_paths = [meas['xdmf_file'] for meas in measurement_lst]
# don't automatically append seed{s} do path anymore!
# suppose seed{s} is included
# if seed_lst[0] > 0:
# for i, (out, xdmf) in enumerate(zip(outfile_root_lst, xdmf_paths)):
# # if isinstance(out, str) and 'seed{s}' not in out:
# # out_ = out.split('/')
# # outfile_root_lst[i] = '/'.join(out_[:-1] + ['seed{s}',
# # out_[-1]])
# if isinstance(xdmf, str) and 'seed{s}' not in xdmf:
# xdmf_ = xdmf.split('/')
# xdmf_paths[i] = '/'.join(xdmf_[:-1] + ['seed{s}', xdmf_[-1]])
# check if a list of seeds is given that {s} is included in path
if len(seed_lst) > 1:
for out in outfile_root_lst:
assert '{s}' in out, ('For a list of seeds, the string \'{s}\' '
'must be included in the file_root and will '
'be replaced by the seed number')
if any(xdmf_paths):
xdmf_lst = []
for pth in xdmf_paths:
if not isinstance(pth, str):
raise TypeError('xdmf_file setting must be None or a string '
'indicating the target XDMF file. Got type {}'.
seed_dict = {}
for seed in seed_lst:
file = XDMFFile(pth.format(s=seed))
file.parameters['rewrite_function_mesh'] = False
seed_dict[seed] = file
xdmf_lst = [None]*len(u_meas_lst)
for count, (index, time, infile) in enumerate(zip(indices, times, files)):
if MPI.rank(MPI.comm_world) == 0:
print('Processing {} at t = {}'.format(infile, time))
t_ = inout.read_HDF5_data(u.function_space().mesh().mpi_comm(), infile,
u, '/u')
assert np.allclose(time, t_), ('Timestamps do not match! {} vs {} '
'(HDF5 file)'.format(time, t_))
# interpolate u to measurement meshes
for k, (u_meas, outfile_root, xdmf, sd) in enumerate(zip(
u_meas_lst, outfile_root_lst, xdmf_lst, noise_sd)):
if project_switch:
u_meas.assign(project(u, u_meas.function_space()))
if V_aux_lst:
if MPI.rank(MPI.comm_world) == 0:
print('- Scalar velocity component')
direction = (options['estimation']['measurements'][k]
if direction.count(0) == 2 and direction.count(1) == 1:
LI.interpolate(u_meas, u.sub(direction.index(1)))
assert u_meas.value_shape() == []
# normalize projection direction
direction = np.array(direction, dtype=np.float64)
direction /= np.sqrt(, direction))
if MPI.rank(MPI.comm_world) == 0:
print('- direction: {}'.format(direction))
LagrangeInterpolator.interpolate(u_aux_lst[k], u)
# This is faster than simply Xobs_aux.split(True) !
u_i = [u_meas] + [u_meas.copy(True) for j in
range(ndim - 1)]
comp_assigner[k].assign(u_i, u_aux_lst[k])
u_meas.vector()[:] *= direction[0]
for ui, d in zip(u_i[1:], direction[1:]):
if d:
u_meas.vector().axpy(d, ui.vector())
if MPI.rank(MPI.comm_world) == 0:
print('- Full velocity vector')
LI.interpolate(u_meas, u)
if sd:
# add noise
for seed in seed_lst:
if sd:
if seed > 0:
np.random.seed(seed + count)
if MPI.rank(MPI.comm_world) == 0:
print('- Add noise with stddev = {}, seed = {}'
.format(sd, seed + count))
noise = np.random.normal(0., sd,
u_meas.vector()[:] += noise
if MPI.rank(MPI.comm_world) == 0:
if print_norms:
print('Writing file at t = {}\t |u_m| = {}'.format(
time, norm(u_meas)))
print('Writing file at t = {}\t'.format(time))
outfile = outfile_root.format(i=index, s=seed)
u_meas.function_space().mesh().mpi_comm(), outfile, u_meas,
'/u', time)
if xdmf:
xdmf[seed].write(u_meas, time)
# write indices and timesteps
# write_timestamps(options, indices, times, seed_lst)
def write_timestamps(options, indices, times, seed_lst):
''' Write time stamps of measurements to csv file.
options (dict): Options dictionary (from YAML input file)
indices (list): List of checkpoint indices
times (list): List of checpoint times
seed_lst (list): List of random seeds
if MPI.rank(MPI.comm_world) > 0:
warning('timestamps.csv is OBSOLETE!')
file_root_lst = [meas['file_root'] for meas in options['estimation']
# if seed_lst[0]:
# for i, out in enumerate(file_root_lst):
# if isinstance(out, str) and 'seed{s}' not in out:
# out_ = out.split('/')
# file_root_lst[i] = '/'.join(out_[:-1]
# + ['seed{s}', out_[-1]])
for file_root in file_root_lst:
for seed in seed_lst:
path = Path(file_root.format(s=seed, i=-1)).parent
if seed > 0 and 'seed{s}'.format(s=seed) not in str(path):
path = path.joinpath('seed{s}'.format(s=seed))
path = path.joinpath('timestamps.csv')
print('Writing timestamps to file: {}'.format(path))
with'w') as file:
writer = csv.writer(file, delimiter=' ')
for i, t in zip(indices, times):
writer.writerow((i, t))
def copy_inputfile(options, inputfile, seed_lst):
''' Copy input file of reference solution to measurements directory.
options (dict): Options dictionary (from YAML input file)
inputfile (str): Path of input file to be copied
seed_lst (list): List of random seeds
if MPI.rank(MPI.comm_world) > 0:
file_root_lst = [meas['file_root'] for meas in options['estimation']
for file_root in file_root_lst:
for seed in seed_lst:
path = Path(file_root.format(s=seed, i=-1)).parent
# if seed > 0 and 'seed{s}'.format(s=seed) not in str(path):
# path = path.joinpath('seed{s}'.format(s=seed))
path = path.joinpath('input.yaml')
# path.parent.mkdir(parents=True, exist_ok=True)
shutil.copy2(str(inputfile), str(path))
print('Copied input file to {}'.format(path))
def dump_example_options(path):
''' Dump example options to given path and exit.
path (str): Path to input file
example = '''\
# example fractional step inputfile for
mesh: './meshes/mesh.h5'
# Path containing checkpoints in a checkpoints/ folder
write_path: './results/test/'
# final time of simulation to be processed
T: 0.4
# simulation time step size (not dt_checkpoint)
dt: 0.001
# Velocity and presse (for monolithic) function spaces of checkpoints
velocity_space: 'p1'
pressure_space: 'p1'
# List of measurements
# Mesh of 1. measurement set
mesh: './measurements/mesh_meas.h5'
# degree of finite element function space
# (1 for linear, 0 for discontinuous piece-wise constant)
fe_degree: 0
# velocity measurement files to be written by this tool
# {i} will be replaced by the corresponding index of the checkpoint
# if given, {s} may be replaced by the seed number, for instance
# path/seed{s}/u{i}.h5
file_root: './measurements/u{i}.h5'
# XDMF file where measurements are optionally stored for
# visualization (one file for all time steps)
xdmf_file: './measurements/meas.xdmf'
# Select a velocity component:
# * None (~) means "use complete vector"
# * else, use a scalar velocity by projecting onto the given
# direction vector, [x, y, (z)]
velocity_direction: ~
# (absolute) standard deviation of Gaussian noise
noise_stddev: 10.
# indices of checkpoints to be processed:
# * 0 == all
# * a list of integes
indices: 0
# second measurement ...
# further measurements ...
with open(path, 'w') as f:
print('Example options:\n\n')
print('\ndumped example options to file: {}'.format(path))
def get_parser():
parser = argparse.ArgumentParser(description='''\
Generate measurements from HDF5 checkpoints, generated by the Fractional-Step
or the monolithic Navier-Stokes solvers.
Reads options from the given input file.
See the example options for further explanations::
(` -d example.yaml`).
''', formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('inputfile', type=str, help='path to yaml input file')
# parser.add_argument('-s', '--seed', type=int, default=-1,
# help='seed for random generator')
parser.add_argument('-s', '--seed', nargs='+', help='seed or list of seeds'
' for noise random number generator. '
'Will take the given seed for the first time step '
'and increment by +1 for all subsequent time steps, '
'so that noise is different for all times '
'but reproducible', default=[-1], type=int)
parser.add_argument('-n', '--print_norms', action='store_true',
help='print norms')
parser.add_argument('-d', '--dump', action='store_true',
help='dump minimal example parameters to inputfile')
return parser
if __name__ == '__main__':
args = get_parser().parse_args()
if args.dump:
seed = args.seed
if seed[0] <= 0:
assert len(seed) == 1, 'if multiple seeds are given, all should be > 0'
options = inout.read_parameters(args.inputfile)
except IOError:
raise IOError('File could not be read: {}'.format(args.inputfile))
generate(options, seed, args.print_norms)
copy_inputfile(options, args.inputfile, seed)