phynexis-deps/mfem
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
c577ee0f43500a2fade34e62cc55cacb44be0840
mfem/mesh/vtkhdf.cpp
T

815 lines
24 KiB
C++
Raw Blame History

// Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced
// at the Lawrence Livermore National Laboratory. All Rights reserved. See files
// LICENSE and NOTICE for details. LLNL-CODE-806117.
//
// This file is part of the MFEM library. For more information and source code
// availability visit https://mfem.org.
//
// MFEM is free software; you can redistribute it and/or modify it under the
// terms of the BSD-3 license. We welcome feedback and contributions, see file
// CONTRIBUTING.md for details.
#include "vtkhdf.hpp"
#ifdef MFEM_USE_HDF5
#include "../general/binaryio.hpp"
#include <algorithm>
#include <numeric>
#include <hdf5_hl.h>
namespace mfem
{
namespace
{
// Template class for HDF5 type IDs (specialized for each type T).
template <typename T> struct TypeID { };
template <> struct TypeID<float> { static hid_t Get() { return H5T_NATIVE_FLOAT; } };
template <> struct TypeID<double> { static hid_t Get() { return H5T_NATIVE_DOUBLE; } };
template <> struct TypeID<int32_t> { static hid_t Get() { return H5T_NATIVE_INT32; } };
template <> struct TypeID<uint64_t> { static hid_t Get() { return H5T_NATIVE_UINT64; } };
template <> struct TypeID<unsigned char> { static hid_t Get() { return H5T_NATIVE_UCHAR; } };
}
hsize_t VTKHDF::Dims::TotalSize() const
{
return std::accumulate(data.begin(), data.begin() + ndims, 1,
std::multiplies<hsize_t>());
}
template <typename T>
hid_t VTKHDF::GetTypeID() { return TypeID<typename std::decay<T>::type>::Get(); }
void VTKHDF::SetupVTKHDF()
{
vtk = H5Gcreate2(file, "VTKHDF", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
// Set attributes: version and type
const long version_buf[2] = {2, 2}; // VTKHDF version 2.2
H5LTset_attribute_long(vtk, ".", "Version", version_buf, 2);
// Note: we don't use the high-level API here since it will write out the
// null terminator, which confuses the VTKHDF reader in ParaView. Fixed in
// VTK MR !12044, https://gitlab.kitware.com/vtk/vtk/-/merge_requests/12044.
const std::string type_str = "UnstructuredGrid";
const hid_t type_id = H5Tcopy(H5T_C_S1);
H5Tset_size(type_id, type_str.size());
H5Tset_strpad(type_id, H5T_STR_NULLPAD);
const hid_t data_space = H5Screate(H5S_SCALAR);
const hid_t type_attr = H5Acreate2(vtk, "Type", type_id, data_space,
H5P_DEFAULT, H5P_DEFAULT);
H5Awrite(type_attr, type_id, type_str.data());
H5Aclose(type_attr);
H5Sclose(data_space);
H5Tclose(type_id);
}
void VTKHDF::EnsureSteps()
{
// If the Steps group has already been created, return early.
if (steps != H5I_INVALID_HID) { return; }
// Otherwise, create the group and its datasets.
EnsureGroup("Steps", steps);
hid_t pd_offsets = H5I_INVALID_HID;
EnsureGroup("Steps/PointDataOffsets", pd_offsets);
H5Gclose(pd_offsets);
}
hid_t VTKHDF::EnsureDataset(hid_t f, const std::string &name, hid_t type,
Dims &dims)
{
const char *name_c = name.c_str();
const herr_t status = H5LTfind_dataset(f, name_c);
Barrier();
if (status == 0)
{
// Dataset does not exist, create it.
const int ndims = dims.ndims;
// The dataset is allowed to grow in the first dimension, but is fixed
// in size in all other dimesions; the maximum dataset size is same as
// dims, but unlimited in first dimension.
Dims max_dims = dims;
max_dims[0] = H5S_UNLIMITED;
const hid_t fspace = H5Screate_simple(ndims, dims, max_dims);
Dims chunk(ndims);
size_t chunk_size_bytes = 1024 * 1024 / 2; // 0.5 MB
const size_t t_bytes = H5Tget_size(type);
for (int i = 1; i < ndims; ++i)
{
chunk[i] = dims[i];
chunk_size_bytes /= dims[i];
}
chunk[0] = chunk_size_bytes / t_bytes;
const hid_t dcpl = H5Pcreate(H5P_DATASET_CREATE);
H5Pset_chunk(dcpl, ndims, chunk);
if (compression_level >= 0)
{
H5Pset_shuffle(dcpl);
H5Pset_deflate(dcpl, compression_level);
}
const hid_t d = H5Dcreate2(f, name_c, type, fspace, H5P_DEFAULT,
dcpl, H5P_DEFAULT);
H5Pclose(dcpl);
return d;
}
else if (status > 0)
{
// Dataset exists, open it.
const hid_t d = H5Dopen2(f, name_c, H5P_DEFAULT);
// Resize the dataset, set dims to its new size.
Dims old_dims(dims.ndims);
const hid_t dspace = H5Dget_space(d);
const int ndims_dset = H5Sget_simple_extent_ndims(dspace);
MFEM_VERIFY(ndims_dset == dims.ndims, "");
H5Sget_simple_extent_dims(dspace, old_dims, NULL);
H5Sclose(dspace);
dims[0] += old_dims[0];
H5Dset_extent(d, dims);
return d;
}
else
{
// Error occurred in H5LTfind_dataset.
MFEM_ABORT("Error finding HDF5 dataset " << name);
}
}
void VTKHDF::EnsureGroup(const std::string &name, hid_t &group)
{
if (group != H5I_INVALID_HID) { return; }
const char *cname = name.c_str();
const htri_t found = H5Lexists(vtk, cname, H5P_DEFAULT);
Barrier();
if (found > 0)
{
group = H5Gopen(vtk, cname, H5P_DEFAULT);
}
else if (found == 0)
{
group = H5Gcreate2(vtk, cname, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
}
else
{
MFEM_ABORT("Error finding HDF5 group " << name);
}
}
template <typename T>
void VTKHDF::AppendParData(hid_t f, const std::string &name, hsize_t locsize,
hsize_t offset, Dims globsize, T *data)
{
const int ndims = globsize.ndims;
Dims dims = globsize;
const hid_t d = EnsureDataset(f, name, GetTypeID<T>(), dims);
// Write the new entry.
const hid_t dspace = H5Dget_space(d);
Dims start(ndims);
start[0] = dims[0] - globsize[0] + offset;
Dims count(ndims);
count[0] = locsize;
for (int i = 1; i < ndims; ++i) { count[i] = globsize[i]; }
H5Sselect_hyperslab(dspace, H5S_SELECT_SET, start, NULL, count, NULL);
H5Dwrite(d, GetTypeID<T>(), H5S_BLOCK, dspace, dxpl, data);
H5Sclose(dspace);
H5Dclose(d);
}
template <typename T>
std::vector<T> VTKHDF::AllGather(const T loc) const
{
std::vector<T> all(mpi_size);
if (UsingMpi())
{
#ifdef MFEM_USE_MPI
const MPI_Datatype type = MPITypeMap<T>::mpi_type;
MPI_Allgather(&loc, 1, type, all.data(), 1, type, comm);
#endif
}
else
{
all[0] = loc;
}
return all;
}
VTKHDF::OffsetTotal VTKHDF::GetOffsetAndTotal(const size_t loc) const
{
const auto all = AllGather(uint64_t(loc));
size_t offset = 0;
for (int i = 0; i < mpi_rank; ++i)
{
offset += all[i];
}
size_t total = offset;
for (int i = mpi_rank; i < mpi_size; ++i)
{
total += all[i];
}
return {offset, total};
}
template <typename T>
VTKHDF::OffsetTotal VTKHDF::AppendParVector(
hid_t f, const std::string &name, const std::vector<T> &data, Dims dims)
{
const size_t locsize = data.size();
const auto offset_total = GetOffsetAndTotal(locsize);
const auto offset = offset_total.offset;
const auto total = offset_total.total;
hsize_t m = 1;
for (int i = 1; i < dims.ndims; ++i) { m *= dims[i]; }
dims[0] = total/m;
AppendParData(f, name, locsize/m, offset/m, dims, data.data());
return {offset/m, total/m};
}
bool VTKHDF::UsingMpi() const
{
#ifdef MFEM_USE_MPI
return comm != MPI_COMM_NULL;
#else
return false;
#endif
}
void VTKHDF::Barrier() const
{
#ifdef MFEM_USE_MPI
if (UsingMpi()) { MPI_Barrier(comm); }
#endif
}
template <typename T>
std::vector<T> VTKHDF::ReadDataset(const std::string &name) const
{
const char *cname = name.c_str();
int ndims;
H5LTget_dataset_ndims(vtk, cname, &ndims);
Dims dims(ndims);
H5LTget_dataset_info(vtk, cname, dims, nullptr, nullptr);
std::vector<T> vals(dims.TotalSize());
H5LTread_dataset(vtk, cname, GetTypeID<T>(), vals.data());
return vals;
}
template <typename T>
T VTKHDF::ReadValue(const std::string &name, hsize_t index) const
{
const char *cname = name.c_str();
int ndims;
H5LTget_dataset_ndims(vtk, cname, &ndims);
const hid_t d = H5Dopen(vtk, cname, H5P_DEFAULT);
// Write the new entry.
const hid_t dspace = H5Dget_space(d);
Dims start(ndims);
start[0] = index;
Dims count(ndims);
for (int i = 0; i < ndims; ++i) { count[i] = 1; }
H5Sselect_hyperslab(dspace, H5S_SELECT_SET, start, NULL, count, NULL);
const hid_t memspace = H5Screate_simple(ndims, count, count);
T value;
H5Dread(d, GetTypeID<T>(), memspace, dspace, dxpl, &value);
H5Sclose(memspace);
H5Sclose(dspace);
H5Dclose(d);
return value;
}
void VTKHDF::TruncateDataset(const std::string &name, hsize_t size)
{
const hid_t d = H5Dopen2(vtk, name.c_str(), H5P_DEFAULT);
const hid_t dspace = H5Dget_space(d);
const int ndims = H5Sget_simple_extent_ndims(dspace);
Dims dims(ndims);
H5Sget_simple_extent_dims(dspace, dims, NULL);
H5Sclose(dspace);
dims[0] = size;
H5Dset_extent(d, dims);
H5Dclose(d);
}
void VTKHDF::Truncate(const real_t t)
{
// Find the first time step 'i' at least as large as 't'. Truncate all
// datasets at the corresponding offsets.
const std::vector<real_t> tvals = ReadDataset<real_t>("Steps/Values");
auto it = std::find_if(tvals.begin(), tvals.end(), [t](real_t t2) { return t2 >= t; });
// Sanity check: we can only use restart mode with the same number of MPI
// ranks (mesh partitions) as the originally save file.
{
Dims dims(1);
H5LTget_dataset_info(vtk, "NumberOfCells", dims, nullptr, nullptr);
MFEM_VERIFY(dims[0] == tvals.size() * mpi_size, "Incompatible VTKHDF sizes.");
}
// Index of found time index (may be 'one-past-the-end' if not found)
const ptrdiff_t i = std::distance(tvals.begin(), it);
// Only truncate if needed
const bool truncate = it != tvals.end();
// Number of steps we are keeping
nsteps = i;
H5LTset_attribute_ulong(vtk, "Steps", "NSteps", &nsteps, 1);
// We want to continue writing immediately after step 'i - 1'. If i = 0,
// then this is at the beginning of the file, and the offsets do not need
// to be updated.
hsize_t npoints = 0;
if (i > 0)
{
point_offsets.next = ReadValue<hsize_t>("Steps/PointOffsets", i - 1);
cell_offsets.next = ReadValue<hsize_t>("Steps/CellOffsets", i - 1);
connectivity_offsets.next =
ReadValue<hsize_t>("Steps/ConnectivityIdOffsets", i - 1);
for (int part = 0; part < mpi_size; ++part)
{
const hsize_t p_i = ReadValue<hsize_t>("Steps/PartOffsets", i - 1 + part);
npoints += ReadValue<hsize_t>("NumberOfPoints", p_i);
cell_offsets.next += ReadValue<hsize_t>("NumberOfCells", p_i);
connectivity_offsets.next +=
ReadValue<hsize_t>("NumberOfConnectivityIds", p_i);
}
point_offsets.next += npoints;
}
// Find the offsets associated with all saved grid functions.
const hid_t g = H5Gopen2(vtk, "Steps/PointDataOffsets", H5P_DEFAULT);
if (g != H5I_INVALID_HID)
{
std::vector<std::string> names;
auto itfn = [](hid_t, const char *name, const H5L_info2_t*, void *data)
{
auto names_ptr = static_cast<std::vector<std::string>*>(data);
names_ptr->emplace_back(name);
return herr_t(0);
};
H5Literate2(g, H5_INDEX_NAME, H5_ITER_NATIVE, nullptr, itfn, &names);
H5Gclose(g);
for (auto name : names)
{
const std::string dset_name = "Steps/PointDataOffsets/" + name;
hsize_t offset = 0;
if (i > 0)
{
offset = ReadValue<hsize_t>(dset_name, i - 1) + npoints;
}
point_data_offsets[name].next = offset;
if (truncate)
{
TruncateDataset(dset_name, nsteps);
TruncateDataset("PointData/" + name, offset);
}
}
}
if (truncate)
{
TruncateDataset("Steps/Values", nsteps);
TruncateDataset("Steps/PartOffsets", nsteps);
TruncateDataset("Steps/PointOffsets", nsteps);
TruncateDataset("Steps/CellOffsets", nsteps);
TruncateDataset("Steps/ConnectivityIdOffsets", nsteps);
TruncateDataset("NumberOfCells", nsteps * mpi_size);
TruncateDataset("NumberOfConnectivityIds", nsteps * mpi_size);
TruncateDataset("NumberOfPoints", nsteps * mpi_size);
TruncateDataset("CellData/attribute", cell_offsets.next);
TruncateDataset("Types", cell_offsets.next);
TruncateDataset("Points", point_offsets.next);
TruncateDataset("Connectivity", connectivity_offsets.next);
TruncateDataset("Offsets", cell_offsets.next + nsteps * mpi_size);
}
}
void VTKHDF::CreateFile(const std::string &filename, Restart restart)
{
if (restart.enabled)
{
bool file_exists = mpi_rank == 0 && [&filename]()
{
std::ifstream f(filename);
return f.good();
}();
#ifdef MFEM_USE_MPI
if (UsingMpi())
{
MPI_Allreduce(MPI_IN_PLACE, &file_exists, 1, MPI_CXX_BOOL, MPI_LOR, comm);
}
#endif
if (file_exists)
{
// Disable file locking, allowing modification to files that may be
// open in ParaView (otherwise writes will fail).
H5Pset_file_locking(fapl, false, true);
file = H5Fopen(filename.c_str(), H5F_ACC_RDWR, fapl);
vtk = H5Gopen(file, "VTKHDF", H5P_DEFAULT);
Truncate(restart.time);
return;
}
}
// At this point, either restart is disabled, or file doesn't exist
// Delete the file if it exists
std::remove(filename.c_str());
// Create the new file
file = H5Fcreate(filename.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, fapl);
// Setup 'VTKHDF' group
SetupVTKHDF();
}
VTKHDF::VTKHDF(const std::string &filename, Restart restart)
{
fapl = H5Pcreate(H5P_FILE_ACCESS);
CreateFile(filename, restart);
}
#ifdef MFEM_PARALLEL_HDF5
static int MpiCommSize(MPI_Comm comm)
{
int comm_size;
MPI_Comm_size(comm, &comm_size);
return comm_size;
}
static int MpiCommRank(MPI_Comm comm)
{
int rank;
MPI_Comm_rank(comm, &rank);
return rank;
}
VTKHDF::VTKHDF(const std::string &filename, MPI_Comm comm_, Restart restart)
: comm(comm_),
mpi_size(MpiCommSize(comm)),
mpi_rank(MpiCommRank(comm))
{
// Create file access property list, needed for parallel I/O
fapl = H5Pcreate(H5P_FILE_ACCESS);
const MPI_Info info = MPI_INFO_NULL;
H5Pset_fapl_mpio(fapl, comm, info);
// Create parallel data transfer property list
dxpl = H5Pcreate(H5P_DATASET_XFER);
H5Pset_dxpl_mpio(dxpl, H5FD_MPIO_COLLECTIVE);
CreateFile(filename, restart);
}
#endif
template <typename T>
void VTKHDF::AppendValue(const hid_t f, const std::string &name, T value)
{
const hsize_t locsize = (mpi_rank == 0) ? 1 : 0;
AppendParData(f, name, locsize, 0, Dims({1}), &value);
}
void VTKHDF::UpdateSteps(real_t t)
{
EnsureSteps();
// Set the NSteps attribute
++nsteps;
H5LTset_attribute_ulong(steps, ".", "NSteps", &nsteps, 1);
AppendValue(steps, "Values", t);
AppendValue(steps, "PartOffsets", part_offset);
AppendValue(steps, "PointOffsets", point_offsets.current);
AppendValue(steps, "CellOffsets", cell_offsets.current);
AppendValue(steps, "ConnectivityIdOffsets", connectivity_offsets.current);
if (!point_data_offsets.empty())
{
const hid_t g = H5Gopen2(steps, "PointDataOffsets", H5P_DEFAULT);
for (const auto &pd : point_data_offsets)
{
const char *name = pd.first.c_str();
AppendValue(g, name, pd.second.current);
}
H5Gclose(g);
}
}
template <typename FP_T>
void VTKHDF::SaveMesh(const Mesh &mesh, bool high_order, int ref)
{
// If refinement level not set, set to default value
if (ref <= 0)
{
ref = 1;
if (high_order)
{
if (auto *nodal_space = mesh.GetNodalFESpace())
{
ref = nodal_space->GetMaxElementOrder();
}
}
}
const Dims mpi_dims({mpi_size});
// If the mesh hasn't changed, we can return early.
if (!mesh_id.HasChanged(mesh, high_order, ref))
{
// The HDF5 format assumes that the "NumberOf" datasets will have size
// given by the number of parts (number of MPI ranks) times the number of
// time steps (see
// https://gitlab.kitware.com/vtk/vtk/-/issues/18981#note_1366124).
//
// If the mesh doesn't change, we don't increment the value in
// 'PartOffsets', and so these values in the "NumberOf" datasets will
// never be read, so we just fill them with a dummy value.
const hsize_t zero = 0;
AppendParData(vtk, "NumberOfPoints", 1, mpi_rank, mpi_dims, &zero);
AppendParData(vtk, "NumberOfCells", 1, mpi_rank, mpi_dims, &zero);
AppendParData(vtk, "NumberOfConnectivityIds", 1, mpi_rank, mpi_dims, &zero);
const int zero_int = 0;
AppendParData(vtk, "Offsets", 1, mpi_rank, mpi_dims, &zero_int);
return;
}
// Set the cached MeshId
mesh_id.Set(mesh, high_order, ref);
// Update the part offsets
part_offset = nsteps * mpi_size;
// Number of times to refine each element
const int ref_0 = high_order ? 1 : ref;
// Return the RefinementGeometry object for element 'e'
auto get_ref_geom = [&](int e, int r) -> RefinedGeometry&
{
const Geometry::Type geom = mesh.GetElementGeometry(e);
return *GlobGeometryRefiner.Refine(geom, r, 1);
};
// Return the number of vertices in element 'e'
auto get_nv = [&](int e)
{
return Geometries.NumVerts[mesh.GetElementGeometry(e)];
};
// Return the number of refined elements for element 'e'
auto get_ne_ref = [&](int e, int r)
{
return get_ref_geom(e, r).RefGeoms.Size() / get_nv(e);
};
// Count the points (and number of refined elements, needed if high_order is
// false).
std::vector<FP_T> points;
hsize_t ne_ref = 0;
hsize_t np = 0;
{
const int ne = mesh.GetNE();
for (int e = 0; e < ne; e++)
{
RefinedGeometry &ref_geom = get_ref_geom(e, ref);
np += ref_geom.RefPts.GetNPoints();
ne_ref += ref_geom.RefGeoms.Size() / get_nv(e);
}
points.reserve(np * 3);
IsoparametricTransformation Tr;
DenseMatrix pmat;
for (int e = 0; e < ne; ++e)
{
RefinedGeometry &ref_geom = get_ref_geom(e, ref);
mesh.GetElementTransformation(e, &Tr);
Tr.Transform(ref_geom.RefPts, pmat);
for (int i = 0; i < pmat.Width(); i++)
{
points.push_back(FP_T(pmat(0,i)));
if (pmat.Height() > 1) { points.push_back(FP_T(pmat(1,i))); }
else { points.push_back(0.0); }
if (pmat.Height() > 2) { points.push_back(FP_T(pmat(2,i))); }
else { points.push_back(0.0); }
}
}
}
const int ne_0 = mesh.GetNE();
const hsize_t ne = high_order ? ne_0 : ne_ref;
AppendParData(vtk, "NumberOfPoints", 1, mpi_rank, mpi_dims, &np);
AppendParData(vtk, "NumberOfCells", 1, mpi_rank, mpi_dims, &ne);
// Save the number of points written
last_np = np;
// Write out 2D data for points
auto point_offset_total = AppendParVector(vtk, "Points", points, Dims({0, 3}));
point_offsets.Update(point_offset_total.total);
// Cell data
{
const auto e_offset_total = GetOffsetAndTotal(ne);
const auto e_offset = e_offset_total.offset;
const auto ne_total = e_offset_total.total;
cell_offsets.Update(ne_total);
// Offsets and connectivity
{
std::vector<int> offsets(ne + 1);
std::vector<int> connectivity;
int off = 0;
if (high_order)
{
Array<int> local_connectivity;
for (int e = 0; e < int(ne); ++e)
{
offsets[e] = off;
const Geometry::Type geom = mesh.GetElementGeometry(e);
CreateVTKElementConnectivity(local_connectivity, geom, ref);
const int nnodes = local_connectivity.Size();
for (int i = 0; i < nnodes; ++i)
{
connectivity.push_back(off + local_connectivity[i]);
}
off += nnodes;
}
offsets.back() = off;
}
else
{
int off_0 = 0;
int e_ref = 0;
for (int e = 0; e < ne_0; ++e)
{
const Geometry::Type geom = mesh.GetElementGeometry(e);
const int nv = get_nv(e);
RefinedGeometry &ref_geom = get_ref_geom(e, ref_0);
Array<int> &rg = ref_geom.RefGeoms;
for (int r = 0; r < rg.Size(); ++e_ref)
{
offsets[e_ref] = off;
off += nv;
const int *p = VTKGeometry::VertexPermutation[geom];
for (int k = 0; k < nv; ++k, ++r)
{
connectivity.push_back(off_0 + rg[p ? (r - k + p[k]) : r]);
}
}
off_0 += ref_geom.RefPts.Size();
}
offsets.back() = off;
}
const hsize_t n = connectivity.size();
AppendParData(vtk, "NumberOfConnectivityIds", 1, mpi_rank, mpi_dims, &n);
auto connectivity_offset_total
= AppendParVector(vtk, "Connectivity", connectivity);
connectivity_offsets.Update(connectivity_offset_total.total);
AppendParData(vtk, "Offsets", ne + 1, e_offset + mpi_rank,
Dims({ne_total + mpi_size}), offsets.data());
}
// Cell types
{
std::vector<unsigned char> cell_types(ne);
const int *vtk_geom_map =
high_order ? VTKGeometry::HighOrderMap : VTKGeometry::Map;
int e_ref = 0;
for (int e = 0; e < ne_0; ++e)
{
const int ne_ref_e = get_ne_ref(e, ref_0);
for (int i = 0; i < ne_ref_e; ++i, ++e_ref)
{
cell_types[e_ref] = static_cast<unsigned char>(
vtk_geom_map[mesh.GetElementGeometry(e)]);
}
}
AppendParData(vtk, "Types", ne, e_offset, Dims({ne_total}),
cell_types.data());
}
// Attributes
{
// Ensure cell data group exists
EnsureGroup("CellData", cell_data);
std::vector<int> attributes(ne);
hsize_t e_ref = 0;
for (int e = 0; e < ne_0; ++e)
{
const int attr = mesh.GetAttribute(e);
const int ne_ref_e = get_ne_ref(e, ref_0);
for (int i = 0; i < ne_ref_e; ++i, ++e_ref)
{
attributes[e_ref] = attr;
}
}
AppendParData(cell_data, "attribute", ne, e_offset, Dims({ne_total}),
attributes.data());
}
}
}
template <typename FP_T>
void VTKHDF::SaveGridFunction(const GridFunction &gf, const std::string &name)
{
// Create the point data group if needed
EnsureGroup("PointData", point_data);
const Mesh &mesh = *gf.FESpace()->GetMesh();
MFEM_VERIFY(!mesh_id.HasChanged(mesh), "Mesh must be saved first");
const int ref = mesh_id.GetRefinementLevel();
const int vdim = gf.VectorDim();
std::vector<FP_T> point_values(vdim * last_np);
DenseMatrix vec_val, pmat;
int off = 0;
for (int e = 0; e < mesh.GetNE(); e++)
{
RefinedGeometry &ref_geom = *GlobGeometryRefiner.Refine(
mesh.GetElementBaseGeometry(e), ref, 1);
gf.GetVectorValues(e, ref_geom.RefPts, vec_val, pmat);
for (int i = 0; i < vec_val.Width(); ++i)
{
for (int vd = 0; vd < vdim; ++vd)
{
point_values[off] = FP_T(vec_val(vd, i));
++off;
}
}
}
Dims dims(vdim == 1 ? 1 : 2);
if (vdim > 1) { dims[1] = vdim; }
auto offset_total = AppendParVector(point_data, name, point_values, dims);
point_data_offsets[name].Update(offset_total.total);
}
void VTKHDF::Flush()
{
H5Fflush(file, H5F_SCOPE_GLOBAL);
}
VTKHDF::~VTKHDF()
{
if (steps != H5I_INVALID_HID) { H5Gclose(steps); }
if (cell_data != H5I_INVALID_HID) { H5Gclose(cell_data); }
if (point_data != H5I_INVALID_HID) { H5Gclose(point_data); }
if (dxpl != H5P_DEFAULT) { H5Pclose(dxpl); }
if (vtk != H5I_INVALID_HID) { H5Gclose(vtk); }
if (fapl != H5I_INVALID_HID) { H5Pclose(fapl); }
if (file != H5I_INVALID_HID) { H5Fclose(file); }
}
template void VTKHDF::SaveMesh<float>(const Mesh&, bool, int);
template void VTKHDF::SaveMesh<double>(const Mesh&, bool, int);
template void VTKHDF::SaveGridFunction<float>(const GridFunction&,
const std::string&);
template void VTKHDF::SaveGridFunction<double>(const GridFunction&,
const std::string&);
} // namespace mfem
#endif // MFEM_USE_HDF5
Reference in New Issue View Git Blame Copy Permalink