documentation + typing, liniting, formating

Author: mlemayTTE

docs/geos_mesh_docs/model.rst

@@ -0,0 +1,13 @@
+Model
+^^^^^^^
+
+The `model` module of `geos-mesh` package contains data model.
+
+
+geos.mesh.model.CellTypeCounts filter
+--------------------------------------
+
+.. automodule:: geos.mesh.model.CellTypeCounts
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/geos_mesh_docs/modules.rst

@@ -11,4 +11,10 @@ GEOS Mesh tools
 
     io
 
+    model
+
+    processing
+
+    stats
+
     utils

docs/geos_mesh_docs/processing.rst

@@ -0,0 +1,13 @@
+Processing filters
+^^^^^^^^^^^^^^^^^^^
+
+The `processing` module of `geos-mesh` package contains filters to process meshes.
+
+
+geos.mesh.processing.SplitMesh filter
+--------------------------------------
+
+.. automodule:: geos.mesh.processing.SplitMesh
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/geos_mesh_docs/stats.rst

@@ -0,0 +1,13 @@
+Mesh stats tools
+^^^^^^^^^^^^^^^^
+
+The `stats` module of `geos-mesh` package contains filter to compute statistics on meshes.
+
+
+geos.mesh.stats.CellTypeCounter filter
+--------------------------------------
+
+.. automodule:: geos.mesh.stats.CellTypeCounter
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/geos_mesh_docs/utils.rst

@@ -1,7 +1,7 @@
 Mesh utilities
 ^^^^^^^^^^^^^^^^
 
-The `utils` module of `geos-mesh` package contains different utilities methods for VTK meshes.
+The `utils` module of `geos-mesh` package contains various utilities for VTK meshes.
 
 
 geos.mesh.utils.genericHelpers module

geos-mesh/src/geos/mesh/doctor/checks/generate_fractures.py

@@ -13,7 +13,7 @@
 from vtkmodules.util.numpy_support import numpy_to_vtk, vtk_to_numpy
 from vtkmodules.util.vtkConstants import VTK_ID_TYPE
 from geos.mesh.doctor.checks.vtk_polyhedron import FaceStream
-from geos.mesh.utils.arrayHelpers import has_invalid_field
+from geos.mesh.utils.arrayHelpers import has_array
 from geos.mesh.utils.genericHelpers import to_vtk_id_list, vtk_iter
 from geos.mesh.io.vtkIO import VtkOutput, read_mesh, write_mesh
 """
@@ -558,7 +558,7 @@ def check( vtk_input_file: str, options: Options ) -> Result:
     try:
         mesh = read_mesh( vtk_input_file )
         # Mesh cannot contain global ids before splitting.
-        if has_invalid_arrays( mesh, [ "GLOBAL_IDS_POINTS", "GLOBAL_IDS_CELLS" ] ):
+        if has_array( mesh, [ "GLOBAL_IDS_POINTS", "GLOBAL_IDS_CELLS" ] ):
             err_msg: str = ( "The mesh cannot contain global ids for neither cells nor points. The correct procedure " +
                              " is to split the mesh and then generate global ids for new split meshes." )
             logging.error( err_msg )

geos-mesh/src/geos/mesh/model/CellTypeCounts.py

@@ -27,7 +27,7 @@ def __str__( self: Self ) -> str:
         """
         return self.print()
 
-    def __add__( self: Self, other: Self ) -> Self:
+    def __add__( self: Self, other: Self ) -> 'CellTypeCounts':
         """Addition operator.
 
         CellTypeCounts addition consists in suming counts.

geos-mesh/src/geos/mesh/processing/SplitMesh.py

@@ -82,6 +82,7 @@ def FillInputPortInformation( self: Self, port: int, info: vtkInformation ) -> i
         """
         if port == 0:
             info.Set( self.INPUT_REQUIRED_DATA_TYPE(), "vtkUnstructuredGrid" )
+        return 1
 
     def RequestDataObject(
         self: Self,

geos-mesh/src/geos/mesh/stats/CellTypeCounter.py

@@ -57,6 +57,7 @@ def FillInputPortInformation( self: Self, port: int, info: vtkInformation ) -> i
         """
         if port == 0:
             info.Set( self.INPUT_REQUIRED_DATA_TYPE(), "vtkUnstructuredGrid" )
+        return 1
 
     def RequestData(
         self: Self,

geos-mesh/src/geos/mesh/utils/arrayHelpers.py

@@ -19,48 +19,38 @@
 __doc__ = """Utilities methods to get information on VTK Arrays."""
 
 
-def has_invalid_field( mesh: vtkUnstructuredGrid, invalid_fields: list[ str ] ) -> bool:
-    """Checks if a mesh contains at least a data arrays within its cell, field or point data
-    having a certain name. If so, returns True, else False.
+def has_array( mesh: vtkUnstructuredGrid, array_names: list[ str ] ) -> bool:
+    """Checks if input mesh contains at least one of input data arrays.
 
     Args:
         mesh (vtkUnstructuredGrid): An unstructured mesh.
-        invalid_fields (list[str]): Field name of an array in any data from the data.
+        array_names (list[str]): List of array names.
 
     Returns:
-        bool: True if one field found, else False.
+        bool: True if at least one array is found, else False.
     """
     # Check the cell data fields
-    cell_data = mesh.GetCellData()
-    for i in range( cell_data.GetNumberOfArrays() ):
-        if cell_data.GetArrayName( i ) in invalid_fields:
-            logging.error( f"The mesh contains an invalid cell field name '{cell_data.GetArrayName( i )}'." )
-            return True
-    # Check the field data fields
-    field_data = mesh.GetFieldData()
-    for i in range( field_data.GetNumberOfArrays() ):
-        if field_data.GetArrayName( i ) in invalid_fields:
-            logging.error( f"The mesh contains an invalid field name '{field_data.GetArrayName( i )}'." )
-            return True
-    # Check the point data fields
-    point_data = mesh.GetPointData()
-    for i in range( point_data.GetNumberOfArrays() ):
-        if point_data.GetArrayName( i ) in invalid_fields:
-            logging.error( f"The mesh contains an invalid point field name '{point_data.GetArrayName( i )}'." )
-            return True
+    data: vtkFieldData | None
+    for data in ( mesh.GetCellData(), mesh.GetFieldData(), mesh.GetPointData() ):
+        if data is None:
+            continue  # type: ignore[unreachable]
+        for arrayName in array_names:
+            if data.HasArray( arrayName ):
+                logging.error( f"The mesh contains the array named '{arrayName}'." )
+                return True
     return False
 
 
 def getFieldType( data: vtkFieldData ) -> str:
-    """A vtk grid can contain 3 types of field data:
+    """Returns whether the data is "vtkFieldData", "vtkCellData" or "vtkPointData".
+
+    A vtk mesh can contain 3 types of field data:
     - vtkFieldData (parent class)
     - vtkCellData  (inheritance of vtkFieldData)
     - vtkPointData (inheritance of vtkFieldData)
 
-    The goal is to return whether the data is "vtkFieldData", "vtkCellData" or "vtkPointData".
-
     Args:
-        data (vtkFieldData)
+        data (vtkFieldData): vtk field data
 
     Returns:
         str: "vtkFieldData", "vtkCellData" or "vtkPointData"
@@ -79,7 +69,7 @@ def getArrayNames( data: vtkFieldData ) -> list[ str ]:
     """Get the names of all arrays stored in a "vtkFieldData", "vtkCellData" or "vtkPointData".
 
     Args:
-        data (vtkFieldData)
+        data (vtkFieldData): vtk field data
 
     Returns:
         list[ str ]: The array names in the order that they are stored in the field data.
@@ -93,8 +83,8 @@ def getArrayByName( data: vtkFieldData, name: str ) -> Optional[ vtkDataArray ]:
     """Get the vtkDataArray corresponding to the given name.
 
     Args:
-        data (vtkFieldData)
-        name (str)
+        data (vtkFieldData): vtk field data
+        name (str): array name
 
     Returns:
         Optional[ vtkDataArray ]: The vtkDataArray associated with the name given. None if not found.
@@ -109,8 +99,8 @@ def getCopyArrayByName( data: vtkFieldData, name: str ) -> Optional[ vtkDataArra
     """Get the copy of a vtkDataArray corresponding to the given name.
 
     Args:
-        data (vtkFieldData)
-        name (str)
+        data (vtkFieldData): vtk field data
+        name (str): array name
 
     Returns:
         Optional[ vtkDataArray ]: The copy of the vtkDataArray associated with the name given. None if not found.
@@ -125,7 +115,7 @@ def getNumpyGlobalIdsArray( data: Union[ vtkCellData, vtkPointData ] ) -> Option
     """Get a numpy array of the GlobalIds.
 
     Args:
-        data (Union[ vtkCellData, vtkPointData ])
+        data (Union[ vtkCellData, vtkPointData ]): Cell or point array.
 
     Returns:
         Optional[ npt.NDArray[ np.int64 ] ]: The numpy array of GlobalIds.
@@ -137,26 +127,25 @@ def getNumpyGlobalIdsArray( data: Union[ vtkCellData, vtkPointData ] ) -> Option
     return vtk_to_numpy( global_ids )
 
 
-def getNumpyArrayByName( data: vtkFieldData, name: str, sorted: bool = False ) -> Optional[ npt.NDArray ]:
+def getNumpyArrayByName( data: vtkCellData | vtkPointData, name: str, sorted: bool = False ) -> Optional[ npt.NDArray ]:
     """Get the numpy array of a given vtkDataArray found by its name.
+
     If sorted is selected, this allows the option to reorder the values wrt GlobalIds. If not GlobalIds was found,
     no reordering will be perform.
 
     Args:
-        data (vtkFieldData)
-        name (str)
+        data (vtkCellData | vtkPointData): vtk field data.
+        name (str): Array name to sort
         sorted (bool, optional): Sort the output array with the help of GlobalIds. Defaults to False.
 
     Returns:
-        Optional[ npt.NDArray ]
+        Optional[ npt.NDArray ]: Sorted array
     """
     dataArray: Optional[ vtkDataArray ] = getArrayByName( data, name )
     if dataArray is not None:
-        arr: Optional[ npt.NDArray ] = vtk_to_numpy( dataArray )
-        if sorted:
-            fieldType: str = getFieldType( data )
-            if fieldType in [ "vtkCellData", "vtkPointData" ]:
-                sortArrayByGlobalIds( data, arr )
+        arr: npt.NDArray[ np.float64 ] = vtk_to_numpy( dataArray )
+        if sorted and ( data.IsA( "vtkCellData" ) or data.IsA( "vtkPointData" ) ):
+            sortArrayByGlobalIds( data, arr )
         return arr
     return None
 
@@ -484,7 +473,7 @@ def getComponentNamesDataSet( dataSet: vtkDataSet, attributeName: str, onPoints:
 
     """
     array: vtkDoubleArray = getVtkArrayInObject( dataSet, attributeName, onPoints )
-    componentNames: list[ str ] = list()
+    componentNames: list[ str ] = []
     if array.GetNumberOfComponents() > 1:
         componentNames += [ array.GetComponentName( i ) for i in range( array.GetNumberOfComponents() ) ]
     return tuple( componentNames )
@@ -651,12 +640,12 @@ def computeCellCenterCoordinates( mesh: vtkDataSet ) -> vtkDataArray:
     return pts.GetData()
 
 
-def sortArrayByGlobalIds( data: Union[ vtkCellData, vtkFieldData ], arr: npt.NDArray[ np.int64 ] ) -> None:
-    """Sort an array following global Ids
+def sortArrayByGlobalIds( data: Union[ vtkCellData, vtkPointData ], arr: npt.NDArray[ np.float64 ] ) -> None:
+    """Sort an array following global Ids.
 
     Args:
         data (vtkFieldData): Global Ids array
-        arr (npt.NDArray[ np.int64 ]): Array to sort
+        arr (npt.NDArray[ np.float64 ]): Array to sort
     """
     globalids: Optional[ npt.NDArray[ np.int64 ] ] = getNumpyGlobalIdsArray( data )
     if globalids is not None: