resolved merge conflict

hysop/backend/host/python/operator/multiresolution_filter.py

@@ -11,8 +11,9 @@ from hysop.tools.decorators import debug
 
 
 class PythonMultiresolutionFilter(RedistributeOperatorBase):
-    """Interpolation between topologies when topology
-    differs only by global resolution
+    """
+    Interpolation between topologies when topology
+    differs only by global resolution.
 
     Source and target must:
      *be CartesianTopology topologies with a target

hysop/core/graph/computational_node.py

@@ -276,6 +276,20 @@ class ComputationalGraphNode(OperatorBase):
         return (not self.input_fields) and (not self.output_fields)
     is_domainless = property(_get_is_domainless)
 
+    @classmethod
+    def expand_tensor_fields(fields):
+        scalar_fields = ()
+        tensor_fields = ()
+        for field in fields:
+            if (field is None):
+                scalar_fields += (None,)
+            elif field.is_tensor:
+                scalar_fields += field.fields
+                tensor_fields += (field,)
+            else:
+                scalar_fields += (field,)
+        return (scalar_fields, tensor_fields)
+    
     @debug
     def _setup_method(self, topgraph_method):
         """

hysop/operator/base/spatial_filtering.py

+"""
+@file advection.py
+LowpassFilter operator generator.
+"""
+from hysop.constants import Implementation
+from hysop.tools.types import check_instance, to_list, first_not_None
+from hysop.tools.decorators import debug
+from hysop.fields.continuous_field import Field
+from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
+from hysop.parameters.scalar_parameter import ScalarParameter
+from hysop.core.graph.node_generator import ComputationalGraphNodeGenerator
+from hysop.core.graph.computational_node_fronted import ComputationalGraphNodeFrontend
+
+
+class LowpassFilterBase(object):
+    """
+    Base implementation for lowpass spatial filtering: small grid -> coarse grid
+    """
+    
+    def __init__(self, input_field, output_field,
+                       input_topo,  output_topo,
+                       **kwds):
+
+        check_instance(input_field,  ScalarField)
+        check_instance(output_field, ScalarField)
+        check_instance(input_topo,  CartesianTopologyDescriptors)
+        check_instance(output_topo, CartesianTopologyDescriptors)
+
+        super(LowpassFilterBase, self).__init__(
+                input_fields={input_field: input_topo},
+                output_fields={output_field: output_topo},
+                **kwds)
+
+        self.Fin  = input_field
+        self.Fout = output_field
+
+
+    @debug
+    def discretize(self):
+        if self.discretized:
+            return
+        super(LowpassFilterBase, self).discretize()
+        dFin  = self.get_input_discrete_field(self.Fin)
+        dFout = self.get_output_discrete_field(self.Fout)
+
+        import sys
+        sys.exit(1)
+
+        self.dFin, self.dFout = dFin, dFout
+
+
+

hysop/operator/spatial_filtering.py

+"""
+@file advection.py
+LowpassFilter operator generator.
+"""
+from hysop.constants import Implementation
+from hysop.tools.types import check_instance, to_list, first_not_None
+from hysop.tools.decorators import debug
+from hysop.fields.continuous_field import Field
+from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
+from hysop.parameters.scalar_parameter import ScalarParameter
+from hysop.core.graph.node_generator import ComputationalGraphNodeGenerator
+from hysop.core.graph.computational_node_fronted import ComputationalGraphNodeFrontend
+
+
+class LowpassFilterFrontend(ComputationalGraphNodeFrontend):
+    """
+    Interface for lowpass spatial filtering: small grid -> coarse grid
+    Available implementations are:
+        *Python using remeshing kernels
+    """
+    @classmethod
+    def implementations(cls):
+        from hysop.backend.host.python.operator.spatial_filtering import \
+            PythonLowpassFilter
+        _implementations = {
+            Implementation.PYTHON: PythonLowpassFilter
+        }
+        return _implementations
+
+    @classmethod
+    def default_implementation(cls):
+        return Implementation.PYTHON
+    
+    def __init__(self, input_variable, output_variable,
+                 implementation=None,
+                 base_kwds=None,
+                 **kwds):
+        """
+        Initialize a LowpassFilter operator.
+
+        Parameters
+        ----------
+        input_variable: ScalarField
+            Input field on fine grid as a tuple (ScalarField, CartesianTopologyDescriptor).
+        output_variable: ScalarField
+            Output field on coarse grid as a tuple (ScalarField, CartesianTopologyDescriptor).
+        implementation: implementation, optional, defaults to None
+            target implementation, should be contained in available_implementations().
+            If None, implementation will be set to default_implementation().
+        base_kwds: dict, optional, defaults to None
+            Base class keywords arguments.
+            If None, an empty dict will be passed.
+        kwds:
+            Extra parameters passed to generated operator.
+
+        Notes
+        -----
+        An implementation should at least support the LowpassFilterBase interface.
+        """
+        check_instance(input_variable, tuple, size=2)
+        check_instance(output_variable, tuple, size=2)
+        input_field, input_topo   = input_variable
+        output_field, output_topo = output_variable
+
+        check_instance(input_field,  ScalarField)
+        check_instance(output_field, ScalarField)
+        check_instance(input_topo,  CartesianTopologyDescriptors)
+        check_instance(output_topo, CartesianTopologyDescriptors)
+        check_instance(base_kwds, dict, keys=str)
+        assert (input_topo != output_topo), "Same topology for input and output."
+
+        super(LowpassFilterFrontend, self).__init__(input_field=input_field, input_topo=input_topo,
+                                                    output_field=output_field, output_topo=output_topo,
+                                                    implementation=implementation, base_kwds=base_kwds, **kwds)
+
+
+
+class LowpassFilter(ComputationalGraphNodeGenerator):
+    """
+    Graphnode generator to lowpass filter multiple fields at once.
+    """
+    @debug
+    def __init__(self, input_variables, output_variables=None,
+                 implementation=None,
+                 base_kwds=None,
+                 **kwds):
+        """
+        Initialize a LowpassFilter operator generator.
+
+        Parameters
+        ----------
+        intput_variables: dict
+            Input fields on fine grid.
+            Dictionary of continuous fields as keys and topologies as values.
+        output_variables: dict
+            Output fields on coarse grid, default to input_fields.
+            Dictionary of continuous fields as keys and topologies as values.
+        implementation: implementation, optional, defaults to None
+            target implementation, should be contained in available_implementations().
+            If None, implementation will be set to default_implementation().
+        base_kwds: dict, optional, defaults to None
+            Base class keywords arguments.
+            If None, an empty dict will be passed.
+        kwds:
+            Extra parameters passed to generated operators.
+        """
+        input_fields = list(self.expand_tensor_fields(input_variables.keys())[0])
+        assert len(set(input_fields)) == len(input_fields)
+        if (output_variables is None):
+            output_variables = input_variables
+        output_fields = list(self.expand_tensor_fields(output_variables.keys())[0])
+        assert len(input_fields) == len(output_fields)
+        for i, field in enumerate(output_fields):
+            if (field is None):
+                output_fields[i] = input_fields[i]
+
+        input_fields  = tuple(input_fields)
+        output_fields = tuple(output_fields)
+        base_kwds = first_not_None(base_kwds, {})
+
+        check_instance(input_fields,  tuple, values=ScalarField)
+        check_instance(output_fields, tuple, values=ScalarField)
+        check_instance(input_variables,  dict, keys=Field, values=CartesianTopologyDescriptors)
+        check_instance(output_variables, dict, keys=Field, values=CartesianTopologyDescriptors)
+        check_instance(base_kwds, dict, keys=str)
+
+        super(LowpassFilter, self).__init__(**base_kwds)
+            
+        self._input_fields     = input_fields
+        self._output_fields    = output_fields
+        self._input_variables  = input_variables
+        self._output_variables = output_variables
+        self._impl             = implementation
+        self._kwds             = kwds
+
+    @debug
+    def _generate(self):
+        nodes = []
+        for (ifield, ofield) in zip(self._input_fields, self._output_fields):
+            stopo = self.get_topo_descriptor(self._input_variables, ifield)
+            ttopo = self.get_topo_descriptor(self._output_variables, ofield)
+            impl  = self._impl
+            kwds  = self._kwds.copy()
+            
+            # if source topology is destination topology there is nothing to be done
+            if (ttopo == stopo):
+                continue
+                
+            # else we build a lowpass filter operator
+            node = LowpassFilterFrontend(input_field=(ifield,stopo) output_field=(ofield,ttopo), 
+                    implementation=impl, **kwds)
+            nodes.append(node)
+        return nodes

hysop/operators.py

@@ -23,10 +23,11 @@ from hysop.operator.integrate              import Integrate
 from hysop.operator.penalization           import PenalizeVorticity
 from hysop.operator.flowrate_correction    import FlowRateCorrection
 from hysop.operator.vorticity_absorption   import VorticityAbsorption
-from hysop.operator.multiresolution_filter import MultiresolutionFilter
 from hysop.operator.dummy                  import Dummy
 from hysop.operator.custom                 import CustomOperator
 from hysop.operator.convergence            import Convergence
+from hysop.operator.multiresolution_filter import MultiresolutionFilter
+from hysop.operator.spatial_filtering import LowpassFilter
 
 from hysop.operator.derivative import SpaceDerivative,                  \
                                       SpectralSpaceDerivative,          \