resqpy 4.15.1__tar.gz → 4.15.3__tar.gz

{resqpy-4.15.1 → resqpy-4.15.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: resqpy
-Version: 4.15.1
+Version: 4.15.3
 Summary: Python API for working with RESQML models
 Home-page: https://github.com/bp/resqpy
 License: MIT

{resqpy-4.15.1 → resqpy-4.15.3}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "poetry.masonry.api"
 
 [tool.poetry]
 name = "resqpy"
-version = "4.15.1" # Set at build time
+version = "4.15.3" # Set at build time
 description = "Python API for working with RESQML models"
 authors = ["BP"]
 license = "MIT"

{resqpy-4.15.1 → resqpy-4.15.3}/resqpy/__init__.py

@@ -28,6 +28,6 @@
 
 import logging
 
-__version__ = "4.15.1"  # Set at build time
+__version__ = "4.15.3"  # Set at build time
 log = logging.getLogger(__name__)
 log.info(f"Imported resqpy version {__version__}")

{resqpy-4.15.1 → resqpy-4.15.3}/resqpy/rq_import/_import_nexus.py

@@ -67,55 +67,78 @@ def import_nexus(
         ensemble_size_limit = None,
         grid_title = 'ROOT',
         mode = 'w',
-        progress_fn = None):
-    """Read a simulation grid geometry and optionally grid properties.
-
-    Input may be from nexus ascii input files, or nexus vdb output.
-
-    Arguments:
-        resqml_file_root (str): output path and file name without .epc or .h5 extension
-        extent_ijk (triple float, optional): ijk extents (fortran ordering)
-        vdb_file (str, optional): vdb input file, either this or corp_file should be not None. Required if importing from a vdb
-        vdb_case (str, optional): required if the vdb contains more than one case. If None, first case in vdb is used
-        corp_file (str, optional): required if importing from corp ascii file. corp ascii input file: nexus corp data without keyword
-        corp_bin_file (str, optional): required if importing from corp binary file
-        corp_xy_units (str, default 'm'): xy length units
-        corp_z_units (str, default 'm'): z length units
-        corp_z_inc_down (bool, default True): if True z values increase with depth
-        ijk_handedness (str, default 'right'): 'right' or 'left'
-        corp_eight_mode (bool, default False): if True the ordering of corner point data is in nexus EIGHT mode
-        geometry_defined_everywhere (bool, default True): if False then inactive cells are marked as not having geometry
-        treat_as_nan (float, default None): if a value is provided corner points with this value will be assigned nan
-        active_mask_file (str, default None): ascii property file holding values 0 or 1, with 1 indicating active cells
-        use_binary (bool, default False): if True a cached binary version of ascii files will be used (pure binary, not corp bin format)
-        resqml_xy_units (str, default 'm'): output xy units for resqml file
-        resqml_z_units (str, default 'm'): output z units for resqml file
-        resqml_z_inc_down (bool, default True): if True z values increase with depth for output resqml file
-        shift_to_local (bool, default False): if True then a local origin will be used in the CRS
-        local_origin_place (str, default 'centre'): 'centre' or 'minimum'. If 'centre' the local origin is placed at the centre of the grid; ignored if shift_to_local is False
-        max_z_void (float, default 0.1): maximum z gap between vertically neighbouring corner points. Vertical gaps greater than this will introduce k gaps into resqml grid. Units are corp z units
-        split_pillars (bool, default True): if False an unfaulted grid will be generated
-        split_tolerance (float, default 0.01): maximum distance between neighbouring corner points before a pillar is considered 'split'. Applies to each of x, y, z differences
-        property_array_files (list, default None): list of (filename, keyword, uom, time_index, null_value, discrete)
-        summary_file (str, default None): nexus output summary file, used to extract timestep dates when loading recurrent data from vdb
-        vdb_static_properties (bool, default True): if True, static vdb properties are imported (only relevant if vdb_file is not None)
-        vdb_recurrent_properties (bool, default False): # if True, recurrent vdb properties are imported (only relevant if vdb_file is not None)
-        timestep_selection (str, default 'all): 'first', 'last', 'first and last', 'all', or list of ints being reporting timestep numbers. Ignored if vdb_recurrent_properties is False
-        use_compressed_time_series (bool, default True): generates reduced time series containing timesteps with recurrent properties from vdb, rather than full nexus summary time series
-        decoarsen (bool, default True): where ICOARSE is present, redistribute data to uncoarse cells
-        ab_property_list (list, default None):  list of (file_name, keyword, property_kind, facet_type, facet, uom, time_index, null_value, discrete)
-        create_property_set (bool, default False): if True a resqml PropertySet is created
-        ensemble_case_dirs_root (str, default None): path up to but excluding realisation number
-        ensemble_property_dictionary (str, default None): dictionary mapping title (or keyword) to (filename, property_kind, facet_type, facet, uom, time_index, null_value, discrete)
-        ensemble_size_limit (int, default None): if present processing of ensemble will terminate after this number of cases is reached
-        grid_title (str, default 'ROOT'): grid citation title
-        mode (str, default 'w'): 'w' or 'a', mode to write or append to hdf5
-        progress_fn (function, default None): if present function must have one floating argument with value increasing from 0 to 1, and is called at intervals to indicate progress
-
-    Returns:
-        resqml model in memory & written to disc
+        progress_fn = None,
+        vdb_property_list = None):
+    """Read a Nexus grid geometry (from ascii input or vdb) and optionally grid properties.
+
+    arguments:
+        - resqml_file_root (str): output path and file name without .epc or .h5 extension
+        - extent_ijk (triple float, optional): ijk extents (fortran ordering)
+        - vdb_file (str, optional): vdb input file, either this or corp_file should be not None;
+          required if importing from a vdb
+        - vdb_case (str, optional): required if the vdb contains more than one case;
+          if None, first case in vdb is used
+        - corp_file (str, optional): required if importing from corp ascii file;
+          corp ascii input file containing nexus corp data without keyword
+        - corp_bin_file (str, optional): required if importing from corp binary file
+        - corp_xy_units (str, default 'm'): xy length units
+        - corp_z_units (str, default 'm'): z length units
+        - corp_z_inc_down (bool, default True): if True z values increase with depth
+        - ijk_handedness (str, default 'right'): 'right' or 'left'
+        - corp_eight_mode (bool, default False): if True the ordering of corner point data
+          is in nexus EIGHT mode
+        - geometry_defined_everywhere (bool, default True): if False then inactive cells are
+          marked as not having geometry
+        - treat_as_nan (float, default None): if a value is provided corner points with
+          this value will be assigned not-a-number
+        - active_mask_file (str, default None): ascii property file holding values 0 or 1,
+          with 1 indicating active cells
+        - use_binary (bool, default False): if True a cached binary version of ascii files
+          will be used (pure binary, not corp bin format)
+        - resqml_xy_units (str, default 'm'): output xy units for resqml file
+        - resqml_z_units (str, default 'm'): output z units for resqml file
+        - resqml_z_inc_down (bool, default True): if True z values increase with depth for
+          output resqml file
+        - shift_to_local (bool, default False): if True then a local origin will be used in the CRS
+        - local_origin_place (str, default 'centre'): 'centre' or 'minimum'; if 'centre' the
+          local origin is placed at the centre of the grid; ignored if shift_to_local is False
+        - max_z_void (float, default 0.1): maximum z gap between vertically neighbouring corner points;
+          vertical gaps greater than this will introduce k gaps into resqml grid; units are corp z units
+        - split_pillars (bool, default True): if False an unfaulted grid will be generated
+        - split_tolerance (float, default 0.01): maximum distance between neighbouring corner points
+          before a pillar is considered 'split'; applies to each of x, y, z differences
+        - property_array_files (list, default None): list of (filename, keyword, uom, time_index, null_value, discrete)
+        - summary_file (str, default None): nexus output summary file, used to extract timestep dates
+          when loading recurrent data from vdb
+        - vdb_static_properties (bool, default True): if True, static vdb properties are imported;
+          only relevant if vdb_file is not None; see also vdb_property_list
+        - vdb_recurrent_properties (bool, default False): if True, recurrent vdb properties are imported;
+          only relevant if vdb_file is not None; see also vdb_property_list
+        - timestep_selection (str, default 'all): 'first', 'last', 'first and last', 'all',
+          or list of ints being reporting timestep numbers; ignored if vdb_recurrent_properties is False
+        - use_compressed_time_series (bool, default True): generates reduced time series containing
+          timesteps with recurrent properties from vdb, rather than full nexus summary time series
+        - decoarsen (bool, default True): where ICOARSE is present, redistribute data to uncoarse cells
+        - ab_property_list (list, optional):  list of
+          (file_name, keyword, property_kind, facet_type, facet, uom, time_index, null_value, discrete)
+        - create_property_set (bool, default False): if True a resqml PropertySet is created
+        - ensemble_case_dirs_root (str, optional): path up to but excluding realisation number
+        - ensemble_property_dictionary (str, optional): dictionary mapping title (or keyword) to
+          (filename, property_kind, facet_type, facet, uom, time_index, null_value, discrete)
+        - ensemble_size_limit (int, optional): if present processing of ensemble will terminate
+          after this number of cases is reached
+        - grid_title (str, default 'ROOT'): grid citation title
+        - mode (str, default 'w'): 'w' or 'a', mode to write or append to hdf5
+        - progress_fn (function, default None): if present function must have one floating argument
+          with value increasing from 0.0 to 1.0, and is called at intervals to indicate progress
+        - vdb_property_list (list of str, optional): list of vdb static and/or recurrent properties to
+          include in the import; if None, all properties are imported; vdb_static_properties and
+          vdb_recurrent_properties boolean arguments must also be set True for respective properties
+          to be included; ignored if not importing from vdb
+
+    returns:
+        - resqml model in memory & written to disc
     """
-
     if resqml_file_root.endswith('.epc'):
         resqml_file_root = resqml_file_root[:-4]
     assert mode in ['w', 'a']
@@ -333,6 +356,8 @@ def import_nexus(
                 prop_import_collection = rp.GridPropertyCollection()
                 prop_import_collection.set_grid(grid)
                 for keyword in props:
+                    if vdb_property_list is not None and keyword not in vdb_property_list:
+                        continue
                     prop_import_collection.import_vdb_static_property_to_cache(vdbase, keyword, grid_name = grid_title)
     #      if active_mask is not None:
     #         prop_import_collection.add_cached_array_to_imported_list(active_mask, active_mask_file, 'ACTIVE', property_kind = 'active',
@@ -520,6 +545,8 @@ def import_nexus(
                     for keyword in recur_prop_list:
                         if vdb.bad_keyword(keyword):
                             continue
+                        if vdb_property_list is not None and keyword not in vdb_property_list:
+                            continue
                         prop_kind, facet_type, facet = rp.property_kind_and_facet_from_keyword(keyword)
                         step_import_collection.import_vdb_recurrent_property_to_cache(
                             vdbase,

resqpy-4.15.3/resqpy/rq_import/_import_vdb_all_grids.py

@@ -0,0 +1,120 @@
+"""_import_vdb_all_grids.py: Module to import a vdb into resqml format."""
+
+# Nexus is a registered trademark of the Halliburton Company
+
+import logging
+
+log = logging.getLogger(__name__)
+
+import resqpy.olio.vdb as vdb
+import resqpy.rq_import as rqi
+
+
+def import_vdb_all_grids(resqml_file_root,
+                         extent_ijk = None,
+                         vdb_file = None,
+                         vdb_case = None,
+                         corp_xy_units = 'm',
+                         corp_z_units = 'm',
+                         corp_z_inc_down = True,
+                         ijk_handedness = 'right',
+                         geometry_defined_everywhere = True,
+                         treat_as_nan = None,
+                         resqml_xy_units = 'm',
+                         resqml_z_units = 'm',
+                         resqml_z_inc_down = True,
+                         shift_to_local = False,
+                         local_origin_place = 'centre',
+                         max_z_void = 0.1,
+                         split_pillars = True,
+                         split_tolerance = 0.01,
+                         vdb_static_properties = True,
+                         vdb_recurrent_properties = False,
+                         decoarsen = True,
+                         timestep_selection = 'all',
+                         create_property_set = False,
+                         vdb_property_list = None):
+    """Creates a RESQML dataset containing grids and grid properties, including LGRs, for a single realisation.
+
+    arguments:
+        - resqml_file_root (str): output path and file name without .epc or .h5 extension
+        - extent_ijk (triple float, optional): ijk extents (fortran ordering)
+        - vdb_file (str, optional): vdb input file, either this or corp_file should be not None;
+          required if importing from a vdb
+        - vdb_case (str, optional): required if the vdb contains more than one case;
+          if None, first case in vdb is used
+        - corp_xy_units (str, default 'm'): xy length units
+        - corp_z_units (str, default 'm'): z length units
+        - corp_z_inc_down (bool, default True): if True z values increase with depth
+        - ijk_handedness (str, default 'right'): 'right' or 'left'
+        - geometry_defined_everywhere (bool, default True): if False then inactive cells are marked
+          as not having geometry
+        - treat_as_nan (float, default None): if a value is provided corner points with this value
+          will be assigned nan (not-a-number)
+        - resqml_xy_units (str, default 'm'): output xy units for resqml file
+        - resqml_z_units (str, default 'm'): output z units for resqml file
+        - resqml_z_inc_down (bool, default True): if True z values increase with depth in output resqml file
+        - shift_to_local (bool, default False): if True then a local origin will be used in the CRS
+        - local_origin_place (str, default 'centre'): 'centre' or 'minimum'; if 'centre' the local origin
+          is placed at the centre of the grid; ignored if shift_to_local is False
+        - max_z_void (float, default 0.1): maximum z gap between vertically neighbouring corner points;
+          vertical gaps greater than this will introduce k gaps into resqml grid; units are corp z units
+        - split_pillars (bool, default True): if False an unfaulted grid will be generated
+        - split_tolerance (float, default 0.01): maximum distance between neighbouring corner points
+          before a pillar is considered 'split'; applies to each of x, y, z differences
+        - vdb_static_properties (bool, default True): if True, static vdb properties are imported;
+          only relevant if vdb_file is not None; see also vdb_property_list
+        - vdb_recurrent_properties (bool, default False): if True, recurrent vdb properties are imported;
+          only relevant if vdb_file is not None; see also vdb_property_list
+        - decoarsen (bool, default True): where ICOARSE is present, redistribute data to uncoarse cells
+        - timestep_selection (str, default 'all): 'first', 'last', 'first and last', 'all', or list of ints
+          being reporting timestep numbers to include; ignored if vdb_recurrent_properties is False
+        - create_property_set (bool, default False): if True a resqml PropertySet is created
+        - vdb_property_list (list of str, optional): list of vdb static and/or recurrent properties to
+          include in the import; if None, all properties are imported; vdb_static_properties and
+          vdb_recurrent_properties boolean arguments must also be set True for respective properties
+          to be included; ignored if not importing from vdb
+    """
+    vdbase = vdb.VDB(vdb_file)
+    case_list = vdbase.cases()
+    assert len(case_list) > 0, 'no cases found in vdb'
+    if vdb_case is None:
+        vdb_case = case_list[0]
+    else:
+        assert vdb_case in case_list, 'case ' + vdb_case + ' not found in vdb: ' + vdb_file
+        vdbase.set_use_case(vdb_case)
+    grid_list = vdbase.list_of_grids()
+    index = 0
+    for grid_name in grid_list:
+        if grid_name.upper().startswith('SMALLGRIDS'):
+            log.warning('vdb import skipping small grids')
+            continue
+        log.debug('importing vdb data for grid ' + str(grid_name))
+        rqi.import_nexus(
+            resqml_file_root,
+            extent_ijk = extent_ijk if grid_name == 'ROOT' else None,  # 3 element numpy vector applicable to ROOT
+            vdb_file = vdb_file,
+            vdb_case = vdb_case,  # if None, first case in vdb is used (usually a vdb only holds one case)
+            corp_xy_units = corp_xy_units,
+            corp_z_units = corp_z_units,
+            corp_z_inc_down = corp_z_inc_down,
+            ijk_handedness = ijk_handedness,
+            geometry_defined_everywhere = geometry_defined_everywhere,
+            treat_as_nan = treat_as_nan,
+            resqml_xy_units = resqml_xy_units,
+            resqml_z_units = resqml_z_units,
+            resqml_z_inc_down = resqml_z_inc_down,
+            shift_to_local = shift_to_local,
+            local_origin_place = local_origin_place,  # 'centre' or 'minimum'
+            max_z_void = max_z_void,  # vertical gaps greater than this will introduce k gaps intp resqml grid
+            split_pillars = split_pillars,  # NB: some LGRs may be unsplit even if ROOT is split
+            split_tolerance = split_tolerance,  # applies to each of x, y, z differences
+            vdb_static_properties = vdb_static_properties,  # if True, static vdb properties are imported
+            vdb_recurrent_properties = vdb_recurrent_properties,
+            decoarsen = decoarsen,
+            timestep_selection = timestep_selection,
+            create_property_set = create_property_set,
+            grid_title = grid_name,
+            mode = 'w' if index == 0 else 'a',
+            vdb_property_list = vdb_property_list)
+        index += 1

{resqpy-4.15.1 → resqpy-4.15.3}/resqpy/surface/_surface.py

@@ -122,6 +122,7 @@ class Surface(rqsb.BaseSurface):
             self.set_from_mesh_file(mesh_file, mesh_format, quad_triangles = quad_triangles)
         elif tsurf_file is not None:
             self.set_from_tsurf_file(tsurf_file)
+        self._load_normal_vector_from_extra_metadata()
 
     @classmethod
     def from_tri_mesh(cls, tri_mesh, exclude_nans = False):
@@ -715,7 +716,7 @@ class Surface(rqsb.BaseSurface):
 
         _, p = self.triangles_and_points()
         crs = rqc.Crs(self.model, uuid = self.crs_uuid)
-        if crs.xy_units == self.z_units:
+        if crs.xy_units == crs.z_units:
             return p
         unit_adjusted_p = p.copy()
         wam.convert_lengths(unit_adjusted_p[:, 2], crs.z_units, crs.xy_units)
@@ -1203,7 +1204,12 @@ class Surface(rqsb.BaseSurface):
         if not self.title:
             self.title = 'surface'
 
-        tri_rep = super().create_xml(add_as_part = False, title = title, originator = originator)
+        em = None
+        if self.normal_vector is not None:
+            assert len(self.normal_vector) == 3
+            em = {'normal vector': f'{self.normal_vector[0]},{self.normal_vector[1]},{self.normal_vector[2]}'}
+
+        tri_rep = super().create_xml(add_as_part = False, title = title, originator = originator, extra_metadata = em)
 
         # todo: if crs_uuid is None, attempt to set to surface patch crs uuid (within patch loop, below)
         if crs_uuid is not None:
@@ -1309,6 +1315,16 @@ class Surface(rqsb.BaseSurface):
 
         return tri_rep
 
+    def _load_normal_vector_from_extra_metadata(self):
+        if self.normal_vector is None and self.extra_metadata is not None:
+            nv_str = self.extra_metadata.get('normal vector')
+            if nv_str is not None:
+                nv_words = nv_str.split(',')
+                assert len(nv_words) == 3, f'failed to convert normal vector string into triplet: {nv_str}'
+                self.normal_vector = np.empty(3, dtype = float)
+                for i in range(3):
+                    self.normal_vector[i] = float(nv_words[i])
+
 
 def distill_triangle_points(t, p):
     """Returns a (triangles, points) pair with points distilled as only those used from p."""

resqpy-4.15.1/resqpy/rq_import/_import_vdb_all_grids.py

@@ -1,108 +0,0 @@
-"""_import_vdb_all_grids.py: Module to import a vdb into resqml format."""
-
-# Nexus is a registered trademark of the Halliburton Company
-
-import logging
-
-log = logging.getLogger(__name__)
-
-import resqpy.olio.vdb as vdb
-import resqpy.rq_import as rqi
-
-
-def import_vdb_all_grids(
-    resqml_file_root,  # output path and file name without .epc or .h5 extension
-    extent_ijk = None,  # 3 element numpy vector applicable to ROOT
-    vdb_file = None,
-    vdb_case = None,  # if None, first case in vdb is used (usually a vdb only holds one case)
-    corp_xy_units = 'm',
-    corp_z_units = 'm',
-    corp_z_inc_down = True,
-    ijk_handedness = 'right',
-    geometry_defined_everywhere = True,
-    treat_as_nan = None,
-    resqml_xy_units = 'm',
-    resqml_z_units = 'm',
-    resqml_z_inc_down = True,
-    shift_to_local = False,
-    local_origin_place = 'centre',  # 'centre' or 'minimum'
-    max_z_void = 0.1,  # vertical gaps greater than this will introduce k gaps intp resqml grid
-    split_pillars = True,
-    split_tolerance = 0.01,  # applies to each of x, y, z differences
-    vdb_static_properties = True,
-    # if True, static vdb properties are imported (only relevant if vdb_file is not None)
-    vdb_recurrent_properties = False,
-    decoarsen = True,
-    timestep_selection = 'all',
-    # 'first', 'last', 'first and last', 'all', or list of ints being reporting timestep numbers
-    create_property_set = False):
-    """Creates a RESQML dataset containing grids and grid properties, including LGRs, for a single realisation.
-
-    Arguments:
-        resqml_file_root (str): output path and file name without .epc or .h5 extension
-        extent_ijk (triple float, optional): ijk extents (fortran ordering)
-        vdb_file (str, optional): vdb input file, either this or corp_file should be not None. Required if importing from a vdb
-        vdb_case (str, optional): required if the vdb contains more than one case. If None, first case in vdb is used
-        corp_xy_units (str, default 'm'): xy length units
-        corp_z_units (str, default 'm'): z length units
-        corp_z_inc_down (bool, default True): if True z values increase with depth
-        ijk_handedness (str, default 'right'): 'right' or 'left'
-        geometry_defined_everywhere (bool, default True): if False then inactive cells are marked as not having geometry
-        treat_as_nan (float, default None): if a value is provided corner points with this value will be assigned nan
-        resqml_xy_units (str, default 'm'): output xy units for resqml file
-        resqml_z_units (str, default 'm'): output z units for resqml file
-        resqml_z_inc_down (bool, default True): if True z values increase with depth for output resqml file
-        shift_to_local (bool, default False): if True then a local origin will be used in the CRS
-        local_origin_place (str, default 'centre'): 'centre' or 'minimum'. If 'centre' the local origin is placed at the centre of the grid; ignored if shift_to_local is False
-        max_z_void (float, default 0.1): maximum z gap between vertically neighbouring corner points. Vertical gaps greater than this will introduce k gaps into resqml grid. Units are corp z units
-        split_pillars (bool, default True): if False an unfaulted grid will be generated
-        split_tolerance (float, default 0.01): maximum distance between neighbouring corner points before a pillar is considered 'split'. Applies to each of x, y, z differences
-        vdb_static_properties (bool, default True): if True, static vdb properties are imported (only relevant if vdb_file is not None)
-        vdb_recurrent_properties (bool, default False): # if True, recurrent vdb properties are imported (only relevant if vdb_file is not None)
-        decoarsen (bool, default True): where ICOARSE is present, redistribute data to uncoarse cells
-        timestep_selection (str, default 'all): 'first', 'last', 'first and last', 'all', or list of ints being reporting timestep numbers. Ignored if vdb_recurrent_properties is False
-        create_property_set (bool, default False): if True a resqml PropertySet is created
-    """
-
-    vdbase = vdb.VDB(vdb_file)
-    case_list = vdbase.cases()
-    assert len(case_list) > 0, 'no cases found in vdb'
-    if vdb_case is None:
-        vdb_case = case_list[0]
-    else:
-        assert vdb_case in case_list, 'case ' + vdb_case + ' not found in vdb: ' + vdb_file
-        vdbase.set_use_case(vdb_case)
-    grid_list = vdbase.list_of_grids()
-    index = 0
-    for grid_name in grid_list:
-        if grid_name.upper().startswith('SMALLGRIDS'):
-            log.warning('vdb import skipping small grids')
-            continue
-        log.debug('importing vdb data for grid ' + str(grid_name))
-        rqi.import_nexus(
-            resqml_file_root,
-            extent_ijk = extent_ijk if grid_name == 'ROOT' else None,  # 3 element numpy vector applicable to ROOT
-            vdb_file = vdb_file,
-            vdb_case = vdb_case,  # if None, first case in vdb is used (usually a vdb only holds one case)
-            corp_xy_units = corp_xy_units,
-            corp_z_units = corp_z_units,
-            corp_z_inc_down = corp_z_inc_down,
-            ijk_handedness = ijk_handedness,
-            geometry_defined_everywhere = geometry_defined_everywhere,
-            treat_as_nan = treat_as_nan,
-            resqml_xy_units = resqml_xy_units,
-            resqml_z_units = resqml_z_units,
-            resqml_z_inc_down = resqml_z_inc_down,
-            shift_to_local = shift_to_local,
-            local_origin_place = local_origin_place,  # 'centre' or 'minimum'
-            max_z_void = max_z_void,  # vertical gaps greater than this will introduce k gaps intp resqml grid
-            split_pillars = split_pillars,  # NB: some LGRs may be unsplit even if ROOT is split
-            split_tolerance = split_tolerance,  # applies to each of x, y, z differences
-            vdb_static_properties = vdb_static_properties,  # if True, static vdb properties are imported
-            vdb_recurrent_properties = vdb_recurrent_properties,
-            decoarsen = decoarsen,
-            timestep_selection = timestep_selection,
-            create_property_set = create_property_set,
-            grid_title = grid_name,
-            mode = 'w' if index == 0 else 'a')
-        index += 1