fmu-pem 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

fmu/pem/pem_functions/run_patchy_cement_model.py

@@ -1,29 +1,33 @@
-from typing import List, Union
-
 import numpy as np
-from rock_physics_open.sandstone_models import (
-    patchy_cement_model_cem_frac as patchy_cement,
+from rock_physics_open.equinor_utilities.std_functions import (
+    gassmann,
+    velocity,
 )
+from rock_physics_open.sandstone_models import patchy_cement_model_dry
 
 from fmu.pem.pem_utilities import (
+    DryRockProperties,
     EffectiveFluidProperties,
-    MatrixProperties,
-    PemConfig,
+    EffectiveMineralProperties,
     PressureProperties,
+    RockMatrixProperties,
     SaturatedRockProperties,
     filter_and_one_dim,
     reverse_filter_and_restore,
 )
+from fmu.pem.pem_utilities.enum_defs import ParameterTypes
+
+from .pressure_sensitivity import apply_dry_rock_pressure_sensitivity_model
 
 
 def run_patchy_cement(
-    mineral: MatrixProperties,
-    fluid: Union[list[EffectiveFluidProperties], EffectiveFluidProperties],
-    cement: MatrixProperties,
+    mineral: EffectiveMineralProperties,
+    fluid: list[EffectiveFluidProperties] | EffectiveFluidProperties,
+    cement: EffectiveMineralProperties,
     porosity: np.ma.MaskedArray,
-    pressure: Union[list[PressureProperties], PressureProperties],
-    config: PemConfig,
-) -> List[SaturatedRockProperties]:
+    pressure: list[PressureProperties] | PressureProperties,
+    rock_matrix_props: RockMatrixProperties,
+) -> tuple[list[SaturatedRockProperties], list[DryRockProperties]]:
     """Prepare inputs and parameters for running the Patchy Cement model
 
     Args:
@@ -32,19 +36,34 @@ def run_patchy_cement(
             properties in a list
         cement: cement properties containing k [Pa], mu [Pa] and rho [kg/m3]
         porosity: porosity fraction
-        pressure: steps in effective pressure in [bar] due to Eclipse standard
-        config: parameters for the PEM
+        pressure: steps in effective pressure, unit Pa
+        rock_matrix_props: parameters for the PEM
 
     Returns:
         saturated rock properties with vp [m/s], vs [m/s], density [kg/m^3], ai
         (vp * density), si (vs * density), vpvs (vp / vs)
+        dry rock properties with bulk modulus [Pa], shear modulus [Pa] and density
+        [kg/m^3]
     """
     # Mineral and porosity are assumed to be single objects, fluid and
     # effective_pressure can be lists
     fluid, pressure = _verify_inputs(fluid, pressure)
+
+    # Calculate depletion from the initial effective pressure
+    initial_effective_pressure = pressure[0].effective_pressure
+    # Container for saturated properties
     saturated_props = []
-    pat_cem_params = config.rock_matrix.model.parameters
-    for fl_prop, pres in zip(fluid, pressure):
+    dry_props = []
+
+    # to please the IDE:
+    k_dry = None
+    mu = None
+    rho_dry = None
+    k_init = None
+    mu_init = None
+
+    pat_cem_params = rock_matrix_props.model.parameters
+    for time_step, (fl_prop, pres) in enumerate(zip(fluid, pressure)):
         (
             mask,
             tmp_min_k,
@@ -57,45 +76,88 @@ def run_patchy_cement(
             tmp_fl_prop_rho,
             tmp_por,
             tmp_pres,
+            init_pres,
         ) = filter_and_one_dim(
             mineral.bulk_modulus,
             mineral.shear_modulus,
-            mineral.dens,
+            mineral.density,
             cement.bulk_modulus,
             cement.shear_modulus,
-            cement.dens,
+            cement.density,
             fl_prop.bulk_modulus,
-            fl_prop.dens,
+            fl_prop.density,
             porosity,
-            pres.effective_pressure * 1.0e5,
+            pres.effective_pressure,
+            initial_effective_pressure,
             return_numpy_array=True,
         )
-        """Estimation of effective mineral properties must be able to handle cases where
-         there is a more complex combination of minerals than the standard sand/shale
-         case. For carbonates the input can be based on minerals (e.g. calcite,
-         dolomite, quartz, smectite, ...) or PRTs (petrophysical rock types) that each
-         have been assigned elastic properties to."""
-        vp, vs, rho, _, _ = patchy_cement(
-            tmp_min_k,
-            tmp_min_mu,
-            tmp_min_rho,
-            tmp_cem_k,
-            tmp_cem_mu,
-            tmp_cem_rho,
-            tmp_fl_prop_k,
-            tmp_fl_prop_rho,
-            tmp_por,
-            tmp_pres,
-            pat_cem_params.cement_fraction,
-            pat_cem_params.critical_porosity,
-            pat_cem_params.coordination_number_function.fcn,
-            pat_cem_params.coordination_number,
-            pat_cem_params.shear_reduction,
+        # At initial pressure, there is no need to estimate pressure effect on dry rock.
+        # If there is no pressure sensitivity, we use the initial pressure for the dry
+        # rock also after start of production, and the only differences will be due to
+        # changes in fluid properties or saturation
+        if time_step == 0:
+            k_dry, mu, rho_dry = patchy_cement_model_dry(
+                tmp_min_k,
+                tmp_min_mu,
+                tmp_min_rho,
+                tmp_cem_k,
+                tmp_cem_mu,
+                tmp_cem_rho,
+                tmp_por,
+                tmp_pres,
+                pat_cem_params.cement_fraction,
+                pat_cem_params.critical_porosity,
+                pat_cem_params.coordination_number_function,
+                pat_cem_params.coord_num,
+                pat_cem_params.shear_reduction,
+            )
+            # For use at depleted pressure
+            k_init = k_dry
+            mu_init = mu
+        if time_step > 0 and rock_matrix_props.pressure_sensitivity:
+            # estimate the properties for the initial pressure by friable model,
+            # then apply correction for depletion
+
+            # Prepare in situ properties
+            in_situ_dict = {
+                ParameterTypes.K.value: k_init,
+                ParameterTypes.MU.value: mu_init,
+                ParameterTypes.RHO.value: tmp_min_rho,
+                ParameterTypes.POROSITY.value: tmp_por,
+            }
+            tmp_matrix = EffectiveMineralProperties(
+                bulk_modulus=tmp_min_k,
+                shear_modulus=tmp_min_mu,
+                density=tmp_min_rho,
+            )
+            depl_props = apply_dry_rock_pressure_sensitivity_model(
+                model=rock_matrix_props.pressure_sensitivity_model,
+                initial_eff_pressure=init_pres,
+                depleted_eff_pressure=tmp_pres,
+                in_situ_dict=in_situ_dict,
+                mineral_properties=tmp_matrix,
+                cement_properties=rock_matrix_props.minerals[rock_matrix_props.cement],
+            )
+            k_dry = depl_props[ParameterTypes.K.value]
+            mu = depl_props[ParameterTypes.MU.value]
+
+        # Saturate rock
+        k_sat = gassmann(k_dry, tmp_por, tmp_fl_prop_k, tmp_min_k)
+        rho_sat = rho_dry + tmp_por * tmp_fl_prop_rho
+        vp, vs = velocity(k_sat, mu, rho_sat)[0:2]
+
+        vp, vs, rho_sat, k_dry, mu, rho_dry = reverse_filter_and_restore(
+            mask, vp, vs, rho_sat, k_dry, mu, rho_dry
+        )
+        saturated_props.append(SaturatedRockProperties(vp=vp, vs=vs, density=rho_sat))
+        dry_props.append(
+            DryRockProperties(
+                bulk_modulus=k_dry,
+                shear_modulus=mu,
+                density=rho_dry,
+            )
         )
-        vp, vs, rho = reverse_filter_and_restore(mask, vp, vs, rho)
-        props = SaturatedRockProperties(vp=vp, vs=vs, dens=rho)
-        saturated_props.append(props)
-    return saturated_props
+    return saturated_props, dry_props
 
 
 def _verify_inputs(fl_prop, pres_prop):

fmu/pem/pem_functions/{run_t_matrix_and_pressure.py → run_t_matrix_model.py}

@@ -1,5 +1,4 @@
 from pathlib import Path
-from typing import List, Union
 
 import numpy as np
 from rock_physics_open.t_matrix_models import (
@@ -9,10 +8,11 @@ from rock_physics_open.t_matrix_models import (
 )
 
 from fmu.pem.pem_utilities import (
+    DryRockProperties,
     EffectiveFluidProperties,
-    MatrixProperties,
-    PemConfig,
+    EffectiveMineralProperties,
     PressureProperties,
+    RockMatrixProperties,
     SaturatedRockProperties,
     filter_and_one_dim,
     reverse_filter_and_restore,
@@ -21,18 +21,19 @@ from fmu.pem.pem_utilities import (
 from .run_patchy_cement_model import _verify_inputs
 
 
-def run_t_matrix_and_pressure_models(
-    mineral_properties: MatrixProperties,
-    fluid_properties: Union[list[EffectiveFluidProperties], EffectiveFluidProperties],
+def run_t_matrix_model(
+    mineral_properties: EffectiveMineralProperties,
+    fluid_properties: list[EffectiveFluidProperties] | EffectiveFluidProperties,
     porosity: np.ma.MaskedArray,
-    vsh: Union[None, np.ma.MaskedArray],
-    pressure: Union[list[PressureProperties], PressureProperties],
-    config: PemConfig,
+    vsh: None | np.ma.MaskedArray,
+    pressure: list[PressureProperties] | PressureProperties,
+    rock_matrix: RockMatrixProperties,
+    model_directory: Path,
     petec_parameter_file: Path = Path("t_mat_params_petec.pkl"),
     exp_parameter_file: Path = Path("t_mat_params_exp.pkl"),
     pres_model_vp: Path = Path("carbonate_pressure_model_vp_exp.pkl"),
     pres_model_vs: Path = Path("carbonate_pressure_model_vs_exp.pkl"),
-) -> List[SaturatedRockProperties]:
+) -> tuple[list[SaturatedRockProperties], list[DryRockProperties]]:
     """Model for carbonate rock with possibility to estimate changes due to
     production, i.e., saturation changes, changes in the fluids due to pore pressure
     change and also changes in the properties of the matrix by increase in effective
@@ -40,11 +41,21 @@ def run_t_matrix_and_pressure_models(
 
     The first timestep is regarded as in situ conditions for the pressure
     substitution, any later timestep also takes into account the changes in effective
-    pressure from the initial one.
+    pressure from the initial one. Pressure sensitivity can be deselected in the
+    configuration of the PEM.
 
     Calibration of parameters for the T-Matrix model must be made before running the
     forward model, this is only possible in RokDoc with 1D match to logs.
 
+    Notice that t-matrix differs from the other saturated rock physics models in that
+    there is no intermediate step for dry rock properties. For this reason, the pressure
+    sensitive model is fixed, as this is a model that is adapted to saturated carbonate
+    rocks. This model can be overridden by saving an alternative model with the same
+    format as the default ones.
+
+    To comply with other functions for saturated rock properties, we also return
+    dry rock properties, but for the time being, the values are set to NaN.
+
     Args:
         mineral_properties: bulk modulus (k) [Pa], shear modulus (mu) [Pa],
             density [kg/m^3]
@@ -53,7 +64,8 @@ def run_t_matrix_and_pressure_models(
         porosity: porosity [fraction]
         vsh: shale volume [fraction]
         pressure: overburden, effective and formation (pore) pressure per restart date
-        config: configuration parameters
+        rock_matrix: rock matrix properties
+        model_directory: folder for model files
         petec_parameter_file: additional parameters for the T-Matrix model, determined
             through optimisation to well logs
         exp_parameter_file: additional parameters for the T-Matrix model, determined
@@ -64,16 +76,18 @@ def run_t_matrix_and_pressure_models(
     Returns:
         saturated rock properties with vp [m/s], vs [m/s], density [kg/m^3],
         ai (vp * density), si (vs * density), vpvs (vp / vs)
+        dry rock properties with values set to NaN
     """
     fluid_properties, pressure = _verify_inputs(fluid_properties, pressure)
 
     # All model files are gathered with the config file for the PEM model,
     # i.e. in ../sim2seis/model
-    petec_parameter_file = config.paths.rel_path_pem / petec_parameter_file
-    exp_parameter_file = config.paths.rel_path_pem / exp_parameter_file
+    petec_parameter_file = model_directory / petec_parameter_file
+    exp_parameter_file = model_directory / exp_parameter_file
 
     saturated_props = []
-    t_mat_params = config.rock_matrix.model.parameters
+    dry_props = []
+    t_mat_params = rock_matrix.model.parameters
 
     if vsh is None and t_mat_params.t_mat_model_version == "EXP":
         raise ValueError("Shale volume must be provided for EXP model")
@@ -83,13 +97,13 @@ def run_t_matrix_and_pressure_models(
         vsh = np.ma.array(
             np.zeros_like(porosity), mask=np.zeros_like(porosity).astype(bool)
         )
-    # Change unit from bar to Pa
-    pres_ovb = pressure[0].overburden_pressure * 1.0e5
-    pres_form = pressure[0].formation_pressure * 1.0e5
+    # Pressures for initial conditions
+    pres_ovb = pressure[0].overburden_pressure
+    pres_form = pressure[0].formation_pressure
 
     for time_step, fl_prop in enumerate(fluid_properties):
         if time_step > 0:
-            pres_depl = pressure[time_step].formation_pressure * 1.0e5
+            pres_depl = pressure[time_step].formation_pressure
             (
                 mask,
                 tmp_min_k,
@@ -105,9 +119,9 @@ def run_t_matrix_and_pressure_models(
             ) = filter_and_one_dim(
                 mineral_properties.bulk_modulus,
                 mineral_properties.shear_modulus,
-                mineral_properties.dens,
+                mineral_properties.density,
                 fl_prop.bulk_modulus,
-                fl_prop.dens,
+                fl_prop.density,
                 porosity,
                 vsh,
                 pres_ovb,
@@ -128,9 +142,9 @@ def run_t_matrix_and_pressure_models(
             ) = filter_and_one_dim(
                 mineral_properties.bulk_modulus,
                 mineral_properties.shear_modulus,
-                mineral_properties.dens,
+                mineral_properties.density,
                 fl_prop.bulk_modulus,
-                fl_prop.dens,
+                fl_prop.density,
                 porosity,
                 vsh,
             )
@@ -162,7 +176,7 @@ def run_t_matrix_and_pressure_models(
                 t_mat_params.freq,
                 str(exp_parameter_file),
             )
-        if time_step > 0:
+        if time_step > 0 and rock_matrix.pressure_sensitivity:
             vp, vs, rho, _, _ = carbonate_pressure_model(
                 tmp_fl_rho,
                 vp,
@@ -177,10 +191,17 @@ def run_t_matrix_and_pressure_models(
                 tmp_pres_depl,
                 pres_model_vp,
                 pres_model_vs,
-                config.paths.rel_path_pem.absolute(),
+                model_directory.absolute(),
                 False,
             )
         vp, vs, rho = reverse_filter_and_restore(mask, vp, vs, rho)
-        props = SaturatedRockProperties(vp=vp, vs=vs, dens=rho)
+        props = SaturatedRockProperties(vp=vp, vs=vs, density=rho)
         saturated_props.append(props)
-    return saturated_props
+        dry_props.append(
+            DryRockProperties(
+                bulk_modulus=np.full_like(vp, np.nan),
+                shear_modulus=np.full_like(vp, np.nan),
+                density=np.full_like(vp, np.nan),
+            )
+        )
+    return saturated_props, dry_props

fmu/pem/pem_utilities/__init__.py

@@ -4,39 +4,57 @@ from .delta_cumsum_time import (
     estimate_sum_delta_time,
 )
 from .export_routines import save_results
+from .fipnum_pvtnum_utilities import (
+    detect_overlaps,
+    input_num_string_to_list,
+    missing_num_areas,
+    num_boolean_array,
+    validate_zone_coverage,
+)
 from .import_config import get_global_params_and_dates, read_pem_config
 from .import_routines import (
     import_fractions,
-    read_geogrid,
-    read_ntg_grid,
     read_sim_grid_props,
 )
 from .pem_class_definitions import (
     DryRockProperties,
     EffectiveFluidProperties,
-    MatrixProperties,
+    EffectiveMineralProperties,
     PressureProperties,
     SaturatedRockProperties,
     SimInitProperties,
     SimRstProperties,
 )
-from .pem_config_validation import Fluids, PemConfig, possible_date_string
+from .pem_config_validation import (
+    Fluids,
+    MineralProperties,
+    PemConfig,
+    RockMatrixProperties,
+)
 from .update_grid import update_inactive_grid_cells
 from .utils import (
+    bar_to_pa,
     estimate_cement,
     filter_and_one_dim,
+    get_masked_array_mask,
     get_shale_fraction,
-    ntg_to_shale_fraction,
+    pa_to_bar,
     restore_dir,
     reverse_filter_and_restore,
+    set_mask,
     to_masked_array,
     update_dict_list,
 )
 
 __all__ = [
     "PemConfig",
+    "RockMatrixProperties",
+    "MineralProperties",
     "Fluids",
+    "bar_to_pa",
+    "pa_to_bar",
     "calculate_diff_properties",
+    "detect_overlaps",
     "estimate_cement",
     "estimate_sum_delta_time",
     "estimate_delta_time",
@@ -44,21 +62,23 @@ __all__ = [
     "get_global_params_and_dates",
     "get_shale_fraction",
     "import_fractions",
-    "ntg_to_shale_fraction",
-    "possible_date_string",
-    "read_geogrid",
-    "read_ntg_grid",
+    "input_num_string_to_list",
+    "missing_num_areas",
+    "num_boolean_array",
     "read_pem_config",
     "read_sim_grid_props",
     "restore_dir",
     "reverse_filter_and_restore",
     "save_results",
     "to_masked_array",
+    "get_masked_array_mask",
+    "set_mask",
     "update_dict_list",
     "update_inactive_grid_cells",
+    "validate_zone_coverage",
     "DryRockProperties",
     "EffectiveFluidProperties",
-    "MatrixProperties",
+    "EffectiveMineralProperties",
     "PressureProperties",
     "SaturatedRockProperties",
     "SimInitProperties",

fmu/pem/pem_utilities/cumsum_properties.py

@@ -1,19 +1,29 @@
 from dataclasses import asdict
-from typing import Tuple
 
-from .pem_config_validation import PemConfig
+from .enum_defs import DifferenceAttribute, DifferenceMethod
 
 
-def calculate_diff_properties(props: list, conf_params: PemConfig) -> Tuple[list, list]:
+def calculate_diff_properties(
+    props: list,
+    diff_dates: list[list[str]],
+    seis_dates: list[str],
+    diff_calculation: dict[DifferenceAttribute, list[DifferenceMethod]],
+) -> tuple[list, list]:
     """
     Function to calculate difference attributes between grid properties
 
-    :param props: grid properties
-    :param conf_params: configuration parameters
-    :return: difference of time steps according to config file
+    Args:
+        props: grid properties
+        diff_dates: list of simulation model dates for difference calculation
+        seis_dates: list of simulation model dates
+        diff_calculation: dictionary of difference calculation attributes and methods
+
+    Returns:
+        diff_prop: difference properties
+        date_str: formatted string for difference dates
     """
-    _verify_diff_inputs(props, conf_params)
-    props = _filter_diff_inputs(props, conf_params)
+    _verify_diff_inputs(props, seis_dates, diff_dates)
+    props = _filter_diff_inputs(props, diff_calculation)
 
     def diff(x, y):
         return x - y
@@ -24,21 +34,16 @@ def calculate_diff_properties(props: list, conf_params: PemConfig) -> Tuple[list
     def ratio(x, y):
         return x / y
 
-    lookup = dict(
-        zip(
-            conf_params.global_params.seis_dates,  # type: ignore
-            range(len(conf_params.global_params.seis_dates)),  # type: ignore
-        )
-    )
+    lookup = dict(zip(seis_dates, range(len(seis_dates))))
     date_str = []
     diff_prop = []
     # Need to iterate over the lists in props, which contain the properties
     # for each date
-    for monitor, base in conf_params.global_params.diff_dates:  # type: ignore
+    for monitor, base in diff_dates:  # type: ignore
         tmp_dict = {}
         for k, v_base in props[lookup[base]].items():
-            if k.upper() in conf_params.diff_calculation:
-                operations = conf_params.diff_calculation[k.upper()]
+            if k in diff_calculation:
+                operations = diff_calculation[k]
                 v_monitor = props[lookup[monitor]][k]
                 for op in operations:
                     if op in locals():
@@ -54,7 +59,7 @@ def calculate_diff_properties(props: list, conf_params: PemConfig) -> Tuple[list
     return diff_prop, date_str
 
 
-def _verify_diff_inputs(prop_set, conf):
+def _verify_diff_inputs(prop_set, seis_dates, diff_dates):
     if not isinstance(prop_set, list):
         raise ValueError(
             f"{__file__}: input grid properties must be contained in a list "
@@ -62,15 +67,13 @@ def _verify_diff_inputs(prop_set, conf):
             f"date in the inner lists"
         )
     for prop_list in prop_set:
-        if len(prop_list) != len(conf.global_params.seis_dates):
+        if len(prop_list) != len(seis_dates):
             raise ValueError(
                 f"{__file__}: mismatch between property sets and "
                 f"simulation model dates: "
-                f"{len(prop_list)} vs. {len(conf.global_params.seis_dates)}"
+                f"{len(prop_list)} vs. {len(seis_dates)}"
             )
-    if not {a for ll in conf.global_params.diff_dates for a in ll}.issubset(
-        set(conf.global_params.seis_dates)
-    ):
+    if not {a for ll in diff_dates for a in ll}.issubset(set(seis_dates)):
         raise ValueError(
             f"{__file__}: trying to take difference between dates not saved from "
             f"simulation model"
@@ -78,27 +81,16 @@ def _verify_diff_inputs(prop_set, conf):
     return
 
 
-def _filter_diff_inputs(prop_list_list, conf):
+def _filter_diff_inputs(prop_list_list, diff_calculation):
     # Filter out the properties that are not in the diff_calculation list.
     # Keep the time-step order in the list
     return_list = [{} for _ in range(len(prop_list_list[0]))]
     for prop_list in prop_list_list:
         for i, prop_set in enumerate(prop_list):
             tmp_dict = {
-                k: v
-                for k, v in asdict(prop_set).items()
-                if k.upper() in conf.diff_calculation
+                k: v for k, v in asdict(prop_set).items() if k in diff_calculation
             }
             if tmp_dict:
                 return_list[i].update(tmp_dict)
-    if conf.global_params is None:
-        raise ValueError(
-            f"{__file__}: unable to calculate cumsum values, global "
-            f"settings are missing"
-        )
-    if conf.global_params.seis_dates is None:
-        raise ValueError(
-            f"{__file__}: unable to calculate cumsum values, global "
-            f"settings seismic dates are missing"
-        )
+
     return return_list

fmu/pem/pem_utilities/delta_cumsum_time.py

@@ -1,5 +1,3 @@
-from typing import Dict, List, Union
-
 import numpy as np
 
 from .pem_class_definitions import (
@@ -7,12 +5,11 @@ from .pem_class_definitions import (
     SimInitProperties,
     TwoWayTime,
 )
-from .pem_config_validation import PemConfig
 
 
 def estimate_delta_time(
     delta_z: np.ma.MaskedArray, vp: np.ma.MaskedArray, vs: np.ma.MaskedArray
-) -> Dict[str, np.ma.MaskedArray]:
+) -> dict[str, np.ma.MaskedArray]:
     """Estimate seismic TWT parameters - PP, PS, SS modes
 
     Args:
@@ -29,7 +26,7 @@ def estimate_delta_time(
     return {"twtpp": dt_pp, "twtss": dt_ss, "twtps": (dt_pp + dt_ss) / 2.0}
 
 
-def _verify_delta_t(arrays: List[np.ma.MaskedArray]) -> None:
+def _verify_delta_t(arrays: list[np.ma.MaskedArray]) -> None:
     for arr in arrays:
         if not isinstance(arr, np.ma.MaskedArray):
             raise TypeError(
@@ -45,8 +42,8 @@ def _verify_delta_t(arrays: List[np.ma.MaskedArray]) -> None:
 
 
 def calculate_time_cumsum(
-    props: Union[list, dict], conf_params: PemConfig
-) -> list[Dict[str, np.ma.MaskedArray]]:
+    props: list | dict,
+) -> list[dict[str, np.ma.MaskedArray]]:
     """
     Function to calculate cumulative sum of time difference properties
 
@@ -81,15 +78,13 @@ def _verify_cumsum_inputs(input_set):
 
 def estimate_sum_delta_time(
     constant_props: SimInitProperties,
-    sat_rock_props: List[SaturatedRockProperties],
-    config: PemConfig,
-) -> List[TwoWayTime]:
+    sat_rock_props: list[SaturatedRockProperties],
+) -> list[TwoWayTime]:
     """Calculate TWT (two-way-time) for seismic signal for each restart date
 
     Args:
         constant_props: constant properties, here the delta Z property of the eclipse
-            grid is used sat_rock_props: effective properties for the saturated rock per
-            restart date
+            grid is used
         sat_rock_props: effective properties for the saturated rock per restart date
         config: configuration parameters
 
@@ -100,5 +95,5 @@ def estimate_sum_delta_time(
         estimate_delta_time(constant_props.delta_z, sat_rock.vp, sat_rock.vs)
         for sat_rock in sat_rock_props
     ]
-    cum_time_list = calculate_time_cumsum(delta_time, config)
+    cum_time_list = calculate_time_cumsum(delta_time)
     return [TwoWayTime(**time_set) for time_set in cum_time_list]