def create_function_from_metadata(pp, fieldname, metadata, saveformat):
"Create a function from metadata"
assert metadata['type'] == 'Function'
# Load mesh
if saveformat == 'hdf5':
mesh = Mesh()
hdf5file = HDF5File(mpi_comm_world(), os.path.join(pp.get_savedir(fieldname), fieldname+'.hdf5'), 'r')
hdf5file.read(mesh, "Mesh", False)
del hdf5file
elif saveformat == 'xml' or saveformat == 'xml.gz':
mesh = Mesh()
hdf5file = HDF5File(mpi_comm_world(), os.path.join(pp.get_savedir(fieldname), "mesh.hdf5"), 'r')
hdf5file.read(mesh, "Mesh", False)
del hdf5file
# Replace loaded mesh if same mesh is loaded previously
mesh = MeshPool(mesh, tolerance=0.0)
shape = eval(metadata["element_value_shape"])
degree = eval(metadata["element_degree"])
family = eval(metadata["element_family"])
# Get space from existing function spaces if mesh is the same
spaces = SpacePool(mesh)
space = spaces.get_custom_space(family, degree, shape)
return Function(space, name=fieldname)
def convert(msh_file, h5_file):
'''Temporary version of convert from msh to h5'''
root, _ = os.path.splitext(msh_file)
assert os.path.splitext(msh_file)[1] == '.msh'
assert os.path.splitext(h5_file)[1] == '.h5'
# Get the xml mesh
xml_file = '.'.join([root, 'xml'])
subprocess.call(['dolfin-convert %s %s' % (msh_file, xml_file)], shell=True)
# Success?
assert os.path.exists(xml_file)
mesh = Mesh(xml_file)
out = HDF5File(mesh.mpi_comm(), h5_file, 'w')
out.write(mesh, 'mesh')
info('Mesh has %d cells' % mesh.num_cells())
info('Mesh size %g %g' % (mesh.hmin(), mesh.hmax()))
outputs = [mesh]
# Save ALL data as facet_functions
names = ('surfaces', 'volumes')
for name, region in zip(names, ('facet_region.xml', 'physical_region.xml')):
r_xml_file = '_'.join([root, region])
f = MeshFunction('size_t', mesh, r_xml_file)
out.write(f, name)
outputs.append(f)
return outputs
def convert(msh_file, h5_file):
'''Convert msh file to h5_file'''
root, _ = os.path.splitext(msh_file)
assert os.path.splitext(msh_file)[1] == '.msh'
assert os.path.splitext(h5_file)[1] == '.h5'
# Get the xml mesh
xml_file = '.'.join([root, 'xml'])
subprocess.call(['dolfin-convert %s %s' % (msh_file, xml_file)],
shell=True)
# Success?
assert os.path.exists(xml_file)
mesh = Mesh(xml_file)
out = HDF5File(mesh.mpi_comm(), h5_file, 'w')
out.write(mesh, 'mesh')
for region in ('facet_region.xml', ):
name, _ = region.split('_')
r_xml_file = '_'.join([root, region])
f = MeshFunction('size_t', mesh, r_xml_file)
out.write(f, name)
# Sucess?
assert os.path.exists(h5_file)
return mesh
def convert(msh_file):
'''Temporary version of convertin from msh to h5'''
root, _ = os.path.splitext(msh_file)
assert os.path.splitext(msh_file)[1] == '.msh'
# Get the xml mesh
xml_file = '.'.join([root, 'xml'])
# Convert to XML
convert2xml(msh_file, xml_file)
# Success?
assert os.path.exists(xml_file)
mesh = Mesh(xml_file)
h5_file = '.'.join([root, 'h5'])
out = HDF5File(mesh.mpi_comm(), h5_file, 'w')
out.write(mesh, 'mesh')
# Save ALL data as facet_functions
data_sets = ('curves', 'surfaces', 'volumes')
regions = ('curve_region.xml', 'facet_region.xml', 'volume_region.xml')
for data_set, region in zip(data_sets, regions):
r_xml_file = '_'.join([root, region])
if os.path.exists(r_xml_file):
f = MeshFunction('size_t', mesh, r_xml_file)
out.write(f, data_set)
# And clean
os.remove(r_xml_file)
# and clean
os.remove(xml_file)
return h5_file
def read_fenics_solution(filepath):
from dolfin import (Mesh, XDMFFile, MeshValueCollection, cpp,
FunctionSpace, Function, HDF5File, MPI)
mesh = Mesh()
with XDMFFile("%s_triangle.xdmf" % filepath.split('.')[0]) as infile:
infile.read(mesh) # read the complete mesh
#mvc_subdo = MeshValueCollection("size_t", mesh, mesh.geometric_dimension() - 1)
#with XDMFFile("%s_triangle.xdmf" % filepath.split('.')[0]) as infile:
# infile.read(mvc_subdo, "subdomains") # read the diferent subdomians
#subdomains = cpp.mesh.MeshFunctionSizet(mesh, mvc_subdo)
#mvc = MeshValueCollection("size_t", mesh, mesh.geometric_dimension() - 2)
#with XDMFFile("%s_line.xdmf" % filepath.split('.')[0]) as infile:
# infile.read(mvc, "boundary_conditions") # read the boundary conditions
#boundary = cpp.mesh.MeshFunctionSizet(mesh, mvc)
# Define function space and basis functions
V = FunctionSpace(mesh, "CG", 1)
U = Function(V)
input_file = HDF5File(MPI.comm_world,
filepath.split('.')[0] + "_solution_field.h5", "r")
input_file.read(U, "solution")
input_file.close()
dofs = V.tabulate_dof_coordinates().reshape(
V.dim(),
mesh.geometry().dim()) # coordinates of nodes
U.set_allow_extrapolation(True)
return U, mesh, dofs.shape[0]
def load_mesh(filename):
""" Loads in the mesh specified by the argument filename. """
info_cyan("Loading mesh: " + filename)
mesh = Mesh()
h5file = HDF5File(mesh.mpi_comm(), filename, "r")
h5file.read(mesh, "mesh", False)
h5file.close()
return mesh
def load_mesh(filename, subdir="mesh", use_partition_from_file=False):
""" Loads the mesh specified by the argument filename. """
info_cyan("Loading mesh: " + filename)
mesh = Mesh()
h5file = HDF5File(mesh.mpi_comm(), filename, "r")
h5file.read(mesh, subdir, use_partition_from_file)
h5file.close()
return mesh
def load_checkpoint(checkpointfolder, w_, w_1):
if checkpointfolder:
h5filename = os.path.join(checkpointfolder, "fields.h5")
h5file = HDF5File(mpi_comm(), h5filename, "r")
for field in w_:
info_red("Loading subproblem: {}".format(field))
h5file.read(w_[field], "{}/current".format(field))
h5file.read(w_1[field], "{}/previous".format(field))
h5file.close()
def load_checkpoint(checkpointfolder, w_, w_1):
if checkpointfolder:
h5filename = os.path.join(checkpointfolder, "fields.h5")
h5file = HDF5File(mpi_comm_world(), h5filename, "r")
for field in w_:
info_red("Loading subproblem: " + field)
h5file.read(w_[field], field + "/current")
h5file.read(w_1[field], field + "/previous")
h5file.close()
def read_h5(h5Path):
mesh = Mesh()
hdf = HDF5File(mesh.mpi_comm(), h5Path, 'r')
hdf.read(mesh, '/mesh', False)
subdomains = MeshFunction('size_t', mesh, 3)
boundaries = MeshFunction('size_t', mesh, 2)
hdf.read(subdomains, '/subdomains')
hdf.read(boundaries, '/boundaries')
return mesh, subdomains, boundaries
def store_mesh(self, mesh, cell_domains=None, facet_domains=None):
"Store mesh in casedir to mesh.hdf5 (dataset Mesh) in casedir."
casedir = self.get_casedir()
meshfile = HDF5File(mpi_comm_world(),
os.path.join(casedir, "mesh.hdf5"), 'w')
meshfile.write(mesh, "Mesh")
if cell_domains is not None:
meshfile.write(cell_domains, "CellDomains")
if facet_domains is not None:
meshfile.write(facet_domains, "FacetDomains")
del meshfile
def _update_xml_gz_file(self, field_name, saveformat, data, timestep, t):
"Create new xml.gz file for current timestep with new data."
assert saveformat == "xml.gz"
fullname, metadata = self._get_datafile_name(field_name, saveformat,
timestep)
meshfile = os.path.join(self.get_savedir(field_name), "mesh.hdf5")
if not os.path.isfile(meshfile):
hdf5file = HDF5File(mpi_comm_world(), meshfile, 'w')
hdf5file.write(data.function_space().mesh(), "Mesh")
del hdf5file
datafile = File(fullname)
datafile << data
return metadata
def save_output(eigenvectors, phi, e_density, potential):
#writing to HDF file
f = HDF5File("out.h5", "w")
f.write(phi, 'phi')
f.write(e_density, 'n(x)')
f.write(potential, 'V(x)')
i = 0
while (i < len(eigenvectors)):
name = 'eigenvector' + str(i)
print eigenvectors[i]
print phi
print e_density
def init_from_restart(restart_folder, sys_comp, uc_comp, u_components,
q_, q_1, q_2, **NS_namespace):
"""Initialize solution from checkpoint files """
if restart_folder:
for ui in sys_comp:
filename = path.join(restart_folder, ui + '.h5')
hdf5_file = HDF5File(mpi_comm_world(), filename, "r")
hdf5_file.read(q_[ui].vector(), "/current", False)
q_[ui].vector().apply('insert')
# Check for the solution at a previous timestep as well
if ui in uc_comp:
q_1[ui].vector().zero()
q_1[ui].vector().axpy(1., q_[ui].vector())
q_1[ui].vector().apply('insert')
if ui in u_components:
hdf5_file.read(q_2[ui].vector(), "/previous", False)
q_2[ui].vector().apply('insert')
def load_h5_mesh(h5_file, scale_factor=None):
'''Unpack to mesh, volumes and surfaces'''
mesh = Mesh()
h5 = HDF5File(mesh.mpi_comm(), h5_file, 'r')
h5.read(mesh, 'mesh', False)
# Convert units
if scale_factor is not None:
assert scale_factor > 0, "Scale factor must be a positive real number!"
mesh.coordinates()[:] *= scale_factor
surfaces = MeshFunction('size_t', mesh, mesh.topology().dim() - 1)
h5.read(surfaces, 'surfaces')
volumes = MeshFunction('size_t', mesh, mesh.topology().dim())
h5.read(volumes, 'volumes')
return mesh, volumes, surfaces
def as_pvd(h5_file):
'''Store facet and cell function for pvd'''
root, ext = os.path.splitext(h5_file)
mesh = Mesh()
hdf = HDF5File(mesh.mpi_comm(), h5_file, 'r')
hdf.read(mesh, '/mesh', False)
facet_markers = FacetFunction('size_t', mesh)
hdf.read(facet_markers, '/facet_markers')
cell_markers = CellFunction('size_t', mesh)
hdf.read(cell_markers, '/cell_markers')
File(root + 'facets' + '.pvd') << facet_markers
File(root + 'volumes' + '.pvd') << cell_markers
return True
def test_hdf5_save(mesh, casedir):
spacepool = SpacePool(mesh)
Q = spacepool.get_space(1, 0)
V = spacepool.get_space(1, 1)
mff = MockFunctionField(Q, dict(save=True, save_as="hdf5"))
mvff = MockVectorFunctionField(V, dict(save=True, save_as="hdf5"))
pp = PostProcessor(dict(casedir=casedir))
pp.add_fields([mff, mvff])
pp.update_all({}, 0.0, 0)
pp.update_all({}, 0.1, 1)
pp.update_all({}, 0.2, 2)
pp.finalize_all()
for mf, FS in [(mff, Q), (mvff, V)]:
assert os.path.isdir(pp.get_savedir(mf.name))
assert os.path.isfile(
os.path.join(pp.get_savedir(mf.name), "metadata.db"))
assert os.path.isfile(
os.path.join(pp.get_savedir(mf.name), mf.name + ".hdf5"))
md = shelve.open(os.path.join(pp.get_savedir(mf.name), "metadata.db"),
'r')
assert 'hdf5' in md["0"]
assert 'hdf5' in md["1"]
assert 'hdf5' in md["2"]
assert 'hdf5' in md['saveformats']
assert md['saveformats'] == ['hdf5']
md.close()
assert len(os.listdir(pp.get_savedir(mf.name))) == 2
# Read back
hdf5file = HDF5File(
mpi_comm_world(),
os.path.join(pp.get_savedir(mf.name), mf.name + ".hdf5"), 'r')
f = Function(FS)
for i in ["0", "1", "2"]:
hdf5file.read(f, mf.name + i)
assert norm(f) == norm(pp.get(mf.name))
def save_checkpoint_solution_h5(tstep, q_, q_1, newfolder, u_components,
NS_parameters):
"""Overwrite solution in Checkpoint folder.
For safety reasons, in case the solver is interrupted, take backup of
solution first.
Must be restarted using the same mesh-partitioning. This will be fixed
soon. (MM)
"""
checkpointfolder = path.join(newfolder, "Checkpoint")
NS_parameters["num_processes"] = MPI.size(MPI.comm_world)
if MPI.rank(MPI.comm_world) == 0:
if path.exists(path.join(checkpointfolder, "params.dat")):
system('cp {0} {1}'.format(
path.join(checkpointfolder, "params.dat"),
path.join(checkpointfolder, "params_old.dat")))
f = open(path.join(checkpointfolder, "params.dat"), 'wb')
pickle.dump(NS_parameters, f)
MPI.barrier(MPI.comm_world)
for ui in q_:
h5file = path.join(checkpointfolder, ui + '.h5')
oldfile = path.join(checkpointfolder, ui + '_old.h5')
# For safety reasons...
if path.exists(h5file):
if MPI.rank(MPI.comm_world) == 0:
system('cp {0} {1}'.format(h5file, oldfile))
MPI.barrier(MPI.comm_world)
###
newfile = HDF5File(MPI.comm_world, h5file, 'w')
newfile.flush()
newfile.write(q_[ui].vector(), '/current')
if ui in u_components:
newfile.write(q_1[ui].vector(), '/previous')
if path.exists(oldfile):
if MPI.rank(MPI.comm_world) == 0:
system('rm {0}'.format(oldfile))
MPI.barrier(MPI.comm_world)
if MPI.rank(MPI.comm_world) == 0 and path.exists(
path.join(checkpointfolder, "params_old.dat")):
system('rm {0}'.format(path.join(checkpointfolder, "params_old.dat")))
def test_store_mesh(casedir):
pp = PostProcessor(dict(casedir=casedir))
from dolfin import (UnitSquareMesh, CellFunction, FacetFunction,
AutoSubDomain, Mesh, HDF5File, assemble, Expression,
ds, dx)
# Store mesh
mesh = UnitSquareMesh(6, 6)
celldomains = CellFunction("size_t", mesh)
celldomains.set_all(0)
AutoSubDomain(lambda x: x[0] < 0.5).mark(celldomains, 1)
facetdomains = FacetFunction("size_t", mesh)
AutoSubDomain(lambda x, on_boundary: x[0] < 0.5 and on_boundary).mark(
facetdomains, 1)
pp.store_mesh(mesh, celldomains, facetdomains)
# Read mesh back
mesh2 = Mesh()
f = HDF5File(mpi_comm_world(), os.path.join(pp.get_casedir(), "mesh.hdf5"),
'r')
f.read(mesh2, "Mesh", False)
celldomains2 = CellFunction("size_t", mesh2)
f.read(celldomains2, "CellDomains")
facetdomains2 = FacetFunction("size_t", mesh2)
f.read(facetdomains2, "FacetDomains")
e = Expression("1+x[1]", degree=1)
dx1 = dx(1, domain=mesh, subdomain_data=celldomains)
dx2 = dx(1, domain=mesh2, subdomain_data=celldomains2)
C1 = assemble(e * dx1)
C2 = assemble(e * dx2)
assert abs(C1 - C2) < 1e-10
ds1 = ds(1, domain=mesh, subdomain_data=facetdomains)
ds2 = ds(1, domain=mesh2, subdomain_data=facetdomains2)
F1 = assemble(e * ds1)
F2 = assemble(e * ds2)
assert abs(F1 - F2) < 1e-10
def convert(msh_file, h5_file, save_mvc=False):
'''Temporary version of convertin from msh to h5'''
root, _ = os.path.splitext(msh_file)
assert os.path.splitext(msh_file)[1] == '.msh'
assert os.path.splitext(h5_file)[1] == '.h5'
# Get the xml mesh
xml_file = '.'.join([root, 'xml'])
subprocess.call(['dolfin-convert %s %s' % (msh_file, xml_file)], shell=True)
# Success?
assert os.path.exists(xml_file)
mesh = Mesh(xml_file)
out = HDF5File(mesh.mpi_comm(), h5_file, 'w')
out.write(mesh, 'mesh')
print('Mesh has %d cells' % mesh.num_cells())
print('Mesh size %g %g' % (mesh.hmin(), mesh.hmax()))
# Save ALL data as facet_functions
names = ('surfaces', 'volumes')
if not save_mvc:
for name, region in zip(names, ('facet_region.xml', 'physical_region.xml')):
r_xml_file = '_'.join([root, region])
f = MeshFunction('size_t', mesh, r_xml_file)
print('%d %s with 1' % (sum(1 for _ in SubsetIterator(f, 1)), name))
out.write(f, name)
return True
for name, region in zip(names, ('facet_region.xml', 'physical_region.xml')):
r_xml_file = '_'.join([root, region])
f = MeshFunction('size_t', mesh, r_xml_file)
# With mesh value collection we only store nonzero tags
mvc = MeshValueCollection('size_t', mesh, f.dim())
# Fill
fill_mvc_from_mf(f, mvc)
# And save
out.write(mvc, name)
return True
def __call__(self):
"""Load file"""
#t0 = time()
cbc_log(20, "Loading: "+self.filename+", Timestep: "+str(self.timestep))
if self.saveformat == 'hdf5':
hdf5file = HDF5File(mpi_comm_world(), self.filename, 'r')
hdf5file.read(self.function, self.fieldname+str(self.timestep))
del hdf5file
data = self.function
elif self.saveformat in ["xml", "xml.gz"]:
V = self.function.function_space()
self.function.assign(Function(V, self.filename))
data = self.function
elif self.saveformat == "shelve":
shelvefile = shelve.open(self.filename, 'r')
data = shelvefile[str(self.timestep)]
shelvefile.close()
cbc_log(20, "Loaded: "+self.filename+", Timestep: "+str(self.timestep))
return data
def save_checkpoint(tstep, t, mesh, w_, w_1, newfolder, parameters):
""" Save checkpoint files.
A part of this is taken from the Oasis code."""
checkpointfolder = os.path.join(newfolder, "Checkpoint")
parameters["num_processes"] = MPI_size
parameters["t_0"] = t
parameters["tstep"] = tstep
parametersfile = os.path.join(checkpointfolder, "parameters.dat")
parametersfile_old = parametersfile + ".old"
if mpi_is_root():
# In case of failure, keep old file.
if os.path.exists(parametersfile):
os.system("mv {0} {1}".format(parametersfile,
parametersfile_old))
dump_parameters(parameters, parametersfile)
mpi_barrier()
h5filename = os.path.join(checkpointfolder, "fields.h5")
h5filename_old = h5filename + ".old"
# In case of failure, keep old file.
if mpi_is_root() and os.path.exists(h5filename):
os.system("mv {0} {1}".format(h5filename, h5filename_old))
h5file = HDF5File(mpi_comm(), h5filename, "w")
h5file.flush()
info_red("Storing mesh")
h5file.write(mesh, "mesh")
for field in w_:
info_red("Storing subproblem: " + field)
mpi_barrier()
h5file.write(w_[field], "{}/current".format(field))
if field in w_1:
h5file.write(w_1[field], "{}/previous".format(field))
mpi_barrier()
h5file.close()
# Since program is still running, delete the old files.
remove_safe(h5filename_old)
mpi_barrier()
remove_safe(parametersfile_old)
def __init__(self, mpi_comm, mesh_dim, filename, rw_mode):
self.h5_file = HDF5File(mpi_comm, filename + "_checkpoint.h5", rw_mode)
self.xdmf_file = XDMFFile(mpi_comm, filename + ".xdmf")
def _update_hdf5_file(self, field_name, saveformat, data, timestep, t):
"""Update hdf5 file with new data.
This creates a hashed dataset within the dataset to save FunctionSpace
information only once, and for all subsequent savings only the vector
is saved and links are created to the FunctionSpace information.
This ensures that the saving is fully compatible with restart and
replay on an arbitrary number of processes.
"""
assert saveformat == "hdf5"
fullname, metadata = self._get_datafile_name(field_name, saveformat,
timestep)
# Create "good enough" hash. This is done to avoid data corruption when restarted from
# different number of processes, different distribution or different function space
local_hash = sha1()
local_hash.update(
str(data.function_space().mesh().num_cells()).encode())
local_hash.update(str(data.function_space().ufl_element()).encode())
local_hash.update(str(data.function_space().dim()).encode())
local_hash.update(str(MPI.size(mpi_comm_world())).encode())
# Global hash (same on all processes), 10 digits long
global_hash = MPI.sum(mpi_comm_world(), int(local_hash.hexdigest(),
16))
global_hash = str(int(global_hash % 1e10)).zfill(10)
#key = (field_name, saveformat)
#datafile = self._datafile_cache.get(key)
#if datafile is None:
# datafile = HDF5File(mpi_comm_world(), fullname, 'w')
# self._datafile_cache[key] = datafile
# Open HDF5File
if not os.path.isfile(fullname):
datafile = HDF5File(mpi_comm_world(), fullname, 'w')
else:
datafile = HDF5File(mpi_comm_world(), fullname, 'a')
# Write to hash-dataset if not yet done
if not datafile.has_dataset(global_hash) or not datafile.has_dataset(
global_hash + "/" + field_name):
datafile.write(data, str(global_hash) + "/" + field_name)
if not datafile.has_dataset("Mesh"):
datafile.write(data.function_space().mesh(), "Mesh")
# Write vector to file
# TODO: Link vector when function has been written to hash
datafile.write(data.vector(), field_name + str(timestep) + "/vector")
# HDF5File.close is broken in 1.4
if dolfin_version() == "1.4.0+":
datafile.close()
del datafile
# Link information about function space from hash-dataset
hdf5_link(fullname,
str(global_hash) + "/" + field_name + "/x_cell_dofs",
field_name + str(timestep) + "/x_cell_dofs")
hdf5_link(fullname,
str(global_hash) + "/" + field_name + "/cell_dofs",
field_name + str(timestep) + "/cell_dofs")
hdf5_link(fullname,
str(global_hash) + "/" + field_name + "/cells",
field_name + str(timestep) + "/cells")
return metadata
shift_origin_parser.add_argument('--no_shift_origin',
dest='shift_origin',
action='store_false')
parser.set_defaults(shift_origin=True)
args = parser.parse_args()
# Some sanity
root, ext = os.path.splitext(args.tile)
assert args.m > 0 and args.n > 0
assert ext == '.h5'
shape = (args.m, args.n)
# Load the tile mesh
h5 = HDF5File(get_comm_world(), args.tile, 'r')
tile = Mesh()
h5.read(tile, 'mesh', False)
# Shift and so
x = tile.coordinates()
xmin = x.min(axis=0)
dx = x.max(axis=0) - xmin
if args.shift_origin: x[:] -= xmin
x[:] *= args.scale_x
# Did it work?
print(dx, 'vs', x.max(axis=0) - x.min(axis=0), xmin, x.min(axis=0))
def save_geometry_to_h5(mesh,
h5name,
h5group="",
markers=None,
markerfunctions={},
microstructure={},
local_basis={},
comm=mpi_comm_world,
other_functions={},
other_attributes={},
overwrite_file=False,
overwrite_group=True):
"""
Save geometry and other geometrical functions to a HDF file.
Parameters
----------
mesh : :class:`dolfin.mesh`
The mesh
h5name : str
Path to the file
h5group : str
Folder within the file. Default is "" which means in
the top folder.
markers : dict
A dictionary with markers. See `get_markers`.
fields : list
A list of functions for the microstructure
local_basis : list
A list of functions for the crl basis
meshfunctions : dict
A dictionary with keys being the dimensions the the values
beeing the meshfunctions.
comm : :class:`dolfin.MPI`
MPI communicator
other_functions : dict
Dictionary with other functions you want to save
other_attributes: dict
Dictionary with other attributes you want to save
overwrite_file : bool
If true, and the file exists, the file will be overwritten (default: False)
overwrite_group : bool
If true and h5group exist, the group will be overwritten.
"""
h5name = os.path.splitext(h5name)[0] + ".h5"
assert isinstance(mesh, Mesh)
file_mode = "a" if os.path.isfile(h5name) and not overwrite_file else "w"
# IF we should append the file but overwrite the group we need to
# check that the group does not exist. If so we need to open it in
# h5py and delete it.
if file_mode == "a" and overwrite_group and h5group != "":
check_h5group(h5name, h5group, delete=True, comm=comm)
with HDF5File(comm, h5name, file_mode) as h5file:
# Save mesh
ggroup = "{}/geometry".format(h5group)
mgroup = "{}/mesh".format(ggroup)
h5file.write(mesh, mgroup)
# Save markerfunctions
df.begin(LogLevel.PROGRESS, "Saving marker functions.")
for dim, key in enumerate(markerfunctions.keys()):
mf = markerfunctions[key]
if mf is not None:
dgroup = "{}/mesh/meshfunction_{}".format(ggroup, dim)
h5file.write(mf, dgroup)
df.end()
# Save markers
df.begin(LogLevel.PROGRESS, "Saving markers.")
for name, (marker, dim) in markers.items():
for key_str in ["domain", "meshfunction"]:
dgroup = "{}/mesh/{}_{}".format(ggroup, key_str, dim)
if h5file.has_dataset(dgroup):
aname = "marker_name_{}".format(name)
h5file.attributes(dgroup)[aname] = marker
df.end()
# Save microstructure
df.begin(LogLevel.PROGRESS, "Saving microstructure.")
for key in microstructure.keys():
ms = microstructure[key]
if ms is not None:
fgroup = "{}/microstructure".format(h5group)
fsubgroup = "{}/{}".format(fgroup, key)
h5file.write(microstructure[key], fsubgroup)
h5file.attributes(fsubgroup)["name"] = key
elm = ms.function_space().ufl_element()
try:
family, degree = elm.family(), elm.degree()
fspace = "{}_{}".format(family, degree)
h5file.attributes(fgroup)["space"] = fspace
h5file.attributes(fgroup)["names"] = ":".join(
microstructure.keys())
except:
pass
df.end()
# Save local basis
df.begin(LogLevel.PROGRESS, "Saving local basis.")
for key in local_basis.keys():
ml = local_basis[key]
if ml is not None:
lgroup = "{}/local basis functions".format(h5group)
h5file.write(ml, lgroup + "/{}".format(key))
elm = ml.function_space().ufl_element()
try:
family, degree = elm.family(), elm.degree()
lspace = "{}_{}".format(family, degree)
h5file.attributes(lgroup)["space"] = lspace
h5file.attributes(lgroup)["names"] = ":".join(local_basis.keys())
except:
pass
df.end()
# Save other functions
df.begin(LogLevel.PROGRESS, "Saving other functions")
for key in other_functions.keys():
mo = other_functions[key]
if mo is not None:
fungroup = "/".join([h5group, key])
h5file.write(mo, fungroup)
elm = mo.function_space().ufl_element()
try:
family, degree, vsize = elm.family(), elm.degree(), elm.value_size(
)
fspace = "{}_{}".format(family, degree)
h5file.attributes(fungroup)["space"] = fspace
h5file.attributes(fungroup)["value_size"] = vsize
except:
pass
df.end()
# Save other attributes
df.begin(LogLevel.PROGRESS, "Saving other attributes")
for key in other_attributes:
if isinstance(other_attributes[key], str) and isinstance(key, str):
h5file.attributes(h5group)[key] = other_attributes[key]
else:
begin(
df.LogLevel.WARNING,
"Invalid attribute {} = {}".format(key,
other_attributes[key]))
end()
df.end()
df.begin(df.LogLevel.INFO, "Geometry saved to {}".format(h5name))
df.end()
save_parser = parser.add_mutually_exclusive_group(required=False)
save_parser.add_argument('--save', dest='save', action='store_true')
save_parser.add_argument('--no-save', dest='save', action='store_false')
parser.set_defaults(save=True)
# Remove Xml and stuff
parser.add_argument('--cleanup',
type=str,
nargs='+',
help='extensions to delete',
default=())
args = parser.parse_args()
# Protecting self
assert not (set(('geo', '.geo')) & set(args.cleanup))
if not args.output:
args.output = '.'.join([os.path.splitext(args.input)[0], 'h5'])
mesh = convert(args.input, args.output)
if args.save:
h5 = HDF5File(mpi_comm_world(), args.output, 'r')
surfaces = MeshFunction('size_t', mesh, mesh.topology().dim() - 1, 0)
h5.read(surfaces, 'facet')
File('results/%s_surf.pvd' %
os.path.splitext(args.input)[0]) << surfaces
cleanup(exts=args.cleanup)
def store(self, filename, function):
with HDF5File(MPI.comm_self, filename, 'w') as fh:
fh.write(function, self.function_name)
def load(self, filename):
function = self.function()
with HDF5File(MPI.comm_self, filename, 'r') as fh:
fh.read(function, self.function_name)
return function
def load_geometry_from_h5(
h5name,
h5group="",
fendo=None,
fepi=None,
include_sheets=True,
comm=mpi_comm_world,
):
"""Load geometry and other mesh data from
a h5file to an object.
If the file contains muliple fiber fields
you can spefify the angles, and if the file
contais sheets and cross-sheets this can also
be included
:param str h5name: Name of the h5file
:param str h5group: The group within the file
:param int fendo: Helix fiber angle (endocardium) (if available)
:param int fepi: Helix fiber angle (epicardium) (if available)
:param bool include_sheets: Include sheets and cross-sheets
:returns: An object with geometry data
:rtype: object
"""
# Set default groups
ggroup = "{}/geometry".format(h5group)
mgroup = "{}/mesh".format(ggroup)
lgroup = "{}/local basis functions".format(h5group)
fgroup = "{}/microstructure".format(h5group)
if not os.path.isfile(h5name):
raise IOError("File {} does not exist".format(h5name))
# Check that the given file contains
# the geometry in the given h5group
if not check_h5group(h5name, mgroup, delete=False, comm=comm):
msg = ("Error!\nGroup: '{}' does not exist in file:"
"\n{}").format(mgroup, h5name)
with h5py.File(h5name) as h:
keys = h.keys()
msg += "\nPossible values for the h5group are {}".format(keys)
raise IOError(msg)
# Dummy class to store attributes in
class Geometry(object):
pass
geo = Geometry()
with HDF5File(comm, h5name, "r") as h5file:
# Load mesh
mesh = Mesh(comm)
h5file.read(mesh, mgroup, False)
geo.mesh = mesh
# Get mesh functions
meshfunctions = ["vfun", "efun", "ffun", "cfun"]\
if mesh.topology().dim() == 3 else ["vfun", "ffun", "cfun"]
for dim, attr in enumerate(meshfunctions):
dgroup = "{}/mesh/meshfunction_{}".format(ggroup, dim)
mf = MeshFunction("size_t", mesh, dim, mesh.domains())
if h5file.has_dataset(dgroup):
h5file.read(mf, dgroup)
setattr(geo, attr, mf)
load_local_basis(h5file, lgroup, mesh, geo)
load_microstructure(h5file, fgroup, mesh, geo, include_sheets)
# Load the boundary markers
markers = load_markers(h5file, mesh, ggroup, dgroup)
geo.markers = markers
origmeshgroup = "{}/original_geometry".format(h5group)
if h5file.has_dataset(origmeshgroup):
original_mesh = Mesh(comm)
h5file.read(original_mesh, origmeshgroup, True)
setattr(geo, "original_geometry", original_mesh)
for attr in meshfunctions:
if not hasattr(geo, attr):
setattr(geo, attr, None)
for attr in (["f0", "s0", "n0", "r0", "c0", "l0"]):
if not hasattr(geo, attr):
setattr(geo, attr, None)
return geo