fmu-pem 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

fmu/pem/pem_utilities/utils.py

@@ -1,17 +1,16 @@
 import os
 from contextlib import contextmanager
 from pathlib import Path
-from typing import List, Optional, Tuple, Union
+from typing import Generator
 
 import numpy as np
 import xtgeo
 
-from .pem_class_definitions import MatrixProperties
-from .pem_config_validation import PemConfig
+from .pem_class_definitions import EffectiveMineralProperties, PressureProperties
 
 
 @contextmanager
-def restore_dir(path: Path) -> None:
+def restore_dir(path: Path) -> Generator:  # type: ignore[return-value]
     """restore_dir run block of code from a given path, restore original path
 
     Args:
@@ -29,7 +28,7 @@ def restore_dir(path: Path) -> None:
 
 
 def to_masked_array(
-    value: Union[float, int], masked_array: np.ma.MaskedArray
+    value: float | int, masked_array: np.ma.MaskedArray
 ) -> np.ma.MaskedArray:
     """Create a masked array with a constant value from an int or float and a template
     masked array
@@ -44,12 +43,40 @@ def to_masked_array(
     return np.ma.MaskedArray(value * np.ones_like(masked_array), mask=masked_array.mask)
 
 
+def get_masked_array_mask(masked_array: np.ma.MaskedArray) -> np.ndarray:
+    """Extract mask from MaskedArray or create default mask."""
+    return (
+        masked_array.mask
+        if hasattr(masked_array, "mask")
+        else np.zeros_like(masked_array.data, dtype=bool)
+    )
+
+
+def set_mask(
+    masked_template: np.ma.MaskedArray,
+    prop_array: np.ma.MaskedArray | None,
+) -> np.ma.MaskedArray | None:
+    """Check for existence of mask in masked_template, return prop_array
+    with masked values. In case prop_array is None, return None"""
+    if prop_array is None:
+        return None
+    return np.ma.masked_where(
+        masked_template.mask
+        if hasattr(masked_template, "mask")
+        else np.zeros_like(prop_array),
+        prop_array,
+    )
+
+
 def filter_and_one_dim(
     *args: np.ma.MaskedArray, return_numpy_array: bool = False
-) -> tuple[np.ma.MaskedArray, ...]:
+) -> tuple[np.ma.MaskedArray | np.ndarray, ...]:
     """Filters multiple masked arrays by removing masked values and flattens them to 1D.
 
-    Typically used in preparation for calling the rock-physics library.
+    If no elements are masked (i.e., mask is scalar False), this function will still
+    flatten the arrays to 1D by treating all entries as valid. This ensures
+    downstream rock physics functions always receive 1D arrays, avoiding shape
+    issues (e.g. (1, nx, ny, nz)) when no masking occurs.
 
     Args:
         *args: One or more masked arrays of identical shape. Each array contains data
@@ -59,26 +86,34 @@ def filter_and_one_dim(
 
     Returns:
         tuple containing:
-            - mask: Boolean array of the same shape as inputs where True indicates
-              positions that were masked in any of the input arrays
-            - filtered arrays: One or more 1D arrays containing only the unmasked values
-              from each input array, in their original order
+            - mask: Boolean array of same shape where True indicates masked positions
+            - filtered arrays: 1D arrays containing the unmasked values from each arg
     """
     if not np.all([isinstance(arg, np.ma.MaskedArray) for arg in args]):
         raise ValueError(f"{__file__}: all inputs should be numpy masked arrays")
+
+    # Combine masks
     mask = args[0].mask
     for i in range(1, len(args)):
         mask = np.logical_or(mask, args[i].mask)
+
+    # If mask is scalar (no masked elements), expand to full-shape False array
+    if np.isscalar(mask):  # covers True/False scalar
+        # All values valid -> create explicit False mask array matching input shape
+        mask = np.zeros(args[0].shape, dtype=bool)
+
+    # Extract unmasked (valid) entries and flatten to 1D
     if return_numpy_array:
-        out_args = [arg[~mask].data for arg in args]
+        out_args = [arg.data[~mask] for arg in args]
     else:
         out_args = [arg[~mask] for arg in args]
-    return mask, *out_args
+
+    return mask, *out_args  # type: ignore[return-value]
 
 
 def reverse_filter_and_restore(
     mask: np.ndarray, *args: np.ndarray
-) -> Tuple[np.ma.MaskedArray, ...]:
+) -> tuple[np.ma.MaskedArray, ...]:
     """Restores 1D filtered arrays back to their original shape with masking.
 
     Typically called with results returned from the rock-physics library.
@@ -152,28 +187,11 @@ def _verify_export_inputs(props, grid, dates, file_format=None):
     )
 
 
-def ntg_to_shale_fraction(
-    ntg: np.ma.MaskedArray, por: np.ma.MaskedArray
-) -> np.ma.MaskedArray:
-    """Calculate sand and shale fraction from N/G property
-
-    Args:
-        ntg: net-to-gross property [fraction]
-        por: total porosity [fraction]
-
-    Returns:
-        shale fraction
-    """
-    clip_ntg: np.ma.MaskedArray = np.ma.clip(np.ma.MaskedArray(ntg), 0.0, 1.0)  # type: ignore[assignment]
-    vsh: np.ma.MaskedArray = np.ma.MaskedArray(1.0 - clip_ntg)
-    return (vsh / (1.0 - por)).clip(0.0, 1.0)
-
-
 def get_shale_fraction(
-    vol_fractions: List[np.ma.MaskedArray],
+    vol_fractions: list[np.ma.MaskedArray],
     fraction_names: list[str],
-    shale_fraction_names: Optional[str | list[str]],
-) -> Optional[np.ma.MaskedArray]:
+    shale_fraction_names: str | list[str] | None = None,
+) -> np.ma.MaskedArray | None:
     """
 
     Args:
@@ -210,7 +228,7 @@ def estimate_cement(
     shear_modulus: float | int,
     density: float | int,
     grid: np.ma.MaskedArray,
-) -> MatrixProperties:
+) -> EffectiveMineralProperties:
     """Creates masked arrays filled with constant cement properties, matching the shape
     and mask of the input grid.
 
@@ -226,12 +244,12 @@ def estimate_cement(
     cement_k = to_masked_array(bulk_modulus, grid)
     cement_mu = to_masked_array(shear_modulus, grid)
     cement_rho = to_masked_array(density, grid)
-    return MatrixProperties(
-        bulk_modulus=cement_k, shear_modulus=cement_mu, dens=cement_rho
+    return EffectiveMineralProperties(
+        bulk_modulus=cement_k, shear_modulus=cement_mu, density=cement_rho
     )
 
 
-def update_dict_list(base_list: List[dict], add_list: List[dict]) -> List[dict]:
+def update_dict_list(base_list: list[dict], add_list: list[dict]) -> list[dict]:
     """Update/add new key/value pairs to dicts in list
 
     Args:
@@ -260,3 +278,37 @@ def _verify_update_inputs(base, add_list):
         and all(isinstance(item, dict) for item in add_list)
     ):
         raise TypeError(f"{__file__}: all items in input lists are not dict")
+
+
+def bar_to_pa(
+    pres_bar: float | np.ndarray | np.ma.MaskedArray,
+) -> float | np.ndarray | np.ma.MaskedArray:
+    """
+    Pressure unit conversion from bar to Pa
+    """
+    return pres_bar * 1.0e5
+
+
+def pa_to_bar(
+    pres_pa: float | np.ndarray | np.ma.MaskedArray,
+) -> float | np.ndarray | np.ma.MaskedArray:
+    """
+    Pressure unit conversion from Pa to bar
+    """
+    return pres_pa * 1.0e-5
+
+
+def convert_single_pressure_to_pa(
+    single_press_bar: PressureProperties,
+) -> PressureProperties:
+    return PressureProperties(
+        effective_pressure=bar_to_pa(single_press_bar.effective_pressure),
+        formation_pressure=bar_to_pa(single_press_bar.formation_pressure),
+        overburden_pressure=bar_to_pa(single_press_bar.overburden_pressure),
+    )
+
+
+def convert_pressures_list_to_pa(
+    press_bar: list[PressureProperties],
+) -> list[PressureProperties]:
+    return [convert_single_pressure_to_pa(pres) for pres in press_bar]

fmu/pem/run_pem.py

@@ -6,9 +6,10 @@ from fmu.pem import pem_utilities as pem_utils
 
 
 def pem_fcn(
-    start_dir: Path,
-    rel_path_pem: Path,
+    config_dir: Path,
     pem_config_file_name: Path,
+    global_config_dir: Path,
+    global_config_file: Path,
     run_from_rms=False,
     proj=None,
 ) -> None:
@@ -18,81 +19,111 @@ def pem_fcn(
 
     """
     # Read and validate all PEM parameters
-    config = pem_utils.read_pem_config(
-        start_dir.joinpath(rel_path_pem, pem_config_file_name)
-    )
+    config = pem_utils.read_pem_config(yaml_file=config_dir / pem_config_file_name)
 
     # Read necessary part of global configurations and parameters
     config.update_with_global(
         pem_utils.get_global_params_and_dates(
-            start_dir, config.paths.rel_path_fmu_config
+            global_config_dir=(config_dir / global_config_dir).resolve(),
+            global_conf_file=global_config_file,
         )
     )
 
     # Import Eclipse simulation grid - INIT and RESTART
-    egrid_file = start_dir / config.paths.rel_path_simgrid / "ECLIPSE.EGRID"
-    init_property_file = start_dir / config.paths.rel_path_simgrid / "ECLIPSE.INIT"
-    restart_property_file = start_dir / config.paths.rel_path_simgrid / "ECLIPSE.UNRST"
-
     sim_grid, constant_props, time_step_props = pem_utils.read_sim_grid_props(
-        egrid_file,
-        init_property_file,
-        restart_property_file,
-        config.global_params.seis_dates,
+        rel_dir_sim_files=config.eclipse_files.rel_path_simgrid,
+        egrid_file=config.eclipse_files.egrid_file,
+        init_property_file=config.eclipse_files.init_property_file,
+        restart_property_file=config.eclipse_files.restart_property_file,
+        seis_dates=config.global_params.seis_dates,
+        fipnum_name=config.alternative_fipnum_name,
     )
 
     # Calculate rock properties - fluids and minerals
-    # Fluid properties calculated for all time-steps
-    fluid_properties = pem_fcns.effective_fluid_properties(
-        time_step_props, config.fluids
-    )
-
     # Effective mineral (matrix) properties - one set valid for all time-steps
     vsh, matrix_properties = pem_fcns.effective_mineral_properties(
-        start_dir, config, constant_props
+        root_dir=config_dir,
+        matrix=config.rock_matrix,
+        sim_init=constant_props,
+        sim_grid=sim_grid,
     )
     # VSH is exported with other constant results, add it to the constant properties
-    constant_props.ntg_pem = vsh
+    constant_props.vsh_pem = vsh
+
+    # Fluid properties calculated for all time-steps
+    fluid_properties, below_bp_grids = pem_fcns.effective_fluid_properties_zoned(
+        restart_props=time_step_props,
+        fluids=config.fluids,
+        pvtnum=constant_props.pvtnum,
+    )
 
     # Estimate effective pressure
     eff_pres = pem_fcns.estimate_pressure(
-        config, constant_props, time_step_props, matrix_properties, fluid_properties
+        rock_matrix=config.rock_matrix,
+        overburden_pressure=config.pressure,
+        sim_init=constant_props,
+        sim_rst=time_step_props,
+        matrix_props=matrix_properties,
+        fluid_props=fluid_properties,
+        sim_dates=config.global_params.seis_dates,
+        fipnum=constant_props.fipnum,
     )
 
     # Estimate saturated rock properties
-    sat_rock_props = pem_fcns.estimate_saturated_rock(
-        config, constant_props, eff_pres, matrix_properties, fluid_properties
+    sat_rock_props, dry_rock = pem_fcns.estimate_saturated_rock(
+        rock_matrix=config.rock_matrix,
+        sim_init=constant_props,
+        press_props=eff_pres,
+        matrix_props=matrix_properties,
+        fluid_props=fluid_properties,
+        model_directory=config.paths.rel_path_pem,
+        fipnum_param=constant_props.fipnum,
     )
 
     # Delta and cumulative time estimates (only TWT properties are kept)
     sum_delta_time = pem_utils.delta_cumsum_time.estimate_sum_delta_time(
-        constant_props, sat_rock_props, config
+        constant_props=constant_props,
+        sat_rock_props=sat_rock_props,
     )
 
     # Calculate difference properties. Possible properties are all that vary with time
     diff_props, diff_date_strs = pem_utils.calculate_diff_properties(
-        [time_step_props, eff_pres, sat_rock_props, sum_delta_time], config
+        props=[time_step_props, eff_pres, sat_rock_props, sum_delta_time],
+        diff_dates=config.global_params.diff_dates,
+        seis_dates=config.global_params.seis_dates,
+        diff_calculation=config.diff_calculation,
     )
 
     # As a precaution, update the grid mask for inactive cells, based on the saturated
     # rock properties
-    sim_grid = pem_utils.update_inactive_grid_cells(sim_grid, sat_rock_props)
+    sim_grid = pem_utils.update_inactive_grid_cells(
+        grid=sim_grid,
+        props=sat_rock_props,
+    )
 
     # Save results to disk or RMS project according to settings in the PEM config
     pem_utils.save_results(
-        start_dir,
-        run_from_rms,
-        config,
-        proj,
-        sim_grid,
-        eff_pres,
-        sat_rock_props,
-        diff_props,
-        diff_date_strs,
-        matrix_properties,
-        fluid_properties,
+        config_dir=config_dir,
+        run_from_rms_flag=run_from_rms,
+        rms_project=proj,
+        sim_grid=sim_grid,
+        grid_name=config.global_params.grid_model,
+        seis_dates=config.global_params.seis_dates,
+        save_to_rms=config.results.save_results_to_rms,
+        save_to_disk=config.results.save_results_to_disk,
+        save_intermediate=config.results.save_intermediate_results,
+        mandatory_path=config.paths.rel_path_mandatory_output,
+        pem_output_path=config.paths.rel_path_output,
+        eff_pres_props=eff_pres,
+        sat_rock_props=sat_rock_props,
+        difference_props=diff_props,
+        difference_date_strs=diff_date_strs,
+        matrix_props=matrix_properties,
+        fluid_props=fluid_properties,
+        bubble_point_grids=below_bp_grids,
+        dry_rock_props=dry_rock,
     )
 
     # Restore original path
-    os.chdir(start_dir)
+    os.chdir(config_dir)
     return

fmu/pem/version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.1'
-__version_tuple__ = version_tuple = (0, 0, 1)
+__version__ = version = '0.0.3'
+__version_tuple__ = version_tuple = (0, 0, 3)
+
+__commit_id__ = commit_id = None

{fmu_pem-0.0.1.dist-info → fmu_pem-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu-pem
-Version: 0.0.1
+Version: 0.0.3
 Summary: pem
 License:                     GNU GENERAL PUBLIC LICENSE
                                Version 3, 29 June 2007
@@ -686,12 +686,8 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Utilities
 Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Natural Language :: English
-Requires-Python: >=3.8
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.24.3
@@ -699,7 +695,7 @@ Requires-Dist: xtgeo>=4.7.1
 Requires-Dist: fmu-tools
 Requires-Dist: fmu-config
 Requires-Dist: fmu-dataio
-Requires-Dist: rock-physics-open>=0.1.2
+Requires-Dist: rock-physics-open>=0.3.3
 Requires-Dist: PyYAML>=6.0.1
 Requires-Dist: pydantic
 Requires-Dist: ert>=14.1.10
@@ -719,50 +715,59 @@ Requires-Dist: sphinx-togglebutton; extra == "docs"
 Requires-Dist: sphinx_rtd_theme; extra == "docs"
 Dynamic: license-file
 
-# How to use fmu-pem
+> [!WARNING]
+> `fmu-pem` is not yet qualified technology, and as of today only applicable for
+    selected pilot test fields.
 
-Petro-elastic model (PEM) for [fmu-sim2seis](https://github.com/equinor/fmu-sim2seis)
-based on the [rock-physics-open](https://github.com/equinor/rock-physics-open)
-library.
+**[📚 User documentation](https://equinor.github.io/fmu-pem/)**
 
-## Installation
+## What is fmu-pem?
+
+Petro-elastic model (PEM) for use in e.g. [fmu-sim2seis](https://github.com/equinor/fmu-sim2seis)
+based on the [rock-physics-open](https://github.com/equinor/rock-physics-open) library.
+
+## How to use fmu-pem?
+
+### Installation
 
 To install `fmu-pem`, first activate a virtual environment, then type:
 
-```
+```shell
 pip install fmu-pem
 ```
 
 The PEM is controlled by parameter settings in a *yaml-file*, given as part of the
-command line arguments, or by the workflow parameter if it is run as an ERT forward model.
+command line arguments, or by the workflow parameter if it is run as an ERT forward
+model.
 
-## Calibration of rock physics models
+### Calibration of rock physics models
 
 Calibration of the rock physics models is normally carried out in
 [RokDoc](https://www.ikonscience.com/rokdoc-geoprediction-software-platform/)
-prior to running the PEM. Fluid and mineral properties can be found in the RokDoc project, or
-from LFP logs, if they are available.
+prior to running the PEM. Fluid and mineral properties can be found in the RokDoc
+project, or from LFP logs, if they are available.
 
-> [!NOTE]  
-> The fluid models contained in this module may not cover all possible cases. Gas condensate, very heavy oil, 
-> or reservoir pressure under hydrocarbon bubble point will need additional proprietary code to run.
+> [!NOTE]
+> The fluid models contained in this module may not cover all possible cases. Gas
+condensate, very heavy oil, > or reservoir pressure under hydrocarbon bubble point will
+need additional proprietary code to run.
 >
 > Equinor users can install additional proprietary models using
+
 > ```bash
 > pip install "git+ssh://git@github.com/equinor/rock-physics"`
 > ```
 
-## User interface
-
-Users can visit https://equinor.github.io/fmu-pem/ in order to get help configuring the `fmu-pem` input data.
-
-# How to develop fmu-pem
+## How to develop fmu-pem?
 
 Developing the user interface can be done by:
+
 ```bash
-cd ./user-interface-config
+cd ./documentation
 npm ci  # Install dependencies
 npm run create-json-schema  # Extract JSON schema from Python code
-npm run dev  # Start local development server
+npm run docs:dev  # Start local development server
 ```
-The JSON schema itself (type, title, description etc.) comes from the corresponding Pydantic models in the Python code.
+
+The JSON schema itself (type, title, description etc.) comes from the corresponding
+Pydantic models in the Python code.

fmu_pem-0.0.3.dist-info/RECORD

@@ -0,0 +1,39 @@
+fmu/__init__.py,sha256=YWSE22UTDSocfqQHxEeXrRkdlA63t_aayQVdJkycwYs,83
+fmu/pem/__init__.py,sha256=FhNaFibcFZEK1Rz7IBRXBgxMHGNlcgrHaD4FtU4pDjs,421
+fmu/pem/__main__.py,sha256=hWYNOkn7gG6jUifHIXbG8ZJmUEDkv251v6OgiaR7rcY,1858
+fmu/pem/run_pem.py,sha256=aMkOHDNg3wtdiZueDAGogrxyVI8Sk2RYHWeSe9AJVXk,4727
+fmu/pem/version.py,sha256=pBZsQt6tlL02W-ri--X_4JCubpAK7jjCSnOmUp_isjc,704
+fmu/pem/forward_models/__init__.py,sha256=WuN66rmgfqrekCy3Ss9NHqsy-lZ4WGY-4VZa3jYDV2s,117
+fmu/pem/forward_models/pem_model.py,sha256=Hj7ueEu5bOKA84ldx1oKEqOntBKYySmY0Y6Z7ghZPeI,2025
+fmu/pem/hook_implementations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmu/pem/hook_implementations/jobs.py,sha256=IQW5m7oeZ_MiemxXv-UGLCPeo4h3QT9oELPlWAzsN60,388
+fmu/pem/pem_functions/__init__.py,sha256=aGFW0Gmr1rZsmzZhKdll9ofWcgpobzsHxfCNwr2Ypqc,551
+fmu/pem/pem_functions/density.py,sha256=txcG0bp2Fq20A2E6O3-KQtiJm60BXOou-TcgZlnnluw,1605
+fmu/pem/pem_functions/effective_pressure.py,sha256=Qd4selju2qGFWJdWuWFJu8Hyad3e_v3yS3nt5SjKXTQ,10706
+fmu/pem/pem_functions/estimate_saturated_rock.py,sha256=S_uqsX5xDOhndSK7bvMYvdPj_VRwffkm17760T6tZNo,11577
+fmu/pem/pem_functions/fluid_properties.py,sha256=i6iOHGCYC3DI4_Pe54DaMaBhJysdQNhAFQVko6PLnys,18325
+fmu/pem/pem_functions/mineral_properties.py,sha256=1TLs8ZG8Js-k8QpgNNLesruUALQsfqgJawcLLfqZJRY,8068
+fmu/pem/pem_functions/pressure_sensitivity.py,sha256=_IG7nMlalFuBlyrS9YpGZ2F-ClLENS75viDO1_OVaEA,13098
+fmu/pem/pem_functions/regression_models.py,sha256=wUw5yIIeR5sGz7OqAp42K4lxLUOKr-B4_1XkM9k2WXA,10391
+fmu/pem/pem_functions/run_friable_model.py,sha256=R3Nb0nQML6k5QrPwDoB7oMHaTkB-rJjCSPnJ_gsrIIQ,6885
+fmu/pem/pem_functions/run_patchy_cement_model.py,sha256=M561C_4dfPW_Nxm0AgzCUdeQ9UVIrZGGhxBayII1IDQ,6667
+fmu/pem/pem_functions/run_t_matrix_model.py,sha256=Ctl5Lw1HJvNYdqKDUnqrOWRisVV2m1J4gJ6S2u8j-Xw,7875
+fmu/pem/pem_utilities/__init__.py,sha256=OjQz4PjT8Rj2WYnuIoRYSnUXgkSsQESLIT3rp14LP5c,2143
+fmu/pem/pem_utilities/cumsum_properties.py,sha256=s3M0bMs6Dogg8cWzj5M6K5xifdRjhZse3dCWZL0_RCo,3431
+fmu/pem/pem_utilities/delta_cumsum_time.py,sha256=vDc7Hvl50qzUXbK4oKq30zlQ2fqMel9EmBO0lmeoDbo,3035
+fmu/pem/pem_utilities/enum_defs.py,sha256=R6Q0G6TQKe1MM4KTp1t_iCaFuCWEwLvIqV6tH3uxCms,2485
+fmu/pem/pem_utilities/export_routines.py,sha256=hteGM4flK8B7Jy4BNk5bU33-_jcNndFrm9RcnzfTdy4,10108
+fmu/pem/pem_utilities/fipnum_pvtnum_utilities.py,sha256=ypwTsyfqqBJ6d8WHY2HkKAdX9ZjHYLdQq_-3w2xEwVQ,7571
+fmu/pem/pem_utilities/import_config.py,sha256=eKV1LsajELCcTijLsGMzQg16XcicedCKmhhZJce-SQ4,3554
+fmu/pem/pem_utilities/import_routines.py,sha256=EVHCS-LaHXKwVgDiE5BDvybJgPi0PjFado2m1O9ezo4,5104
+fmu/pem/pem_utilities/pem_class_definitions.py,sha256=Q_k5s_Zj8q_9TKdnxdJdOeN1UVGZbH997ngs8_5t0Es,5504
+fmu/pem/pem_utilities/pem_config_validation.py,sha256=ps_mFuwh2SgpsoSC_5IwlLpMaLDzx9BRyEYvgSf3CQw,27441
+fmu/pem/pem_utilities/rpm_models.py,sha256=S4BDv5aTaMHgk-nSYxBQ1I_SzkSGXVd6HNtoUViElwE,21212
+fmu/pem/pem_utilities/update_grid.py,sha256=Ay0XPGXBl5CtdL5keTGzs0AKp44LgsuqxwBVwmHZV_s,1838
+fmu/pem/pem_utilities/utils.py,sha256=dHfQLDfwG27eC86lHN12PrITuock8M5IH-gD7eWAtCE,10583
+fmu_pem-0.0.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+fmu_pem-0.0.3.dist-info/METADATA,sha256=t2TFRKI9Cq718cFQxGYnmzfK1_8s9PSSGKpJ141K_Xo,43848
+fmu_pem-0.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fmu_pem-0.0.3.dist-info/entry_points.txt,sha256=NSoFnob1PAE6FzRyNJZn5idocnCB1ptNg6R8zYf7Gnc,98
+fmu_pem-0.0.3.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
+fmu_pem-0.0.3.dist-info/RECORD,,

fmu_pem-0.0.1.dist-info/RECORD

@@ -1,37 +0,0 @@
-fmu/__init__.py,sha256=YWSE22UTDSocfqQHxEeXrRkdlA63t_aayQVdJkycwYs,83
-fmu/pem/__init__.py,sha256=FhNaFibcFZEK1Rz7IBRXBgxMHGNlcgrHaD4FtU4pDjs,421
-fmu/pem/__main__.py,sha256=L8HW2P6_AQX70gcgmMdbW0BouCQdI0OVab-U4QkcPOk,1361
-fmu/pem/run_pem.py,sha256=z6UAuEAJlSVcbTeC2q5q8_ToKe0HIgQPHZfjRWSg6PI,3218
-fmu/pem/version.py,sha256=vgltXBYF55vNcC2regxjGN0_cbebmm8VgcDdQaDapWQ,511
-fmu/pem/forward_models/__init__.py,sha256=WuN66rmgfqrekCy3Ss9NHqsy-lZ4WGY-4VZa3jYDV2s,117
-fmu/pem/forward_models/pem_model.py,sha256=fKDD1-euwLBMr6rAjDYG0o-k7uKYRxG6De6bywF3AXI,2203
-fmu/pem/hook_implementations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fmu/pem/hook_implementations/jobs.py,sha256=IQW5m7oeZ_MiemxXv-UGLCPeo4h3QT9oELPlWAzsN60,388
-fmu/pem/pem_functions/__init__.py,sha256=G2tu5E1PFvlw36fLdmr2A4Xr9ZqbKMf104OU5ydh_3A,539
-fmu/pem/pem_functions/density.py,sha256=36A8yccsnVPXCpnIfuwNUf9FVvXDkCBpcn4UFuPngFE,1777
-fmu/pem/pem_functions/effective_pressure.py,sha256=3p_bFwgS-PtCN0hAaJXYLwdzuv2J5PHDLWhzyBQNfgU,6118
-fmu/pem/pem_functions/estimate_saturated_rock.py,sha256=azJjVwuUGCyiO-FIY-TYktR3PSBRoOB2ceY33PJyMsc,2756
-fmu/pem/pem_functions/fluid_properties.py,sha256=HCRay1blnWiK19N0nncoV6ftB-DHPC8d029Xsg4jaFw,10458
-fmu/pem/pem_functions/mineral_properties.py,sha256=ilf1TwE4DDev65TdHEuudxgLj41IRBWgSjXghNrCPak,8394
-fmu/pem/pem_functions/regression_models.py,sha256=7YfEiAbjxnP1UP1ugW8ay202grbumG4_vFppEpBkEDE,9085
-fmu/pem/pem_functions/run_friable_model.py,sha256=rT-LQ17gSrJS_l524LKiLnK5Q0Y5zx8lKRuO7GFd3fk,4258
-fmu/pem/pem_functions/run_patchy_cement_model.py,sha256=B-j-Aza2yT6qbBXIsR3HZmtjcBkONLqnq7AYbrgp_uU,4201
-fmu/pem/pem_functions/run_t_matrix_and_pressure.py,sha256=RmvFRm6QNvhpFp9Ar_ifWru6Yp0h-XnE9WS4lUR37Nk,6821
-fmu/pem/pem_utilities/__init__.py,sha256=r9vSDgrY4B2NwBK5PL-4GMD5o1aT2IpR1vaeOCgJ-tI,1687
-fmu/pem/pem_utilities/cumsum_properties.py,sha256=W2FtawYPZzdydGsVoOYCWIgOItNGKCRzhHzI5sUw05M,3769
-fmu/pem/pem_utilities/delta_cumsum_time.py,sha256=J83PSpO2xjxHP5tpDpleVxynt0eytqHLgbGzj79wTQI,3267
-fmu/pem/pem_utilities/enum_defs.py,sha256=nJWpvXBFRIE-f7A4AjsVwldM2fxSZGRXAYC0faEOckw,1067
-fmu/pem/pem_utilities/export_routines.py,sha256=gZa3AscefV9h55JQXL7juQg5SpMvhnN5nbBHFU2VtCI,9879
-fmu/pem/pem_utilities/import_config.py,sha256=H6nH_MVnVhuS4q-4KWhoOvQbGzV5Jnw1-KlD1BRccmY,3232
-fmu/pem/pem_utilities/import_routines.py,sha256=PRnHn2wsHRewi2z3AlSNu9i3li9srfPNq_TS9qv89a4,5263
-fmu/pem/pem_utilities/pem_class_definitions.py,sha256=IOwzHfMsoPoGWIs1-I-kI2wVbhgR5TjZHygXOMsECMk,3282
-fmu/pem/pem_utilities/pem_config_validation.py,sha256=nxHCCLCOV0bODH7LfFjdbQRbe0zhLulKYcMgG1YnjjQ,17878
-fmu/pem/pem_utilities/rpm_models.py,sha256=TxW8lmIMluU1JsgGUT6nlR899mlVk8GgQx2p5ODnr78,5726
-fmu/pem/pem_utilities/update_grid.py,sha256=InGaWrgIH5G9xyGqazAxQmVHL0nve4B9dAttisBsIpU,1775
-fmu/pem/pem_utilities/utils.py,sha256=Gm_onSB7KuHZ0iKzx5TjHCOBYkatewSyEXgC9J-UA70,8871
-fmu_pem-0.0.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-fmu_pem-0.0.1.dist-info/METADATA,sha256=-3GgiilfNJq6zv7F6eD0fIZ5qYSIeFs6nlh2cL7VeBk,43944
-fmu_pem-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fmu_pem-0.0.1.dist-info/entry_points.txt,sha256=NSoFnob1PAE6FzRyNJZn5idocnCB1ptNg6R8zYf7Gnc,98
-fmu_pem-0.0.1.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
-fmu_pem-0.0.1.dist-info/RECORD,,