Clean the log

Author: RomainBaville

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

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

@@ -44,9 +44,10 @@
     # Optional inputs.
     convertFaultToSurface: bool # Defaults to False
     speHandler: bool # Defaults to False
+    loggerName: str # Defaults to "GEOS Block Merge"
 
     # Instantiate the filter
-    mergeBlockFilter: GeosBlockMerge = GeosBlockMerge( inputMesh, convertFaultToSurface, speHandler )
+    mergeBlockFilter: GeosBlockMerge = GeosBlockMerge( inputMesh, convertFaultToSurface, speHandler, loggerName )
 
     # Set the handler of yours (only if speHandler is True).
     yourHandler: logging.Handler
@@ -59,8 +60,6 @@
     outputMesh: vtkMultiBlockDataSet = mergeBlockFilter.getOutput()
 """
 
-loggerTitle: str = "GEOS Block Merge"
-
 
 class GeosBlockMerge():
 
@@ -69,6 +68,7 @@ def __init__(
         inputMesh: vtkMultiBlockDataSet,
         convertFaultToSurface: bool = False,
         speHandler: bool = False,
+        loggerName: str = "GEOS Block Merge",
     ) -> None:
         """VTK Filter that merge ranks of GEOS output mesh.
 
@@ -83,6 +83,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 Merge".
 
         """
         self.inputMesh: vtkMultiBlockDataSet = inputMesh
@@ -94,12 +96,12 @@ def __init__(
             PhaseTypeEnum.FLUID.type: set(),
         }
 
-        # Logger.
+        # 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:
@@ -161,18 +163,18 @@ def applyFilter( self: Self ) -> None:
                 # Convert the volume mesh to a surface mesh
                 if self.convertFaultToSurface:
                     if not isTriangulate( volumeMesh ):
-                        volumeMesh.ShallowCopy( triangulateMesh( volumeMesh ) )
-                    surfaceMesh: vtkPolyData = convertUnstructuredGridToPolyData( volumeMesh )
+                        volumeMesh.ShallowCopy( triangulateMesh( volumeMesh, self.logger ) )
+                    surfaceMesh: vtkPolyData = convertUnstructuredGridToPolyData( volumeMesh, self.logger )
                     surfaceMesh.ShallowCopy( computeNormals( surfaceMesh, logger=self.logger ) )
                     surfaceMesh.ShallowCopy( computeTangents( surfaceMesh, logger=self.logger ) )
                     # Add the merged block to the output mesh
                     self.outputMesh.SetBlock( newIndex, surfaceMesh )
                 else:
                     self.outputMesh.SetBlock( newIndex, volumeMesh )
 
-            self.logger.info( "The filter succeeded." )
+            self.logger.info( f"The filter { self.logger.name } succeeded." )
         except ( ValueError, TypeError, RuntimeError, AssertionError, VTKError ) as e:
-            self.logger.critical( f"The filter failed.\n{ e }" )
+            self.logger.error( f"The filter { self.logger.name } failed.\n{ e }" )
 
         return
 
@@ -197,6 +199,8 @@ def renameAttributes(
                     else:
                         renameAttribute( mesh, attributeName, newName, False )
 
+        return
+
     def computePhaseNames( self: Self ) -> None:
         """Get the names of the phases in the mesh from Cell attributes."""
         # All the phase attributes are on cells

geos-pv/src/geos/pv/plugins/PVGeomechanicsWorkflow.py

@@ -108,10 +108,12 @@
 class PVGeomechanicsWorkflow( VTKPythonAlgorithmBase ):
 
     def __init__( self: Self ) -> None:
-        """Paraview plugin to clean and add new outputs Geos output mesh.
+        """Paraview plugin to compute geomechanics properties on volume and on surface directly from the GEOS simulation output mesh.
 
-        To apply in the case of output ".pvd" file contains Volume, Fault or
-        Well elements.
+        This plugin is the combination of three other:
+            - First PVGeosBlockExtractAndMerge
+            - Secondly PVGeomechanicsCalculator
+            - Thirdly PVSurfaceGeomechanics (if the input mesh contains faults)
         """
         super().__init__(
             nInputPorts=1,
@@ -141,6 +143,8 @@ def __init__( self: Self ) -> None:
         self.logger.setLevel( logging.INFO )
         self.logger.addHandler( VTKHandler() )
 
+        self.logger.info( f"Apply plugin { self.logger.name }." )
+
     @smproperty.doublevector(
         name="GrainBulkModulus",
         label="Grain bulk modulus (Pa)",
@@ -223,7 +227,7 @@ def setRockCohesion( self: Self, rockCohesion: float ) -> None:
     @smdomain.xml( """
         <Documentation>
             Reference friction angle to compute critical pore pressure.
-            The unit is °. Default is no friction case (i.e., 0.°).
+            The unit is °. Default is an average friction angle (i.e., 10°).
         </Documentation>
     """ )
     def setFrictionAngle( self: Self, frictionAngle: float ) -> None:
@@ -320,7 +324,6 @@ def RequestData(
         Returns:
             int: 1 if calculation successfully ended, 0 otherwise.
         """
-        self.logger.info( f"Apply plugin { self.logger.name }." )
         try:
             self.volumeMesh = self.GetOutputData( outInfoVec, 0 )
             self.faultMesh = self.GetOutputData( outInfoVec, 1 )

geos-pv/src/geos/pv/plugins/PVGeosBlockExtractAndMerge.py

@@ -118,6 +118,8 @@ def __init__( self: Self ) -> None:
         self.logger.setLevel( logging.INFO )
         self.logger.addHandler( VTKHandler() )
 
+        self.logger.info( f"Apply plugin { self.logger.name }." )
+
     def RequestDataObject(
         self: Self,
         request: vtkInformation,
@@ -170,8 +172,6 @@ def RequestInformation(
         Returns:
             int: 1 if calculation successfully ended, 0 otherwise.
         """
-        self.logger.info( f"Apply plugin { self.logger.name }." )
-
         executive = self.GetExecutive()
         inInfo = inInfoVec[ 0 ]
         self.timeSteps = inInfo.GetInformationObject( 0 ).Get( executive.TIME_STEPS() )

geos-pv/src/geos/pv/utils/workflowFunctions.py

@@ -3,13 +3,12 @@
 # SPDX-FileContributor: Romain Baville
 # ruff: noqa: E402 # disable Module level import not at top of file
 
-
 from geos.processing.post_processing.GeosBlockExtractor import GeosBlockExtractor
 from geos.processing.post_processing.GeosBlockMerge import GeosBlockMerge
 
 from vtkmodules.vtkCommonDataModel import vtkMultiBlockDataSet
 
-from paraview.detail.loghandler import ( VTKHandler ) # type: ignore[import-not-found]
+from paraview.detail.loghandler import ( VTKHandler )  # type: ignore[import-not-found]
 
 
 def doExtractAndMerge(
@@ -23,47 +22,59 @@ def doExtractAndMerge(
     """Apply block extraction and merge.
 
     Args:
-        mesh (vtkMultiBlockDataSet): Mesh to process.
-        outputCells (vtkMultiBlockDataSet): Output volume mesh.
-        outputFaults (vtkMultiBlockDataSet): Output surface mesh.
-        outputWells (vtkMultiBlockDataSet): Output well mesh.
+        mesh (vtkMultiBlockDataSet): Mesh to process
+        outputCells (vtkMultiBlockDataSet): Output volume mesh
+        outputFaults (vtkMultiBlockDataSet): Output surface mesh
+        outputWells (vtkMultiBlockDataSet): Output well mesh
+        extractFault (bool, Optional): True if SurfaceElementRegion needs to be extracted, False otherwise.
+        extractWell (bool, Optional): True if WellElementRegion needs to be extracted, False otherwise.
     """
     # Extract blocks
-    blockExtractor: GeosBlockExtractor = GeosBlockExtractor( mesh, extractFault=extractFault, extractWell=extractWell, speHandler=True )
+    blockExtractor: GeosBlockExtractor = GeosBlockExtractor( mesh,
+                                                             extractFault=extractFault,
+                                                             extractWell=extractWell,
+                                                             speHandler=True )
     if not blockExtractor.logger.hasHandlers():
         blockExtractor.setLoggerHandler( VTKHandler() )
     blockExtractor.applyFilter()
 
     # recover output objects from GeosBlockExtractor filter and merge internal blocks
     volumeBlockExtracted: vtkMultiBlockDataSet = blockExtractor.extractedGeosDomain.volume
-    outputCells.ShallowCopy( mergeBlocksFilter( volumeBlockExtracted, False ) )
+    outputCells.ShallowCopy( mergeBlocksFilter( volumeBlockExtracted, False, "Volume" ) )
     outputCells.Modified()
 
     if extractFault:
         faultBlockExtracted: vtkMultiBlockDataSet = blockExtractor.extractedGeosDomain.fault
-        outputFaults.ShallowCopy( mergeBlocksFilter( faultBlockExtracted, True ) )
+        outputFaults.ShallowCopy( mergeBlocksFilter( faultBlockExtracted, True, "Fault" ) )
         outputFaults.Modified()
 
     if extractWell:
         wellBlockExtracted: vtkMultiBlockDataSet = blockExtractor.extractedGeosDomain.well
-        outputWells.ShallowCopy( mergeBlocksFilter( wellBlockExtracted, False ) )
+        outputWells.ShallowCopy( mergeBlocksFilter( wellBlockExtracted, False, "Well" ) )
         outputWells.Modified()
 
     return
 
-def mergeBlocksFilter( mesh: vtkMultiBlockDataSet,
-                        convertSurfaces: bool = False, ) -> vtkMultiBlockDataSet:
+
+def mergeBlocksFilter(
+    mesh: vtkMultiBlockDataSet,
+    convertSurfaces: bool = False,
+    domainToMerge: str = "Volume",
+) -> vtkMultiBlockDataSet:
     """Apply vtk merge block filter on input multi block mesh.
 
     Args:
         mesh (vtkMultiBlockDataSet): Mesh to merge.
         convertSurfaces (bool, optional): True to convert surface from vtkUnstructuredGrid to vtkPolyData.
             Defaults to False.
+        domainToMerge (str, optional): The name of the GEOS domain processed.
+            Defaults to "Volume".
 
     Returns:
         vtkMultiBlockDataSet: Mesh composed of internal merged blocks.
     """
-    mergeBlockFilter: GeosBlockMerge = GeosBlockMerge( mesh, convertSurfaces, True )
+    loggerName = f"GEOS Block Merge for the domain { domainToMerge }."
+    mergeBlockFilter: GeosBlockMerge = GeosBlockMerge( mesh, convertSurfaces, True, loggerName )
     if not mergeBlockFilter.logger.hasHandlers():
         mergeBlockFilter.setLoggerHandler( VTKHandler() )
     mergeBlockFilter.applyFilter()