def test_vtk_unstructured_points(n): points = np.random.randn(n, 3) data = [ ("p", np.random.randn(n)), ("vel", np.random.randn(3, n)), ] file_name = f"points_{n}.vtu" compressor = None grid = UnstructuredGrid( (n, DataArray("points", points, vector_format=VF_LIST_OF_VECTORS)), cells=np.arange(n, dtype=np.uint32), cell_types=np.asarray([VTK_VERTEX] * n, dtype=np.uint8)) for name, field in data: grid.add_pointdata( DataArray(name, field, vector_format=VF_LIST_OF_COMPONENTS)) from os.path import exists if exists(file_name): raise RuntimeError("output file '%s' already exists" % file_name) outf = open(file_name, "w") AppendedDataXMLGenerator(compressor)(grid).write(outf) outf.close()
def write_vtk(self, file_name, fields, compressor=None): from pyvisfile.vtk import (UnstructuredGrid, DataArray, AppendedDataXMLGenerator, VTK_TETRA, VF_LIST_OF_VECTORS, VF_LIST_OF_COMPONENTS) grid = UnstructuredGrid( (self.nodes.shape[-1], DataArray( "points", self.nodes, vector_format=VF_LIST_OF_COMPONENTS)), cells=self.vis_simplices, cell_types=np.asarray([VTK_TETRA] * self.discr.K * self.nsimplices_per_el, dtype=np.uint8)) for name, field in fields: grid.add_pointdata( DataArray(name, field.reshape(-1), vector_format=VF_LIST_OF_COMPONENTS)) from os.path import exists if exists(file_name): raise RuntimeError("output file '%s' already exists" % file_name) outf = open(file_name, "w") AppendedDataXMLGenerator(compressor)(grid).write(outf) outf.close()
def _dump_arrays(self, filename): from pyvisfile.vtk import (UnstructuredGrid, DataArray, AppendedDataXMLGenerator, VTK_VERTEX) n = self.numPoints da = DataArray("points", self.points) grid = UnstructuredGrid((n, da), cells=np.arange(n), cell_types=np.asarray([VTK_VERTEX] * n)) for name, field in self.data: da = DataArray(name, field) grid.add_pointdata(da) with open(filename + '.vtu', "w") as f: AppendedDataXMLGenerator(None)(grid).write(f)
def write_vtk_file(self, file_name, names_and_fields, compressor=None, real_only=False): from pyvisfile.vtk import (UnstructuredGrid, DataArray, AppendedDataXMLGenerator, VTK_LINE, VTK_TRIANGLE, VTK_TETRA, VF_LIST_OF_COMPONENTS) el_types = { 1: VTK_LINE, 2: VTK_TRIANGLE, 3: VTK_TETRA, } el_type = el_types[self.vis_discr.dim] with cl.CommandQueue(self.vis_discr.cl_context) as queue: nodes = self.vis_discr.nodes().with_queue(queue).get() names_and_fields = [(name, self._resample_and_get(queue, fld)) for name, fld in names_and_fields] connectivity = self._vis_connectivity() nprimitive_elements = (connectivity.shape[0] * connectivity.shape[1]) grid = UnstructuredGrid( (self.vis_discr.nnodes, DataArray("points", nodes.reshape(self.vis_discr.ambient_dim, -1), vector_format=VF_LIST_OF_COMPONENTS)), cells=connectivity.reshape(-1), cell_types=np.asarray([el_type] * nprimitive_elements, dtype=np.uint8)) # for name, field in separate_by_real_and_imag(cell_data, real_only): # grid.add_celldata(DataArray(name, field, # vector_format=VF_LIST_OF_COMPONENTS)) for name, field in separate_by_real_and_imag(names_and_fields, real_only): grid.add_pointdata( DataArray(name, field, vector_format=VF_LIST_OF_COMPONENTS)) from os.path import exists if exists(file_name): raise RuntimeError("output file '%s' already exists" % file_name) with open(file_name, "w") as outf: AppendedDataXMLGenerator(compressor)(grid).write(outf)
def write_vertex_vtk_file(mesh, file_name, compressor=None, overwrite=False): from pyvisfile.vtk import (UnstructuredGrid, DataArray, AppendedDataXMLGenerator, VF_LIST_OF_COMPONENTS) # {{{ create cell_types from pyvisfile.vtk import (VTK_LINE, VTK_TRIANGLE, VTK_TETRA, VTK_QUAD, VTK_HEXAHEDRON) from meshmode.mesh import TensorProductElementGroup, SimplexElementGroup cell_types = np.empty(mesh.nelements, dtype=np.uint8) cell_types.fill(255) for egrp in mesh.groups: if isinstance(egrp, SimplexElementGroup): vtk_cell_type = { 1: VTK_LINE, 2: VTK_TRIANGLE, 3: VTK_TETRA, }[egrp.dim] elif isinstance(egrp, TensorProductElementGroup): vtk_cell_type = { 1: VTK_LINE, 2: VTK_QUAD, 3: VTK_HEXAHEDRON, }[egrp.dim] else: raise NotImplementedError("mesh vtk file writing for " "element group of type '%s'" % type(egrp).__name__) cell_types[ egrp.element_nr_base: egrp.element_nr_base + egrp.nelements] = \ vtk_cell_type assert (cell_types != 255).all() # }}} grid = UnstructuredGrid( (mesh.nvertices, DataArray( "points", mesh.vertices, vector_format=VF_LIST_OF_COMPONENTS)), cells=np.hstack( [vgrp.vertex_indices.reshape(-1) for vgrp in mesh.groups]), cell_types=cell_types) import os from meshmode import FileExistsError if os.path.exists(file_name): if overwrite: os.remove(file_name) else: raise FileExistsError("output file '%s' already exists" % file_name) with open(file_name, "w") as outf: AppendedDataXMLGenerator(compressor)(grid).write(outf)
def cells(self): connectivity = np.hstack( [grp.vis_connectivity.reshape(-1) for grp in self.groups]) grp_offsets = np.cumsum([0] + [grp.ndofs for grp in self.vis_discr.groups]) offsets = np.hstack([ grp_offset + np.arange(grp.nunit_dofs, grp.nelements * grp.nunit_dofs + 1, grp.nunit_dofs) for grp_offset, grp in zip(grp_offsets, self.vis_discr.groups) ]) from pyvisfile.vtk import DataArray return (self.vis_discr.mesh.nelements, DataArray("connectivity", connectivity), DataArray("offsets", offsets))
def write_nodal_adjacency_vtk_file(file_name, mesh, compressor=None, overwrite=False): from pyvisfile.vtk import ( UnstructuredGrid, DataArray, AppendedDataXMLGenerator, VTK_LINE, VF_LIST_OF_COMPONENTS) centroids = np.empty( (mesh.ambient_dim, mesh.nelements), dtype=mesh.vertices.dtype) for grp in mesh.groups: iel_base = grp.element_nr_base centroids[:, iel_base:iel_base+grp.nelements] = ( np.sum(mesh.vertices[:, grp.vertex_indices], axis=-1) / grp.vertex_indices.shape[-1]) adj = mesh.nodal_adjacency nconnections = len(adj.neighbors) connections = np.empty((nconnections, 2), dtype=np.int32) nb_starts = adj.neighbors_starts for iel in range(mesh.nelements): connections[nb_starts[iel]:nb_starts[iel+1], 0] = iel connections[:, 1] = adj.neighbors grid = UnstructuredGrid( (mesh.nelements, DataArray("points", centroids, vector_format=VF_LIST_OF_COMPONENTS)), cells=connections.reshape(-1), cell_types=np.asarray([VTK_LINE] * nconnections, dtype=np.uint8)) import os from meshmode import FileExistsError if os.path.exists(file_name): if overwrite: os.remove(file_name) else: raise FileExistsError("output file '%s' already exists" % file_name) with open(file_name, "w") as outf: AppendedDataXMLGenerator(compressor)(grid).write(outf)
def add_data(self, visf, variables=[], scalars=[], vectors=[], time=None, step=None, scale_factor=1): if scalars or vectors: import warnings warnings.warn("`scalars' and `vectors' arguments are deprecated", DeprecationWarning) variables = scalars + vectors from pyvisfile.vtk import DataArray, VF_LIST_OF_COMPONENTS for name, field in variables: visf.grid.add_pointdata( DataArray(name, scale_factor * field, vector_format=VF_LIST_OF_COMPONENTS)) self.register_pathname(time, visf.get_head_pathname())
from pyvisfile.vtk import (UnstructuredGrid, DataArray, AppendedDataXMLGenerator, VTK_VERTEX, VF_LIST_OF_VECTORS, VF_LIST_OF_COMPONENTS) n = 5000 points = np.random.randn(n, 3) data = [ ("p", np.random.randn(n)), ("vel", np.random.randn(3, n)), ] file_name = "points.vtu" compressor = None grid = UnstructuredGrid( (n, DataArray("points", points, vector_format=VF_LIST_OF_VECTORS)), cells=np.arange(n, dtype=np.uint32), cell_types=np.asarray([VTK_VERTEX] * n, dtype=np.uint8)) for name, field in data: grid.add_pointdata( DataArray(name, field, vector_format=VF_LIST_OF_COMPONENTS)) from os.path import exists if exists(file_name): raise RuntimeError("output file '%s' already exists" % file_name) outf = open(file_name, "w") AppendedDataXMLGenerator(compressor)(grid).write(outf) outf.close()
def write_xdmf_file(self, file_name, names_and_fields, attrs=None, h5_file_options=None, dataset_options=None, real_only=False, overwrite=False): """Write an XDMF file (with an ``.xmf`` extension) containing the arrays in *names_and_fields*. The heavy data is written to binary HDF5 files, which requires installing :ref:`h5py <h5py:install>`. Distributed memory visualization is not yet supported. :arg names_and_fields: a list of ``(name, array)``, where *array* is an array-like object (see :meth:`Visualizer.write_vtk_file`). :arg attrs: a :class:`dict` of scalar attributes that will be saved in the root HDF5 group. :arg h5_file_options: a :class:`dict` passed directly to :class:`h5py.File` that allows controlling chunking, compatibility, etc. :arg dataset_options: a :class:`dict` passed directly to :meth:`h5py.Group.create_dataset`. """ if attrs is None: attrs = {} if h5_file_options is None: h5_file_options = {} dataset_defaults = {"compression": "gzip", "compression_opts": 6} if dataset_options is not None: dataset_defaults.update(dataset_options) dataset_options = dataset_defaults if "comm" in h5_file_options \ or h5_file_options.get("driver", None) == "mpio": raise NotImplementedError("distributed memory visualization") # {{{ hdf5 try: import h5py except ImportError as exc: raise ImportError("'write_xdmf_file' requires 'h5py'") from exc import os h5_file_name = "{}.h5".format(os.path.splitext(file_name)[0]) # }}} # {{{ expand -> filter -> resample -> to_numpy fields names_and_fields = preprocess_fields(names_and_fields) names_and_fields = [ (name, resample_to_numpy( self.connection, field, stack=True, by_group=True)) for name, field in names_and_fields ] # }}} # {{{ write hdf5 + create xml tree # NOTE: 01-03-2021 based on Paraview 5.8.1 with (internal) VTK 8.90.0 # # The current setup writes a grid for each element group. The grids # are completely separate, i.e. each one gets its own subset of the # nodes / connectivity / fields. This seems to work reasonably well. # # This mostly works with the Xdmf3ReaderS (S for spatial) Paraview # plugin. It seems to also work with the XMDFReader (for Xdmf2) plugin, # but that's not very tested. # # A few nice-to-haves / improvements # # * writing a single grid per meshmode.Mesh. `meshio` actually does this # using the XDMF `TopologyType.Mixed` # * writing object ndarrays as separate `DataItem`s. Tried this using # an Xdmf `DataItemType.Function`, but Paraview did not recognize it. # * Using `Reference` DataItems to e.g. store the nodes globally on the # domain and just reference it in the individual grids. This crashed # Paraview. from pyvisfile.xdmf import ( XdmfUnstructuredGrid, DataArray, GeometryType, Information) if self.vis_discr.ambient_dim == 2: geometry_type = GeometryType.XY elif self.vis_discr.ambient_dim == 3: geometry_type = GeometryType.XYZ else: raise ValueError(f"unsupported dimension: {self.vis_discr.dim}") with h5py.File(h5_file_name, "w", **h5_file_options) as h5: tags = [] for key, value in attrs.items(): h5.attrs[key] = value tags.append(Information(name=key, value=str(value))) # {{{ create grids nodes = self._xdmf_nodes_numpy() connectivity = self._vtk_connectivity # global nodes h5grid = h5.create_group("Grid") grids = [] node_nr_base = 0 for igrp, (vgrp, gnodes) in enumerate(zip(connectivity.groups, nodes)): grp_name = f"Group_{igrp:05d}" h5grp = h5grid.create_group(grp_name) # offset connectivity back to local numbering visconn = vgrp.vis_connectivity.reshape(vgrp.nsubelements, -1) \ - node_nr_base node_nr_base += self.vis_discr.groups[igrp].ndofs # hdf5 side dset = h5grp.create_dataset("Nodes", data=gnodes.T, **dataset_options) gnodes = DataArray.from_dataset(dset) dset = h5grp.create_dataset("Connectivity", data=visconn, **dataset_options) gconnectivity = DataArray.from_dataset(dset) # xdmf side topology_type = self._vtk_to_xdmf_cell_type(vgrp.vtk_cell_type) grid = XdmfUnstructuredGrid( gnodes, gconnectivity, topology_type=topology_type, geometry_type=geometry_type, name=grp_name) # fields for name, field in separate_by_real_and_imag( names_and_fields, real_only): dset = h5grp.create_dataset(name, data=field[igrp], **dataset_options) grid.add_attribute(DataArray.from_dataset(dset)) grids.append(grid) # }}} # }}} # {{{ write xdmf from pyvisfile.xdmf import XdmfWriter writer = XdmfWriter(tuple(grids), tags=tuple(tags)) writer.write_pretty(file_name)
def write_vtk_file(self, file_name, names_and_fields, compressor=None, real_only=False, overwrite=False, use_high_order=None, par_manifest_filename=None, par_file_names=None): """Write a Vtk XML file (typical extension ``.vtu``) containing the visualization data in *names_and_fields*. Can optionally also write manifests for distributed memory simulation (typical extension ``.pvtu``). See also :meth:`write_parallel_vtk_file` for a convenience wrapper. :arg names_and_fields: A list of tuples ``(name, value)``, where *name* is a string and *value* is a :class:`~meshmode.dof_array.DOFArray` or a constant, or an object array of those. *value* may also be a data class (see :mod:`dataclasses`), whose attributes will be inserted into the visualization with their names prefixed by *name*. If *value* is *None*, then there is no data to write and the corresponding *name* will not appear in the data file. If *value* is *None*, it should be *None* collectively across all ranks for parallel writes; otherwise the behavior of this routine is undefined. :arg overwrite: If *True*, silently overwrite existing files. :arg use_high_order: Writes arbitrary order Lagrange VTK elements. These elements are described in `this blog post <https://blog.kitware.com/modeling-arbitrary-order-lagrange-finite-elements-in-the-visualization-toolkit/>`__ and are available in VTK 8.1 and newer. :arg par_manifest_filename: If not *None* write a distributed-memory manifest with this file name if *file_name* matches the first entry in *par_file_names*. :arg par_file_names: A list of file names of visualization files to include in the distributed-memory manifest. .. versionchanged:: 2020.2 - Added *par_manifest_filename* and *par_file_names*. - Added *use_high_order*. """ # noqa if use_high_order is None: use_high_order = False if use_high_order: if not self.is_equidistant: raise RuntimeError("Cannot visualize high-order Lagrange elements " "using a non-equidistant visualizer. " "Call 'make_visualizer' with 'force_equidistant=True'.") connectivity = self._vtk_lagrange_connectivity else: connectivity = self._vtk_connectivity from pyvisfile.vtk import ( UnstructuredGrid, DataArray, AppendedDataXMLGenerator, ParallelXMLGenerator, VF_LIST_OF_COMPONENTS) nodes = self._vis_nodes_numpy() names_and_fields = preprocess_fields(names_and_fields) names_and_fields = [ (name, resample_to_numpy(self.connection, fld)) for name, fld in names_and_fields ] # {{{ create cell_types nsubelements = sum(vgrp.nsubelements for vgrp in connectivity.groups) cell_types = np.empty(nsubelements, dtype=np.uint8) cell_types.fill(255) for vgrp in connectivity.groups: isubelements = np.s_[ vgrp.subelement_nr_base: vgrp.subelement_nr_base + vgrp.nsubelements] cell_types[isubelements] = vgrp.vtk_cell_type assert (cell_types < 255).all() # }}} # {{{ shrink elements if abs(self.element_shrink_factor - 1.0) > 1.0e-14: node_nr_base = 0 for vgrp in self.vis_discr.groups: nodes_view = ( nodes[:, node_nr_base:node_nr_base + vgrp.ndofs] .reshape(nodes.shape[0], vgrp.nelements, vgrp.nunit_dofs)) el_centers = np.mean(nodes_view, axis=-1) nodes_view[:] = ( (self.element_shrink_factor * nodes_view) + (1-self.element_shrink_factor) * el_centers[:, :, np.newaxis]) node_nr_base += vgrp.ndofs # }}} # {{{ create grid nodes = nodes.reshape(self.vis_discr.ambient_dim, -1) points = DataArray("points", nodes, vector_format=VF_LIST_OF_COMPONENTS) grid = UnstructuredGrid( (nodes.shape[1], points), cells=connectivity.cells, cell_types=cell_types) for name, field in separate_by_real_and_imag(names_and_fields, real_only): grid.add_pointdata( DataArray(name, field, vector_format=VF_LIST_OF_COMPONENTS) ) # }}} # {{{ write # {{{ write either both the vis file and the manifest, or neither import os responsible_for_writing_par_manifest = ( par_file_names and par_file_names[0] == file_name) if os.path.exists(file_name): if overwrite: # we simply overwrite below, no need to remove pass else: raise FileExistsError("output file '%s' already exists" % file_name) if (responsible_for_writing_par_manifest and par_manifest_filename is not None): if os.path.exists(par_manifest_filename): if overwrite: # we simply overwrite below, no need to remove pass else: raise FileExistsError("output file '%s' already exists" % par_manifest_filename) else: pass # }}} with open(file_name, "w") as outf: generator = AppendedDataXMLGenerator( compressor=compressor, vtk_file_version=connectivity.version) generator(grid).write(outf) if par_file_names is not None: if par_manifest_filename is None: raise ValueError("must specify par_manifest_filename if " "par_file_names are given") if responsible_for_writing_par_manifest: with open(par_manifest_filename, "w") as outf: generator = ParallelXMLGenerator(par_file_names) generator(grid).write(outf)
def write_vertex_vtk_file(mesh, file_name, compressor=None, overwrite=False): from pyvisfile.vtk import ( UnstructuredGrid, DataArray, AppendedDataXMLGenerator, VF_LIST_OF_COMPONENTS) # {{{ create cell_types from pyvisfile.vtk import ( VTK_LINE, VTK_TRIANGLE, VTK_TETRA, VTK_QUAD, VTK_HEXAHEDRON) from meshmode.mesh import TensorProductElementGroup, SimplexElementGroup cell_types = np.empty(mesh.nelements, dtype=np.uint8) cell_types.fill(255) for egrp in mesh.groups: if isinstance(egrp, SimplexElementGroup): vtk_cell_type = { 1: VTK_LINE, 2: VTK_TRIANGLE, 3: VTK_TETRA, }[egrp.dim] elif isinstance(egrp, TensorProductElementGroup): vtk_cell_type = { 1: VTK_LINE, 2: VTK_QUAD, 3: VTK_HEXAHEDRON, }[egrp.dim] else: raise NotImplementedError("mesh vtk file writing for " "element group of type '%s'" % type(egrp).__name__) cell_types[ egrp.element_nr_base: egrp.element_nr_base + egrp.nelements] = \ vtk_cell_type assert (cell_types != 255).all() # }}} # {{{ create cell connectivity cells = np.empty( sum(egrp.vertex_indices.size for egrp in mesh.groups), dtype=mesh.vertex_id_dtype) # NOTE: vtk uses z-order for the linear quads tensor_order = { 1: (0, 1), 2: (0, 1, 3, 2), 3: (0, 1, 3, 2, 4, 5, 7, 6) } vertex_nr_base = 0 for egrp in mesh.groups: i = np.s_[vertex_nr_base:vertex_nr_base + egrp.vertex_indices.size] if isinstance(egrp, SimplexElementGroup): cells[i] = egrp.vertex_indices.reshape(-1) elif isinstance(egrp, TensorProductElementGroup): cells[i] = egrp.vertex_indices[:, tensor_order[egrp.dim]].reshape(-1) else: raise TypeError("unsupported group type") vertex_nr_base += egrp.vertex_indices.size # }}} grid = UnstructuredGrid( (mesh.nvertices, DataArray("points", mesh.vertices, vector_format=VF_LIST_OF_COMPONENTS)), cells=cells, cell_types=cell_types) import os if os.path.exists(file_name): if overwrite: os.remove(file_name) else: raise FileExistsError("output file '%s' already exists" % file_name) with open(file_name, "w") as outf: AppendedDataXMLGenerator(compressor)(grid).write(outf)
def __init__(self, discr, pcontext=None, basename=None, compressor=None): logger.info("init vtk visualizer: start") hedge.tools.Closable.__init__(self) from pytools import assert_not_a_file if basename is not None: self.pvd_name = basename + ".pvd" assert_not_a_file(self.pvd_name) else: self.pvd_name = None self.pcontext = pcontext self.compressor = compressor if self.pcontext is None or self.pcontext.is_head_rank: self.timestep_to_pathnames = {} else: self.timestep_to_pathnames = None from pyvisfile.vtk import UnstructuredGrid, DataArray, \ VTK_LINE, VTK_TRIANGLE, VTK_TETRA, VF_LIST_OF_VECTORS from hedge.mesh.element import Interval, Triangle, Tetrahedron # For now, we use IntVector here because the Python allocator # is somewhat reluctant to return allocated chunks of memory # to the OS. from hedge._internal import IntVector cells = IntVector() cell_types = IntVector() for eg in discr.element_groups: ldis = eg.local_discretization smi = ldis.get_submesh_indices() cells.reserve(len(cells) + len(smi) * len(eg.members)) for el, el_slice in zip(eg.members, eg.ranges): for element in smi: for j in element: cells.append(el_slice.start + j) if ldis.geometry is Interval: vtk_eltype = VTK_LINE elif ldis.geometry is Triangle: vtk_eltype = VTK_TRIANGLE elif ldis.geometry is Tetrahedron: vtk_eltype = VTK_TETRA else: raise RuntimeError("unsupported element type: %s" % ldis.geometry) cell_types.extend([vtk_eltype] * len(smi) * len(eg.members)) self.grid = UnstructuredGrid( (len(discr), DataArray("points", discr.nodes, vector_format=VF_LIST_OF_VECTORS)), np.asarray(cells), cell_types=np.asarray(cell_types, dtype=np.uint8)) logger.info("init vtk visualizer: done")
def write_vtk_file(self, file_name, names_and_fields, compressor=None, real_only=False, overwrite=False): from pyvisfile.vtk import (UnstructuredGrid, DataArray, AppendedDataXMLGenerator, VF_LIST_OF_COMPONENTS) with cl.CommandQueue(self.vis_discr.cl_context) as queue: nodes = self.vis_discr.nodes().with_queue(queue).get() names_and_fields = [(name, self._resample_and_get(queue, fld)) for name, fld in names_and_fields] vc_groups = self._vis_connectivity() # {{{ create cell_types nsubelements = sum(vgrp.nsubelements for vgrp in vc_groups) cell_types = np.empty(nsubelements, dtype=np.uint8) cell_types.fill(255) for vgrp in vc_groups: cell_types[ vgrp.subelement_nr_base: vgrp.subelement_nr_base + vgrp.nsubelements] = \ vgrp.vtk_cell_type assert (cell_types < 255).all() # }}} if self.element_shrink_factor != 1: for vgrp in self.vis_discr.groups: nodes_view = vgrp.view(nodes) el_centers = np.mean(nodes_view, axis=-1) nodes_view[:] = ((self.element_shrink_factor * nodes_view) + (1 - self.element_shrink_factor) * el_centers[:, :, np.newaxis]) grid = UnstructuredGrid( (self.vis_discr.nnodes, DataArray("points", nodes.reshape(self.vis_discr.ambient_dim, -1), vector_format=VF_LIST_OF_COMPONENTS)), cells=np.hstack( [vgrp.vis_connectivity.reshape(-1) for vgrp in vc_groups]), cell_types=cell_types) # for name, field in separate_by_real_and_imag(cell_data, real_only): # grid.add_celldata(DataArray(name, field, # vector_format=VF_LIST_OF_COMPONENTS)) for name, field in separate_by_real_and_imag(names_and_fields, real_only): grid.add_pointdata( DataArray(name, field, vector_format=VF_LIST_OF_COMPONENTS)) import os from meshmode import FileExistsError if os.path.exists(file_name): if overwrite: os.remove(file_name) else: raise FileExistsError("output file '%s' already exists" % file_name) with open(file_name, "w") as outf: AppendedDataXMLGenerator(compressor)(grid).write(outf)