refactor: Move PVMergeBlocksEnhanced plugin and create the VTK filter

docs/geos_mesh_docs/processing.rst

@@ -45,10 +45,20 @@ geos.mesh.processing.SplitMesh filter
     :undoc-members:
     :show-inheritance:
 
+
+geos.mesh.processing.MergeBlockEnhanced filter
+------------------------------------------------
+
+.. automodule:: geos.mesh.processing.MergeBlockEnhanced
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+
 geos.mesh.processing.ClipToMainFrame filter
 --------------------------------------------
 
 .. automodule:: geos.mesh.processing.ClipToMainFrame
     :members:
     :undoc-members:
-    :show-inheritance:
+    :show-inheritance:

docs/geos_posp_docs/PVplugins.rst

@@ -64,11 +64,6 @@ PVGeomechanicsWorkflowVolumeWell plugin
 
 .. automodule:: PVplugins.PVGeomechanicsWorkflowVolumeWell
 
-PVplugins.PVMergeBlocksEnhanced module
---------------------------------------
-
-.. automodule:: PVplugins.PVMergeBlocksEnhanced
-
 
 PVMohrCirclePlot plugin
 ---------------------------------

docs/geos_pv_docs/processing.rst

@@ -24,6 +24,12 @@ PVSplitMesh
 .. automodule:: geos.pv.plugins.PVSplitMesh
 
 
+PVMergeBlocksEnhanced module
+--------------------------------------
+
+.. automodule:: geos.pv.plugins.PVMergeBlocksEnhanced
+
+
 PVClipToMainFrame
 ----------------------------------
 

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

@@ -2,8 +2,9 @@
 # SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies.
 # SPDX-FileContributor: Romain Baville
 import numpy as np
-import numpy.typing as npt
+import logging
 
+import numpy.typing as npt
 from typing import Union, Any
 from typing_extensions import Self
 
@@ -13,7 +14,7 @@
     vtkDataSet,
 )
 
-from geos.utils.Logger import ( getLogger, Logger, logging, CountWarningHandler )
+from geos.utils.Logger import ( getLogger, Logger, CountWarningHandler )
 from geos.mesh.utils.arrayHelpers import ( getArrayInObject, getComponentNames, getNumberOfComponents,
                                            getVtkDataTypeInObject, isAttributeGlobal, getAttributePieceInfo,
                                            checkValidValuesInDataSet, checkValidValuesInMultiBlock )

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

@@ -0,0 +1,132 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies.
+# SPDX-FileContributor: Paloma Martinez
+# ruff: noqa: E402 # disable Module level import not at top of file
+import logging
+
+from typing_extensions import Self
+
+from geos.utils.Logger import Logger, getLogger
+from geos.utils.Errors import VTKError
+from geos.mesh.utils.multiblockModifiers import mergeBlocks
+
+from vtkmodules.vtkCommonDataModel import (
+    vtkMultiBlockDataSet,
+    vtkUnstructuredGrid,
+)
+
+__doc__ = """
+Merge Blocks Keeping Partial Attributes is a filter that allows to merge blocks from a multiblock dataset while keeping partial attributes.
+
+Input is a vtkMultiBlockDataSet and output is a vtkUnstructuredGrid.
+
+.. Note::
+    - You may encounter issues if two datasets of the input multiblock dataset have duplicated cell IDs.
+    - Partial attributes are filled with default values depending on their types.
+        - 0 for uint data.
+        - -1 for int data.
+        - nan for float data.
+
+
+To use it:
+
+.. code-block:: python
+
+    from geos.mesh.processing.MergeBlockEnhanced import MergeBlockEnhanced
+    import logging
+    from geos.utils.Errors import VTKError
+
+    # Define filter inputs
+    multiblockdataset: vtkMultiblockDataSet
+    speHandler: bool # optional
+
+    # Instantiate the filter
+    filter: MergeBlockEnhanced = MergeBlockEnhanced( multiblockdataset, speHandler )
+
+    # Use your own handler (if speHandler is True)
+    yourHandler: logging.Handler
+    filter.setLoggerHandler( yourHandler )
+
+    # Do calculations
+    try:
+        filter.applyFilter()
+    except VTKError:
+        logging.error("Something went wrong in VTK")
+
+    # Get the merged mesh
+    filter.getOutput()
+"""
+
+loggerTitle: str = "Merge Block Enhanced"
+
+
+class MergeBlockEnhanced:
+
+    def __init__(
+        self: Self,
+        inputMesh: vtkMultiBlockDataSet,
+        speHandler: bool = False,
+    ) -> None:
+        """Merge a multiblock dataset and keep the partial attributes in the output mesh.
+
+        Partial attributes are filled with default values depending on the data type such that:
+            - 0 for uint data.
+            - -1 for int data.
+            - nan for float data.
+
+        Args:
+            inputMesh (vtkMultiBlockDataSet): The input multiblock dataset to merge.
+            speHandler (bool, optional) : True to use a specific handler, False to use the internal handler.
+            Defaults to False.
+        """
+        self.inputMesh: vtkMultiBlockDataSet = inputMesh
+        self.outputMesh: vtkUnstructuredGrid = vtkUnstructuredGrid()
+
+        # Logger
+        self.logger: Logger
+        if not speHandler:
+            self.logger = getLogger( loggerTitle, True )
+        else:
+            self.logger = logging.getLogger( loggerTitle )
+            self.logger.setLevel( logging.INFO )
+
+    def setLoggerHandler( self: Self, handler: logging.Handler ) -> None:
+        """Set a specific handler for the filter logger.
+
+        In this filter 4 log levels are use, .info, .error, .warning and .critical, be sure to have at least the same 4 levels.
+
+        Args:
+            handler (logging.Handler): The handler to add.
+        """
+        if not self.logger.hasHandlers():
+            self.logger.addHandler( handler )
+        else:
+            self.logger.warning(
+                "The logger already has an handler, to use yours set the argument 'speHandler' to True during the filter initialization."
+            )
+
+    def applyFilter( self: Self ) -> None:
+        """Merge the blocks of a multiblock dataset mesh.
+
+        Returns:
+            bool: True if the blocks were successfully merged, False otherwise.
+
+        Raises:
+            VTKError (geos.utils.Errors) : error captured if any from the VTK log
+        """
+        self.logger.info( f"Applying filter { self.logger.name }." )
+
+        outputMesh: vtkUnstructuredGrid
+        outputMesh = mergeBlocks( self.inputMesh, keepPartialAttributes=True, logger=self.logger )
+        self.logger.info( f"The filter {self.logger.name} failed." )
+        self.outputMesh = outputMesh
+        self.logger.info( f"The filter {self.logger.name} succeeded." )
+
+
+    def getOutput( self: Self ) -> vtkUnstructuredGrid:
+        """Get the merged mesh.
+
+        Returns:
+            vtkUnstructuredGrid: The merged mesh.
+        """
+        return self.outputMesh

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

@@ -677,7 +677,6 @@ def isAttributeGlobal( multiBlockDataSet: vtkMultiBlockDataSet, attributeName: s
         dataSet: vtkDataSet = vtkDataSet.SafeDownCast( multiBlockDataSet.GetDataSet( blockIndex ) )
         if not isAttributeInObjectDataSet( dataSet, attributeName, onPoints ):
             return False
-
     return True
 
 

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

@@ -1,45 +1,97 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies.
-# SPDX-FileContributor: Martin Lemay
+# SPDX-FileContributor: Martin Lemay, Paloma Martinez
 from typing import Union
+import logging
+# import re
+
 from vtkmodules.vtkCommonDataModel import ( vtkCompositeDataSet, vtkDataObjectTreeIterator, vtkMultiBlockDataSet,
-                                            vtkDataSet )
-from vtkmodules.vtkFiltersCore import vtkAppendDataSets
+                                            vtkUnstructuredGrid, vtkDataSet )
+from packaging.version import Version
+from vtkmodules.vtkCommonCore import vtkLogger
+
+# TODO: remove this condition when all codes are adapted for VTK newest version.
+import vtk
+if Version( vtk.__version__ ) >= Version( "9.5" ):
+    from vtkmodules.vtkFiltersParallel import vtkMergeBlocks
+else:
+    from vtkmodules.vtkFiltersCore import vtkAppendDataSets
+
 from geos.mesh.utils.arrayModifiers import fillAllPartialAttributes
+from geos.utils.Errors import VTKError
+from geos.utils.Logger import ( getLogger, Logger, VTKCaptureLog, RegexExceptionFilter)
 
 __doc__ = """Contains a method to merge blocks of a VTK multiblock dataset."""
 
-
-# TODO : fix function for keepPartialAttributes = True
 def mergeBlocks(
-    input: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ],
+    inputMesh: Union[ vtkMultiBlockDataSet, vtkCompositeDataSet ],
     keepPartialAttributes: bool = False,
-) -> vtkDataSet:
-    """Merge all blocks of a multi block mesh.
+    logger: Union[ Logger, None ] = None,
+) -> vtkUnstructuredGrid:
+    """Merge all blocks of a multiblock dataset mesh with the possibility of keeping all partial attributes present in the initial mesh.
 
     Args:
-        input (vtkMultiBlockDataSet | vtkCompositeDataSet ): composite
-            object to merge blocks
-        keepPartialAttributes (bool): if True, keep partial attributes after merge.
-
-            Defaults to False.
+        inputMesh (vtkMultiBlockDataSet | vtkCompositeDataSet ): The input multiblock dataset to merge.
+        keepPartialAttributes (bool): If False (default), only global attributes are kept during the merge. If True, partial attributes are filled with default values and kept in the output mesh.
+        logger (Union[Logger, None], optional): A logger to manage the output messages.
+            Defaults to None, an internal logger is used.
 
     Returns:
-        vtkUnstructuredGrid: merged block object
+        vtkUnstructuredGrid: Merged dataset or input mesh if it's already a single block
+
+    Raises:
+        geos.utilsVTKError ():
+
+    .. Note::
+        Default filling values:
+            - 0 for uint data.
+            - -1 for int data.
+            - nan for float data.
+
+    .. Warning:: This function will not work properly if there are duplicated cell IDs in the different blocks of the input mesh.
 
     """
-    if keepPartialAttributes:
-        fillAllPartialAttributes( input )
-
-    af = vtkAppendDataSets()
-    af.MergePointsOn()
-    iter: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator()
-    iter.SetDataSet( input )
-    iter.VisitOnlyLeavesOn()
-    iter.GoToFirstItem()
-    while iter.GetCurrentDataObject() is not None:
-        block: vtkDataSet = vtkDataSet.SafeDownCast( iter.GetCurrentDataObject() )
-        af.AddInputData( block )
-        iter.GoToNextItem()
-    af.Update()
-    return af.GetOutputDataObject( 0 )
+    if logger is None:
+        logger: Logger = getLogger( "mergeBlocks", True )
+
+    vtkLogger.SetStderrVerbosity(vtkLogger.VERBOSITY_TRACE)
+    logger.addFilter(RegexExceptionFilter()) # will raise VTKError if captured VTK Error
+    logger.setLevel(logging.DEBUG)
+
+    # Fill the partial attributes with default values to keep them during the merge.
+    if keepPartialAttributes and not fillAllPartialAttributes( inputMesh, logger ):
+        logger.warning( "Failed to fill partial attributes. Merging without keeping partial attributes." )
+
+    if Version( vtk.__version__ ) >= Version( "9.5" ):
+        filter: vtkMergeBlocks = vtkMergeBlocks()
+        filter.SetInputData( inputMesh )
+        filter.Update()
+
+        outputMesh: vtkUnstructuredGrid = filter.GetOutputDataObject( 0 )
+
+    else:
+        if inputMesh.IsA( "vtkDataSet" ):
+            logger.warning( "Input mesh is already a single block." )
+            outputMesh = inputMesh
+        else:
+            with VTKCaptureLog() as captured_log:
+
+                af: vtkAppendDataSets = vtkAppendDataSets()
+                af.MergePointsOn()
+                iterator: vtkDataObjectTreeIterator = vtkDataObjectTreeIterator()
+                iterator.SetDataSet( inputMesh )
+                iterator.VisitOnlyLeavesOn()
+                iterator.GoToFirstItem()
+                while iterator.GetCurrentDataObject() is not None:
+                    block: vtkDataSet = vtkDataSet.SafeDownCast( iterator.GetCurrentDataObject() )
+                    af.AddInputData( block )
+                    iterator.GoToNextItem()
+
+                af.Update()
+                captured_log.seek(0) #be kind let's just rewind
+                captured = captured_log.read().decode()
+
+            logger.debug(captured.strip())
+            outputMesh: vtkUnstructuredGrid = af.GetOutputDataObject( 0 )
+
+    return outputMesh

geos-mesh/tests/conftest.py

@@ -10,7 +10,7 @@
 import numpy.typing as npt
 
 from vtkmodules.vtkCommonDataModel import vtkDataSet, vtkMultiBlockDataSet, vtkPolyData
-from vtkmodules.vtkIOXML import vtkXMLGenericDataObjectReader
+from vtkmodules.vtkIOXML import vtkXMLGenericDataObjectReader, vtkXMLMultiBlockDataReader
 
 
 @pytest.fixture
@@ -163,6 +163,10 @@ def _get_dataset( datasetType: str ) -> Union[ vtkMultiBlockDataSet, vtkPolyData
             vtkFilename = "data/displacedFault.vtm"
         elif datasetType == "emptymultiblock":
             vtkFilename = "data/displacedFaultempty.vtm"
+        elif datasetType == "multiblockGeosOutput":
+            # adapted from example GEOS/inputFiles/compositionalMultiphaseWell/simpleCo2InjTutorial_smoke.xml
+            reader: vtkXMLMultiBlockDataReader = vtkXMLMultiBlockDataReader()
+            vtkFilename = "data/simpleReservoirViz_small_000478.vtm"
         elif datasetType == "fracture":
             vtkFilename = "data/fracture_res5_id.vtu"
         elif datasetType == "emptyFracture":

geos-mesh/tests/data/simpleReservoirViz_small_000478.vtm

@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+<VTKFile type="vtkMultiBlockDataSet" version="1.0">
+	<vtkMultiBlockDataSet>
+		<Block name="cartesianMesh">
+			<Block name="Level0">
+				<Block name="CellElementRegion">
+					<Block name="reservoir">
+						<DataSet name="rank_0" file="simpleReservoirViz_small_000478/cartesianMesh/Level0/reservoir/rank_0.vtu" />
+						<DataSet name="rank_1" file="simpleReservoirViz_small_000478/cartesianMesh/Level0/reservoir/rank_1.vtu" />
+					</Block>
+				</Block>
+				<Block name="WellElementRegion">
+					<Block name="wellRegion">
+						<DataSet name="rank_1" file="simpleReservoirViz_small_000478/cartesianMesh/Level0/wellRegion/rank_1.vtu" />
+					</Block>
+				</Block>
+			</Block>
+		</Block>
+	</vtkMultiBlockDataSet>
+</VTKFile>