ResSimpy 2.5.2__tar.gz → 2.5.3__tar.gz

{ressimpy-2.5.2 → ressimpy-2.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ResSimpy
-Version: 2.5.2
+Version: 2.5.3
 Summary: A Python library for working with Reservoir Simulator Models.
 License: Apache-2.0
 License-File: LICENSE.MD

{ressimpy-2.5.2 → ressimpy-2.5.3}/ResSimpy/FileOperations/file_operations.py

@@ -726,17 +726,19 @@ def split_lines_for_long_string(long_string: str, max_length: int, comment_chara
     return compiled_string
 
 
-def split_list_of_strings_by_length(list_of_strings: list[str], max_length: int) -> list[str]:
+def split_list_of_strings_by_length(list_of_strings: list[str], max_length: int,
+                                    comment_characters: None | list[str] = None) -> list[str]:
     """Splits a list of strings into a new list of strings with a maximum length.
 
     Args:
         list_of_strings (list[str]): The list of strings to be split.
         max_length (int): The maximum length of each string in the new list.
+        comment_characters (Optional[list[str]]): The comment characters to filter out. Defaults to None
 
     Returns:
         list[str]: A new list of strings split from the original list.
     """
-    return [split_lines_for_long_string(string, max_length) for string in list_of_strings]
+    return [split_lines_for_long_string(string, max_length, comment_characters) for string in list_of_strings]
 
 
 def get_full_file_path(file_path: str, origin: str, rootdir: Optional[str] = None, is_nexus: bool = True) -> str:
@@ -804,14 +806,20 @@ def split_file_as_list_by_date(file_as_list: list[str], date_token: str = 'TIME'
         of that token.
     """
     split_file: dict[str, list[str]] = {}
-    current_token_value = None
+    date_token_value = None
+    no_token_dict_key = f'BEFORE_FIRST_{date_token}'
+
     for i, line in enumerate(file_as_list):
         if check_token(date_token, line, comment_characters=comment_characters):
             # TODO handle 3 part dates in this bit
-            current_token_value = get_expected_token_value(token=date_token, token_line=line,
-                                                           file_list=file_as_list[i:],
-                                                           comment_characters=comment_characters)
-            split_file[current_token_value] = [line]
-        elif current_token_value is not None:
-            split_file[current_token_value].append(line)
+            date_token_value = get_expected_token_value(token=date_token, token_line=line,
+                                                        file_list=file_as_list[i:],
+                                                        comment_characters=comment_characters)
+            split_file[date_token_value] = [line]
+        elif date_token_value is None:
+            if no_token_dict_key not in split_file:
+                split_file[no_token_dict_key] = []
+            split_file[no_token_dict_key].append(line)
+        elif date_token_value is not None:
+            split_file[date_token_value].append(line)
     return split_file

{ressimpy-2.5.2 → ressimpy-2.5.3}/ResSimpy/Nexus/DataModels/Network/NexusProc.py

@@ -1,6 +1,11 @@
 from dataclasses import dataclass
-from typing import Optional, Mapping
+from typing import Optional
+
+from ResSimpy.DataModelBaseClasses.NetworkObject import NetworkObject
+from ResSimpy.Enums.UnitsEnum import UnitSystem
+from ResSimpy.Nexus.NexusEnums.DateFormatEnum import DateFormat
 from ResSimpy.Nexus.NexusKeywords.proc_keywords import PREDEFINED_VARS, CONDITIONAL_KEYWORDS, NEXUS_ALL_PROC_FUNCS
+from ResSimpy.Units.AttributeMappings.BaseUnitMapping import BaseUnitMapping
 
 
 # set custom error message
@@ -9,18 +14,15 @@ class SetError(Exception):
 
 
 @dataclass(kw_only=True, repr=True)
-class NexusProc:
+class NexusProc(NetworkObject):
     """Class that represents a single nexus procedure."""
-    __date: Optional[str]
-    __name: Optional[str]
     __priority: Optional[int]
     __contents: Optional[list[str]]
     __contents_breakdown: dict[str, int]
 
-    def __init__(self, date: Optional[str] = None,
-                 contents: Optional[list[str]] = None,
-                 name: Optional[str] = None,
-                 priority: Optional[int] = None) -> None:
+    def __init__(self, date: Optional[str] = None, contents: Optional[list[str]] = None,
+                 name: Optional[str] = None, priority: Optional[int] = None, unit_system: Optional[UnitSystem] = None,
+                 start_date: Optional[str] = None, date_format: Optional[DateFormat] = None) -> None:
         """Initialize the attributes of the class.
 
         Attributes:
@@ -33,33 +35,23 @@ class NexusProc:
         Methods:
                 reset_nexus_proc_function_counts(): Returns a dictionary of zero counts for the nexus proc functions.
         """
-
-        self.__date = date
-        self.__name = name
         self.__priority = priority
         self.__contents = contents
+
         self.__contents_breakdown = self.reset_nexus_proc_function_counts()
+        super().__init__(properties_dict={}, date=date, date_format=date_format, start_date=start_date,
+                         unit_system=unit_system, name=name)
 
     @property
     def contents(self) -> Optional[list[str]]:
         """Returns the contents of the main body of the procedure."""
         return self.__contents
 
-    @property
-    def date(self) -> Optional[str]:
-        """Returns the date that the procedure occurred."""
-        return self.__date
-
     @property
     def priority(self) -> Optional[int]:
         """Returns the priority of the procedure."""
         return self.__priority
 
-    @property
-    def name(self) -> Optional[str]:
-        """Returns the name of the procedure."""
-        return self.__name
-
     @property
     def contents_breakdown(self) -> dict[str, int]:
         """Returns the dictionary counts of the proc functions."""
@@ -76,9 +68,9 @@ class NexusProc:
                            'Nexus Keyword Manual page 1013.')
 
     @staticmethod
-    def get_keyword_mapping() -> Mapping[str, tuple[str, type]]:
+    def get_keyword_mapping() -> dict[str, tuple[str, type]]:
         """Gets the mapping of nexus keywords to attribute definitions."""
-        keywords = {
+        keywords: dict[str, tuple[str, type]] = {
             'NAME': ('name', str),
             'PRIORITY': ('priority', str)
         }
@@ -99,3 +91,21 @@ class NexusProc:
         to_search = predef_vars | cond | all_proc_funcs
 
         return to_search
+
+    def to_string(self) -> str:
+        """Outputs the procedure as a string in the format it would be written in a Nexus file."""
+        output_str = "PROCS"
+        if self.name is not None:
+            output_str += f" NAME {self.name}"
+        if self.priority is not None:
+            output_str += f" PRIORITY {self.priority}"
+        output_str += '\n'
+        if self.contents is not None:
+            output_str += '\n'.join(self.contents) + '\n'
+        output_str += "ENDPROCS\n"
+        return output_str
+
+    @property
+    def units(self) -> BaseUnitMapping:
+        """Returns the attribute to unit map for the data object."""
+        return BaseUnitMapping(None)

{ressimpy-2.5.2 → ressimpy-2.5.3}/ResSimpy/Nexus/DataModels/Network/NexusProcs.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass, field
 from typing import Sequence, TYPE_CHECKING
 
 from ResSimpy.Nexus.DataModels.Network.NexusProc import NexusProc
+from ResSimpy.Time.ISODateTime import ISODateTime
 
 if TYPE_CHECKING:
     from ResSimpy.Nexus.NexusNetwork import NexusNetwork
@@ -35,3 +36,11 @@ class NexusProcs:
     def _add_to_memory(self, procs_to_add: list[NexusProc]) -> None:
         """Adds the list of Nexus procedure objects to memory."""
         self.__procs.extend(procs_to_add)
+
+    def to_string_for_date(self, date: ISODateTime) -> str:
+        """Outputs the procedures for a specific date."""
+        output_str = ''
+        procs_for_date = [x for x in self.__procs if x.iso_date == date]
+        for proc in procs_for_date:
+            output_str += proc.to_string()
+        return output_str

ressimpy-2.5.3/ResSimpy/Nexus/DataModels/Network/NexusStreamTracer.py

@@ -0,0 +1,89 @@
+"""Class representing a single Nexus STREAM_TRACER entry."""
+
+from __future__ import annotations
+from dataclasses import dataclass
+
+from ResSimpy.DataModelBaseClasses.DataObjectMixin import DataObjectMixinDictType
+from ResSimpy.Enums.UnitsEnum import UnitSystem
+from ResSimpy.Nexus.NexusEnums.DateFormatEnum import DateFormat
+from ResSimpy.DataModelBaseClasses.NetworkObject import NetworkObject
+from ResSimpy.Units.AttributeMappings.BaseUnitMapping import BaseUnitMapping
+
+
+@dataclass(kw_only=True, repr=False)
+class NexusStreamTracer(NetworkObject):
+    """Represents a single row in a Nexus STREAM_TRACER table.
+
+    A STREAM_TRACER block associates named streams with a fluid component and
+    an optional tracer name and concentration, e.g.::
+
+        STREAM_TRACER
+        NAME       COMPONENT   TRACER   CONCENTRATION
+        SEAWTR     WATER       SALT     1.0
+        TRTWTR     WATER       SALT     1.0
+        ENDSTREAM_TRACER
+
+    Attributes:
+        name (str): The stream name (NAME column). Used in WELLS tables as the STREAM value.
+        component (str): The fluid component associated with this stream (COMPONENT column),
+            e.g. ``'WATER'``, ``'GAS'``, ``'OIL'``.
+        tracer (Optional[str]): The tracer label (TRACER column). Defaults to None.
+        concentration (Optional[float]): Tracer concentration (CONCENTRATION column). Defaults to None.
+    """
+
+    component: str | None = None
+    tracer: str | None = None
+    concentration: float | None = None
+
+    def __init__(
+        self,
+        properties_dict: DataObjectMixinDictType | None = None,
+        date: str | None = None,
+        date_format: DateFormat | None = None,
+        start_date: str | None = None,
+        unit_system: UnitSystem | None = None,
+        name: str | None = None,
+        component: str | None = None,
+        tracer: str | None = None,
+        concentration: float | None = None,
+    ) -> None:
+        """Initialises the NexusStreamTracer class.
+
+        Args:
+            properties_dict (Optional[dict]): dict of the properties to set on the object.
+            date (Optional[str]): The date of the object.
+            date_format (Optional[DateFormat]): The date format that the object uses.
+            start_date (Optional[str]): The start date of the model.
+            unit_system (Optional[UnitSystem]): The unit system of the object e.g. ENGLISH, METRIC.
+            name (Optional[str]): The stream name (NAME column).
+            component (Optional[str]): Fluid component, e.g. ``'WATER'``, ``'GAS'``, ``'OIL'``.
+            tracer (Optional[str]): Tracer label (TRACER column).
+            concentration (Optional[float]): Tracer concentration (CONCENTRATION column).
+        """
+        self.component = component
+        self.tracer = tracer
+        self.concentration = concentration
+
+        super().__init__(
+            properties_dict=properties_dict,
+            date=date,
+            date_format=date_format,
+            start_date=start_date,
+            unit_system=unit_system,
+            name=name,
+        )
+
+    @staticmethod
+    def get_keyword_mapping() -> dict[str, tuple[str, type]]:
+        """Gets the mapping of Nexus STREAM_TRACER column headers to attribute definitions."""
+        return {
+            'NAME': ('name', str),
+            'COMPONENT': ('component', str),
+            'TRACER': ('tracer', str),
+            'CONCENTRATION': ('concentration', float),
+        }
+
+    @property
+    def units(self) -> BaseUnitMapping:
+        """Returns the attribute-to-unit map for this data object."""
+        return BaseUnitMapping(unit_system=self.unit_system)

ressimpy-2.5.3/ResSimpy/Nexus/DataModels/Network/NexusStreamTracers.py

@@ -0,0 +1,73 @@
+"""Container class for Nexus STREAM_TRACER entries."""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Sequence, TYPE_CHECKING
+
+from ResSimpy.Nexus.DataModels.Network.NexusStreamTracer import NexusStreamTracer
+
+if TYPE_CHECKING:
+    from ResSimpy.Nexus.NexusNetwork import NexusNetwork
+
+
+@dataclass(kw_only=True)
+class NexusStreamTracers:
+    """Container for all :class:`NexusStreamTracer` objects parsed from STREAM_TRACER blocks.
+
+    Also exposes a :py:attr:`component_map` property that returns a ``dict[str, str]``
+    mapping each stream name (uppercased) to its declared COMPONENT, which is used by
+    :class:`~ResSimpy.Nexus.NexusNetwork.NexusNetwork` to classify well types.
+    """
+
+    __stream_tracers: list[NexusStreamTracer] = field(default_factory=list)
+
+    def __init__(self, parent_network: NexusNetwork) -> None:
+        """Initialises the NexusStreamTracers class.
+
+        Args:
+            parent_network (NexusNetwork): The network that these stream tracers belong to.
+        """
+        self.__parent_network: NexusNetwork = parent_network
+        self.__stream_tracers: list[NexusStreamTracer] = []
+
+    def get_all(self) -> Sequence[NexusStreamTracer]:
+        """Returns all loaded :class:`NexusStreamTracer` objects."""
+        self.__parent_network.get_load_status()
+        return self.__stream_tracers
+
+    def get_by_name(self, name: str) -> NexusStreamTracer | None:
+        """Returns the first :class:`NexusStreamTracer` whose stream name matches *name* (case-insensitive).
+
+        Args:
+            name (str): Stream name to look up.
+
+        Returns:
+            NexusStreamTracer | None: Matching object, or ``None`` if not found.
+        """
+        self.__parent_network.get_load_status()
+        name_upper = name.upper()
+        for st in self.__stream_tracers:
+            if st.name is not None and st.name.upper() == name_upper:
+                return st
+        return None
+
+    @property
+    def component_map(self) -> dict[str, str]:
+        """Returns a ``dict`` mapping stream name → component (both uppercased).
+
+        Example::
+
+            {'SEAWTR': 'WATER', 'TRTWTR': 'WATER', 'GASSTREAM': 'GAS'}
+        """
+        self.__parent_network.get_load_status()
+        return {
+            st.name.upper(): st.component.upper()
+            for st in self.__stream_tracers
+            if st.name is not None and st.component is not None
+        }
+
+    def _add_to_memory(self, stream_tracers_to_add: list[NexusStreamTracer] | None) -> None:
+        """Appends a list of :class:`NexusStreamTracer` objects to the internal store."""
+        if stream_tracers_to_add is None:
+            return
+        self.__stream_tracers.extend(stream_tracers_to_add)

{ressimpy-2.5.2 → ressimpy-2.5.3}/ResSimpy/Nexus/DataModels/Network/NexusWellLists.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Literal, Sequence
 
 from ResSimpy.DataModelBaseClasses.NetworkList import NetworkList
 from ResSimpy.GenericContainerClasses.NetworkLists import NetworkLists
-from ResSimpy.Nexus.DataModels.NexusWellList import NexusWellList
+from ResSimpy.Nexus.DataModels.Network.NexusWellList import NexusWellList
 
 if TYPE_CHECKING:
     from ResSimpy.Nexus.NexusNetwork import NexusNetwork

{ressimpy-2.5.2 → ressimpy-2.5.3}/ResSimpy/Nexus/DataModels/StructuredGrid/NexusGrid.py

@@ -6,7 +6,7 @@ import copy
 import numpy as np
 import pandas as pd
 from dataclasses import dataclass, field
-from typing import Optional, TYPE_CHECKING, Any, Final
+from typing import TYPE_CHECKING, Any, Final
 import warnings
 from sys import maxsize
 
@@ -43,14 +43,14 @@ class PropertyToLoad:
 
 @dataclass(kw_only=True)
 class NexusGrid(Grid):
-    __array_functions_list: Optional[list[list[str]]] = None
-    __array_functions_df: Optional[pd.DataFrame] = None
+    __array_functions_list: list[list[str]] | None = None
+    __array_functions_df: pd.DataFrame | None = None
     __array_functions_loaded: bool = False
-    __grid_file_contents: Optional[list[str]] = None
-    __grid_file_nested: Optional[list[str]] = None
-    __faults_df: Optional[pd.DataFrame] = None
+    __grid_file_contents: list[str] | None = None
+    __grid_file_nested: list[str] | None = None
+    __faults_df: pd.DataFrame | None = None
     __grid_faults_loaded: bool = False
-    __grid_nexus_file: Optional[NexusFile] = None
+    __grid_nexus_file: NexusFile | None = None
     __corp: GridArrayDefinition
     __dx: GridArrayDefinition
     __dy: GridArrayDefinition
@@ -125,14 +125,14 @@ class NexusGrid(Grid):
     __kyeff: GridArrayDefinition
     __kzeff: GridArrayDefinition
     __grid_multir_loaded: bool = False
-    __multir: Optional[list[NexusMultir]] = None
+    __multir: list[NexusMultir] | None = None
     __lgrs: NexusLGRs
     __overs: list[NexusOver] = field(default_factory=list)
     __tovers: list[NexusTOver] = field(default_factory=list)
     __ftrans: list[NexusFtrans] = field(default_factory=list)
     __model_unit_system: UnitSystem
 
-    def __init__(self, model_unit_system: UnitSystem, grid_nexus_file: Optional[NexusFile] = None,
+    def __init__(self, model_unit_system: UnitSystem, grid_nexus_file: NexusFile | None = None,
                  assume_loaded: bool = False,
                  ) -> None:
         """Initialises the NexusGrid class.
@@ -146,15 +146,15 @@ class NexusGrid(Grid):
         super().__init__(assume_loaded=assume_loaded)
         self.__array_functions_loaded: bool = assume_loaded
         self.__grid_faults_loaded: bool = assume_loaded
-        self.__array_functions_list: Optional[list[list[str]]] = None
-        self.__array_functions_df: Optional[pd.DataFrame] = None
-        self.__grid_file_contents: Optional[list[str]] = None if grid_nexus_file is None else \
+        self.__array_functions_list: list[list[str]] | None = None
+        self.__array_functions_df: pd.DataFrame | None = None
+        self.__grid_file_contents: list[str] | None = None if grid_nexus_file is None else \
             grid_nexus_file.get_flat_list_str_file_including_includes
-        self.__grid_file_nested: Optional[list[str]] = None if grid_nexus_file is None else \
+        self.__grid_file_nested: list[str] | None = None if grid_nexus_file is None else \
             grid_nexus_file.file_content_as_list
-        self.__faults_df: Optional[pd.DataFrame] = None
-        self.__grid_nexus_file: Optional[NexusFile] = grid_nexus_file
-        self.__grid_array_functions: Optional[list[NexusGridArrayFunction]] = None
+        self.__faults_df: pd.DataFrame | None = None
+        self.__grid_nexus_file: NexusFile | None = grid_nexus_file
+        self.__grid_array_functions: list[NexusGridArrayFunction] | None = None
         self.__corp: GridArrayDefinition = GridArrayDefinition()
         self.__iequil: GridArrayDefinition = GridArrayDefinition()
         self.__ipvt: GridArrayDefinition = GridArrayDefinition()
@@ -257,14 +257,14 @@ class NexusGrid(Grid):
         # Prevent reload from disk
         self._grid_properties_loaded = True
 
-    def to_dict(self) -> dict[str, Optional[int] | GridArrayDefinition]:
+    def to_dict(self) -> dict[str, int | None | GridArrayDefinition]:
         """Returns a dictionary representation of grid array.
         Checks if grid properties are not loaded and loads them.
         """
         self.load_grid_properties_if_not_loaded()
 
         original_dict = self.__dict__
-        new_dict: dict[str, Optional[int] | GridArrayDefinition] = {}
+        new_dict: dict[str, int | None | GridArrayDefinition] = {}
         for key in original_dict.keys():
             new_key = key
             if new_key[0] == '_':
@@ -709,13 +709,13 @@ class NexusGrid(Grid):
         self.__array_functions_df = afo.summarize_model_functions(self.__array_functions_list)
         self.__array_functions_loaded = True
 
-    def get_array_functions_list(self) -> Optional[list[list[str]]]:
+    def get_array_functions_list(self) -> list[list[str]] | None:
         """Returns the grid array functions as a list of function lines."""
         if not self.__array_functions_loaded:
             self.load_array_functions()
         return self.__array_functions_list
 
-    def get_array_functions_df(self) -> Optional[pd.DataFrame]:
+    def get_array_functions_df(self) -> pd.DataFrame | None:
         """Returns the grid array functions as a dataframe."""
         if not self.__array_functions_loaded:
             self.load_array_functions()
@@ -753,7 +753,7 @@ class NexusGrid(Grid):
             self.__faults_df = new_df.drop(['TMULT'], axis=1)
         self.__grid_faults_loaded = True
 
-    def get_faults_df(self) -> Optional[pd.DataFrame]:
+    def get_faults_df(self) -> pd.DataFrame | None:
         """Returns the fault definition and transmissility multiplier information as a dataframe."""
         self.load_grid_properties_if_not_loaded()
         if not self.__grid_faults_loaded:
@@ -804,7 +804,7 @@ class NexusGrid(Grid):
     def __extract_multir_tableline(line: str) -> None | NexusMultir:
         """Takes a single line in a file and extracts a Multir object from it."""
         stored_values = fo.split_line(line)
-        if not stored_values:
+        if not stored_values or len(stored_values) < 3:
             return None
         region_1_str, region_2_str, tmult_str = stored_values[0:3]
         region_1 = int(region_1_str)
@@ -854,7 +854,7 @@ class NexusGrid(Grid):
             return None
 
     @property
-    def array_functions(self) -> Optional[list[NexusGridArrayFunction]]:
+    def array_functions(self) -> list[NexusGridArrayFunction] | None:
         """Returns a list of the array functions defined in the structured grid file."""
         self.load_grid_properties_if_not_loaded()
         if self.__grid_array_functions is None:
@@ -1814,7 +1814,8 @@ class NexusGrid(Grid):
 
         # add the faults
         faults_df = self.get_faults_df()
-        grid_str += NexusGrid.fault_df_to_string(faults_df)
+        if faults_df is not None and not faults_df.empty:
+            grid_str += NexusGrid.fault_df_to_string(faults_df)
 
         if self.array_functions:
             for array_function in self.array_functions:

{ressimpy-2.5.2 → ressimpy-2.5.3}/ResSimpy/Nexus/NexusNetwork.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 import re
 import warnings
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional, Any, Literal
+from typing import TYPE_CHECKING, Any, Literal
 
 import ResSimpy.FileOperations.file_operations as fo
 from ResSimpy.DataModelBaseClasses.DataObjectMixin import DataObjectMixinDictType
@@ -38,6 +38,8 @@ from ResSimpy.Nexus.DataModels.Network.NexusProc import NexusProc
 from ResSimpy.Nexus.DataModels.Network.NexusProcs import NexusProcs
 from ResSimpy.Nexus.DataModels.Network.NexusStation import NexusStation
 from ResSimpy.Nexus.DataModels.Network.NexusStations import NexusStations
+from ResSimpy.Nexus.DataModels.Network.NexusStreamTracer import NexusStreamTracer
+from ResSimpy.Nexus.DataModels.Network.NexusStreamTracers import NexusStreamTracers
 from ResSimpy.Nexus.DataModels.Network.NexusTarget import NexusTarget
 from ResSimpy.Nexus.DataModels.Network.NexusTargets import NexusTargets
 from ResSimpy.Nexus.DataModels.Network.NexusWellConnection import NexusWellConnection
@@ -48,7 +50,7 @@ from ResSimpy.Nexus.DataModels.Network.NexusWellbores import NexusWellbores
 from ResSimpy.Nexus.DataModels.Network.NexusWellhead import NexusWellhead
 from ResSimpy.Nexus.DataModels.Network.NexusWellheads import NexusWellheads
 from ResSimpy.Nexus.DataModels.NexusFile import NexusFile
-from ResSimpy.Nexus.DataModels.NexusWellList import NexusWellList
+from ResSimpy.Nexus.DataModels.Network.NexusWellList import NexusWellList
 from ResSimpy.Nexus.NexusEnums.ActivationChangeEnum import ActivationChangeEnum
 from ResSimpy.Nexus.nexus_collect_tables import collect_all_tables_to_objects
 
@@ -80,6 +82,7 @@ class NexusNetwork(Network):
     conlists: NexusConLists
     stations: NexusStations
     guide_rates: NexusGuideRates
+    stream_tracers: NexusStreamTracers
     _has_been_loaded: bool = False
 
     def __init__(self, model: NexusSimulator, assume_loaded: bool = False) -> None:
@@ -109,6 +112,12 @@ class NexusNetwork(Network):
         self.drills: NexusDrills = NexusDrills(self)
         self.drill_sites: NexusDrillSites = NexusDrillSites(self)
         self.guide_rates: NexusGuideRates = NexusGuideRates(self)
+        self.stream_tracers: NexusStreamTracers = NexusStreamTracers(self)
+
+    @property
+    def stream_tracer_map(self) -> dict[str, str]:
+        """Returns a stream-name to component mapping derived from parsed STREAM_TRACER objects."""
+        return self.stream_tracers.component_map
 
     @property
     def model(self) -> NexusSimulator:
@@ -163,9 +172,8 @@ class NexusNetwork(Network):
             time = self.__model.start_date
             name_ = None
             priority_ = None
-            # initialize an empty proc object, so we can use its staticmethod reset_nexus_proc_function_counts
-            proc_obj = NexusProc()
-            nexus_proc_function_counts = proc_obj.reset_nexus_proc_function_counts()
+            nexus_proc_function_counts = NexusProc.reset_nexus_proc_function_counts()
+            date_format = self.__model.date_format
 
             for line in file_contents:
 
@@ -176,7 +184,8 @@ class NexusNetwork(Network):
                 # check for keyword ENDPROCS to signal end of the procedure
                 if fo.check_token('ENDPROCS', line=line):
                     # create the proc object
-                    proc_obj = NexusProc(contents=proc_contents, date=time, name=name_, priority=priority_)
+                    proc_obj = NexusProc(contents=proc_contents, date=time, name=name_, priority=priority_,
+                                         date_format=date_format, start_date=self.__model.start_date)
 
                     # set the proc function counts
                     proc_obj.contents_breakdown = nexus_proc_function_counts
@@ -231,14 +240,15 @@ class NexusNetwork(Network):
         Table headers with None next to their name are currently skipped awaiting development.
         """
 
-        def type_check_lists(value: Optional[list[Any] | dict[str, list[NexusConstraint]]]) -> Optional[list[Any]]:
+        def type_check_lists(value: list[Any] | dict[str, list[NexusConstraint]] | None) -> list[Any] | None:
             """Guards against dictionaries coming from the dictionary."""
             if isinstance(value, dict):
                 raise TypeError(f"Expected a list, instead received a dict: {value}")
             return value
 
-        def type_check_dicts(value: Optional[list[Any] | dict[str, list[NexusConstraint]]]) -> \
-                Optional[dict[str, list[NexusConstraint]]]:
+        def type_check_dicts(
+            value: list[Any] | dict[str, list[NexusConstraint]] | None
+        ) -> dict[str, list[NexusConstraint]] | None:
             """Guards against dictionaries coming from the dictionary."""
             if isinstance(value, list):
                 raise TypeError(f"Expected a dict, instead received a list: {value}")
@@ -269,6 +279,7 @@ class NexusNetwork(Network):
                                       'STATION': NexusStation,
                                       'DRILL': NexusDrill,
                                       'DRILLSITE': NexusDrillSite,
+                                      'STREAM_TRACER': NexusStreamTracer,
                                       }
 
         for surface in self.__model.model_files.surface_files.values():
@@ -297,6 +308,7 @@ class NexusNetwork(Network):
             self.drills._add_to_memory(type_check_lists(nexus_obj_dict.get('DRILL')))
             self.drill_sites._add_to_memory(type_check_lists(nexus_obj_dict.get('DRILLSITE')))
             self.guide_rates._add_to_memory(type_check_lists(nexus_obj_dict.get('GUIDERATE')))
+            self.stream_tracers._add_to_memory(type_check_lists(nexus_obj_dict.get('STREAM_TRACER')))
 
             actions_check = type_check_lists(nexus_obj_dict.get('ACTIONS'))
             if actions_check is not None:
@@ -335,7 +347,9 @@ class NexusNetwork(Network):
         return activation_changes
 
     def __update_well_types(self) -> None:
-        """Updates the types of all of the wells using information found in the wells table."""
+        """Updates the types of all of the wells using information found in the wells table.
+        Falls back to the STREAM_TRACER component_map when the stream name is not a standard phase keyword.
+        """
         for connection in self.well_connections.get_all():
             if connection.name is None or connection.stream is None:
                 # Connection cannot be used to determine well type, so ignore it.
@@ -347,7 +361,8 @@ class NexusNetwork(Network):
                 warnings.warn(UserWarning(f'Cannot find matching well for {connection.name} declared in surface file.'))
                 continue
 
-            match connection.stream.upper():
+            stream_upper = connection.stream.upper()
+            match stream_upper:
                 case 'PRODUCER':
                     well_type = WellType.PRODUCER
                 case 'GAS':
@@ -357,7 +372,18 @@ class NexusNetwork(Network):
                 case 'OIL':
                     well_type = WellType.OIL_INJECTOR
                 case _:
-                    well_type = WellType.PRODUCER
+                    # Look up the stream name in the STREAM_TRACER component map to resolve
+                    # custom stream names (e.g. 'SEAWTR', 'TRTWTR', etc.) to
+                    # their declared COMPONENT and map that to a WellType.
+                    component = self.stream_tracers.component_map.get(stream_upper)
+                    if component == 'WATER':
+                        well_type = WellType.WATER_INJECTOR
+                    elif component == 'GAS':
+                        well_type = WellType.GAS_INJECTOR
+                    elif component == 'OIL':
+                        well_type = WellType.OIL_INJECTOR
+                    else:
+                        well_type = WellType.PRODUCER
 
             well_to_modify.well_type = well_type
 

{ressimpy-2.5.2 → ressimpy-2.5.3}/ResSimpy/Nexus/nexus_collect_tables.py

@@ -14,7 +14,7 @@ from ResSimpy.Nexus.DataModels.Network.NexusConLists import NexusConLists
 from ResSimpy.Nexus.DataModels.Network.NexusNodeLists import NexusNodeLists
 from ResSimpy.Nexus.DataModels.Network.NexusConstraint import NexusConstraint
 from ResSimpy.Nexus.DataModels.Network.NexusWellLists import NexusWellLists
-from ResSimpy.Nexus.DataModels.NexusWellList import NexusWellList
+from ResSimpy.Nexus.DataModels.Network.NexusWellList import NexusWellList
 from ResSimpy.Nexus.NexusEnums.ActivationChangeEnum import ActivationChangeEnum
 from ResSimpy.Nexus.NexusEnums.DateFormatEnum import DateFormat
 from ResSimpy.Nexus.nexus_constraint_operations import load_inline_constraints

{ressimpy-2.5.2 → ressimpy-2.5.3}/ResSimpy/Nexus/nexus_constraint_operations.py

@@ -7,7 +7,7 @@ import re
 from ResSimpy.DataModelBaseClasses.DataObjectMixin import DataObjectMixinDictType
 from ResSimpy.Nexus.DataModels.Network.NexusConstraint import NexusConstraint
 from ResSimpy.Enums.UnitsEnum import UnitSystem
-from ResSimpy.Nexus.DataModels.NexusWellList import NexusWellList
+from ResSimpy.Nexus.DataModels.Network.NexusWellList import NexusWellList
 from ResSimpy.Nexus.NexusEnums.DateFormatEnum import DateFormat
 from ResSimpy.Nexus.nexus_file_operations import get_next_value, correct_datatypes
 from ResSimpy.Utils.invert_nexus_map import nexus_keyword_to_attribute_name