subscript 1.14.6__tar.gz → 1.15.0__tar.gz

{subscript-1.14.6 → subscript-1.15.0}/.github/workflows/codecov.yml

@@ -60,6 +60,6 @@ jobs:
         pytest tests --disable-warnings --cov=subscript --cov-report=xml
 
     - name: Upload coverage to Codecov
-      uses: codecov/codecov-action@v5
+      uses: codecov/codecov-action@v6
       with:
         token: ${{ secrets.CODECOV_TOKEN }}

{subscript-1.14.6 → subscript-1.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subscript
-Version: 1.14.6
+Version: 1.15.0
 Summary: Equinor's collection of subsurface reservoir modelling scripts
 Author-email: Equinor <rnyb@equinor.com>
 License-Expression: GPL-3.0-only
@@ -26,6 +26,7 @@ Requires-Dist: resdata
 Requires-Dist: res2df
 Requires-Dist: ert>=10.2.0b13
 Requires-Dist: fmu-tools
+Requires-Dist: gaussianfft
 Requires-Dist: grid3d_maps
 Requires-Dist: jinja2
 Requires-Dist: matplotlib

{subscript-1.14.6 → subscript-1.15.0}/pyproject.toml

@@ -38,6 +38,7 @@ dependencies = [
     "res2df",
     "ert>=10.2.0b13",
     "fmu-tools",
+    "gaussianfft",
     "grid3d_maps",
     "jinja2",
     "matplotlib",
@@ -214,6 +215,7 @@ ignore = [
     "PLR0904", # too-many-public-methods
     "PLR1702", # too-many-nested-blocks
     "RUF067",  # non empty init module
+    "RUF069",  # unreliable-floating-point-equality
     "PLC1901",  # compare-to-empty-string
 ]
 

{subscript-1.14.6 → subscript-1.15.0}/src/subscript/eclcompress/eclcompress.py

@@ -154,7 +154,7 @@ def file_is_binary(filename: str | Path) -> bool:
     Args:
         filename: File to check
     """
-    # https://stackoverflow.com/questions/898669/how-can-i-detect-if-a-file-is-binary-non-text-in-python  # noqa
+    # https://stackoverflow.com/questions/898669/how-can-i-detect-if-a-file-is-binary-non-text-in-python
     textchars = bytearray({7, 8, 9, 10, 12, 13, 27} | set(range(0x20, 0x100)) - {0x7F})
     with open(filename, "rb") as filehandle:
         return bool(filehandle.read(1024).translate(None, textchars))

{subscript-1.14.6 → subscript-1.15.0}/src/subscript/field_statistics/field_statistics.py

@@ -1080,6 +1080,7 @@ def get_specifications(
         use_population_stdev = input_dict[key]
 
     use_geogrid_fields = False
+    geogrid_name = None
     zone_names_used = None
     zone_conformity = None
     zone_code_names = None
@@ -1339,6 +1340,11 @@ def calc_stats(
     if not use_geogrid_fields:
         return
 
+    # Get list of active realization (Must be active for all iterations in iter_list)
+    active_real, number_of_skipped = get_active_real(
+        iter_list, ens_path, nreal, geogrid_name
+    )
+
     ensemble_path = ens_path
 
     logger.info(f"Number of realizations: {nreal}")
@@ -1356,8 +1362,8 @@ def calc_stats(
                         (ertbox_size[0], ertbox_size[1], ertbox_size[2], nreal),
                         dtype=np.float32,
                     )
-                    number_of_skipped = 0
-                    for real_number in range(nreal):
+
+                    for real_number in active_real:
                         grid_dimensions, subgrids, property_param = (
                             read_ensemble_realization(
                                 ensemble_path,
@@ -1368,11 +1374,7 @@ def calc_stats(
                                 geogrid_name,
                             )
                         )
-                        if grid_dimensions is None:
-                            txt = f" Skip non-existing realization: {real_number}"
-                            logger.info(txt)
-                            number_of_skipped += 1
-                            continue
+                        assert grid_dimensions is not None
                         ertbox_prop_values = get_values_in_ertbox(
                             grid_dimensions,
                             subgrids,
@@ -1445,8 +1447,8 @@ def calc_stats(
                         (ertbox_size[0], ertbox_size[1], ertbox_size[2], nreal),
                         dtype=np.int32,
                     )
-                    number_of_skipped = 0
-                    for real_number in range(nreal):
+
+                    for real_number in active_real:
                         grid_dimensions, subgrids, property_param = (
                             read_ensemble_realization(
                                 ensemble_path,
@@ -1457,11 +1459,7 @@ def calc_stats(
                                 geogrid_name,
                             )
                         )
-
-                        if grid_dimensions is None:
-                            logger.info(f" Skip realization: {real_number}")
-                            number_of_skipped += 1
-                            continue
+                        assert grid_dimensions is not None
                         ertbox_prop_values = get_values_in_ertbox(
                             grid_dimensions,
                             subgrids,
@@ -1576,7 +1574,8 @@ def calc_temporary_field_stats(
     # Check if any need to continue to calculation
     if not use_temporary_fields:
         return
-
+    # Get list of active realization (Must be active for all iterations in iter_list)
+    active_real, number_of_skipped = get_active_real(iter_list, ens_path, nreal)
     # Import realizations of temporary field parameters
     for param_name in param_list:
         for iteration in iter_list:
@@ -1590,9 +1589,7 @@ def calc_temporary_field_stats(
                 (ertbox_size[0], ertbox_size[1], ertbox_size[2], nreal),
                 dtype=np.float32,
             )
-
-            number_of_skipped = 0
-            for real_number in range(nreal):
+            for real_number in active_real:
                 filepath = (
                     ens_path
                     / Path(
@@ -1600,11 +1597,7 @@ def calc_temporary_field_stats(
                     )
                     / Path(full_param_filename)
                 )
-                if not filepath.exists():
-                    txt = f" Skip non-existing realization: {real_number}"
-                    logger.info(txt)
-                    number_of_skipped += 1
-                    continue
+                assert filepath.exists()
                 property = xtgeo.gridproperty_from_file(filepath, fformat="roff")
                 values = property.values
                 all_values[:, :, :, real_number] = values
@@ -1657,6 +1650,38 @@ def calc_temporary_field_stats(
                 xtgeo_ertbox_stdev.to_file(result_stdev_file_path, fformat="roff")
 
 
+def get_active_real(
+    iter_list: list, ens_path: Path, nreal: int, geogrid_name: str = ""
+):
+    """Get a list of active realizations"""
+    number_of_skipped = 0
+    active_real = []
+    for real_number in range(nreal):
+        real_exist = True
+        for iteration in iter_list:
+            ensemble_path = ens_path / Path(
+                "realization-" + str(real_number) + "/iter-" + str(iteration)
+            )
+            if len(geogrid_name) > 0:
+                grid_path = Path("share/results/grids/" + geogrid_name + ".roff")
+                file_path_grid = ensemble_path / grid_path
+                txt = f" Skip non-existing realization of grid: {real_number}"
+            else:
+                file_path_grid = ensemble_path
+                txt = f" Skip non-existing realization: {real_number}"
+            if not file_path_grid.exists():
+                logger.info(txt)
+                number_of_skipped += 1
+                # No need to check other iterations since active_real should
+                # only be those realizations that exists for all specified
+                # iterations in iter_list
+                real_exist = False
+                continue
+        if real_exist:
+            active_real.append(real_number)
+    return active_real, number_of_skipped
+
+
 def generate_script(
     rms_load_script, ert_config_path, result_path, field_stat_config_file
 ):
@@ -1853,25 +1878,47 @@ def main():
         if init_path and param_names:
             for param_name in param_names:
                 for iteration in iter_list:
-                    new_name = "mean_" + param_name + "_" + str(iteration)
-                    param_file_name = Path(result_path) / Path(new_name + ".roff")
-                    prop_param = xtgeo.gridproperty_from_file(
-                        param_file_name, fformat="roff"
+                    mean_name = "mean_" + param_name + "_" + str(iteration)
+                    std_name = "stdev_" + param_name + "_" + str(iteration)
+
+                    mean_param_file_name = Path(result_path) / Path(mean_name + ".roff")
+                    mean_prop_param = xtgeo.gridproperty_from_file(
+                        mean_param_file_name, fformat="roff"
                     )
-                    print(f"Read: {{new_name}} into {{GRIDNAME}}")
-                    if label:
-                        new_name = new_name + "_" + label
-                    prop_param.to_roxar(PRJ, GRIDNAME, new_name)
+                    print(f"Read: {{mean_name}} into {{GRIDNAME}}")
 
-                    new_name = "stdev_" + param_name + "_" + str(iteration)
-                    param_file_name = Path(result_path) / Path(new_name + ".roff")
-                    prop_param = xtgeo.gridproperty_from_file(
-                        param_file_name, fformat="roff"
+                    std_param_file_name = Path(result_path) / Path(std_name + ".roff")
+                    std_prop_param = xtgeo.gridproperty_from_file(
+                        std_param_file_name, fformat="roff"
                     )
-                    print(f"Read: {{new_name}} into {{GRIDNAME}}")
+                    print(f"Read: {{std_name}} into {{GRIDNAME}}")
+
                     if label:
-                        new_name = new_name + "_" + label
-                    prop_param.to_roxar(PRJ, GRIDNAME, new_name)
+                        new_mean_name = mean_name + "_" + label
+                        new_std_name = std_name + "_" + label
+                        difference_mean_name = "diff_" + new_mean_name
+                        difference_std_name = "diff_" + new_std_name
+
+                    mean_prop_param.to_roxar(PRJ, GRIDNAME, new_mean_name)
+                    std_prop_param.to_roxar(PRJ, GRIDNAME, new_std_name)
+
+                    if iteration == iter_list[0]:
+                        # Init
+                        mean_prop_param_init = mean_prop_param
+                        std_prop_param_init = std_prop_param
+                    elif iteration == iter_list[-1]:
+                        mean_prop_param_upd = mean_prop_param
+                        std_prop_param_upd = std_prop_param
+                        diff_mean_prop_param = mean_prop_param_upd.copy()
+                        diff_std_prop_param = std_prop_param_upd.copy()
+                        diff_mean_prop_param.values = \
+                            mean_prop_param_upd.values - mean_prop_param_init.values
+                        diff_std_prop_param.values = \
+                            std_prop_param_upd.values - std_prop_param_init.values
+                        diff_mean_prop_param.to_roxar(PRJ,
+                            GRIDNAME, difference_mean_name)
+                        diff_std_prop_param.to_roxar(PRJ,
+                            GRIDNAME, difference_std_name)
 
 if __name__ == "__main__":
     main()

{subscript-1.14.6 → subscript-1.15.0}/src/subscript/fmuobs/fmuobs.py

@@ -335,10 +335,10 @@ def fmuobs(
                     starttime=starttime,
                 )
         else:
-            dframe = ertobs2df(input_str, cwd=includedir)
+            dframe = ertobs2df(input_str, cwd=includedir, starttime=starttime)
 
     if starttime:
-        dframe = compute_date_from_days(dframe)
+        dframe = compute_date_from_days(dframe, starttime=starttime)
 
     if not validate_internal_dframe(dframe):
         logger.error("Observation dataframe is invalid!")

subscript-1.15.0/src/subscript/restartthinner/restartthinner.py

@@ -0,0 +1,249 @@
+"""Restart file (UNRST) thinner, command line application"""
+
+import argparse
+import datetime
+import logging
+import shutil
+import subprocess
+import tempfile
+from contextlib import chdir
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from resdata.resfile import ResdataFile
+
+from subscript import __version__, getLogger
+
+logger = getLogger(__name__)
+
+DESCRIPTION = """
+Slice a subset of restart-dates from an E100 Restart file (UNRST)
+
+Example::
+
+    $ restartthinner --restarts 4 ECLIPSE.UNRST
+
+where four restarts evenly spread out in relevant dates will be picked and
+written to the same filename (keeping the original is optional)
+"""
+
+
+def find_resdata_app(toolname: str) -> str:
+    """Locate path of resdata apps, trying common suffixes (.x, .c.x, .cpp.x).
+
+    Args:
+        toolname: Base name of the tool (e.g., 'rd_unpack')
+
+    Returns:
+        Full path to the executable.
+
+    Raises:
+        OSError: If tool cannot be found in PATH.
+    """
+    for ext in [".x", ".c.x", ".cpp.x", ""]:  # Order matters.
+        if path := shutil.which(toolname + ext):
+            return path
+    raise OSError(f"{toolname} not found in PATH")
+
+
+def date_slicer(
+    slicedates: list[pd.Timestamp],
+    restartdates: list[datetime.datetime],
+    restartindices: list[int],
+) -> list[int]:
+    """Make a list of report indices that match the input slicedates."""
+    slicedatelist = []
+    for slicedate in slicedates:
+        daydistances = [abs((pd.Timestamp(slicedate) - x).days) for x in restartdates]
+        slicedatelist.append(restartindices[daydistances.index(min(daydistances))])
+    return slicedatelist
+
+
+def rd_repacker(rstfilename: str, slicerstindices: list[int], quiet: bool) -> None:
+    """Repack a UNRST file keeping only selected restart indices.
+
+    Uses rd_unpack and rd_pack utilities from resdata to unpack the UNRST file,
+    remove unwanted dates, and repack into a new UNRST file.
+
+    Args:
+        rstfilename: Path to the UNRST file.
+        slicerstindices: List of restart indices to keep.
+        quiet: If True, suppress subprocess output.
+
+    Raises:
+        OSError: If rd_unpack or rd_pack tools are not found.
+    """
+    rd_unpack = find_resdata_app("rd_unpack")
+    rd_pack = find_resdata_app("rd_pack")
+
+    rstpath = Path(rstfilename)
+    rstdir = rstpath.parent or Path(".")
+    rstname = rstpath.name
+
+    with chdir(rstdir):
+        tempdir = Path(tempfile.mkdtemp(dir="."))
+        try:
+            # Move UNRST into temp directory and work there
+            shutil.move(rstname, tempdir / rstname)
+
+            with chdir(tempdir):
+                subprocess.run(
+                    [rd_unpack, rstname],
+                    stdout=subprocess.DEVNULL if quiet else None,
+                    check=True,
+                )
+
+                for file in Path(".").glob("*.X*"):
+                    index = int(file.suffix.lstrip(".X"))
+                    if index not in slicerstindices:
+                        file.unlink()
+
+                remaining_files = sorted(Path(".").glob("*.X*"))
+                subprocess.run(
+                    [rd_pack, *[str(f) for f in remaining_files]],
+                    stdout=subprocess.DEVNULL if quiet else None,
+                    check=True,
+                )
+
+                # Move result back up
+                shutil.move(rstname, Path("..") / rstname)
+        finally:
+            shutil.rmtree(tempdir)
+
+
+def get_restart_indices(rstfilename: str) -> list[int]:
+    """Extract a list of restart indices for a filename.
+
+    Args:
+        rstfilename: Path to the UNRST file.
+
+    Returns:
+        List of restart report indices.
+
+    Raises:
+        FileNotFoundError: If the file does not exist.
+    """
+    if Path(rstfilename).exists():
+        # This function segfaults if file does not exist
+        return ResdataFile.file_report_list(str(rstfilename))
+    raise FileNotFoundError(f"{rstfilename} not found")
+
+
+def restartthinner(
+    filename: str,
+    numberofslices: int,
+    quiet: bool = False,
+    dryrun: bool = True,
+    keep: bool = False,
+) -> None:
+    """Thin an existing UNRST file to selected number of restarts.
+
+    Args:
+        filename: Path to the UNRST file.
+        numberofslices: Number of restart dates to keep.
+        quiet: If True, suppress informational output.
+        dryrun: If True, only show what would be done without modifying files.
+        keep: If True, keep original file with .orig suffix.
+    """
+    rst = ResdataFile(filename)
+    restart_indices = get_restart_indices(filename)
+    restart_dates = [
+        rst.iget_restart_sim_time(index) for index in range(len(restart_indices))
+    ]
+
+    if numberofslices > 1:
+        slicedates = pd.DatetimeIndex(
+            np.linspace(
+                pd.Timestamp(restart_dates[0]).value,
+                pd.Timestamp(restart_dates[-1]).value,
+                int(numberofslices),
+            )
+        ).to_list()
+    else:
+        slicedates = [restart_dates[-1]]  # Only return last date if only one is wanted
+
+    slicerstindices = date_slicer(slicedates, restart_dates, restart_indices)
+    slicerstindices = sorted(set(slicerstindices))  # uniquify
+
+    if not quiet:
+        logger.info("Selected restarts:")
+        logger.info("-----------------------")
+        for idx, rstidx in enumerate(restart_indices):
+            slicepresent = "X" if rstidx in slicerstindices else ""
+            logger.info(
+                "%4d  %s  %s",
+                rstidx,
+                datetime.date.strftime(restart_dates[idx], "%Y-%m-%d"),
+                slicepresent,
+            )
+        logger.info("-----------------------")
+
+    if not dryrun:
+        if keep:
+            backupname = filename + ".orig"
+            logger.info("Backing up %s to %s", filename, backupname)
+            shutil.copyfile(filename, backupname)
+        rd_repacker(filename, slicerstindices, quiet)
+        logger.info("Written to %s", filename)
+
+
+def get_parser() -> argparse.ArgumentParser:
+    """Setup parser"""
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter, description=DESCRIPTION
+    )
+    parser.add_argument("UNRST", help="Name of UNRST file")
+    parser.add_argument(
+        "-n",
+        "--restarts",
+        type=int,
+        help="Number of restart dates wanted",
+        required=True,
+    )
+    parser.add_argument(
+        "-d",
+        "--dryrun",
+        action="store_true",
+        default=False,
+        help="Dry-run only, do not touch files",
+    )
+    parser.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        default=False,
+        help="Mute output from script",
+    )
+    parser.add_argument(
+        "-k",
+        "--keep",
+        action="store_true",
+        default=False,
+        help="Keep original UNRST file",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version="%(prog)s (subscript version " + __version__ + ")",
+    )
+    return parser
+
+
+def main() -> None:
+    """Endpoint for command line script."""
+    parser = get_parser()
+    args = parser.parse_args()
+
+    if args.restarts <= 0:
+        parser.error("Number of restarts must be a positive number")
+    if args.UNRST.endswith(".DATA"):
+        parser.error("Provide the UNRST file, not the DATA file")
+    if args.quiet:
+        logger.setLevel(logging.WARNING)
+
+    restartthinner(args.UNRST, args.restarts, args.quiet, args.dryrun, args.keep)
+
+
+if __name__ == "__main__":
+    main()

subscript-1.15.0/src/subscript/version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.15.0'
+__version_tuple__ = version_tuple = (1, 15, 0)
+
+__commit_id__ = commit_id = 'g6d34949f7'

{subscript-1.14.6 → subscript-1.15.0}/src/subscript.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subscript
-Version: 1.14.6
+Version: 1.15.0
 Summary: Equinor's collection of subsurface reservoir modelling scripts
 Author-email: Equinor <rnyb@equinor.com>
 License-Expression: GPL-3.0-only
@@ -26,6 +26,7 @@ Requires-Dist: resdata
 Requires-Dist: res2df
 Requires-Dist: ert>=10.2.0b13
 Requires-Dist: fmu-tools
+Requires-Dist: gaussianfft
 Requires-Dist: grid3d_maps
 Requires-Dist: jinja2
 Requires-Dist: matplotlib

{subscript-1.14.6 → subscript-1.15.0}/src/subscript.egg-info/SOURCES.txt

@@ -343,6 +343,7 @@ tests/testdata_fmuobs/ert-doc.yml
 tests/testdata_fmuobs/fmu-ensemble-obs.yml
 tests/testdata_fmuobs/hist_obs_wells.txt
 tests/testdata_fmuobs/ri-obs.csv
+tests/testdata_fmuobs/summary_obs_without_date.obs
 tests/testdata_gravity/HIST.EGRID
 tests/testdata_gravity/HIST.INIT
 tests/testdata_gravity/HIST.UNRST

{subscript-1.14.6 → subscript-1.15.0}/src/subscript.egg-info/requires.txt

@@ -2,6 +2,7 @@ resdata
 res2df
 ert>=10.2.0b13
 fmu-tools
+gaussianfft
 grid3d_maps
 jinja2
 matplotlib