resqpy 4.5.0__py3-none-any.whl → 4.6.3__py3-none-any.whl

resqpy/lines/_polyline_set.py

@@ -68,7 +68,9 @@ class PolylineSet(rql_c._BasePolyline):
         self.save_polys = False
         self.boolnotconstant = None
         self.boolvalue = None
+        self.closed_array = None
         self.crs_uuid = crs_uuid
+        self.indices = None
 
         super().__init__(model = parent_model,
                          uuid = uuid,
@@ -92,10 +94,11 @@ class PolylineSet(rql_c._BasePolyline):
                     break
             self.polys = polylines
             # Setting the title of the first polyline given as the PolylineSet title
-            if len(polylines) > 1:
-                self.title = f"{polylines[0].title} + {len(polylines)-1} polylines"
-            else:
-                self.title = polylines[0].title
+            if not self.title:
+                if len(polylines) > 1:
+                    self.title = f"{polylines[0].title} + {len(polylines)-1} polylines"
+                else:
+                    self.title = polylines[0].title
 
         elif irap_file is not None:  # Create from an input IRAP file
             if crs_uuid is None:
@@ -113,6 +116,7 @@ class PolylineSet(rql_c._BasePolyline):
         root = self.root
 
         self.rep_int_root = self.model.referenced_node(rqet.find_tag(root, 'RepresentedInterpretation'))
+        self.closed_array = np.empty((0,), dtype = bool)
 
         for patch_node in rqet.list_of_tag(root, 'LinePatch'):  # Loop over all LinePatches - likely just the one
             assert patch_node is not None  # Required field
@@ -134,7 +138,7 @@ class PolylineSet(rql_c._BasePolyline):
             closed_array = self.get_bool_array(closed_node)
 
             count_node = rqet.find_tag(patch_node, 'NodeCountPerPolyline')
-            rql_c.load_hdf5_array(self, count_node, 'count_perpol', tag = 'Values')
+            rql_c.load_hdf5_array(self, count_node, 'count_perpol', tag = 'Values', dtype = 'int')
 
             points_node = rqet.find_tag(geometry_node, 'Points')
             assert points_node is not None  # Required field
@@ -155,12 +159,16 @@ class PolylineSet(rql_c._BasePolyline):
             # delattr(self,'count_perpol')
 
             self.polys.extend(subpolys)
+            self.closed_array = np.concatenate((self.closed_array, closed_array))
+
+        self.bool_array_format()
 
     def _set_from_irap(self, irap_file):
         inpoints = rsl.read_lines(irap_file)
         self.count_perpol = []
         closed_array = []
-        self.title = os.path.basename(irap_file).split(".")[0]
+        if not self.title:
+            self.title = os.path.basename(irap_file).split(".")[0]
         for i, poly in enumerate(inpoints):
             if len(poly) > 1:  # Polylines must have at least 2 points
                 self.count_perpol.append(len(poly))
@@ -183,7 +191,8 @@ class PolylineSet(rql_c._BasePolyline):
             inpoints = f.readlines()
         self.count_perpol = []
         closed_array = []
-        self.title = os.path.basename(charisma_file).split(".")[0]
+        if not self.title:
+            self.title = os.path.basename(charisma_file).split(".")[0]
         for i, line in enumerate(inpoints):
             line = line.split()
             coord_entry = np.array([[float(line[3]), float(line[4]), float(line[5])]])
@@ -278,32 +287,45 @@ class PolylineSet(rql_c._BasePolyline):
         pindex.text = '0'
 
         if self.boolnotconstant:
+
             # We have mixed data - use a BooleanArrayFromIndexArray
             closed = rqet.SubElement(patch, ns['resqml2'] + 'ClosedPolylines')
             closed.set(ns['xsi'] + 'type', ns['xsd'] + 'BooleanArrayFromIndexArray')
             closed.text = '\n'
 
-            bool_val = rqet.SubElement(closed, ns['resqml2'] + 'Value')
+            bool_val = rqet.SubElement(closed, ns['resqml2'] + 'IndexIsTrue')
             bool_val.set(ns['xsi'] + 'type', ns['xsd'] + 'boolean')
-            bool_val.text = str(self.boolvalue).lower()
-
-            ind_val = rqet.SubElement(closed, ns['resqml2'] + 'Indices')
-            ind_val.set(ns['xsi'] + 'type', ns['eml'] + 'Hdf5Dataset')
-            ind_val.text = '\n'
+            bool_val.text = str(not self.boolvalue).lower()
 
             count = rqet.SubElement(closed, ns['resqml2'] + 'Count')
             count.set(ns['xsi'] + 'type', ns['xsd'] + 'positiveInteger')
             count.text = str(len(self.count_perpol))
 
-            self.model.create_hdf5_dataset_ref(ext_uuid, self.uuid, 'indices_patch0', root = ind_val)
+            ind_val = rqet.SubElement(closed, ns['resqml2'] + 'Indices')
+            ind_val.set(ns['xsi'] + 'type', ns['resqml2'] + 'IntegerHdf5Array')
+            ind_val.text = '\n'
+
+            iv_null = rqet.SubElement(ind_val, ns['resqml2'] + 'NullValue')
+            iv_null.set(ns['xsi'] + 'type', ns['xsd'] + 'integer')
+            iv_null.text = '-1'
+
+            iv_values = rqet.SubElement(ind_val, ns['resqml2'] + 'Values')
+            iv_values.set(ns['xsi'] + 'type', ns['eml'] + 'Hdf5Dataset')
+            iv_values.text = '\n'
+
+            self.model.create_hdf5_dataset_ref(ext_uuid, self.uuid, 'indices_patch0', root = iv_values)
+
         else:
+
             # All bools are the same - use a BooleanConstantArray
             closed = rqet.SubElement(patch, ns['resqml2'] + 'ClosedPolylines')
             closed.set(ns['xsi'] + 'type', ns['resqml2'] + 'BooleanConstantArray')
             closed.text = '\n'
+
             bool_val = rqet.SubElement(closed, ns['resqml2'] + 'Value')
             bool_val.set(ns['xsi'] + 'type', ns['xsd'] + 'boolean')
             bool_val.text = str(self.boolvalue).lower()
+
             count = rqet.SubElement(closed, ns['resqml2'] + 'Count')
             count.set(ns['xsi'] + 'type', ns['xsd'] + 'positiveInteger')
             count.text = str(len(self.count_perpol))
@@ -367,7 +389,7 @@ class PolylineSet(rql_c._BasePolyline):
         if self.uuid is None:
             self.uuid = bu.new_uuid()
         self.combine_polylines(self.polys)
-        self.bool_array_format(self.closed_array)
+        self.bool_array_format()
         self.save_polys = save_polylines
         if self.save_polys:
             for poly in self.polys:
@@ -377,29 +399,37 @@ class PolylineSet(rql_c._BasePolyline):
         h5_reg.register_dataset(self.uuid, 'points_patch0', self.coordinates)
         h5_reg.register_dataset(self.uuid, 'NodeCountPerPolyline_patch0', self.count_perpol.astype(np.int32))
         if self.boolnotconstant:
-            h5_reg.register_dataset(self.uuid, 'indices_patch0', self.indices)
+            h5_reg.register_dataset(self.uuid, 'indices_patch0', np.array(self.indices, dtype = np.int32))
         h5_reg.write(file_name, mode = mode)
 
     def get_bool_array(self, closed_node):
-        # TODO: Check if also defined boolean arrays
-        """Returns a boolean array using details in the node location.
+        # TODO: check for other permissible forms of the abstract boolean array
+        """Returns a boolean array using details in the xml node location.
 
-        If type of boolean array is BooleanConstantArray, uses the array value and count to generate the array. If type of boolean array is BooleanArrayFromIndexArray, find the "other" value bool and indices of the "other" values, and insert these into an array opposite to the main bool.
+        arguments:
+            closed_node (xml node): the node under which the boolean array information sits
 
-        args:
-            closed_node: the node under which the boolean array information sits
+        returns:
+            1D numpy bool array set True for those pplylines within the set which are marked as closed
         """
-        if rqet.node_type(closed_node) == 'BooleanConstantArray':
+        # if type of boolean array is BooleanConstantArray, uses the array value and count to generate
+        # the array; if type of boolean array is BooleanArrayFromIndexArray, finds the "other" value
+        # bool and indices of the "other" values, and inserts these into an array opposite to the main bool
+        flavour = rqet.node_type(closed_node)
+        if flavour == 'BooleanConstantArray':
             count = rqet.find_tag_int(closed_node, 'Count')
             value = rqet.bool_from_text(rqet.node_text(rqet.find_tag(closed_node, 'Value')))
-            return np.full((count), value)
-        elif rqet.node_type(closed_node) == 'BooleanArrayFromIndexArray':
+            return np.full((count,), value, dtype = bool)
+        elif flavour == 'BooleanArrayFromIndexArray':
             count = rqet.find_tag_int(closed_node, 'Count')
-            indices_arr = rql_c.load_hdf5_array(self, closed_node, 'indices_arr', tag = 'Indices')
+            indices_node = rqet.find_tag(closed_node, 'Indices')
+            assert indices_node is not None
+            indices_arr = rql_c.load_hdf5_array(self, indices_node, 'indices_arr', tag = 'Values', dtype = 'int')
             istrue = rqet.bool_from_text(rqet.node_text(rqet.find_tag(closed_node, 'IndexIsTrue')))
-            out = np.full((count), not istrue)
+            out = np.full((count,), not istrue, dtype = bool)
             out[indices_arr] = istrue
             return out
+        raise ValueError(f'unrecognised closed array xml node type: {flavour}')
 
     def convert_to_polylines(self,
                              closed_array = None,
@@ -496,32 +526,32 @@ class PolylineSet(rql_c._BasePolyline):
 
         self.polys = polylines
 
-    def bool_array_format(self, closed_array):
-        """Determines an appropriate output boolean array format from an input array of bools.
+    def bool_array_format(self):
+        """Determines an appropriate output boolean array format depending on the closed_array bools.
 
         self.boolnotconstant - set to True if all are not open or all closed
         self.boolvalue - value of isclosed for all polylines, or for the majority of polylines if mixed
         self.indices - array of indices where the values are not self.boolvalue, if the polylines are mixed
         """
 
+        assert self.closed_array is not None
         self.indices = []
         self.boolnotconstant = False
-        if all(closed_array):
+        if all(self.closed_array):
             self.boolvalue = True
-        elif not all(closed_array) and not any(closed_array):
+        elif not any(self.closed_array):
             self.boolvalue = False
         else:
-            if np.count_nonzero(closed_array) > (len(closed_array) / 2):
+            if np.count_nonzero(self.closed_array) > (len(self.closed_array) // 2):
                 self.boolvalue = True
-                for i, val in enumerate(closed_array):
+                for i, val in enumerate(self.closed_array):
                     if not val:
                         self.indices.append(i)
             else:
                 self.boolvalue = False
-                for i, val in enumerate(closed_array):
+                for i, val in enumerate(self.closed_array):
                     if val:
                         self.indices.append(i)
-        if len(self.indices) > 0:
             self.boolnotconstant = True
 
     def set_interpretation_root(self, rep_int_root, recursive = True):

resqpy/model/_hdf5.py

@@ -208,12 +208,15 @@ def _h5_array_element(model,
     if object is None:
         object = model
 
-    # Check if attribute has already be cached
+    if isinstance(dtype, str) and dtype == 'pack':
+        dtype = bool
+
+    # check if attribute has already been cached
     if array_attribute is not None:
         existing_value = getattr(object, array_attribute, None)
 
         # Watch out for np.array(None): check existing_value has a valid "shape"
-        if existing_value is not None and getattr(existing_value, "shape", False):
+        if existing_value is not None and getattr(existing_value, 'shape', False):
             if index is None:
                 return None  # this option allows caching of array without actually referring to any element
             return existing_value[tuple(index)]
@@ -222,14 +225,20 @@ def _h5_array_element(model,
     if h5_root is None:
         return None
     if cache_array:
+        str_dtype = str(dtype)
         shape_tuple = tuple(h5_root[h5_key_pair[1]].shape)
-        if required_shape is None or shape_tuple == required_shape:
-            object.__dict__[array_attribute] = np.zeros(shape_tuple, dtype = dtype)
+        if required_shape is None:
+            required_shape = shape_tuple
+        object.__dict__[array_attribute] = np.zeros(required_shape, dtype = dtype)
+        if shape_tuple == required_shape:
             object.__dict__[array_attribute][:] = h5_root[h5_key_pair[1]]
+        elif (len(shape_tuple) == len(required_shape) and ('bool' in str_dtype or 'int8' in str_dtype) and
+              8 * (shape_tuple[-1] - 1) < required_shape[-1] <= 8 * shape_tuple[-1]):
+            a = np.unpackbits(h5_root[h5_key_pair[1]], axis = -1).astype(bool)
+            object.__dict__[array_attribute][:] = a[..., :required_shape[-1]]
         else:
-            object.__dict__[array_attribute] = np.zeros(required_shape, dtype = dtype)
-            object.__dict__[array_attribute][:] = np.array(h5_root[h5_key_pair[1]],
-                                                           dtype = dtype).reshape(required_shape)
+            object.__dict__[array_attribute][:] =  \
+                np.array(h5_root[h5_key_pair[1]], dtype = dtype).reshape(required_shape)
         _h5_release(model)
         if index is None:
             return None
@@ -241,6 +250,7 @@ def _h5_array_element(model,
             result = h5_root[h5_key_pair[1]][tuple(index)]
         else:
             shape_tuple = tuple(h5_root[h5_key_pair[1]].shape)
+            # todo: handle unpacking of a single bit into a bool?
             if shape_tuple == required_shape:
                 result = h5_root[h5_key_pair[1]][tuple(index)]
             else:

resqpy/model/_model.py

@@ -1344,7 +1344,8 @@ class Model():
               required to cache or access cached array
            dtype (string or data type): the data type of the elements of the array (need not match hdf5 array in precision)
            required_shape (tuple of ints, optional): if not None, the hdf5 array will be reshaped to this shape; if index
-              is not None, it is taken to be applicable to the required shape
+              is not None, it is taken to be applicable to the required shape; required if the array is bool data that was
+              written with resqpy specific dtype of 'pack'
 
         returns:
            if index is None, then None;

resqpy/model/_xml.py

@@ -153,9 +153,9 @@ def _create_ref_node(model, flavour, title, uuid, content_type = None, root = No
     else:
         ct_node.text = 'application/x-resqml+xml;version=2.0;type=' + content_type
 
-    if not title:
+    if title is None or len(title) == 0:
         title = model.title(uuid = uuid)
-        if title is None:
+        if title is None or len(title) == 0:
             title = 'untitled'
     title_node = rqet.SubElement(ref_node, ns['eml'] + 'Title')
     title_node.set(ns['xsi'] + 'type', ns['eml'] + 'DescriptionString')
@@ -204,8 +204,8 @@ def _create_rels_part(model):
 def _create_citation(root = None, title = '', originator = None):
     """Creates a citation xml node and optionally appends as a child of root."""
 
-    if title is None:
-        title = ''
+    if title is None or len(title) == 0:
+        title = 'untitled'
 
     citation = rqet.Element(ns['eml'] + 'Citation')
     citation.set(ns['xsi'] + 'type', ns['eml'] + 'Citation')

resqpy/multi_processing/_multiprocessing.py

@@ -80,6 +80,7 @@ def function_multiprocessing(function: Callable,
     if tmp_dir_path is None:
         tmp_dir_path = '.'
     tmp_dir = Path(tmp_dir_path) / f'tmp_{uuid.uuid4()}'
+    os.makedirs(tmp_dir)
     for i, kwargs in enumerate(kwargs_list):
         kwargs["index"] = i
         kwargs["parent_tmp_dir"] = str(tmp_dir)

resqpy/multi_processing/wrappers/grid_surface_mp.py

@@ -33,12 +33,15 @@ def find_faces_to_represent_surface_regular_wrapper(
         trimmed: bool = False,
         is_curtain = False,
         extend_fault_representation: bool = False,
+        flange_inner_ring = False,
+        saucer_parameter = None,
         retriangulate: bool = False,
         related_uuid = None,
         progress_fn: Optional[Callable] = None,
         extra_metadata = None,
         return_properties: Optional[List[str]] = None,
-        raw_bisector: bool = False) -> Tuple[int, bool, str, List[Union[UUID, str]]]:
+        raw_bisector: bool = False,
+        use_pack: bool = False) -> Tuple[int, bool, str, List[Union[UUID, str]]]:
     """Multiprocessing wrapper function of find_faces_to_represent_surface_regular_optimised.
 
     arguments:
@@ -79,6 +82,8 @@ def find_faces_to_represent_surface_regular_wrapper(
            the returned dictionary has the passed strings as keys and numpy arrays as values
         raw_bisector (bool, default False): if True and grid bisector is requested then it is left in a raw
            form without assessing which side is shallower (True values indicate same side as origin cell)
+        use_pack (bool, default False): if True, boolean properties will be stored in numpy packed format,
+           which will only be readable by resqpy based applications
 
     returns:
         Tuple containing:
@@ -150,6 +155,8 @@ def find_faces_to_represent_surface_regular_wrapper(
                                               convexity_parameter = 2.0,
                                               reorient = True,
                                               extend_with_flange = extend_fault_representation,
+                                              flange_inner_ring = flange_inner_ring,
+                                              saucer_parameter = saucer_parameter,
                                               flange_radial_distance = flange_radius,
                                               make_clockwise = False)
         extended = extend_fault_representation
@@ -181,6 +188,8 @@ def find_faces_to_represent_surface_regular_wrapper(
                                                  convexity_parameter = 2.0,
                                                  reorient = True,
                                                  extend_with_flange = extend_fault_representation,
+                                                 flange_inner_ring = flange_inner_ring,
+                                                 saucer_parameter = saucer_parameter,
                                                  flange_radial_distance = flange_radius,
                                                  make_clockwise = False)
         del pset
@@ -345,13 +354,13 @@ def find_faces_to_represent_surface_regular_wrapper(
                 raise ValueError(f'unrecognised property name {p_name}')
         if property_collection.number_of_imports() > 0:
             # log.debug('writing gcs property hdf5 data')
-            property_collection.write_hdf5_for_imported_list()
+            property_collection.write_hdf5_for_imported_list(use_pack = use_pack)
             uuids_properties = property_collection.create_xml_for_imported_list_and_add_parts_to_model(
                 find_local_property_kinds = True)
             uuid_list.extend(uuids_properties)
         if grid_pc is not None and grid_pc.number_of_imports() > 0:
             # log.debug('writing grid property (bisector) hdf5 data')
-            grid_pc.write_hdf5_for_imported_list()
+            grid_pc.write_hdf5_for_imported_list(use_pack = use_pack)
             # log.debug('creating xml for grid property (bisector)')
             uuids_properties = grid_pc.create_xml_for_imported_list_and_add_parts_to_model(
                 find_local_property_kinds = True)

resqpy/olio/intersection.py

@@ -76,7 +76,7 @@ def line_triangle_intersect(line_p, line_v, triangle, line_segment = False, l_to
     return line_p + t * line_v
 
 
-@njit
+@njit  # pragma: no cover
 def line_triangle_intersect_numba(
     line_p: np.ndarray,
     line_v: np.ndarray,
@@ -164,8 +164,7 @@ def line_triangles_intersects(line_p, line_v, triangles, line_segment = False):
         ts[:] = np.where(np.logical_or(ts < 0.0, ts > 1.0), np.nan, ts)
     np.divide(np.sum(np.cross(p02s, line_rv) * lp_t0s, axis = 1), denoms, out = us, where = nz)
     np.divide(np.sum(np.cross(line_rv, p01s) * lp_t0s, axis = 1), denoms, out = vs, where = nz)
-    ts[:] = np.where(np.logical_or(np.logical_or(us < 0.0, us > 1.0), np.logical_or(vs < 0.0, us + vs > 1.0)), np.nan,
-                     ts)
+    ts[np.where(np.logical_or(np.logical_or(us < 0.0, us > 1.0), np.logical_or(vs < 0.0, us + vs > 1.0)))] = np.nan
 
     intersects = np.empty((n, 3))
     intersects[:] = line_v * np.repeat(ts, 3).reshape((n, 3)) + line_p

resqpy/olio/read_nexus_fault.py

@@ -13,8 +13,8 @@ import numpy as np
 import pandas as pd
 
 
-def load_nexus_fault_mult_table(file_name):
-    """Reads a Nexus (!) format file containing one or more MULT keywords and returns a dataframe with the MULT rows."""
+def load_nexus_fault_mult_table_from_list(file_as_list):
+    """Reads a Nexus (!) format list of file contents containing one or more MULT keywords and returns a dataframe with the MULT rows."""
 
     def is_number(s):
         try:
@@ -41,70 +41,18 @@ def load_nexus_fault_mult_table(file_name):
 
     face_dict = {'TX': 'I', 'TY': 'J', 'TZ': 'K', 'TI': 'I', 'TJ': 'J', 'TK': 'K'}
 
-    if os.path.isfile(file_name):
-        chunks = []
-        with open(file_name) as f:
-            for line in f:
-                if len(line.strip()):
-                    if (not line.strip()[0] == '!') & (not line.strip()[0] == 'C'):
-                        line = line.partition('!')[0]  # removing trailing comments
-                        # line = line.partition('C')[0]  # removing trailing comments
-                        tokens = line.split()
-                        if ISTABLE:
-                            if is_number(tokens[0]):
-                                ISRECORD = True
-
-                            if ISRECORD and (not is_number(tokens[0])):
-                                data = chunks[0:]
-                                d_elems = np.array([np.array(data[i].split()) for i in range(len(data))])
-                                # fill empty elements with zero
-                                lens = np.array([len(i) for i in d_elems])
-                                # Mask of valid places in each row
-                                mask = np.arange(lens.max()) < lens[:, None]
-                                # Setup output array and put elements from data into masked positions
-                                outdata = np.zeros(mask.shape, dtype = d_elems.dtype)
-                                outdata[mask] = np.concatenate(d_elems)
-                                df = pd.DataFrame(outdata)
-                                for column in df.columns:
-                                    df[column] = pd.to_numeric(df[column], errors = 'ignore')
-                                df.columns = ['i1', 'i2', 'j1', 'j2', 'k1', 'k2', 'mult']
-                                df['grid'] = grid
-                                df['name'] = name
-                                df['face'] = face
-                                dfs.append(df)
-                                num_tables += 1
-
-                                ISTABLE = False
-                                ISRECORD = False
-                                chunks = []
-
-                        if ISTABLE:
-                            if re.match("(.*)GRID(.*)", tokens[0]):
-                                if len(tokens) > 0:
-                                    grid = tokens[1]
-                            elif re.match("(.*)FNAME(.*)", tokens[0]):
-                                if len(tokens) > 0:
-                                    name = tokens[1]
-                            else:
-                                if re.match(r"^MULT$", tokens[0]):
-                                    ISTABLE = False
-                                    ISRECORD = False
-                                    chunks = []
-                                else:
-                                    chunks.append(line.strip())
-
-                        if re.match(r"^MULT$", tokens[0]):
-                            if len(tokens) > 0:
-                                face = face_dict[tokens[1]]
-                            if 'MINUS' in tokens:
-                                face += '-'  # indicates data apply to 'negative' faces of specified cells
-                            grid = 'ROOT'  # nexus default
-                            name = 'NONE'
-                            ISTABLE = True
-
-            else:
+    chunks = []
+    for line in file_as_list:
+        if len(line.strip()):
+            if (not line.strip()[0] == '!') & (not line.strip()[0] == 'C'):
+                line = line.partition('!')[0]  # removing trailing comments
+                # line = line.partition('C')[0]  # removing trailing comments
+                tokens = line.split()
                 if ISTABLE:
-                    if ISRECORD:
+                    if is_number(tokens[0]):
+                        ISRECORD = True
+
+                    if ISRECORD and (not is_number(tokens[0])):
                         data = chunks[0:]
                         d_elems = np.array([np.array(data[i].split()) for i in range(len(data))])
                         # fill empty elements with zero
@@ -128,6 +76,59 @@ def load_nexus_fault_mult_table(file_name):
                         ISRECORD = False
                         chunks = []
 
+                if ISTABLE:
+                    if re.match("(.*)GRID(.*)", tokens[0]):
+                        if len(tokens) > 0:
+                            grid = tokens[1]
+                    elif re.match("(.*)FNAME(.*)", tokens[0]):
+                        if len(tokens) > 0:
+                            name = tokens[1]
+                    else:
+                        if re.match(r"^MULT$", tokens[0]):
+                            ISTABLE = False
+                            ISRECORD = False
+                            chunks = []
+                        else:
+                            chunks.append(line.strip())
+
+                if re.match(r"^MULT$", tokens[0]):
+                    if len(tokens) > 0:
+                        face = face_dict[tokens[1]]
+                    if 'MINUS' in tokens:
+                        face += '-'  # indicates data apply to 'negative' faces of specified cells
+                    grid = 'ROOT'  # nexus default
+                    name = 'NONE'
+                    ISTABLE = True
+
+    else:
+        if ISTABLE:
+            if ISRECORD:
+                data = chunks[0:]
+                d_elems = np.array([np.array(data[i].split()) for i in range(len(data))])
+                # fill empty elements with zero
+                lens = np.array([len(i) for i in d_elems])
+                # Mask of valid places in each row
+                mask = np.arange(lens.max()) < lens[:, None]
+                # Setup output array and put elements from data into masked positions
+                outdata = np.zeros(mask.shape, dtype = d_elems.dtype)
+                outdata[mask] = np.concatenate(d_elems)
+                df = pd.DataFrame(outdata)
+                for column in df.columns:
+                    df[column] = pd.to_numeric(df[column], errors = 'ignore')
+                df.columns = ['i1', 'i2', 'j1', 'j2', 'k1', 'k2', 'mult']
+                df['grid'] = grid
+                df['name'] = name
+                df['face'] = face
+                dfs.append(df)
+                num_tables += 1
+
+                ISTABLE = False
+                ISRECORD = False
+                chunks = []
+
+    if not dfs:
+        return pd.DataFrame()
+
     fault_df = pd.concat(dfs).reset_index(drop = True)
 
     convert_dict = {'i1': int, 'i2': int, 'j1': int, 'j2': int, 'k1': int, 'k2': int, 'mult': float}
@@ -136,7 +137,10 @@ def load_nexus_fault_mult_table(file_name):
     return fault_df
 
 
-def load_nexus_fault_mult_table_new(file_name):
+def load_nexus_fault_mult_table(file_name):
     """Reads a Nexus (!) format file containing one or more MULT keywords and returns a dataframe with the MULT rows."""
 
-    return load_nexus_fault_mult_table(file_name)
+    with open(file_name) as f:
+        file_as_list = f.readlines()
+
+    return load_nexus_fault_mult_table_from_list(file_as_list)