refactor: Move the paraview plugin and create a VTK filter for CreateConstantAttributePerRegion

docs/geos_mesh_docs/processing.rst

@@ -3,6 +3,13 @@ Processing filters
 
 The `processing` module of `geos-mesh` package contains filters to process meshes.
 
+geos.mesh.processing.CreateConstantAttributePerRegion filter
+-------------------------------------------------------------
+
+.. automodule:: geos.mesh.processing.CreateConstantAttributePerRegion
+    :members:
+    :undoc-members:
+    :show-inheritance:
 
 geos.mesh.processing.FillPartialArrays filter
 ----------------------------------------------

docs/geos_posp_docs/PVplugins.rst

@@ -16,12 +16,6 @@ PVAttributeMapping plugin
 .. automodule:: PVplugins.PVAttributeMapping
 
 
-PVCreateConstantAttributePerRegion plugin
----------------------------------------------------
-
-.. automodule:: PVplugins.PVCreateConstantAttributePerRegion
-
-
 PVExtractMergeBlocksVolume plugin
 -------------------------------------------
 

docs/geos_pv_docs/processing.rst

@@ -1,8 +1,16 @@
 Post-/Pre-processing
 =========================
 
+
+PVCreateConstantAttributePerRegion
+-----------------------------------
+
+.. automodule:: geos.pv.plugins.PVCreateConstantAttributePerRegion
+
+
 PVFillPartialArrays
 --------------------
+
 .. automodule:: geos.pv.plugins.PVFillPartialArrays
 
 

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

@@ -7,7 +7,7 @@
 
 from geos.utils.Logger import logging, Logger, getLogger
 from geos.mesh.utils.arrayModifiers import fillPartialAttributes
-from geos.mesh.utils.arrayHelpers import isAttributeInObject
+from geos.mesh.utils.arrayHelpers import getAttributePieceInfo
 
 from vtkmodules.vtkCommonDataModel import vtkMultiBlockDataSet
 
@@ -23,7 +23,7 @@
 0 for uint data, -1 for int data and nan for float data.
 
 To use a handler of yours for the logger, set the variable 'speHandler' to True and add it to the filter
-with the member function addLoggerHandler.
+with the member function setLoggerHandler.
 
 To use it:
 
@@ -42,7 +42,7 @@
 
     # Set the handler of yours (only if speHandler is True).
     yourHandler: logging.Handler
-    filter.addLoggerHandler( yourHandler )
+    filter.setLoggerHandler( yourHandler )
 
     # Do calculations.
     filter.applyFilter()
@@ -106,15 +106,17 @@ def applyFilter( self: Self ) -> bool:
         """
         self.logger.info( f"Apply filter { self.logger.name }." )
 
+        onPoints: Union[ None, bool ]
+        onBoth: bool
         for attributeName in self.dictAttributesValues:
-            self._setPieceRegionAttribute( attributeName )
-            if self.onPoints is None:
+            onPoints, onBoth = getAttributePieceInfo( self.multiBlockDataSet, attributeName )
+            if onPoints is None:
                 self.logger.error( f"{ attributeName } is not in the mesh." )
                 self.logger.error( f"The attribute { attributeName } has not been filled." )
                 self.logger.error( f"The filter { self.logger.name } failed." )
                 return False
 
-            if self.onBoth:
+            if onBoth:
                 self.logger.error(
                     f"Their is two attribute named { attributeName }, one on points and the other on cells. The attribute must be unique."
                 )
@@ -124,7 +126,7 @@ def applyFilter( self: Self ) -> bool:
 
             if not fillPartialAttributes( self.multiBlockDataSet,
                                           attributeName,
-                                          onPoints=self.onPoints,
+                                          onPoints=onPoints,
                                           listValues=self.dictAttributesValues[ attributeName ],
                                           logger=self.logger ):
                 self.logger.error( f"The filter { self.logger.name } failed." )
@@ -133,22 +135,3 @@ def applyFilter( self: Self ) -> bool:
         self.logger.info( f"The filter { self.logger.name } succeed." )
 
         return True
-
-    def _setPieceRegionAttribute( self: Self, attributeName: str ) -> None:
-        """Set the attribute self.onPoints and self.onBoth.
-
-        self.onPoints is True if the region attribute is on points, False if it is on cells, None otherwise.
-
-        self.onBoth is True if a region attribute is on points and on cells, False otherwise.
-
-        Args:
-           attributeName (str): The name of the attribute to verify.
-        """
-        self.onPoints: Union[ bool, None ] = None
-        self.onBoth: bool = False
-        if isAttributeInObject( self.multiBlockDataSet, attributeName, False ):
-            self.onPoints = False
-        if isAttributeInObject( self.multiBlockDataSet, attributeName, True ):
-            if self.onPoints is False:
-                self.onBoth = True
-            self.onPoints = True

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

@@ -47,6 +47,102 @@ def has_array( mesh: vtkUnstructuredGrid, array_names: list[ str ] ) -> bool:
     return False
 
 
+def getAttributePieceInfo(
+    mesh: Union[ vtkDataSet, vtkMultiBlockDataSet ],
+    attributeName: str,
+) -> tuple[ Union[ None, bool ], bool ]:
+    """Get the attribute piece information.
+
+    Two information are given:
+        - onPoints (Union[None, bool]): True if the attribute is on points or on both pieces, False if it is on cells, None otherwise.
+        - onBoth (bool): True if the attribute is on points and on cells, False otherwise.
+
+    Args:
+        mesh (Union[vtkDataSet, vtkMultiBlockDataSet]): The mesh with the attribute.
+        attributeName (str): The name of the attribute.
+
+    Returns:
+        tuple[Union[None, bool], bool]: The piece information of the attribute.
+    """
+    onPoints: Union[ bool, None ] = None
+    onBoth: bool = False
+    if isAttributeInObject( mesh, attributeName, False ):
+        onPoints = False
+    if isAttributeInObject( mesh, attributeName, True ):
+        if onPoints is False:
+            onBoth = True
+        onPoints = True
+
+    return ( onPoints, onBoth )
+
+
+def checkValidValuesInMultiBlock(
+    multiBlockDataSet: vtkMultiBlockDataSet,
+    attributeName: str,
+    listValues: list[ Any ],
+    onPoints: bool,
+) -> tuple[ list[ Any ], list[ Any ] ]:
+    """Check if each value is valid , ie if that value is a data of the attribute in at least one dataset of the multiblock.
+
+    Args:
+        multiBlockDataSet (vtkMultiBlockDataSet): The multiblock dataset mesh to check.
+        attributeName (str): The name of the attribute with the data.
+        listValues (list[Any]): The list of values to check.
+        onPoints (bool): True if the attribute is on points, False if on cells.
+
+    Returns:
+        tuple[list[Any], list[Any]]: Tuple containing the list of valid values and the list of the invalid ones.
+    """
+    validValues: list[ Any ] = []
+    invalidValues: list[ Any ] = []
+    listFlatIdDataSet: list[ int ] = getBlockElementIndexesFlatten( multiBlockDataSet )
+    for flatIdDataSet in listFlatIdDataSet:
+        dataSet: vtkDataSet = vtkDataSet.SafeDownCast( multiBlockDataSet.GetDataSet( flatIdDataSet ) )
+        # Get the valid values of the dataset.
+        validValuesDataSet: list[ Any ] = checkValidValuesInDataSet( dataSet, attributeName, listValues, onPoints )[ 0 ]
+
+        # Keep the new true values.
+        for value in validValuesDataSet:
+            if value not in validValues:
+                validValues.append( value )
+
+    # Get the false indexes.
+    for value in listValues:
+        if value not in validValues:
+            invalidValues.append( value )
+
+    return ( validValues, invalidValues )
+
+
+def checkValidValuesInDataSet(
+    dataSet: vtkDataSet,
+    attributeName: str,
+    listValues: list[ Any ],
+    onPoints: bool,
+) -> tuple[ list[ Any ], list[ Any ] ]:
+    """Check if each value is valid , ie if that value is a data of the attribute in the dataset.
+
+    Args:
+        dataSet (vtkDataSet): The dataset mesh to check.
+        attributeName (str): The name of the attribute with the data.
+        listValues (list[Any]): The list of values to check.
+        onPoints (bool): True if the attribute is on points, False if on cells.
+
+    Returns:
+        tuple[list[Any], list[Any]]: Tuple containing the list of valid values and the list of the invalid ones.
+    """
+    attributeNpArray = getArrayInObject( dataSet, attributeName, onPoints )
+    validValues: list[ Any ] = []
+    invalidValues: list[ Any ] = []
+    for value in listValues:
+        if value in attributeNpArray:
+            validValues.append( value )
+        else:
+            invalidValues.append( value )
+
+    return ( validValues, invalidValues )
+
+
 def getFieldType( data: vtkFieldData ) -> str:
     """Returns whether the data is "vtkFieldData", "vtkCellData" or "vtkPointData".
 
@@ -357,6 +453,24 @@ def getArrayInObject( dataSet: vtkDataSet, attributeName: str, onPoints: bool )
     return npArray
 
 
+def getVtkDataTypeInObject( multiBlockDataSet: Union[ vtkDataSet, vtkMultiBlockDataSet ], attributeName: str,
+                            onPoints: bool ) -> int:
+    """Return VTK type of requested array from input mesh.
+
+    Args:
+        multiBlockDataSet (Union[vtkDataSet, vtkMultiBlockDataSet]): Input multiBlockDataSet.
+        attributeName (str): Name of the attribute.
+        onPoints (bool): True if attributes are on points, False if they are on cells.
+
+    Returns:
+        int: The type of the vtk array corresponding to input attribute name.
+    """
+    if isinstance( multiBlockDataSet, vtkDataSet ):
+        return getVtkArrayTypeInObject( multiBlockDataSet, attributeName, onPoints )
+    else:
+        return getVtkArrayTypeInMultiBlock( multiBlockDataSet, attributeName, onPoints )
+
+
 def getVtkArrayTypeInObject( dataSet: vtkDataSet, attributeName: str, onPoints: bool ) -> int:
     """Return VTK type of requested array from dataset input.
 

geos-mesh/tests/test_CreateConstantAttributePerRegion.py

@@ -0,0 +1,122 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies.
+# SPDX-FileContributor: Romain Baville
+# SPDX-License-Identifier: Apache 2.0
+# ruff: noqa: E402 # disable Module level import not at top of file
+# mypy: disable-error-code="operator"
+import pytest
+from typing import Union, Any
+from vtkmodules.vtkCommonDataModel import ( vtkDataSet, vtkMultiBlockDataSet )
+
+from geos.mesh.processing.CreateConstantAttributePerRegion import CreateConstantAttributePerRegion, np
+
+
+@pytest.mark.parametrize(
+    "meshType, newAttributeName, regionName, dictRegionValues, componentNames, componentNamesTest, valueNpType, succeed",
+    [
+        # Test the name of the new attribute (new on the mesh, one present on the other piece).
+        ## For vtkDataSet.
+        ( "dataset", "newAttribute", "GLOBAL_IDS_POINTS", {}, (), (), np.float32, True ),
+        ( "dataset", "CellAttribute", "GLOBAL_IDS_POINTS", {}, (), (), np.float32, True ),
+        ## For vtkMultiBlockDataSet.
+        ( "multiblock", "newAttribute", "GLOBAL_IDS_POINTS", {}, (), (), np.float32, True ),
+        ( "multiblock", "CellAttribute", "GLOBAL_IDS_POINTS", {}, (), (), np.float32, True ),
+        ( "multiblock", "GLOBAL_IDS_CELLS", "GLOBAL_IDS_POINTS", {}, (), (), np.float32, True ),
+        # Test if the region attribute is on cells or on points.
+        ( "dataset", "newAttribute", "FAULT", {}, (), (), np.float32, True ),
+        # Test the component name.
+        ( "dataset", "newAttribute", "FAULT", {}, ( "X" ), (), np.float32, True ),
+        ( "dataset", "newAttribute", "FAULT", {}, (), ( "Component0", "Component1" ), np.float32, True ),
+        ( "dataset", "newAttribute", "FAULT", {}, ( "X" ), ( "Component0", "Component1" ), np.float32, True ),
+        ( "dataset", "newAttribute", "FAULT", {}, ( "X", "Y" ), ( "X", "Y" ), np.float32, True ),
+        ( "dataset", "newAttribute", "FAULT", {}, ( "X", "Y", "Z" ), ( "X", "Y" ), np.float32, True ),
+        # Test the type of value.
+        ( "dataset", "newAttribute", "FAULT", {}, (), (), np.int8, True ),
+        ( "dataset", "newAttribute", "FAULT", {}, (), (), np.int16, True ),
+        ( "dataset", "newAttribute", "FAULT", {}, (), (), np.int32, True ),
+        ( "dataset", "newAttribute", "FAULT", {}, (), (), np.int64, True ),
+        ( "dataset", "newAttribute", "FAULT", {}, (), (), np.uint8, True ),
+        ( "dataset", "newAttribute", "FAULT", {}, (), (), np.uint16, True ),
+        ( "dataset", "newAttribute", "FAULT", {}, (), (), np.uint32, True ),
+        ( "dataset", "newAttribute", "FAULT", {}, (), (), np.uint64, True ),
+        ( "dataset", "newAttribute", "FAULT", {}, (), (), np.float64, True ),
+        # Test index/value.
+        ( "dataset", "newAttribute", "FAULT", {
+            0: [ 0 ],
+            100: [ 1 ]
+        }, (), (), np.float32, True ),
+        ( "dataset", "newAttribute", "FAULT", {
+            0: [ 0 ],
+            100: [ 1 ],
+            101: [ 2 ]
+        }, (), (), np.float32, True ),
+        ( "dataset", "newAttribute", "FAULT", {
+            0: [ 0 ],
+            100: [ 1 ],
+            101: [ 2 ],
+            2: [ 3 ]
+        }, (), (), np.float32, True ),
+        ( "dataset", "newAttribute", "FAULT", {
+            0: [ 0, 0 ],
+            100: [ 1, 1 ]
+        }, (), ( "Component0", "Component1" ), np.float32, True ),
+        ( "dataset", "newAttribute", "FAULT", {
+            0: [ 0, 0 ],
+            100: [ 1, 1 ],
+            101: [ 2, 2 ]
+        }, (), ( "Component0", "Component1" ), np.float32, True ),
+        ( "dataset", "newAttribute", "FAULT", {
+            0: [ 0, 0 ],
+            100: [ 1, 1 ],
+            101: [ 2, 2 ],
+            2: [ 3, 3 ]
+        }, (), ( "Component0", "Component1" ), np.float32, True ),
+        # Test common error.
+        ## Number of components.
+        ( "dataset", "newAttribute", "FAULT", {
+            0: [ 0 ],
+            100: [ 1, 1 ]
+        }, (), (), np.float32, False ),  # Number of value inconsistent.
+        ( "dataset", "newAttribute", "FAULT", {
+            0: [ 0, 0 ],
+            100: [ 1, 1 ]
+        }, (), (), np.float32, False ),  # More values than components.
+        ( "dataset", "newAttribute", "FAULT", {
+            0: [ 0 ],
+            100: [ 1 ]
+        }, ( "X", "Y" ), ( "X", "Y" ), np.float32, False ),  # More components than value.
+        ## Attribute name.
+        ( "dataset", "PERM", "FAULT", {}, (), (), np.float32, False ),  # The attribute name already exist.
+        ## Region attribute.
+        ( "dataset", "newAttribute", "PERM", {}, (),
+          (), np.float32, False ),  # Region attribute has too many components.
+        ( "multiblock", "newAttribute", "FAULT", {}, (), (), np.float32, False ),  # Region attribute is partial.
+    ] )
+def test_CreateConstantAttributePerRegion(
+    dataSetTest: Union[ vtkMultiBlockDataSet, vtkDataSet ],
+    meshType: str,
+    newAttributeName: str,
+    regionName: str,
+    dictRegionValues: dict[ Any, Any ],
+    componentNames: tuple[ str, ...],
+    componentNamesTest: tuple[ str, ...],
+    valueNpType: int,
+    succeed: bool,
+) -> None:
+    """Test CreateConstantAttributePerRegion."""
+    mesh: Union[ vtkMultiBlockDataSet, vtkDataSet ] = dataSetTest( meshType )
+    nbComponents: int = len( componentNamesTest )
+    if nbComponents == 0:  # If the attribute has one component, the component has no name.
+        nbComponents += 1
+
+    filter: CreateConstantAttributePerRegion = CreateConstantAttributePerRegion(
+        mesh,
+        regionName,
+        dictRegionValues,
+        newAttributeName,
+        valueNpType=valueNpType,
+        nbComponents=nbComponents,
+        componentNames=componentNames,
+    )
+
+    assert filter.applyFilter() == succeed