xtgeo 4.10.1__cp313-cp313-macosx_11_0_arm64.whl → 4.14.0__cp313-cp313-macosx_11_0_arm64.whl

xtgeo/grid3d/_grid_etc1.py

@@ -193,7 +193,8 @@ def get_dz(
     if not flip:
         result *= -1
 
-    result = np.ma.masked_array(result, self._actnumsv == 0 if asmasked else False)
+    if asmasked:
+        result = np.ma.masked_array(result, self._actnumsv == 0)
 
     return GridProperty(
         ncol=self._ncol,
@@ -305,27 +306,126 @@ def get_bulk_volume(
     )
 
 
+def get_phase_bulk_volumes(
+    grid: Grid,
+    water_contact: float | GridProperty,
+    gas_contact: float | GridProperty,
+    boundary: Polygons | None,
+    asmasked: bool = True,
+    precision: Literal[1, 2, 4] = 2,
+) -> tuple[GridProperty, GridProperty, GridProperty]:
+    """Return the geometric phase cell volume for all cells as three GridProperty object
+    namely gas_bulkvol, oil_bulkvol, water_bulkvol."""
+    if precision not in (1, 2, 4):
+        raise ValueError("The precision key has an invalid entry, use 1, 2, or 4")
+
+    grid._set_xtgformat2()
+
+    grid_cpp = grid._get_grid_cpp()
+
+    prec_cpp = _internal.geometry.HexVolumePrecision.P2
+    if precision == 1:
+        prec_cpp = _internal.geometry.HexVolumePrecision.P1
+    elif precision == 4:
+        prec_cpp = _internal.geometry.HexVolumePrecision.P4
+
+    polygon = None
+    if boundary is not None:
+        df_polygon = boundary.get_dataframe(copy=False)
+        # Extract X, Y, Z coordinates from the first polygon (POLY_ID == 0)
+        # assuming single polygon for now
+        df_polygon = df_polygon[df_polygon["POLY_ID"] == df_polygon["POLY_ID"].iloc[0]]
+        boundary_array = np.stack(
+            [
+                df_polygon["X_UTME"].values,
+                df_polygon["Y_UTMN"].values,
+                df_polygon["Z_TVDSS"].values,
+            ],
+            axis=1,
+        )
+        polygon = _internal.xyz.Polygon(boundary_array)
+
+    if isinstance(water_contact, (int, float)):
+        water_contact = GridProperty(grid, values=water_contact)
+    if isinstance(gas_contact, (int, float)):
+        gas_contact = GridProperty(grid, values=gas_contact)
+
+    assert np.all(water_contact.values >= gas_contact.values), (
+        "Water contact is position shallower than gas contact in some cells"
+    )
+
+    gas_volume, oil_volume, water_volume = grid_cpp.get_phase_cell_volumes(
+        water_contact.values,
+        gas_contact.values,
+        polygon,
+        prec_cpp,
+        asmasked,
+    )
+    if asmasked:
+        gas_volume = np.ma.masked_greater(gas_volume, UNDEF_LIMIT)
+        oil_volume = np.ma.masked_greater(oil_volume, UNDEF_LIMIT)
+        water_volume = np.ma.masked_greater(water_volume, UNDEF_LIMIT)
+
+    return (
+        GridProperty(
+            ncol=grid.ncol,
+            nrow=grid.nrow,
+            nlay=grid.nlay,
+            name="gas_bulkvol",
+            values=gas_volume,
+            discrete=False,
+        ),
+        GridProperty(
+            ncol=grid.ncol,
+            nrow=grid.nrow,
+            nlay=grid.nlay,
+            name="oil_bulkvol",
+            values=oil_volume,
+            discrete=False,
+        ),
+        GridProperty(
+            ncol=grid.ncol,
+            nrow=grid.nrow,
+            nlay=grid.nlay,
+            name="water_bulkvol",
+            values=water_volume,
+            discrete=False,
+        ),
+    )
+
+
 def get_heights_above_ffl(
     grid: Grid,
     ffl: GridProperty,
     option: Literal[
-        "cell_center_above_ffl", "cell_corners_above_ffl"
+        "cell_center_above_ffl",
+        "cell_corners_above_ffl",
+        "truncated_cell_corners_above_ffl",
     ] = "cell_center_above_ffl",
 ) -> tuple[GridProperty, GridProperty, GridProperty]:
     """Compute delta heights for cell top, bottom and midpoints above a given level."""
 
-    valid_options = ("cell_center_above_ffl", "cell_corners_above_ffl")
+    valid_options = (
+        "cell_center_above_ffl",
+        "cell_corners_above_ffl",
+        "truncated_cell_corners_above_ffl",
+    )
     if option not in valid_options:
         raise ValueError(
             f"The option key <{option}> is invalid, must be one of {valid_options}"
         )
+    if option == "cell_center_above_ffl":
+        option_flag = _internal.grid3d.HeightAboveFFLOption.CellCenter
+    elif option == "cell_corners_above_ffl":
+        option_flag = _internal.grid3d.HeightAboveFFLOption.CellCorners
+    else:
+        option_flag = _internal.grid3d.HeightAboveFFLOption.TruncatedCellCorners
 
     grid._set_xtgformat2()
 
     grid_cpp = grid._get_grid_cpp()
     htop_arr, hbot_arr, hmid_arr = grid_cpp.get_height_above_ffl(
-        ffl.values.ravel(),
-        1 if option == "cell_center_above_ffl" else 2,
+        ffl.values.ravel(), option_flag
     )
 
     htop = GridProperty(
@@ -1053,13 +1153,18 @@ def inactivate_inside(
         raise RuntimeError("Problems with one or more polygons. Not closed?")
 
 
-def collapse_inactive_cells(self: Grid) -> None:
+def collapse_inactive_cells(self: Grid, internal: bool = True) -> None:
     """Collapse inactive cells."""
-    self._set_xtgformat1()
+    logger.debug("Collapsing inactive cells...")
+    self._set_xtgformat2()
 
-    _cxtgeo.grd3d_collapse_inact(
-        self.ncol, self.nrow, self.nlay, self._zcornsv, self._actnumsv
-    )
+    grid_cpp = _internal.grid3d.Grid(self)
+    new_zcornsv = grid_cpp.collapse_inactive_cells(collapse_internal=internal)
+
+    if new_zcornsv is not None:
+        self._zcornsv = new_zcornsv
+
+    logger.debug("Collapsing inactive cells done")
 
 
 def copy(self: Grid) -> Grid:
@@ -1242,85 +1347,86 @@ def reduce_to_one_layer(self: Grid) -> None:
     self._subgrids = None
 
 
-def translate_coordinates(
-    self: Grid,
-    translate: tuple[float, float, float] = (0.0, 0.0, 0.0),
-    flip: tuple[int, int, int] = (1, 1, 1),
+def reverse_row_axis(
+    self: Grid, ijk_handedness: Literal["left", "right"] | None = None
 ) -> None:
-    """Translate grid coordinates."""
-    self._set_xtgformat1()
+    """Flip the row-axis for xtgformat=2 grid arrays.
 
-    tx, ty, tz = translate
-    fx, fy, fz = flip
+    This reverses the J-direction (rows) by flipping along axis 1 for both
+    coordsv and zcornsv arrays, and also handles the corner ordering within
+    each pillar to maintain proper geometry.
+    """
+    if ijk_handedness == self.ijk_handedness:
+        return
 
-    ier = _cxtgeo.grd3d_translate(
-        self._ncol,
-        self._nrow,
-        self._nlay,
-        fx,
-        fy,
-        fz,
-        tx,
-        ty,
-        tz,
-        self._coordsv,
-        self._zcornsv,
-    )
-    if ier != 0:
-        raise RuntimeError(f"Something went wrong in translate, code: {ier}")
+    self._set_xtgformat2()
 
-    logger.info("Translation of coords done")
+    # Flip coordsv along the row axis (axis 1) and make contiguous with copy()
+    self._coordsv = np.flip(self._coordsv, axis=1).copy()
 
+    # For zcornsv, we need to flip along row axis and also swap corner ordering
+    # Original corner order: SW, SE, NW, NE (indices 0,1,2,3)
+    # After row flip: NW, NE, SW, SE (should become indices 0,1,2,3)
+    # So we need to rearrange: [2,3,0,1]
+    zcorns_flipped = np.flip(self._zcornsv, axis=1)  # Flip along row axis
+    self._zcornsv = zcorns_flipped[:, :, :, [2, 3, 0, 1]].copy()  # Reorder corners
 
-def reverse_row_axis(
-    self: Grid, ijk_handedness: Literal["left", "right"] | None = None
-) -> None:
-    """Reverse rows (aka flip) for geometry and assosiated properties."""
-    if ijk_handedness == self.ijk_handedness:
-        return
+    # Also flip actnum along row axis
+    self._actnumsv = np.flip(self._actnumsv, axis=1).copy()
 
-    # update the handedness
-    if ijk_handedness is None:
-        self._ijk_handedness = estimate_handedness(self)
+    # Update handedness
+    if self._ijk_handedness == "left":
+        self._ijk_handedness = "right"
+    else:
+        self._ijk_handedness = "left"
 
-    original_handedness = self._ijk_handedness
-    original_xtgformat = self._xtgformat
+    # Handle properties if they exist
+    if self._props and self._props.props:
+        for prop in self._props.props:
+            prop.values = np.flip(prop.values, axis=1).copy()
 
-    self._set_xtgformat1()
+    logger.info("Reversing of row axis done")
 
-    ier = _cxtgeo.grd3d_reverse_jrows(
-        self._ncol,
-        self._nrow,
-        self._nlay,
-        self._coordsv.ravel(),
-        self._zcornsv.ravel(),
-        self._actnumsv.ravel(),
-    )
 
-    if ier != 0:
-        raise RuntimeError(f"Something went wrong in jswapping, code: {ier}")
+def reverse_column_axis(
+    self: Grid, ijk_handedness: Literal["left", "right"] | None = None
+) -> None:
+    """Flip the column-axis for xtgformat=2 grid arrays.
 
-    if self._props is None:
+    This reverses the I-direction (columns) by flipping along axis 0 for both
+    coordsv and zcornsv arrays, and also handles the corner ordering within
+    each pillar to maintain proper geometry.
+    """
+    if ijk_handedness == self.ijk_handedness:
         return
 
-    # do it for properties
-    if self._props.props:
-        for prp in self._props.props:
-            prp.values = prp.values[:, ::-1, :]
+    self._set_xtgformat2()
+
+    # Flip coordsv along the column axis (axis 0) and make contiguous with copy()
+    self._coordsv = np.flip(self._coordsv, axis=0).copy()
 
-    # update the handedness
-    if ijk_handedness is None:
-        self._ijk_handedness = estimate_handedness(self)
+    # For zcornsv, we need to flip along column axis and also swap corner ordering
+    # Original corner order: SW, SE, NW, NE (indices 0,1,2,3)
+    # After column flip: SE, SW, NE, NW (should become indices 0,1,2,3)
+    # So we need to rearrange: [1,0,3,2]
+    zcorns_flipped = np.flip(self._zcornsv, axis=0)  # Flip along column axis
+    self._zcornsv = zcorns_flipped[:, :, :, [1, 0, 3, 2]].copy()  # Reorder corners
 
-    if original_handedness == "left":
+    # Also flip actnum along column axis
+    self._actnumsv = np.flip(self._actnumsv, axis=0).copy()
+
+    # Update handedness
+    if self._ijk_handedness == "left":
         self._ijk_handedness = "right"
     else:
         self._ijk_handedness = "left"
 
-    if original_xtgformat == 2:
-        self._set_xtgformat2()
+    # Handle properties if they exist
+    if self._props and self._props.props:
+        for prop in self._props.props:
+            prop.values = np.flip(prop.values, axis=0).copy()
 
-    logger.info("Reversing of rows done")
+    logger.info("Reversing of column axis done")
 
 
 def get_adjacent_cells(
@@ -1383,7 +1489,10 @@ def estimate_design(
     """Estimate (guess) (sub)grid design by examing DZ in median thickness column."""
     actv = self.get_actnum().values
 
-    dzv = self.get_dz(asmasked=False).values
+    dzv_raw = self.get_dz(asmasked=False).values
+    # Although asmasked is False the array values will still be a masked numpy
+    # Need to convert to an ordinary numpy to avoid warnings later
+    dzv = np.ma.filled(dzv_raw, fill_value=0.0)
 
     # treat inactive thicknesses as zero
     dzv[actv == 0] = 0.0
@@ -1400,6 +1509,11 @@ def estimate_design(
     # find cumulative thickness as a 2D array
     dzcum: np.ndarray = np.sum(dzv, axis=2, keepdims=False)
 
+    # Ensure dzcum is a regular numpy array to avoid warnings
+    if isinstance(dzcum, np.ma.MaskedArray):
+        dzcum = np.ma.filled(dzcum, fill_value=0.0)
+    dzcum = np.asarray(dzcum)
+
     # find the average thickness for nonzero thicknesses
     dzcum2 = dzcum.copy()
     dzcum2[dzcum == 0.0] = np.nan

xtgeo/grid3d/_grid_export.py

@@ -49,10 +49,11 @@ def export_roff(
         )
 
 
-def export_grdecl(grid: Grid, gfile: FileLike, mode: int) -> None:
-    """Export grid to Eclipse GRDECL format (ascii, mode=1) or binary (mode=0)."""
+def export_grdecl(grid: Grid, gfile: FileLike, mode: int, rle: bool = False) -> None:
+    """Export grid to Eclipse GRDECL format (ascii, mode=1) or binary (mode=0).
+    Optionally for ASCII GRDECL, run-length encoding RLE can be applied"""
     fileformat = "grdecl" if mode == 1 else "bgrdecl"
-    GrdeclGrid.from_xtgeo_grid(grid).to_file(gfile, fileformat=fileformat)
+    GrdeclGrid.from_xtgeo_grid(grid).to_file(gfile, fileformat=fileformat, rle=rle)
 
 
 def export_egrid(grid: Grid, gfile: FileLike) -> None:

xtgeo/grid3d/_grid_hybrid.py

@@ -4,9 +4,8 @@ from typing import TYPE_CHECKING
 
 import numpy as np
 
-from xtgeo import _cxtgeo
+import xtgeo._internal as _internal  # type: ignore
 from xtgeo.common import null_logger
-from xtgeo.common.constants import UNDEF_INT
 
 logger = null_logger(__name__)
 
@@ -23,44 +22,29 @@ def make_hybridgrid(
     region_number: int | None = None,
 ) -> None:
     """Make hybrid grid."""
-    self._set_xtgformat1()
+    self._set_xtgformat2()
 
     newnlay = self.nlay * 2 + nhdiv
-    newnzcorn = self.ncol * self.nrow * (newnlay + 1) * 4
-    newnactnum = self.ncol * self.nrow * newnlay
 
-    # initialize
-    hyb_zcornsv = np.zeros(newnzcorn, dtype=np.float64)
-    hyb_actnumsv = np.zeros(newnactnum, dtype=np.int32)
-
-    if region is None:
-        region_number = -1
-        rvalues = np.ones(1, dtype=np.int32)
-    else:
-        rvalues = np.ma.filled(region.values, fill_value=UNDEF_INT)
-        rvalues = rvalues.ravel()
-
-    _cxtgeo.grd3d_convert_hybrid(
-        self.ncol,
-        self.nrow,
-        self.nlay,
-        self._coordsv,
-        self._zcornsv,
-        self._actnumsv,
-        newnlay,
-        hyb_zcornsv,
-        hyb_actnumsv,
+    grid3d_cpp = _internal.grid3d.Grid(self)
+    region_array = (
+        region.values.astype(np.int32)
+        if region
+        else np.empty((0, 0, 0), dtype=np.int32)
+    )
+    hyb_zcornsv, hyb_actnumsv = grid3d_cpp.convert_to_hybrid_grid(
         toplevel,
         bottomlevel,
         nhdiv,
-        rvalues,
-        region_number,
+        region_array,
+        int(region_number) if region_number is not None else -1,
     )
 
     # when a hybridgrid is made, the current subrid settings lose relevance, hence
     # it is forced set to None
     self.subgrids = None
 
+    # update the grid in place
     self._nlay = newnlay
     self._zcornsv = hyb_zcornsv
-    self._actnumsv = hyb_actnumsv
+    self._actnumsv = hyb_actnumsv.astype(np.int32)

xtgeo/grid3d/_grid_refine.py

@@ -243,7 +243,7 @@ def refine_vertically(
     # update instance:
     self._nlay = newnlay
     self._zcornsv = ref_zcornsv
-    self._actnumsv = ref_actnumsv
+    self._actnumsv = ref_actnumsv.astype(np.int32)
 
     if self.subgrids is None or len(self.subgrids) <= 1:
         self.subgrids = None

xtgeo/grid3d/_grid_translate_coords.py

@@ -0,0 +1,154 @@
+"""Private module for translating coordiantes plus flipping and rotation."""
+
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d import Grid
+
+
+def _rotate_grid3d(
+    new_grd: Grid, add_rotation: float, rotation_xy: tuple[float, float] | None = None
+) -> None:
+    """Rotate the grid around the cell 1,1,1 corner, or some other coordinate."""
+
+    # Convert angle to radians
+    angle_rad = math.radians(add_rotation)
+
+    # Create rotation matrix coefficients
+    cos_theta = math.cos(angle_rad)
+    sin_theta = math.sin(angle_rad)
+
+    # extract
+    coord_array = new_grd._coordsv.copy()
+    rotated_coords = coord_array.copy()
+
+    if rotation_xy is None:
+        x0, y0, _ = new_grd._coordsv[0, 0, :3]
+    else:
+        x0, y0 = rotation_xy
+
+    x_coords = coord_array[:, :, [0, 3]].copy()  # x1 and x2
+    y_coords = coord_array[:, :, [1, 4]].copy()  # y1 and y2
+
+    # Translate to origin
+    x_translated = x_coords - x0
+    y_translated = y_coords - y0
+
+    # Rotate using rotation matrix
+    x_rotated = x_translated * cos_theta - y_translated * sin_theta
+    y_rotated = x_translated * sin_theta + y_translated * cos_theta
+
+    # Translate back and assign
+    rotated_coords[:, :, [0, 3]] = x_rotated + x0
+    rotated_coords[:, :, [1, 4]] = y_rotated + y0
+
+    # Z coordinates remain unchanged (indices 2 and 5)
+    new_grd._coordsv = rotated_coords.copy()
+
+
+def _flip_vertically(grid: Grid) -> None:
+    """Flip the grid vertically."""
+
+    # find average depth of corners
+    avg_z = grid._zcornsv.mean()
+
+    grid._zcornsv = grid._zcornsv[:, :, ::-1, :]
+    grid._zcornsv *= -1
+
+    # find the new average and compute the difference for shifting
+    new_avg_z = grid._zcornsv.mean()
+    diff = avg_z - new_avg_z
+    grid._zcornsv += diff
+
+    grid._actnumsv = np.flip(grid._actnumsv, axis=2).copy()
+
+    # Handle properties if they exist
+    if grid._props and grid._props.props:
+        for prop in grid._props.props:
+            prop.values = np.flip(prop.values, axis=2).copy()
+
+    # When we flip the grid, the subgrid info must also be flipped
+    subgrids = grid.get_subgrids()
+    if subgrids:
+        reverted = dict(reversed(subgrids.items()))
+        grid.set_subgrids(reverted)
+
+    if grid._ijk_handedness == "left":
+        grid._ijk_handedness = "right"
+    else:
+        grid._ijk_handedness = "left"
+
+
+def _translate_geometry(grid: Grid, translate: tuple[float, float, float]) -> None:
+    grid._coordsv[:, :, 0] += translate[0]
+    grid._coordsv[:, :, 1] += translate[1]
+    grid._coordsv[:, :, 2] += translate[2]
+    grid._coordsv[:, :, 3] += translate[0]
+    grid._coordsv[:, :, 4] += translate[1]
+    grid._coordsv[:, :, 5] += translate[2]
+
+    grid._zcornsv += translate[2]
+
+
+def _transfer_to_target(grid: Grid, target: tuple[float, float, float]) -> None:
+    # get the coordinates for the active cells
+    x, y, z = grid.get_xyz(asmasked=True)
+
+    # set the grid center to the desired target coordinates
+    shift_x = target[0] - x.values.mean()
+    shift_y = target[1] - y.values.mean()
+    shift_z = target[2] - z.values.mean()
+
+    _translate_geometry(grid, (shift_x, shift_y, shift_z))
+
+
+def translate_coordinates(
+    self: Grid,
+    translate: tuple[float, float, float] = (0.0, 0.0, 0.0),
+    flip: tuple[int, int, int] = (1, 1, 1),
+    add_rotation: float = 0.0,
+    rotation_point: tuple[float, float] | None = None,
+    target_coordinates: tuple[float, float, float] | None = None,
+) -> None:
+    """Rotate, flip grid and translate grid coordinates.
+
+    This should be done in a sequence like this
+    1) Add rotation (with value ``add_rotation``) to rotate the grid counter-clockwise
+    2) Flip the grid
+    3a) translate the grid by adding (x, y, z), OR
+    3b) set a target location the grid centre.
+
+    """
+    self._set_xtgformat2()
+
+    if abs(add_rotation) > 1e-10:  # Skip rotation if angle is essentially zero
+        _rotate_grid3d(self, add_rotation, rotation_xy=rotation_point)
+
+    if flip[2] == -1:
+        _flip_vertically(self)
+
+    if flip[0] == -1:
+        self.reverse_column_axis()
+
+    if flip[1] == -1:
+        self.reverse_row_axis()
+
+    use_translate = False
+    if not all(abs(x) < 1e-10 for x in translate):
+        _translate_geometry(self, translate)
+        use_translate = True
+
+    if target_coordinates and use_translate:
+        raise ValueError(
+            "Using both key 'translate' and key 'target_coordinates' is not allowed. "
+            "Use either."
+        )
+
+    if target_coordinates:
+        # transfer the grid's geometrical centre to a given location
+        _transfer_to_target(self, target_coordinates)

xtgeo/grid3d/_gridprop_export.py

@@ -17,6 +17,7 @@ from xtgeo.common.exceptions import InvalidFileFormatError
 from xtgeo.common.log import null_logger
 from xtgeo.io._file import FileFormat, FileWrapper
 
+from ._grdecl_format import run_length_encoding
 from ._roff_parameter import RoffParameter
 
 if TYPE_CHECKING:
@@ -37,6 +38,7 @@ def to_file(
     append: bool = False,
     dtype: type[np.float32] | type[np.float64] | type[np.int32] | None = None,
     fmt: str | None = None,
+    rle: bool = False,
 ) -> None:
     """Export the grid property to file."""
     logger.debug("Export property to file %s as %s", pfile, fformat)
@@ -62,6 +64,7 @@ def to_file(
             append=append,
             binary=binary,
             fmt=fmt,
+            rle=rle,
         )
     elif fformat == "xtgcpprop":
         _export_xtgcpprop(gridprop, xtg_file.name)
@@ -104,6 +107,7 @@ def _export_grdecl(
     append: bool = False,
     binary: bool = False,
     fmt: str | None = None,
+    rle: bool = False,
 ) -> None:
     """Export ascii or binary GRDECL"""
     vals: npt.NDArray = gridprop.values.ravel(order="F")
@@ -132,18 +136,36 @@ def _export_grdecl(
         else:
             # Always the case when not binary
             assert isinstance(fout, io.TextIOWrapper)
-            fout.write(name)
-            fout.write("\n")
-            for i, v in enumerate(vals):
-                fout.write(" ")
-                if fmt:
-                    fout.write(fmt % v)
-                elif gridprop.isdiscrete:
-                    fout.write(str(v))
-                else:
-                    fout.write(f"{v:3e}")
-                if i % 6 == 5:
-                    fout.write("\n")
+            fout.write(f"{name}\n")
+            if rle:
+                counts, unique_values = run_length_encoding(vals)
+                for i, (count, unique_value) in enumerate(zip(counts, unique_values)):
+                    fout.write(" ")
+                    if fmt:
+                        formatted_value = fmt % unique_value
+                    elif gridprop.isdiscrete:
+                        formatted_value = str(unique_value)
+                    else:
+                        formatted_value = f"{unique_value:3e}"
+                    if count > 1:
+                        # Try to preserve the alignment
+                        text_width = len(formatted_value)
+                        new_text = f"{count}*{formatted_value.lstrip()}"
+                        formatted_value = " " * (text_width - len(new_text)) + new_text
+                    fout.write(formatted_value)
+                    if i % 6 == 5:
+                        fout.write("\n")
+            else:
+                for i, v in enumerate(vals):
+                    fout.write(" ")
+                    if fmt:
+                        fout.write(fmt % v)
+                    elif gridprop.isdiscrete:
+                        fout.write(str(v))
+                    else:
+                        fout.write(f"{v:3e}")
+                    if i % 6 == 5:
+                        fout.write("\n")
             fout.write(" /\n")