exovista 1.0.0__tar.gz

exovista-1.0.0/.flake8

@@ -0,0 +1,31 @@
+# -*- conf -*-
+# flake8 settings for Nevada core files.
+#
+# E1: Indentation
+# - E129: visually indented line with same indent as next logical line
+#
+# E2: Whitespace
+# - E203: space before :
+# - E221: multiple spaces before operator
+# - E241: multiple spaces after ','
+# - E272: multiple spaces before keyword
+#
+# E7: Statement
+# - E731: do not assign a lambda expression, use a def
+#
+# W5: Line break warning
+# - W503: line break before binary operator
+# - W504: line break after binary operator
+#
+# These are required to get the package.py files to test clean:
+# - F999: syntax error in doctest
+#
+# N8: PEP8-naming
+# - N801: class names should use CapWords convention
+# - N813: camelcase imported as lowercase
+# - N814: camelcase imported as constant
+#
+[flake8]
+ignore = E129,E221,E241,E272,E731,W503,W504,F999,N801,N813,N814,E203,W605
+max-line-length = 88
+exclude = lib/nevada/external,test,__init__.py,.cache,.git,opt,third_party,lib/nevada/snl,var/nevada/py-packages,var/nevada/spack/repo/packages,docs/nevada,bin/hisread.py,bin/exoread.py,var/nevada/ci,var/nevada/distro,var/nevada/tmp,var/nevada/sandboxes,var/nevada/spack/experimental-repo,TestResults.*

exovista-1.0.0/.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: Upload Python Package to PyPI when a Release is Created
+on:
+  release:
+    types: [created]
+jobs:
+  pypi-publish:
+    name: Publish release to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/exovista
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.x"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build
+      - name: Build package
+        run: |
+          python -m build
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

exovista-1.0.0/.gitignore

@@ -0,0 +1,13 @@
+*.pyc
+__pycache__
+.cache
+.coverage
+htmlcov
+*.bak
+
+# Ignore personal settings
+.vscode
+.vscode/settings.json
+/exovista.egg-info
+/.idea
+.DS_Store

exovista-1.0.0/LICENSE

@@ -0,0 +1,27 @@
+Copyright 2022 National Technology & Engineering Solutions of Sandia, LLC
+(NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+Government retains certain rights in this software.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies,
+either expressed or implied, of Sandia Corporation.

exovista-1.0.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: exovista
+Version: 1.0.0
+Summary: Python wrappers to the ExodusII finite element database model
+License-File: LICENSE
+Requires-Dist: netcdf4
+Requires-Dist: pyvista
+Requires-Dist: numpy
+Requires-Dist: scipy
+Dynamic: license-file

exovista-1.0.0/README.md

@@ -0,0 +1,77 @@
+# ExoVista
+
+An extension of the Sandia exodusii library for exporting PyVista meshes to Exodus format with user-defined element blocks and side sets. This project focuses on a simpler interface for PyVista users (e.g., meshes created via meshio or PyVista’s geometric utilities).
+
+# Why ExoVista?
+
+While PyVista can read and write Exodus files via meshio, this support is limited. For example, in the SIERRA toolset, element blocks are essential for defining material zones, and side sets are commonly used to assign boundary conditions. Currently, meshio cannot save side sets or user-defined element blocks.
+
+ExoVista makes it easy to define side sets and element blocks by assigning a "region" cell array to the surface and volume meshes. Internally, the library automatically splits element blocks by cell type before exporting to an Exodus file.
+
+## Usage
+basic imports
+```python
+import exovista
+import numpy as np
+import pyvista as pv
+```
+
+Load the letter_a PyVista example (a tetrahedral volume mesh).
+After centering the mesh, extract the surface and assign cell-wise region arrays that define element blocks and side sets in the exported Exodus file.
+```python
+def export_tetra_mesh():
+    volume = pv.examples.download_letter_a()
+    volume.points -= volume.center
+    surface = volume.extract_surface()
+
+    volume["region"] = 1 * (volume.cell_centers().points[:, 0] > 0)
+    volume.plot(show_edges=True, categories=True, parallel_projection=True, text="element blocks")
+    
+    surface["region"] = 1 * (surface.cell_centers().points[:, 2] > 0)
+    surface.plot(show_edges=True, categories=True, parallel_projection=True, text="side sets")
+
+    exovista.write_exo("test.exo", volume, surface)
+    return None
+```
+<div style="display: flex; gap: 10px;">
+  <img src="https://github.com/user-attachments/assets/38b84cb6-7b45-43fa-82a4-1ae72bd81b14" width="48%">
+  <img src="https://github.com/user-attachments/assets/1140ffbf-c8b3-4e88-8db6-47c421d3fccc" width="48%">
+</div>
+
+This example constructs a structured cylindrical volume made of hexahedral cells.
+As before, extract the surface and assign region arrays before exporting.
+```python
+def export_hex_mesh():
+    volume = pv.CylinderStructured(radius=np.linspace(1, 2, 5)).cast_to_unstructured_grid()
+    surface = volume.extract_surface()
+
+    volume["region"] = 1*(volume.cell_centers().points[:, 1] > 0) + 2*(volume.cell_centers().points[:, 2] > 0)
+    volume.plot(show_edges=True, categories=True, parallel_projection=True, text="element blocks")
+
+    surface["region"] = 1*(surface.cell_centers().points[:, 0] > 0)
+    surface.plot(show_edges=True, categories=True, parallel_projection=True, text="side sets")
+
+    exovista.write_exo("test.exo", volume, surface)
+    return None
+```
+<div style="display: flex; gap: 10px;">
+  <img src="https://github.com/user-attachments/assets/2cdf9a4a-fdc6-491b-9e3b-724d2d817c92" width="48%">
+  <img src="https://github.com/user-attachments/assets/7400879b-49a3-45d6-8d4f-3f4297fbf166" width="48%">
+</div>
+
+## Install
+
+```
+python -m pip install .
+```
+
+## Copyright
+This repo is a fork of https://github.com/sandialabs/exodusii and therefore inherits the below copyright: 
+
+```
+Copyright 2022 National Technology & Engineering Solutions of Sandia, LLC
+(NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
+Government retains certain rights in this software.
+
+SCR# 2748
+```

exovista-1.0.0/exovista/__init__.py

@@ -0,0 +1,44 @@
+from .file import exodusii_file, ExodusIIFile, write_globals
+from .parallel_file import parallel_exodusii_file, MFExodusIIFile
+from .allclose import allclose
+from .similar import similar
+from .extension import *  # noqa: F403
+from .lineout import lineout
+from .find_in_region import find_element_data_in_region, find_node_data_in_region
+from .exoread import main as exoread
+from .write_pyvista import write_exo
+
+def File(filename, *files, mode="r"):
+
+    if mode not in "rw":
+        raise ValueError(f"Invalid Exodus file mode {mode!r}")
+
+    if mode == "r":
+        files = _find_files(filename, *files)
+        if len(files) > 1:
+            f = parallel_exodusii_file(*files)
+        elif len(files) == 1:
+            f = exodusii_file(files[0], mode="r")
+        else:
+            raise ValueError("No files to open")
+    elif mode == "w":
+        if files:
+            raise TypeError(f"Exodus writer takes 1 file but {len(files)+1} were given")
+        f = exodusii_file(filename, mode="w")
+
+    return f
+
+
+exo_file = File
+
+
+def _find_files(*files):
+    import glob
+
+    found = []
+    for file in files:
+        globbed_files = glob.glob(file)
+        if not globbed_files:
+            raise FileNotFoundError(file)
+        found.extend(globbed_files)
+    return found

exovista-1.0.0/exovista/allclose.py

@@ -0,0 +1,217 @@
+import sys
+import numpy as np
+from io import StringIO
+from .util import string_kinds
+
+
+def allclose(
+    file1,
+    file2,
+    atol=1.0e-12,
+    rtol=1.0e-12,
+    dimensions=True,
+    variables=True,
+    verbose=False,
+):
+    """Returns True if two files are data-wise equal within a tolerance."""
+
+    from .file import ExodusIIFile
+
+    if not isinstance(file1, ExodusIIFile):
+        file1 = ExodusIIFile(file1)
+    if not isinstance(file2, ExodusIIFile):
+        file2 = ExodusIIFile(file2)
+
+    ach = allclose_helper(file1, file2, atol, rtol, verbose=verbose)
+
+    ach.set_dimensions(dimensions)
+    ach.set_variables(variables)
+
+    ach.compare_dimensions()
+    ach.compare_variables()
+
+    return True if not ach.errors else False
+
+
+def _allclose(a, b, atol=1.0e-08, rtol=1.0e-05):
+    """Returns True if two arrays are element - wise equal within a tolerance."""
+
+    def compatible_dtypes(x, y):
+        if x.dtype.kind in string_kinds and y.dtype.kind not in string_kinds:
+            return False
+        if y.dtype.kind in string_kinds and x.dtype.kind not in string_kinds:
+            return False
+        return True
+
+    def compatible_shape(x, y):
+        return x.shape == y.shape
+
+    if a is None or b is None:
+        if a != b:
+            raise ValueError(
+                f"cannot compare type {type(a).__name__} to type {type(b).__name__}"
+            )
+        return True
+
+    x = np.asanyarray(a)
+    y = np.asanyarray(b)
+
+    if not compatible_dtypes(x, y):
+        raise TypeError(
+            f"adiff not supported for input dtypes {x.dtype.kind} and {y.dtype.kind}"
+        )
+    elif not compatible_shape(x, y):
+        raise ValueError("input arguments must have same shape")
+
+    if x.dtype.kind in string_kinds:
+        x = sorted(x.flatten())
+        y = sorted(y.flatten())
+        return all([x[i] == y[i] for i in range(len(x))])
+
+    return np.allclose(x, y, atol=atol, rtol=rtol)
+
+
+class allclose_helper:
+    def __init__(self, file1, file2, atol, rtol, print_threshold=10, verbose=False):
+        self.file1 = file1
+        self.file2 = file2
+        self.atol = atol
+        self.rtol = rtol
+        self.print_threshold = print_threshold
+        self.verbose = verbose
+
+        self._dims_to_compare = None
+        self._vars_to_compare = None
+
+        self.errors = 0
+
+    def log_error(self, message, end="\n"):
+        if self.verbose:
+            sys.stderr.write(f"==> Error: {message}{end}")
+        self.errors += 1
+
+    def all_dimensions(self):
+        dims1 = self.file1.dimension_names()
+        dims2 = self.file2.dimension_names()
+        return sorted(set(dims1 + dims2))
+
+    def all_variables(self):
+        vars1 = self.file1.variable_names()
+        vars2 = self.file2.variable_names()
+        return sorted(set(vars1 + vars2))
+
+    def set_dimensions(self, dimensions):
+        if dimensions is True:
+            dimensions = self.all_dimensions()
+        elif dimensions is None or dimensions is False:
+            dimensions = []
+        elif isinstance(dimensions, str):
+            dimensions = [dimensions]
+            if dimensions[0].startswith("~"):
+                # Compare all - except those being negated
+                skip = dimensions[0][1:].split("|")
+                dimensions = [_ for _ in self.all_dimensions() if _ not in skip]
+        if not isinstance(dimensions, (list, tuple)):
+            raise ValueError("Expected list of dimensions to compare")
+        self.validate_dimensions(dimensions)
+        self._dims_to_compare = tuple(dimensions)
+
+    def set_variables(self, variables):
+        if variables is True:
+            variables = self.all_variables()
+        elif variables is None or variables is False:
+            variables = []
+        elif isinstance(variables, str):
+            variables = [variables]
+            if variables[0].startswith("~"):
+                # Compare all - except those being negated
+                skip = variables[0][1:].split("|")
+                variables = [_ for _ in self.all_variables() if _ not in skip]
+        if not isinstance(variables, (list, tuple)):
+            raise ValueError("Expected list of variables to compare")
+        self.validate_variables(variables)
+        self._vars_to_compare = tuple(variables)
+
+    def validate_dimensions(self, dimensions):
+        invalid = 0
+        valid_dimensions = self.all_dimensions()
+        for dimension in dimensions:
+            if dimension not in valid_dimensions:
+                self.log_error(f"{dimension} is not a valid dimension")
+                invalid += 1
+        if invalid:
+            raise ValueError("One or more invalid dimensions")
+
+    def validate_variables(self, variables):
+        invalid = 0
+        valid_variables = self.all_variables()
+        for variable in variables:
+            if variable not in valid_variables:
+                self.log_error(f"{variable} is not a valid variable")
+                invalid += 1
+        if invalid:
+            raise ValueError("One or more invalid variables")
+
+    def compare_dimensions(self):
+        if self._dims_to_compare is None:
+            raise ValueError("Dimensions to compare must first be set")
+        for dimension in self._dims_to_compare:
+            self.compare_dimension(dimension)
+        self._dims_to_compare = None
+
+    def compare_dimension(self, dim):
+        if dim not in self.file1.fh.dimensions:
+            self.log_error(f"dimension {dim} not found in {self.file1.filename}")
+            return
+        elif dim not in self.file2.fh.dimensions:
+            self.log_error(f"dimension {dim} not found in {self.file2.filename}")
+            return
+        elif dim in ("time_step",):
+            return
+
+        dim1 = self.file1.get_dimension(dim)
+        dim2 = self.file1.get_dimension(dim)
+        if not _allclose(dim1, dim2, atol=self.atol, rtol=self.rtol):
+            err = StringIO()
+            err.write(
+                f"{self.file1.filename}::{dim} != "
+                f"{self.file2.filename}::{dim} ({dim1} != {dim2})"
+            )
+            self.log_error(err.getvalue())
+
+    def compare_variables(self):
+        if self._vars_to_compare is None:
+            raise ValueError("Variables to compare must first be set")
+        for variable in self._vars_to_compare:
+            self.compare_variable(variable)
+        self._vars_to_compare = None
+
+    def compare_variable(self, var):
+        if var not in self.file1.fh.variables:
+            self.log_error(f"variable {var} not found in {self.file1.filename}")
+            return
+        elif var not in self.file2.fh.variables:
+            self.log_error(f"variable {var} not found in {self.file2.filename}")
+            return
+
+        var1 = self.file1.get_variable(var)
+        var2 = self.file2.get_variable(var)
+        if var1.shape != var2.shape:
+            err = StringIO()
+            err.write(
+                f"{self.file1.filename}::{var}.shape != "
+                f"{self.file2.filename}::{var}.shape "
+                f"({var1.shape} != {var2.shape})"
+            )
+            self.log_error(err.getvalue())
+            return
+
+        if not _allclose(var1, var2, atol=self.atol, rtol=self.rtol):
+            err = StringIO()
+            s1 = np.array2string(var1, threshold=self.print_threshold)
+            s2 = np.array2string(var2, threshold=self.print_threshold)
+            err.write(
+                f"{self.file1.filename}::{var} != "
+                f"{self.file2.filename}::{var} ({s1} != {s2})"
+            )
+            self.log_error(err.getvalue())

exovista-1.0.0/exovista/config.py

@@ -0,0 +1,21 @@
+import os
+from types import SimpleNamespace
+
+
+def env_boolean(var, default=None):
+    value = os.getenv(var, default)
+    if value is None:
+        return default
+    if value.lower() in ("false", "0", "off", ""):
+        return False
+    return True
+
+
+def initialize_config():
+    cfg = SimpleNamespace()
+    cfg.use_netcdf4_if_possible = env_boolean("EXODUSII_USE_NETCDF4", default="on")
+    cfg.debug = env_boolean("EXODUSII_DEBUG", default="off")
+    return cfg
+
+
+config = initialize_config()

exovista-1.0.0/exovista/copy.py

@@ -0,0 +1,197 @@
+from .exodus_h import types
+
+
+copy_extra_set_info = False
+
+
+def copy(source, target):
+    """Copy the source ExodusII file to the target"""
+    target.put_init(
+        source.title(),
+        source.num_dimensions(),
+        source.num_nodes(),
+        source.num_elems(),
+        source.num_blks(),
+        source.num_node_sets(),
+        source.num_side_sets(),
+        num_edge=source.num_edges(),
+        num_edge_blk=source.num_edge_blk(),
+        num_face=source.num_faces(),
+        num_face_blk=source.num_face_blk(),
+    )
+    copy_mesh(source, target)
+    copy_variable_params(source, target)
+    copy_variable_histories(source, target)
+
+
+def copy_mesh(source, target):
+    """Copies ExodusII mesh information from source to target"""
+
+    target.put_coord_names(source.get_coord_names())
+    target.put_coords(source.get_coords())
+
+    for block in source.elem_blocks():
+        target.put_element_block(
+            block.id,
+            block.elem_type,
+            block.num_block_elems,
+            block.num_elem_nodes,
+            num_faces_per_elem=block.num_elem_faces,
+            num_edges_per_elem=block.num_elem_edges,
+            num_attr=block.num_elem_attrs,
+        )
+        for type in (types.node, types.edge, types.face):
+            conn = source.get_element_conn(block.id, type=type)
+            if conn is not None:
+                target.put_element_conn(block.id, conn, type=type)
+
+    if target.num_faces():
+        for block in source.face_blocks():
+            target.put_face_block(
+                block.id,
+                block.elem_type,
+                block.num_block_faces,
+                block.num_face_nodes,
+                block.num_face_attrs,
+            )
+            conn = source.get_face_block_conn(block.id)
+            target.put_face_conn(block.id, conn)
+
+    if target.num_edges():
+        for block in source.edge_blocks():
+            target.put_edge_block(
+                block.id,
+                block.elem_type,
+                block.num_block_edges,
+                block.num_edge_nodes,
+                block.num_edge_attrs,
+            )
+            conn = source.get_edge_block_conn(block.id)
+            target.put_edge_conn(block.id, conn)
+
+    for ns in source.node_sets():
+        target.put_node_set_param(ns.id, ns.num_nodes, ns.num_dist_facts)
+        target.put_node_set_name(ns.id, ns.name)
+        target.put_node_set_nodes(ns.id, ns.nodes)
+        if ns.num_dist_facts:
+            target.put_node_set_dist_fact(ns.id, ns.dist_facts)
+
+    for es in source.edge_sets():
+        target.put_edge_set_param(
+            es.id, es.num_edges, es.num_nodes_per_edge, es.num_dist_facts
+        )
+
+    for fs in source.face_sets():
+        target.put_face_set_param(
+            fs.id, fs.num_faces, fs.num_nodes_per_face, fs.num_dist_facts
+        )
+
+    for es in source.elem_sets():
+        target.put_element_set_param(es.id, es.num_elems, es.num_dist_facts)
+
+    for ss in source.side_sets():
+        target.put_side_set_param(ss.id, ss.num_sides, ss.num_dist_facts)
+        target.put_side_set_name(ss.id, ss.name)
+        target.put_side_set_sides(ss.id, ss.elems, ss.sides)
+        if ss.num_dist_facts:
+            target.put_side_set_dist_fact(ss.id, ss.dist_facts)
+
+    node_id_map = source.get_node_id_map()
+    target.put_node_id_map(node_id_map)
+
+    elem_id_map = source.get_element_id_map()
+    target.put_element_id_map(elem_id_map)
+
+    if source.num_edges():
+        edge_id_map = source.get_edge_id_map()
+        target.put_edge_id_map(edge_id_map)
+
+    if source.num_faces():
+        face_id_map = source.get_face_id_map()
+        target.put_face_id_map(face_id_map)
+
+
+def copy_variable_params(source, target):
+
+    target.put_global_variable_params(source.get_global_variable_number())
+    target.put_global_variable_names(source.get_global_variable_names())
+
+    target.put_node_variable_params(source.get_node_variable_number())
+    target.put_node_variable_names(source.get_node_variable_names())
+
+    if source.get_element_variable_number() is not None:
+        target.put_element_variable_params(source.get_element_variable_number())
+        target.put_element_variable_names(source.get_element_variable_names())
+        table = source.get_element_variable_truth_table()
+        if table is not None:
+            target.put_element_variable_truth_table(table)
+
+    if source.get_face_variable_number() is not None:
+        target.put_face_variable_params(source.get_face_variable_number())
+        target.put_face_variable_names(source.get_face_variable_names())
+        table = source.get_face_variable_truth_table()
+        if table is not None:
+            target.put_face_variable_truth_table(table)
+
+    if source.get_edge_variable_number() is not None:
+        target.put_edge_variable_params(source.get_edge_variable_number())
+        target.put_edge_variable_names(source.get_edge_variable_names())
+        table = source.get_edge_variable_truth_table()
+        if table is not None:
+            target.put_edge_variable_truth_table(table)
+
+    target.put_node_set_variable_params(source.get_node_set_variable_number())
+    target.put_node_set_variable_names(source.get_node_set_variable_names())
+
+    if copy_extra_set_info:
+
+        target.put_edge_set_variable_params(source.get_edge_set_variable_number())
+        target.put_edge_set_variable_names(source.get_edge_set_variable_names())
+
+        target.put_face_set_variable_params(source.get_face_set_variable_number())
+        target.put_face_set_variable_names(source.get_face_set_variable_names())
+
+        target.put_element_set_variable_params(source.get_element_set_variable_number())
+        target.put_element_set_variable_names(source.get_element_set_variable_names())
+
+        target.put_side_set_variable_params(source.get_side_set_variable_number())
+        target.put_side_set_variable_names(source.get_side_set_variable_names())
+
+
+def copy_variable_histories(source, target):
+
+    for (time_step, time) in enumerate(source.get_times(), start=1):
+        target.put_time(time_step, time)
+
+    values = source.get_all_global_variable_values()
+    target.put_global_variable_values(None, values)
+
+    for name in source.get_node_variable_names():
+        values = source.get_node_variable_values(name)
+        target.put_node_variable_values(None, name, values)
+
+    for block_id in source.get_element_block_ids():
+        for name in source.get_element_variable_names():
+            values = source.get_element_variable_values(block_id, name)
+            target.put_element_variable_values(None, block_id, name, values)
+
+    for block_id in source.get_edge_block_ids():
+        for name in source.get_edge_variable_names():
+            values = source.get_edge_variable_values(block_id, name)
+            target.put_edge_variable_values(None, block_id, name, values)
+
+    for block_id in source.get_face_block_ids():
+        for name in source.get_face_variable_names():
+            values = source.get_face_variable_values(block_id, name)
+            target.put_face_variable_values(None, block_id, name, values)
+
+    if copy_extra_set_info:
+        for set_id in source.get_node_set_ids():
+            for name in source.get_node_set_variable_names():
+                values = source.get_node_set_variable_values(block_id, name)
+                target.put_node_set_variable_values(None, block_id, name, values)
+
+        for set_id in source.get_side_set_ids():
+            for name in source.get_side_set_variable_names():
+                values = source.get_side_set_variable_values(block_id, name)
+                target.put_side_set_variable_values(None, block_id, name, values)