ResSimpy 2.3.9__tar.gz → 2.4.0__tar.gz

{ressimpy-2.3.9 → ressimpy-2.4.0}/PKG-INFO

@@ -1,24 +1,25 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: ResSimpy
-Version: 2.3.9
+Version: 2.4.0
 Summary: A Python library for working with Reservoir Simulator Models.
 License: Apache-2.0
 Keywords: ResSimpy,Reservoir Engineering
 Author: BP
-Requires-Python: >=3.10,<3.12
+Requires-Python: >=3.10,<3.13
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: System :: Filesystems
-Requires-Dist: numpy (>=1.25,<2.0)
-Requires-Dist: pandas (>=1.5,<2.0)
-Requires-Dist: resqpy (>=4.12,<5.0)
-Requires-Dist: typing-extensions (>=4.8,<5.0)
+Requires-Dist: numpy (>=1.26,<2.0)
+Requires-Dist: pandas (>=2.2,<3.0)
+Requires-Dist: resqpy (>=5.1,<6.0)
+Requires-Dist: typing-extensions (>=4.12,<5.0)
 Description-Content-Type: text/markdown
 
 # ResSimpy: Python API for working with Reservoir Simulator models

ressimpy-2.4.0/ResSimpy/DataModelBaseClasses/Ftrans.py

@@ -0,0 +1,32 @@
+from abc import ABC
+from dataclasses import dataclass
+from typing import Optional
+
+from ResSimpy.Enums.UnitsEnum import UnitSystem
+
+
+@dataclass
+class Ftrans(ABC):
+    """Used to represent an abstract base of Ftrans for transmissibility modification by cell.
+
+    Attributes:
+        i1 (int): i coordinate of the first cell
+        i2 (int): i coordinate of the second cell
+        j1 (int): j coordinate of the first cell
+        j2 (int): j coordinate of the second cell
+        k1 (int): k coordinate of the first cell
+        k2 (int): k coordinate of the second cell
+        value (float): The value to be assigned to the range.
+        grid (Optional[str]): The grid that the Over function relates to.
+        fault_name (Optional[str]): The named fault that the Over function relates to.
+    """
+    i1: int
+    i2: int
+    j1: int
+    j2: int
+    k1: int
+    k2: int
+    value: float
+    unit_system: UnitSystem
+    grid: Optional[str] = None
+    fault_name: Optional[str] = None

{ressimpy-2.3.9 → ressimpy-2.4.0}/ResSimpy/DataModelBaseClasses/Grid.py

@@ -11,6 +11,7 @@ import numpy as np
 from ResSimpy.DataModelBaseClasses.GridArrayDefinition import GridArrayDefinition
 from ResSimpy.DataModelBaseClasses.GridArrayFunction import GridArrayFunction
 from ResSimpy.DataModelBaseClasses.Over import Over
+from ResSimpy.Enums.UnitsEnum import UnitSystem
 from ResSimpy.FileOperations.File import File
 from ResSimpy.GenericContainerClasses.LGRs import LGRs
 
@@ -169,7 +170,8 @@ class Grid(ABC):
         return self._lgrs
 
     @abstractmethod
-    def load_structured_grid_file(self, structure_grid_file: File, lazy_loading: bool) -> Grid:
+    def load_structured_grid_file(self, structure_grid_file: File,
+                                  model_unit_system: UnitSystem, lazy_loading: bool) -> Grid:
         """Loads in a structured grid file with all grid properties, and the array functions defined with 'FUNCTION'.
 
         Args:
@@ -177,6 +179,7 @@ class Grid(ABC):
             converting into a structured grid file class.
             lazy_loading(bool): If set to True, parts of the grid will only be loaded in
              when requested via properties on the object.
+            model_unit_system(UnitSystem): The default unit system used in the model.
         """
         raise NotImplementedError("Implement this in the derived class")
 

{ressimpy-2.3.9 → ressimpy-2.4.0}/ResSimpy/DataModelBaseClasses/Over.py

@@ -33,3 +33,5 @@ class Over(ABC):
     threshold: Optional[float] = None
     grid: Optional[str] = None
     fault_name: Optional[str] = None
+    array_values: Optional[list[float]] = None
+    include_file: Optional[str] = None

{ressimpy-2.3.9 → ressimpy-2.4.0}/ResSimpy/Nexus/DataModels/FcsFile.py

@@ -275,8 +275,10 @@ class FcsNexusFile(NexusFile):
                                             nexus_file.last_modified))
             elif key in cls.fcs_keyword_map_single():
                 full_file_path = nfo.get_full_file_path(value, origin_path)
+                skip_arrays = True if key == 'STRUCTURED_GRID' else False
                 nexus_file = NexusFile.generate_file_include_structure(
-                    file_path=value, origin=fcs_file_path, recursive=recursive, top_level_file=True)
+                    file_path=value, origin=fcs_file_path, recursive=recursive, top_level_file=True,
+                    skip_arrays=skip_arrays)
                 setattr(fcs_file, cls.fcs_keyword_map_single()[key], nexus_file)
                 fcs_file.include_objects.append(nexus_file)
                 fcs_file.include_locations.append(full_file_path)

{ressimpy-2.3.9 → ressimpy-2.4.0}/ResSimpy/Nexus/DataModels/Network/NexusWellhead.py

@@ -33,7 +33,7 @@ class NexusWellhead(Wellhead):
         temperature (float):  The temperature of the fluid in the well  (TEMP)
         elevation_profile (str):  The well elevation profile. (ELEVPR)
         temperature_profile (str):  The well temperature profile. (TEMPPR)
-        dp_add (float):  The additional pressure drop across the well (DPADD)
+        dp_add (float):  The additional pressure drop across the well  (DPADD)
         rate_mult (float):  The rate multiplier for the well. (RATEMULT)
         delta_depth (float):  The depth difference between the two points in the connection  (DDEPTH)
         heat_transfer_coeff (float):  The heat transfer coefficient for the well  (HTC)

{ressimpy-2.3.9 → ressimpy-2.4.0}/ResSimpy/Nexus/DataModels/NexusFile.py

@@ -223,6 +223,29 @@ class NexusFile(File):
             inc_full_path = nfo.get_full_file_path(inc_file_path, origin=full_file_path)
             # store the included files as files inside the object
             inc_file_list.append(inc_full_path)
+
+            # test the include to see if the first few lines have only array data
+            # limit number of lines loaded here in future?
+            if skip_arrays:
+                try:
+                    inc_file_as_list = nfo.load_file_as_list(inc_full_path)
+                except FileNotFoundError:
+                    # handle files not found - this is handled in an exception in the main loop
+                    pass
+                else:
+                    all_numeric = False
+                    for inc_file_line in inc_file_as_list[0:50]:
+                        split_line = nfo.split_line(inc_file_line, upper=False)
+                        # check if it is numeric data
+                        # this won't work if the array has scientific notation.
+                        if any(not x.lstrip('-+').replace('.', '', 1).isnumeric() for x in split_line):
+                            # don't set skip_next_include if the line is not entirely numeric
+                            all_numeric = False
+                            break
+                        all_numeric = True
+                    if all_numeric:
+                        skip_next_include = True
+
             if not recursive:
                 continue
             elif skip_arrays and skip_next_include:

{ressimpy-2.3.9 → ressimpy-2.4.0}/ResSimpy/Nexus/DataModels/NexusPVTMethod.py

@@ -181,7 +181,7 @@ class NexusPVTMethod(DynamicProperty):
                 printable_str += '\n'
             elif isinstance(value, dict):
                 for subkey in value.keys():
-                    printable_str += f"{key.replace('_',' ')} {subkey}\n"
+                    printable_str += f"{key.replace('_', ' ')} {subkey}\n"
                     df = value[subkey]
                     if isinstance(df, pd.DataFrame):
                         printable_str += df.to_string(na_rep='', index=False,

{ressimpy-2.3.9 → ressimpy-2.4.0}/ResSimpy/Nexus/DataModels/NexusRockMethod.py

@@ -86,7 +86,7 @@ class NexusRockMethod(DynamicProperty):
                 printable_str += f'{key}\n'
                 printable_str += value.to_string(na_rep='', index=False) + '\n\n'
             elif isinstance(value, dict):
-                printable_str += f"{key.replace('_',' ')}\n"
+                printable_str += f"{key.replace('_', ' ')}\n"
                 for subkey in value.keys():
                     printable_str += f"SWINIT {subkey}\n"
                     df = value[subkey]

ressimpy-2.4.0/ResSimpy/Nexus/DataModels/StructuredGrid/NexusFtrans.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from ResSimpy.DataModelBaseClasses.Ftrans import Ftrans
+from ResSimpy.Enums.UnitsEnum import UnitSystem
+
+
+@dataclass
+class NexusFtrans(Ftrans):
+    """Used to represent an abstract base of Ftrans for transmissibility modification by cell.
+
+    Attributes:
+        i1 (int): i coordinate of the first cell
+        i2 (int): i coordinate of the second cell
+        j1 (int): j coordinate of the first cell
+        j2 (int): j coordinate of the second cell
+        k1 (int): k coordinate of the first cell
+        k2 (int): k coordinate of the second cell
+        value (float): The value to be assigned to the range.
+        grid (Optional[str]): The grid that the Over function relates to.
+        fault_name (Optional[str]): The named fault that the Over function relates to.
+    """
+    i1: int
+    i2: int
+    j1: int
+    j2: int
+    k1: int
+    k2: int
+    value: float
+    unit_system: UnitSystem
+    grid: Optional[str] = None
+    fault_name: Optional[str] = None

{ressimpy-2.3.9 → ressimpy-2.4.0}/ResSimpy/Nexus/DataModels/StructuredGrid/NexusGrid.py

@@ -8,14 +8,17 @@ from dataclasses import dataclass, field
 from typing import Optional, TYPE_CHECKING, Any, Final
 import warnings
 
+from ResSimpy.Enums.UnitsEnum import UnitSystem
 from ResSimpy.FileOperations.File import File
 from ResSimpy.DataModelBaseClasses.Grid import Grid
 from ResSimpy.DataModelBaseClasses.GridArrayDefinition import GridArrayDefinition
 from ResSimpy.Nexus.DataModels.NexusFile import NexusFile
+from ResSimpy.Nexus.DataModels.StructuredGrid.NexusFtrans import NexusFtrans
 from ResSimpy.Nexus.DataModels.StructuredGrid.NexusGridArrayFunction import NexusGridArrayFunction
 from ResSimpy.Nexus.DataModels.StructuredGrid.NexusLGRs import NexusLGRs
 from ResSimpy.Nexus.DataModels.StructuredGrid.NexusMultir import NexusMultir
 from ResSimpy.Nexus.DataModels.StructuredGrid.NexusOver import NexusOver
+from ResSimpy.Nexus.DataModels.StructuredGrid.NexusTOver import NexusTOver
 from ResSimpy.Nexus.NexusKeywords.nexus_keywords import VALID_NEXUS_KEYWORDS
 from ResSimpy.Nexus.NexusKeywords.structured_grid_keywords import GRID_ARRAY_FORMAT_KEYWORDS
 from ResSimpy.Nexus.structured_grid_operations import StructuredGridOperations
@@ -122,11 +125,17 @@ class NexusGrid(Grid):
     __multir: Optional[list[NexusMultir]] = 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, grid_nexus_file: Optional[NexusFile] = None, assume_loaded: bool = False) -> None:
+    def __init__(self, model_unit_system: UnitSystem, grid_nexus_file: Optional[NexusFile] = None,
+                 assume_loaded: bool = False,
+                 ) -> None:
         """Initialises the NexusGrid class.
 
         Args:
+            model_unit_system (UnitSystem): the default unit system to use for the model.
             grid_nexus_file (Optional[NexusFile]): the NexusFile representation of a structured grid file for \
                 reading and interpreting the grid properties from.
             assume_loaded (bool): Create the object assuming the grid has already been loaded into memory.
@@ -218,6 +227,9 @@ class NexusGrid(Grid):
 
         self.__lgrs: NexusLGRs = NexusLGRs(grid_file_as_list=self.__grid_file_contents, parent_grid=self)
         self.__overs: list[NexusOver] = []
+        self.__tovers: list[NexusTOver] = []
+        self.__ftrans: list[NexusFtrans] = []
+        self.__model_unit_system: UnitSystem = model_unit_system
 
     def __wrap(self, value: Any) -> Any:
         if isinstance(value, tuple | list | set | frozenset):
@@ -512,6 +524,8 @@ class NexusGrid(Grid):
 
         ignore_line = False
         array_name = 'ROOT'
+        property_dict: dict = {}
+        unit_system = self.__model_unit_system
 
         for idx, (original_line_location, line) in enumerate(file_as_list_with_original_line_numbers):
 
@@ -531,6 +545,9 @@ class NexusGrid(Grid):
             if ignore_line:
                 continue
 
+            nfo.check_property_in_line(line, property_dict, file_as_list)
+            unit_system = property_dict.get('UNIT_SYSTEM', self.__model_unit_system)
+
             if nfo.check_token('ARRAYS', line):
                 temp_array_name = fo.get_token_value('ARRAYS', line, [line])
                 if temp_array_name is None:
@@ -583,12 +600,17 @@ class NexusGrid(Grid):
         # load the overs:
         if fo.value_in_file('OVER', file_as_list):
             self.__overs = NexusGrid.load_nexus_overs(file_as_list)
+        if fo.value_in_file('FTRANS', file_as_list):
+            self.__ftrans = NexusGrid.load_nexus_ftrans(file_as_list, unit_system)
+        if fo.value_in_file('TOVER', file_as_list):
+            self.__tovers = NexusGrid.load_nexus_tovers(file_as_list)
 
         self._grid_properties_loaded = True
 
     @classmethod
     def load_structured_grid_file(cls: type[NexusGrid], structured_grid_file: File,
-                                  lazy_loading: bool = True) -> NexusGrid:
+                                  model_unit_system: UnitSystem, lazy_loading: bool = True,
+                                  ) -> NexusGrid:
         """Loads in a structured grid file with all grid properties, and the array functions defined with 'FUNCTION'.
 
         Other grid modifiers are currently not supported.
@@ -596,6 +618,7 @@ class NexusGrid(Grid):
         Args:
             structured_grid_file (NexusFile): the NexusFile representation of a structured grid file for converting \
                 into a structured grid file class
+            model_unit_system (UnitSystem): the default unit system to use for the model
             lazy_loading (bool): If set to True, parts of the grid will only be loaded in when requested via \
                 properties on the object.
 
@@ -611,7 +634,7 @@ class NexusGrid(Grid):
         if not isinstance(structured_grid_file, NexusFile):
             raise ValueError(f"Cannot load file of type {type(structured_grid_file)}.")
 
-        loaded_structured_grid_file = cls(grid_nexus_file=structured_grid_file)
+        loaded_structured_grid_file = cls(grid_nexus_file=structured_grid_file, model_unit_system=model_unit_system)
 
         if not lazy_loading:
             loaded_structured_grid_file.load_grid_properties_if_not_loaded()
@@ -1465,16 +1488,27 @@ class NexusGrid(Grid):
                     for array in arrays:
                         operator_value = split_line[0]
                         operator_matches = [x for x in potential_operators if x == operator_value[0]]
-                        if not operator_matches:
+                        if not operator_matches and ('GE' in split_line or 'LE' in split_line):
                             # if the operator is not found then it is GE or LE
                             value = float(split_line[0])
                             operator = split_line[1]
                             threshold_value = float(split_line[2])
                             split_line_position = 3
-                        else:
+                        elif operator_matches:
                             operator = operator_matches[0]
                             # remove the operator and the remaining string is the value
-                            value = float(split_line[0][1:])
+                            trimmed_value = split_line[0].replace(operator, '')
+                            if trimmed_value == '':
+                                # then the value is in the next element of split_line
+                                value = float(split_line[1])
+                                split_line_position = 2
+                            else:
+                                value = float(split_line[0][1:])
+                                split_line_position = 1
+                        else:
+                            # no operator match and not GE or LE then it is implicitly '*'
+                            value = float(split_line[0])
+                            operator = '*'
                             split_line_position = 1
                         overs_list.append(NexusOver(array=array, grid=grid, fault_name=fname,
                                                     i1=i1, i2=i2, j1=j1, j2=j2, k1=k1, k2=k2, operator=operator,
@@ -1485,7 +1519,7 @@ class NexusGrid(Grid):
             if nfo.check_token('OVER', line):
                 reading_over = True
                 over_split_line = nfo.split_line(line)
-                arrays = over_split_line[over_split_line.index('OVER')+1:]
+                arrays = over_split_line[over_split_line.index('OVER') + 1:]
 
         return overs_list
 
@@ -1495,3 +1529,132 @@ class NexusGrid(Grid):
         if not self._grid_properties_loaded:
             self.load_grid_properties_if_not_loaded()
         return self.__overs
+
+    @property
+    def tovers(self) -> list[NexusTOver]:
+        """Returns the TOVER table as a list of NexusTOver objects."""
+        if not self._grid_properties_loaded:
+            self.load_grid_properties_if_not_loaded()
+        return self.__tovers
+
+    @staticmethod
+    def load_nexus_tovers(file_content_as_list: list[str]) -> list[NexusTOver]:
+        """Loads the Nexus TOVER tables to a list of objects.
+
+        Args:
+        file_content_as_list (list[str]): list of strings representing the file contents.
+
+        Returns:
+            list[NexusOver]: list of NexusTOver objects representing the TOVER table.
+        """
+        ignore_list = ['OVER', 'TX', 'TY', 'TZ', 'GRID', 'ROOT', 'TOVER',
+                       'TX+', 'TX-', 'TZ+', 'TZ-', 'TY+', 'TY-',
+                       'TXF+', 'TXF-', 'TYF+', 'TYF-', 'TZF+', 'TZF-', 'INCLUDE',
+                       'ADD', 'SUB', 'DIV', 'EQ', 'MULT']
+        valid_end_tokens = [x for x in VALID_NEXUS_KEYWORDS if x not in ignore_list]
+        tovers_list: list[NexusTOver] = []
+        reading_tover = False
+        grid = 'ROOT'
+        array = ''
+        potential_operators: Final = ['ADD', 'SUB', 'DIV', 'MULT', 'EQ']
+        i1, i2, j1, j2, k1, k2 = 0, 0, 0, 0, 0, 0
+        operator = ''
+        for i, line in enumerate(file_content_as_list):
+            if nfo.check_token('TOVER', line.upper()):
+                array = nfo.get_expected_token_value(token='TOVER', token_line=line,
+                                                     file_list=file_content_as_list[i:])
+                reading_tover = True
+
+            if not reading_tover:
+                continue
+            if nfo.nexus_token_found(line, valid_end_tokens):
+                # reset reading after another token found
+                reading_tover = False
+                grid = 'ROOT'
+                array = ''
+                operator = ''
+                i1, i2, j1, j2, k1, k2 = 0, 0, 0, 0, 0, 0
+                continue
+
+            if any(nfo.check_token(x, line.upper()) for x in potential_operators):
+                split_line = nfo.split_line(line)
+                i1, i2, j1, j2, k1, k2 = (int(x) for x in split_line[0:6])
+                operator = split_line[-1]
+                continue
+            if nfo.check_token('INCLUDE', line.upper()):
+                include_file = nfo.get_expected_token_value(token='INCLUDE', token_line=line,
+                                                            file_list=file_content_as_list[i:])
+                new_tover = NexusTOver(i1=i1, i2=i2, j1=j1, j2=j2, k1=k1, k2=k2,
+                                       include_file=include_file, array=array, grid=grid, operator=operator,
+                                       value=0)
+                tovers_list.append(new_tover)
+                i1, i2, j1, j2, k1, k2 = 0, 0, 0, 0, 0, 0
+                operator = ''
+
+            elif i1 and i2 and j1 and j2 and k1 and k2 and operator and nfo.get_next_value(0, [line]):
+                # not an include file, so it must be a value or array of values
+                number_of_values = (i2 - i1 + 1) * (j2 - j1 + 1) * (k2 - k1 + 1)
+                array_values = fo.get_multiple_expected_sequential_values(file_content_as_list[i:],
+                                                                          number_tokens=number_of_values,
+                                                                          ignore_values=[])
+                new_tover = NexusTOver(i1=i1, i2=i2, j1=j1, j2=j2, k1=k1, k2=k2,
+                                       include_file=None, array=array, grid=grid, operator=operator,
+                                       value=0, array_values=[float(x) for x in array_values])
+                i1, i2, j1, j2, k1, k2 = 0, 0, 0, 0, 0, 0
+                operator = ''
+                tovers_list.append(new_tover)
+
+        return tovers_list
+
+    @staticmethod
+    def load_nexus_ftrans(file_content_as_list: list[str], unit_system: UnitSystem) -> list[NexusFtrans]:
+        """Function to read in FTRANS tables from a file.
+
+        Args:
+            file_content_as_list (list[str]): list of strings representing the file contents.
+            unit_system (UnitSystem): the unit system used in the grid file.
+
+        Returns:
+            list[NexusFtrans]: list of NexusFtrans objects representing the FTRANS table.
+        """
+        ignore_list = ['FTRANS', 'GRID', 'FNAME', 'ROOT']
+        valid_end_tokens = [x for x in VALID_NEXUS_KEYWORDS if x not in ignore_list]
+        ftrans_list: list[NexusFtrans] = []
+        reading = False
+        grid = 'ROOT'
+        fname = None
+        for line in file_content_as_list:
+            if nfo.nexus_token_found(line, valid_end_tokens):
+                reading = False
+                grid = 'ROOT'
+                fname = None
+                continue
+
+            if reading:
+                split_line = nfo.split_line(line)
+                if nfo.check_token('GRID', line):
+                    grid = nfo.get_expected_token_value('GRID', line, file_content_as_list)
+                if nfo.check_token('FNAME', line):
+                    fname = nfo.get_expected_token_value('FNAME', line, file_content_as_list)
+                if len(split_line) == 7:
+                    i1, j1, k1, i2, j2, k2 = (int(x) for x in split_line[0:6])
+                    value = float(split_line[-1])
+                    # cut out the ranges
+                    ftrans_list.append(NexusFtrans(grid=grid, fault_name=fname,
+                                                   i1=i1, i2=i2, j1=j1, j2=j2, k1=k1, k2=k2,
+                                                   value=value, unit_system=unit_system))
+
+            if nfo.check_token('FTRANS', line):
+                # reset the default values if another FTRANS call is found
+                grid = 'ROOT'
+                fname = None
+                reading = True
+
+        return ftrans_list
+
+    @property
+    def ftrans(self) -> list[NexusFtrans]:
+        """Returns the OVER table as a list of NexusOver objects."""
+        if not self._grid_properties_loaded:
+            self.load_grid_properties_if_not_loaded()
+        return self.__ftrans

ressimpy-2.4.0/ResSimpy/Nexus/DataModels/StructuredGrid/NexusTOver.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from ResSimpy.DataModelBaseClasses.Over import Over
+
+
+@dataclass(kw_only=True)
+class NexusTOver(Over):
+    """Used to represent an Override for transmissibility arrays using values per cell.
+
+    Attributes:
+        array (str): The array to be modified by the over.
+        i1 (int): The start of the i range.
+        i2 (int): The end of the i range.
+        j1 (int): The start of the j range.
+        j2 (int): The end of the j range.
+        k1 (int): The start of the k range.
+        k2 (int): The end of the k range.
+        operator (str): The operator to be assigned to the range.
+        grid (Optional[str]): The grid that the Over function relates to.
+        include_file (str): The include file that the TOver function reads values from.
+    """
+    array: str
+    i1: int
+    i2: int
+    j1: int
+    j2: int
+    k1: int
+    k2: int
+    operator: str
+    include_file: Optional[str]
+    grid: Optional[str] = None
+    array_values: Optional[list[float]] = None

{ressimpy-2.3.9 → ressimpy-2.4.0}/ResSimpy/Nexus/NexusSimulator.py

@@ -629,7 +629,8 @@ class NexusSimulator(Simulator):
 
         if self.model_files.structured_grid_file is not None:
             self._grid = NexusGrid.load_structured_grid_file(self.model_files.structured_grid_file,
-                                                             lazy_loading=self.__lazy_loading)
+                                                             lazy_loading=self.__lazy_loading,
+                                                             model_unit_system=self.default_units)
 
         # Load in wellspec files
         if self.model_files.well_files is not None and \

{ressimpy-2.3.9 → ressimpy-2.4.0}/ResSimpy/Nexus/load_wells.py

@@ -147,7 +147,9 @@ def load_wells(nexus_file: NexusFile, start_date: str, default_units: UnitSystem
 
         trimmed_line = line.strip()
 
-        # Exclude block comments
+        if trimmed_line.startswith('!'):
+            continue
+
         if len(trimmed_line) > 0 and trimmed_line[0] == '[':
             exclude_section = True
 
@@ -252,6 +254,7 @@ def load_wells(nexus_file: NexusFile, start_date: str, default_units: UnitSystem
                 well_name_list.append(well_name.upper())
                 wells.append(new_well)
             wellspec_found = False
+            header_index = -1
     return wells, date_format