refactor: Merge the four geomechanics workflow plugins in one (#175)

Author: RomainBaville

docs/geos_pv_docs/processing.rst

@@ -53,36 +53,17 @@ PVGeosBlockExtractAndMerge plugin
 .. automodule:: geos.pv.plugins.PVGeosBlockExtractAndMerge
 
 
-
 Geomechanics workflows
 ++++++++++++++++++++++++
 
 
-PVGeomechanicsWorkflowVolume plugin
----------------------------------------------
-
-.. automodule:: geos.pv.plugins.PVGeomechanicsWorkflowVolume
-
-
-PVGeomechanicsWorkflowVolumeSurface plugin
-----------------------------------------------------
-
-.. automodule:: geos.pv.plugins.PVGeomechanicsWorkflowVolumeSurface
-
-
-PVGeomechanicsWorkflowVolumeSurfaceWell plugin
---------------------------------------------------------
-
-.. automodule:: geos.pv.plugins.PVGeomechanicsWorkflowVolumeSurfaceWell
-
-
-PVGeomechanicsWorkflowVolumeWell plugin
--------------------------------------------------
+PVGeomechanicsWorkflow plugin
+------------------------------
 
-.. automodule:: geos.pv.plugins.PVGeomechanicsWorkflowVolumeWell
+.. automodule:: geos.pv.plugins.PVGeomechanicsWorkflow
 
 
 PVGeomechanicsCalculator plugin
 ---------------------------------------
 
-.. automodule:: geos.pv.plugins.PVGeomechanicsCalculator
+.. automodule:: geos.pv.plugins.PVGeomechanicsCalculator

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

@@ -62,16 +62,17 @@ def triangulateMesh(
     Returns:
         vtkUnstructuredGrid: Triangulated mesh
     """
+    vtkErrorLogger: Logger
     if logger is None:
-        logger = getLogger( "Triangulate", True )
-    # Creation of a child logger to deal with VTKErrors without polluting parent logger
-    vtkErrorLogger: Logger = getLogger( f"{logger.name}.vtkErrorLogger", True )
-    vtkErrorLogger.propagate = False
+        vtkErrorLogger = getLogger( "Triangulate Mesh vtkError Logger", True )
+    else:
+        vtkErrorLogger = logging.getLogger( f"{ logger.name } vtkError Logger" )
+        vtkErrorLogger.setLevel( logging.INFO )
+        vtkErrorLogger.addHandler( logger.handlers[ 0 ] )
+        vtkErrorLogger.propagate = False
 
     vtkLogger.SetStderrVerbosity( vtkLogger.VERBOSITY_ERROR )
-
     vtkErrorLogger.addFilter( RegexExceptionFilter() )  # will raise VTKError if captured VTK Error
-    vtkErrorLogger.setLevel( logging.DEBUG )
 
     with VTKCaptureLog() as capturedLog:
         triangulateMeshFilter: vtkDataSetTriangleFilter = vtkDataSetTriangleFilter()
@@ -81,7 +82,8 @@ def triangulateMesh(
         capturedLog.seek( 0 )
         captured = capturedLog.read().decode()
 
-        vtkErrorLogger.debug( captured.strip() )
+    if captured != "":
+        vtkErrorLogger.error( captured.strip() )
 
     triangulatedMesh: vtkUnstructuredGrid = triangulateMeshFilter.GetOutput()
 
@@ -107,16 +109,17 @@ def convertUnstructuredGridToPolyData(
     Returns:
         vtkPolyData: Extracted surface
     """
+    vtkErrorLogger: Logger
     if logger is None:
-        logger = getLogger( "ConvertVtkUnstructuredGridToVtkPolyData.", True )
-    # Creation of a child logger to deal with VTKErrors without polluting parent logger
-    vtkErrorLogger: Logger = getLogger( f"{logger.name}.vtkErrorLogger", True )
-    vtkErrorLogger.propagate = False
+        vtkErrorLogger = getLogger( "Convert vtkUnstructuredGrid To vtkPolyData vtkError Logger", True )
+    else:
+        vtkErrorLogger = logging.getLogger( f"{ logger.name } vtkError Logger" )
+        vtkErrorLogger.setLevel( logging.INFO )
+        vtkErrorLogger.addHandler( logger.handlers[ 0 ] )
+        vtkErrorLogger.propagate = False
 
     vtkLogger.SetStderrVerbosity( vtkLogger.VERBOSITY_ERROR )
-
     vtkErrorLogger.addFilter( RegexExceptionFilter() )  # will raise VTKError if captured VTK Error
-    vtkErrorLogger.setLevel( logging.DEBUG )
 
     with VTKCaptureLog() as capturedLog:
         extractSurfaceFilter: vtkDataSetSurfaceFilter = vtkDataSetSurfaceFilter()
@@ -131,7 +134,8 @@ def convertUnstructuredGridToPolyData(
         capturedLog.seek( 0 )
         captured = capturedLog.read().decode()
 
-        vtkErrorLogger.debug( captured.strip() )
+    if captured != "":
+        vtkErrorLogger.error( captured.strip() )
 
     extractedSurface: vtkPolyData = extractSurfaceFilter.GetOutput()
 
@@ -460,8 +464,8 @@ def getTangentsVectors( surface: vtkPolyData ) -> Tuple[ npt.NDArray[ np.float64
     try:
         tangents1 = vtk_to_numpy( vtkTangents )
     except AttributeError as err:
-        print( "No tangential attribute found in the mesh. Use the computeTangents function beforehand." )
-        raise VTKError( err ) from err
+        context: str = f"No tangential attribute found in the mesh. Use the computeTangents function beforehand.\n{ err }"
+        raise VTKError( context ) from err
     else:
         # Compute second tangential component
         normals: npt.NDArray[ np.float64 ] = getNormalVectors( surface )
@@ -471,22 +475,30 @@ def getTangentsVectors( surface: vtkPolyData ) -> Tuple[ npt.NDArray[ np.float64
     return ( tangents1, tangents2 )
 
 
-def getLocalBasisVectors( surface: vtkPolyData ) -> npt.NDArray[ np.float64 ]:
+def getLocalBasisVectors(
+    surface: vtkPolyData,
+    logger: Union[ Logger, None ] = None,
+) -> npt.NDArray[ np.float64 ]:
     """Return the local basis vectors for all cells of the input surface.
 
     Args:
         surface(vtkPolydata): The input surface.
+        logger (Union[Logger, None], optional): A logger to manage the output messages.
+            Defaults to None, an internal logger is used.
 
     Returns:
         npt.NDArray[np.float64]: Array with normal, tangential 1 and tangential 2 vectors.
     """
+    if logger is None:
+        logger = getLogger( "getLocalBasisVectors", True )
+
     try:
         normals: npt.NDArray[ np.float64 ] = getNormalVectors( surface )
         surfaceWithNormals: vtkPolyData = surface
     # ValueError raised if no normals found in the mesh
     except ValueError:
         # In that case, the normals are computed.
-        surfaceWithNormals = computeNormals( surface )
+        surfaceWithNormals = computeNormals( surface, logger )
         normals = getNormalVectors( surfaceWithNormals )
 
     # Tangents require normals to be present in the mesh
@@ -495,7 +507,7 @@ def getLocalBasisVectors( surface: vtkPolyData ) -> npt.NDArray[ np.float64 ]:
                          npt.NDArray[ np.float64 ] ] = getTangentsVectors( surfaceWithNormals )
     # If no tangents is present in the mesh, they are computed on that surface
     except VTKError:
-        surfaceWithTangents: vtkPolyData = computeTangents( surfaceWithNormals )
+        surfaceWithTangents: vtkPolyData = computeTangents( surfaceWithNormals, logger )
         tangents = getTangentsVectors( surfaceWithTangents )
 
     return np.array( ( normals, *tangents ) )
@@ -515,16 +527,17 @@ def computeNormals(
     Returns:
         vtkPolyData: The surface with normal attribute.
     """
+    vtkErrorLogger: Logger
     if logger is None:
-        logger = getLogger( "computeSurfaceNormals" )
-    # Creation of a child logger to deal with VTKErrors without polluting parent logger
-    vtkErrorLogger: Logger = getLogger( f"{logger.name}.vtkErrorLogger" )
-    vtkErrorLogger.propagate = False
+        vtkErrorLogger = getLogger( "Compute Surface Normals vtkError Logger", True )
+    else:
+        vtkErrorLogger = logging.getLogger( f"{ logger.name } vtkError Logger" )
+        vtkErrorLogger.setLevel( logging.INFO )
+        vtkErrorLogger.addHandler( logger.handlers[ 0 ] )
+        vtkErrorLogger.propagate = False
 
     vtkLogger.SetStderrVerbosity( vtkLogger.VERBOSITY_ERROR )
-
     vtkErrorLogger.addFilter( RegexExceptionFilter() )  # will raise VTKError if captured VTK Error
-    vtkErrorLogger.setLevel( logging.DEBUG )
 
     with VTKCaptureLog() as capturedLog:
         normalFilter: vtkPolyDataNormals = vtkPolyDataNormals()
@@ -536,7 +549,8 @@ def computeNormals(
         capturedLog.seek( 0 )
         captured = capturedLog.read().decode()
 
-        vtkErrorLogger.debug( captured.strip() )
+    if captured != "":
+        vtkErrorLogger.error( captured.strip() )
 
     outputSurface = normalFilter.GetOutput()
 
@@ -562,22 +576,23 @@ def computeTangents(
     Returns:
         vtkPolyData: The surface with tangent attribute
     """
-    # need to compute texture coordinates required for tangent calculation
-    surface1: vtkPolyData = computeSurfaceTextureCoordinates( triangulatedSurface )
+    # Need to compute texture coordinates required for tangent calculation
+    surface1: vtkPolyData = computeSurfaceTextureCoordinates( triangulatedSurface, logger )
 
     # TODO: triangulate the surface before computation of the tangents if needed.
 
-    # compute tangents
+    # Compute tangents
+    vtkErrorLogger: Logger
     if logger is None:
-        logger = getLogger( "computeSurfaceTangents" )
-    # Creation of a child logger to deal with VTKErrors without polluting parent logger
-    vtkErrorLogger: Logger = getLogger( f"{logger.name}.vtkErrorLogger" )
-    vtkErrorLogger.propagate = False
+        vtkErrorLogger = getLogger( "Compute Surface Tangents vtkError Logger", True )
+    else:
+        vtkErrorLogger = logging.getLogger( f"{ logger.name } vtkError Logger" )
+        vtkErrorLogger.setLevel( logging.INFO )
+        vtkErrorLogger.addHandler( logger.handlers[ 0 ] )
+        vtkErrorLogger.propagate = False
 
     vtkLogger.SetStderrVerbosity( vtkLogger.VERBOSITY_ERROR )
-
     vtkErrorLogger.addFilter( RegexExceptionFilter() )  # will raise VTKError if captured VTK Error
-    vtkErrorLogger.setLevel( logging.DEBUG )
 
     with VTKCaptureLog() as capturedLog:
 
@@ -591,7 +606,8 @@ def computeTangents(
         capturedLog.seek( 0 )
         captured = capturedLog.read().decode()
 
-        vtkErrorLogger.debug( captured.strip() )
+    if captured != "":
+        vtkErrorLogger.error( captured.strip() )
 
     if surfaceOut is None:
         raise VTKError( "Something went wrong in VTK calculation." )
@@ -623,16 +639,17 @@ def computeSurfaceTextureCoordinates(
         vtkPolyData: The input surface with generated texture map.
     """
     # Need to compute texture coordinates required for tangent calculation
+    vtkErrorLogger: Logger
     if logger is None:
-        logger = getLogger( "computeSurfaceTextureCoordinates" )
-    # Creation of a child logger to deal with VTKErrors without polluting parent logger
-    vtkErrorLogger: Logger = getLogger( f"{logger.name}.vtkErrorLogger" )
-    vtkErrorLogger.propagate = False
+        vtkErrorLogger = getLogger( "Compute Surface Texture Coordinates vtkError Logger", True )
+    else:
+        vtkErrorLogger = logging.getLogger( f"{ logger.name } vtkError Logger" )
+        vtkErrorLogger.setLevel( logging.INFO )
+        vtkErrorLogger.addHandler( logger.handlers[ 0 ] )
+        vtkErrorLogger.propagate = False
 
     vtkLogger.SetStderrVerbosity( vtkLogger.VERBOSITY_ERROR )
-
     vtkErrorLogger.addFilter( RegexExceptionFilter() )  # will raise VTKError if captured VTK Error
-    vtkErrorLogger.setLevel( logging.DEBUG )
 
     with VTKCaptureLog() as capturedLog:
 
@@ -644,6 +661,7 @@ def computeSurfaceTextureCoordinates(
         capturedLog.seek( 0 )
         captured = capturedLog.read().decode()
 
-        vtkErrorLogger.debug( captured.strip() )
+    if captured != "":
+        vtkErrorLogger.error( captured.strip() )
 
     return textureFilter.GetOutput()

geos-processing/src/geos/processing/post_processing/GeomechanicsCalculator.py

@@ -85,6 +85,7 @@
     mesh: vtkUnstructuredGrid
     computeAdvancedProperties: bool # optional, defaults to False
     speHandler: bool # optional, defaults to False
+    loggerName: str # Defaults to "Geomechanics Calculator"
 
     # Instantiate the filter
     geomechanicsCalculatorFilter: GeomechanicsCalculator = GeomechanicsCalculator( mesh, computeAdvancedProperties, speHandler )
@@ -693,7 +694,7 @@ def __init__(
             computeAdvancedProperties (bool, optional): True to compute advanced geomechanics properties, False otherwise.
                 Defaults to False.
             loggerName (str, optional): Name of the filter logger.
-                Defaults to "Geomechanics Calculator"
+                Defaults to "Geomechanics Calculator".
             speHandler (bool, optional): True to use a specific handler, False to use the internal handler.
                 Defaults to False.
         """

geos-processing/src/geos/processing/post_processing/GeosBlockExtractor.py

@@ -38,6 +38,7 @@
     extractFault: bool # Defaults to False
     extractWell: bool # Defaults to False
     speHandler: bool # Defaults to False
+    loggerName: str # Defaults to "Geos Block Extractor"
 
     # Instantiate the filter
     geosBlockExtractor: GeosBlockExtractor = GeosBlockExtractor( geosMesh, extractFault, extractWell, speHandler )
@@ -56,8 +57,6 @@
     geosDomainExtracted = geosBlockExtractor.extractedGeosDomain.well # For well domain
 """
 
-loggerTitle: str = "Geos Block Extractor"
-
 
 class GeosExtractDomainBlock( vtkExtractBlock ):
 
@@ -149,6 +148,7 @@ def __init__(
         extractFault: bool = False,
         extractWell: bool = False,
         speHandler: bool = False,
+        loggerName: str = "Geos Block Extractor",
     ) -> None:
         """Blocks from the ElementRegions from a GEOS output multiBlockDataset mesh.
 
@@ -160,6 +160,8 @@ def __init__(
                 Defaults to False.
             speHandler (bool, optional): True to use a specific handler, False to use the internal handler.
                 Defaults to False.
+            loggerName (str, optional): Name of the filter logger.
+                Defaults to "Geos Block Extractor".
         """
         self.geosMesh: vtkMultiBlockDataSet = geosMesh
         self.extractedGeosDomain = self.ExtractedGeosDomain()
@@ -173,9 +175,9 @@ def __init__(
         # Logger.
         self.logger: Logger
         if not speHandler:
-            self.logger = getLogger( loggerTitle, True )
+            self.logger = getLogger( loggerName, True )
         else:
-            self.logger = logging.getLogger( loggerTitle )
+            self.logger = logging.getLogger( loggerName )
             self.logger.setLevel( logging.INFO )
 
     def setLoggerHandler( self: Self, handler: logging.Handler ) -> None:
@@ -201,15 +203,18 @@ def applyFilter( self: Self ) -> None:
             extractGeosDomain: GeosExtractDomainBlock = GeosExtractDomainBlock()
             extractGeosDomain.SetInputData( self.geosMesh )
 
+            domainNames: list = []
             for domain in self.domainToExtract:
                 extractGeosDomain.RemoveAllIndices()
                 extractGeosDomain.AddGeosDomainName( domain )
                 extractGeosDomain.Update()
                 self.extractedGeosDomain.setExtractedDomain( domain, extractGeosDomain.GetOutput() )
+                domainNames.append( domain.value )
+
+            self.logger.info( f"The GEOS domain { domainNames } have been extracted." )
+            self.logger.info( f"The filter { self.logger.name } succeeded." )
 
-            self.logger.info( "The filter succeeded." )
+        except ( ValueError, TypeError ) as e:
+            self.logger.error( f"The filter { self.logger.name } failed.\n{ e }." )
 
-        except ValueError as ve:
-            self.logger.error( f"The filter failed.\n{ ve }." )
-        except TypeError as te:
-            self.logger.error( f"The filter failed.\n{ te }." )
+        return