Add python unit tests (#2142)

* Adding parameterized pygeosx unit tests

* Adding pytest target to cmake

Author: cssherman

geosx_mesh_doctor/checks/collocated_nodes.py

@@ -10,8 +10,7 @@
     vtkPoints,
 )
 from vtkmodules.vtkCommonDataModel import (
-    vtkIncrementalOctreePointLocator,
-)
+    vtkIncrementalOctreePointLocator, )
 
 from . import vtk_utils
 
@@ -46,7 +45,9 @@ def __check(mesh, options: Options) -> Result:
             # If it's not inserted, `point_id` contains the node that was already at that location.
             # But in that case, `point_id` is the new numbering in the destination points array.
             # It's more useful for the user to get the old index in the original mesh, so he can look for it in his data.
-            logging.debug(f"Point {i} at {points.GetPoint(i)} has been rejected, point {filtered_to_original[point_id.get()]} is already inserted.")
+            logging.debug(
+                f"Point {i} at {points.GetPoint(i)} has been rejected, point {filtered_to_original[point_id.get()]} is already inserted."
+            )
             rejected_points[point_id.get()].append(i)
         else:
             # If it's inserted, `point_id` contains the new index in the destination array.

geosx_mesh_doctor/checks/generate_fractures.py

@@ -24,11 +24,9 @@
     vtkUnstructuredGrid,
 )
 from vtkmodules.vtkFiltersGeometry import (
-    vtkMarkBoundaryFilter,
-)
+    vtkMarkBoundaryFilter, )
 from vtk.util.numpy_support import (
-    vtk_to_numpy,
-)
+    vtk_to_numpy, )
 
 import networkx
 
@@ -56,6 +54,7 @@ class FractureNodesInfo:
 
 
 class FractureCellsInfo:
+
     def __init__(self, mesh: vtkUnstructuredGrid, cell_to_faces: Dict[int, Iterable[int]]):
         # For each cell (the key), gets the local (to the face, i.e. 0 to 3 for a tet) faces that are part of the fracture.
         # There can be multiple faces involved.
@@ -93,8 +92,7 @@ def _iter(id_list: vtkIdList) -> Iterator[int]:
         yield id_list.GetId(i)
 
 
-def __duplicate_fracture_nodes(mesh: vtkUnstructuredGrid,
-                               connected_components: Iterable[Iterable[int]],
+def __duplicate_fracture_nodes(mesh: vtkUnstructuredGrid, connected_components: Iterable[Iterable[int]],
                                node_frac_info: FractureNodesInfo) -> Tuple[vtkUnstructuredGrid, DuplicatedNodesInfo]:
     """
     Splits the mesh on the fracture.
@@ -123,7 +121,7 @@ def __duplicate_fracture_nodes(mesh: vtkUnstructuredGrid,
 
     # Building an indicator to find fracture cells.
     # A fracture cell is a cell which touches a fracture internal node.
-    is_fracture_side_cells = numpy.zeros(num_cells, dtype=bool)  # Defaults to "not a fracture cell".
+    is_fracture_side_cells = numpy.zeros(num_cells, dtype=bool)    # Defaults to "not a fracture cell".
     for fracture_side_cells in connected_components:
         for fracture_side_cell in fracture_side_cells:
             is_fracture_side_cells[fracture_side_cell] = True
@@ -132,8 +130,8 @@ def __duplicate_fracture_nodes(mesh: vtkUnstructuredGrid,
     # The idea is that I do not want to fill holes in the numbering,
     # I just want to increment the next number by one.
     # A negative number means that this is a duplicated number.
-    renumbered_nodes = numpy.ones(num_points, dtype=int) * -1  # Defaults to "moved".
-    next_point_id = 0  # When a node needs to be duplicated, `next_point_id` is the next available node.
+    renumbered_nodes = numpy.ones(num_points, dtype=int) * -1    # Defaults to "moved".
+    next_point_id = 0    # When a node needs to be duplicated, `next_point_id` is the next available node.
     for node_idx in range(num_points):
         if not node_frac_info.is_internal_fracture_node[node_idx]:
             renumbered_nodes[node_idx] = next_point_id
@@ -157,13 +155,13 @@ def __duplicate_fracture_nodes(mesh: vtkUnstructuredGrid,
                 # Here we find or build the new number of the node.
                 if node_frac_info.is_internal_fracture_node[new_cell_point_id]:
                     assert renumbered_nodes[new_cell_point_id] == -1
-                    if new_cell_point_id in dup_nodes:  # if already duplicated, take the same
+                    if new_cell_point_id in dup_nodes:    # if already duplicated, take the same
                         new_cell_point_ids.SetId(i, dup_nodes[new_cell_point_id])
-                    else:  # otherwise, duplicate
+                    else:    # otherwise, duplicate
                         dup_nodes[new_cell_point_id] = next_point_id
                         new_cell_point_ids.SetId(i, next_point_id)
                         next_point_id += 1
-                else:  # Here, it's not an internal fracture node which was not duplicated.
+                else:    # Here, it's not an internal fracture node which was not duplicated.
                     assert not renumbered_nodes[new_cell_point_id] == -1
                     new_cell_point_ids.SetId(i, renumbered_nodes[new_cell_point_id])
             new_cells.ReplaceCellAtId(fracture_side_cell, new_cell_point_ids)
@@ -184,7 +182,8 @@ def __duplicate_fracture_nodes(mesh: vtkUnstructuredGrid,
         new_cells.ReplaceCellAtId(cell_idx, new_cell_point_ids)
 
     # Now we finish the process for vtk points.
-    num_new_points = num_points - sum(node_frac_info.is_internal_fracture_node) + sum(map(len, component_to_dup_nodes.values()))
+    num_new_points = num_points - sum(node_frac_info.is_internal_fracture_node) + sum(
+        map(len, component_to_dup_nodes.values()))
     assert next_point_id == num_new_points
 
     old_points = mesh.GetPoints()
@@ -216,19 +215,16 @@ def __duplicate_fracture_nodes(mesh: vtkUnstructuredGrid,
             nodes_validation[renumbered_nodes[n]] = True
     assert all(nodes_validation)
 
-    output = mesh.NewInstance()  # keeping the same instance type.
+    output = mesh.NewInstance()    # keeping the same instance type.
     output.SetPoints(new_points)
-    output.SetCells(mesh.GetCellTypesArray(), new_cells)  # The cell types are unchanged; we reuse the old cell types!
+    output.SetCells(mesh.GetCellTypesArray(), new_cells)    # The cell types are unchanged; we reuse the old cell types!
 
-    duplicated_nodes_info = DuplicatedNodesInfo(renumbered_nodes=renumbered_nodes,
-                                                duplicated_nodes=duplicated_nodes)
+    duplicated_nodes_info = DuplicatedNodesInfo(renumbered_nodes=renumbered_nodes, duplicated_nodes=duplicated_nodes)
 
     return output, duplicated_nodes_info
 
 
-def __copy_fields(input_mesh: vtkUnstructuredGrid,
-                  output_mesh: vtkUnstructuredGrid,
-                  cell_frac_info: FractureCellsInfo,
+def __copy_fields(input_mesh: vtkUnstructuredGrid, output_mesh: vtkUnstructuredGrid, cell_frac_info: FractureCellsInfo,
                   duplicated_nodes_info: DuplicatedNodesInfo) -> None:
     """
     Given input and output meshes, copies the fields from the input into the output.
@@ -269,15 +265,16 @@ def __copy_fields(input_mesh: vtkUnstructuredGrid,
     # The "field data" will contain the fracture information
     field_data = input_mesh.GetFieldData()
     if field_data.GetNumberOfArrays() > 0:
-        logging.warning(f"Copying field data that already has arrays. No modification was made w.r.t. nodes duplications.")
+        logging.warning(
+            f"Copying field data that already has arrays. No modification was made w.r.t. nodes duplications.")
 
     # Building the field data for the fracture
     if field_data.HasArray("fracture_info"):
         logging.warning("Field data \"fracture_info\" already exists, nothing done.")
     else:
         frac_array = vtkIntArray()
-        frac_array.SetName("fracture_info")  # TODO hard coded name.
-        frac_array.SetNumberOfComponents(4)  # Warning the component has to be defined first...
+        frac_array.SetName("fracture_info")    # TODO hard coded name.
+        frac_array.SetNumberOfComponents(4)    # Warning the component has to be defined first...
         frac_array.SetNumberOfTuples(len(cell_frac_info.field_data))
         for i, data in enumerate(cell_frac_info.field_data):
             frac_array.SetTuple(i, data)
@@ -290,7 +287,8 @@ def __copy_fields(input_mesh: vtkUnstructuredGrid,
         duplication_max_multiplicity = max(map(len, duplicated_nodes_info.duplicated_nodes.values()))
         nodes_array = vtkIntArray()
         nodes_array.SetName("duplicated_points_info")
-        nodes_array.SetNumberOfComponents(duplication_max_multiplicity)  # Warning the component has to be defined first...
+        nodes_array.SetNumberOfComponents(
+            duplication_max_multiplicity)    # Warning the component has to be defined first...
         nodes_array.SetNumberOfTuples(len(duplicated_nodes_info.duplicated_nodes))
         for i, data in enumerate(duplicated_nodes_info.duplicated_nodes.values()):
             tmp = list(data) + [-1] * (duplication_max_multiplicity - len(data))
@@ -300,21 +298,24 @@ def __copy_fields(input_mesh: vtkUnstructuredGrid,
     output_mesh.SetFieldData(field_data)
 
 
-def __color_fracture_sides(mesh: vtkUnstructuredGrid, cell_frac_info: FractureCellsInfo, node_frac_info: FractureNodesInfo) -> Iterable[Iterable[int]]:
+def __color_fracture_sides(mesh: vtkUnstructuredGrid, cell_frac_info: FractureCellsInfo,
+                           node_frac_info: FractureNodesInfo) -> Iterable[Iterable[int]]:
     """
     Given all the cells that are in contact with the detected fracture,
     we separate them into bucket of connected cells touching the fractures.
     We do this because all the cells in one same bucket are connected and need to stay connected.
     So they need to share the same nodes as they did before the split.
     :return: All the buckets connected fracture cells.
     """
-    def does_face_contain_boundary_node(_face_point_ids: Iterable[int]) -> bool:  # Small helper function.
+
+    def does_face_contain_boundary_node(_face_point_ids: Iterable[int]) -> bool:    # Small helper function.
         for face_point_id in _face_point_ids:
             if node_frac_info.is_boundary_fracture_node[face_point_id]:
                 return True
         return False
 
-    face_node_set_to_cell = defaultdict(list)  # For each face (defined by its node set), gives all the cells containing this face.
+    face_node_set_to_cell = defaultdict(
+        list)    # For each face (defined by its node set), gives all the cells containing this face.
     for c, local_frac_f in cell_frac_info.cell_to_faces.items():
         cell = mesh.GetCell(c)
         for f in [i for i in range(cell.GetNumberOfFaces()) if i not in local_frac_f]:
@@ -357,8 +358,7 @@ def __find_boundary_nodes(mesh: vtkUnstructuredGrid) -> Sequence[int]:
     return vtk_to_numpy(is_boundary_point)
 
 
-def __build_fracture_nodes(mesh: vtkUnstructuredGrid,
-                           cell_frac_info: FractureCellsInfo,
+def __build_fracture_nodes(mesh: vtkUnstructuredGrid, cell_frac_info: FractureCellsInfo,
                            split_on_domain_boundary: bool) -> FractureNodesInfo:
     """
     Given the description of the fracture in @p cell_frac_info, computes the underlying nodes.
@@ -375,9 +375,9 @@ def __build_fracture_nodes(mesh: vtkUnstructuredGrid,
             for e in range(face.GetNumberOfEdges()):
                 edge = face.GetEdge(e)
                 edge_nodes = []
-                for i in range(edge.GetNumberOfPoints()):  # TODO, do less pedantic
+                for i in range(edge.GetNumberOfPoints()):    # TODO, do less pedantic
                     edge_nodes.append(edge.GetPointId(i))
-                fracture_edges[tuple(sorted(edge_nodes))] += 1  # TODO frozenset?
+                fracture_edges[tuple(sorted(edge_nodes))] += 1    # TODO frozenset?
 
     boundary_fracture_edges = []
     # Boundary edges are seen twice because each 2d fracture element is seen twice too.
@@ -414,7 +414,7 @@ def __build_fracture_nodes(mesh: vtkUnstructuredGrid,
 
     # Now compute the internal fracture nodes by "difference".
     is_internal_fracture_node = numpy.zeros(mesh.GetNumberOfPoints(), dtype=bool)
-    for n in range(mesh.GetNumberOfPoints()):  # TODO duplicated, reorg the code.
+    for n in range(mesh.GetNumberOfPoints()):    # TODO duplicated, reorg the code.
         if is_fracture_node[n] and not is_boundary_fracture_node[n]:
             is_internal_fracture_node[n] = True
 
@@ -438,21 +438,21 @@ def __find_involved_cells(mesh: vtkUnstructuredGrid, options: Options) -> Tuple[
         raise ValueError(f"Cell field {options.field} does not exist in mesh, nothing done")
 
     cells_to_faces = defaultdict(list)
-    is_fracture_node = numpy.zeros(mesh.GetNumberOfPoints(), dtype=bool)  # all False
+    is_fracture_node = numpy.zeros(mesh.GetNumberOfPoints(), dtype=bool)    # all False
 
     # For each face of each cell, we search for the unique neighbor cell (if it exists).
     # Then, if the 2 values of the two cells match the field requirements,
     # we store the cell and its local face index: this is indeed part of the surface that we'll need to be split.
     neighbor_cell_ids = vtkIdList()
     for cell_id in range(mesh.GetNumberOfCells()):
-        if f[cell_id] not in options.field_values:  # No need to consider a cell if its field value is not in the target range.
+        if f[cell_id] not in options.field_values:    # No need to consider a cell if its field value is not in the target range.
             continue
         cell = mesh.GetCell(cell_id)
         for i in range(cell.GetNumberOfFaces()):
             face = cell.GetFace(i)
             mesh.GetCellNeighbors(cell_id, face.GetPointIds(), neighbor_cell_ids)
             assert neighbor_cell_ids.GetNumberOfIds() < 2
-            for j in range(neighbor_cell_ids.GetNumberOfIds()):  # It's 0 or 1...
+            for j in range(neighbor_cell_ids.GetNumberOfIds()):    # It's 0 or 1...
                 neighbor_cell_id = neighbor_cell_ids.GetId(j)
                 if f[neighbor_cell_id] != f[cell_id] and f[neighbor_cell_id] in options.field_values:
                     cells_to_faces[cell_id].append(i)

geosx_mesh_doctor/checks/generate_global_ids.py

@@ -2,8 +2,7 @@
 import logging
 
 from vtkmodules.vtkCommonCore import (
-    vtkIdTypeArray,
-)
+    vtkIdTypeArray, )
 
 from . import vtk_utils
 

geosx_mesh_doctor/checks/vtk_utils.py

@@ -2,19 +2,17 @@
 import logging
 
 from vtkmodules.vtkCommonDataModel import (
-    vtkUnstructuredGrid,
-)
+    vtkUnstructuredGrid, )
 from vtkmodules.vtkIOLegacy import (
     vtkUnstructuredGridWriter,
     vtkUnstructuredGridReader,
 )
 from vtkmodules.vtkIOXML import (
-    vtkXMLUnstructuredGridReader,
-)
+    vtkXMLUnstructuredGridReader, )
 
 
 def read_mesh(vtk_input_file: str) -> vtkUnstructuredGrid:
-    reader = vtkXMLUnstructuredGridReader()  # TODO Find a generic way to read the vtk mesh.
+    reader = vtkXMLUnstructuredGridReader()    # TODO Find a generic way to read the vtk mesh.
     reader.SetFileName(vtk_input_file)
     reader.Update()
     return reader.GetOutput()
@@ -36,5 +34,3 @@ def write_mesh(mesh: vtkUnstructuredGrid, output: str) -> None:
     writer.SetInputData(mesh)
     logging.info(f"Writing mesh into file {output}")
     writer.Write()
-
-

geosx_mesh_doctor/parsing/cli_parsing.py

@@ -7,7 +7,6 @@
 
 from . import all_checks_helpers
 
-
 __OPTIONS_SEP = ":"
 __KV_SEP = "="
 
@@ -60,7 +59,8 @@ def validate_cli_options(check_name: str, valid_keys: Set[str], options: Dict[st
         if len(invalid_keys) == 1:
             logging.warning(f"Key \"{invalid_keys.pop()}\" is not a valid option of \"{check_name}\". Ignoring it.")
         else:
-            logging.warning(f"Keys \"{', '.join(invalid_keys)}\" are not valid options of \"{check_name}\". Ignoring them.")
+            logging.warning(
+                f"Keys \"{', '.join(invalid_keys)}\" are not valid options of \"{check_name}\". Ignoring them.")
 
 
 def parse_and_set_verbosity(cli_args: List[str]) -> None:
@@ -70,16 +70,8 @@ def parse_and_set_verbosity(cli_args: List[str]) -> None:
     :return: None
     """
     dummy_verbosity_parser = argparse.ArgumentParser(add_help=None)
-    dummy_verbosity_parser.add_argument('-v',
-                                        '--verbose',
-                                        action='count',
-                                        default=1,
-                                        dest=__VERBOSE_KEY)
-    dummy_verbosity_parser.add_argument('-q',
-                                        '--quiet',
-                                        action='count',
-                                        default=0,
-                                        dest=__QUIET_KEY)
+    dummy_verbosity_parser.add_argument('-v', '--verbose', action='count', default=1, dest=__VERBOSE_KEY)
+    dummy_verbosity_parser.add_argument('-q', '--quiet', action='count', default=0, dest=__QUIET_KEY)
     args = dummy_verbosity_parser.parse_known_args(cli_args[1:])[0]
     d = vars(args)
     v = d[__VERBOSE_KEY] - d[__QUIET_KEY]
@@ -141,7 +133,7 @@ def parse(cli_args: List[str]) -> Arguments:
                                 help=check_helper.get_help())
     args = parser.parse_args(cli_args[1:])
 
-    args = vars(args)  # converting to `dict` allows to access keys by variable.
+    args = vars(args)    # converting to `dict` allows to access keys by variable.
     checks = OrderedDict()
     for check_name in all_checks_helpers.keys():
         options = args[check_name]

geosx_mesh_doctor/parsing/collocated_nodes_parsing.py

@@ -33,7 +33,7 @@ def display_results(options: Options, result: Result):
     for bucket in result.nodes_buckets:
         for node in bucket:
             all_duplicated_nodes.append(node)
-    all_duplicated_nodes = set(all_duplicated_nodes)  # Surely useless
+    all_duplicated_nodes = set(all_duplicated_nodes)    # Surely useless
     logging.error(f"You have {len(all_duplicated_nodes)} collocated nodes (tolerance = {options.tolerance}).")
 
     logging.info("Here are all the buckets of collocated nodes.")

geosx_mesh_doctor/parsing/generate_fractures_parsing.py

@@ -8,7 +8,7 @@
 
 __POLICY = "policy"
 __FIELD_POLICY = "field"
-__POLICIES = (__FIELD_POLICY,)
+__POLICIES = (__FIELD_POLICY, )
 
 __FIELD_NAME = "name"
 __FIELD_VALUES = "values"
@@ -17,10 +17,13 @@
 __SPLIT_ON_DOMAIN_BOUNDARY = "split_on_domain_boundary"
 __GENERATE_FIELD_DATA = "generate_field_data"
 
-__ALL_KEYWORDS = {__POLICY, __FIELD_NAME, __FIELD_VALUES, __FIELD_POLICY, __OUTPUT_FILE, __SPLIT_ON_DOMAIN_BOUNDARY, __GENERATE_FIELD_DATA}
+__ALL_KEYWORDS = {
+    __POLICY, __FIELD_NAME, __FIELD_VALUES, __FIELD_POLICY, __OUTPUT_FILE, __SPLIT_ON_DOMAIN_BOUNDARY,
+    __GENERATE_FIELD_DATA
+}
 
 
-def get_help():  # TODO use a formatter module.
+def get_help():    # TODO use a formatter module.
     msg = f"""\
     Splits the mesh to generate the faults and fractures. [EXPERIMENTAL]
     

geosx_mesh_doctor/parsing/generate_global_ids_parsing.py

@@ -6,7 +6,6 @@
 
 from . import cli_parsing
 
-
 __OUTPUT_FILE = "output"
 
 __ALL_KEYWORDS = {__OUTPUT_FILE}

geosx_mesh_doctor/tests/test_collocated_nodes.py

@@ -3,11 +3,9 @@
 import pytest
 
 from vtkmodules.vtkCommonCore import (
-    vtkPoints,
-)
+    vtkPoints, )
 from vtkmodules.vtkCommonDataModel import (
-    vtkUnstructuredGrid,
-)
+    vtkUnstructuredGrid, )
 
 from checks.collocated_nodes import Options, __check
 
@@ -40,4 +38,3 @@ def test_simple_collocated_points(data: Tuple[vtkPoints, int]):
     assert len(result.nodes_buckets) == num_nodes_bucket
     if num_nodes_bucket == 1:
         assert len(result.nodes_buckets[0]) == points.GetNumberOfPoints()
-