improve custom python operator that handle fields as function arguments...

improve custom python operator that handle fields as function arguments instead of data buffers (get access to topology informations)

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

@@ -31,7 +31,6 @@ class PythonCustomOperator(HostOperator):
                     output_fields[v] = variables[v]
                 elif isinstance(v, Parameter):
                     output_params[v.name] = v
-
         self.invars, self.outvars = invars, outvars
         self.func = func
 
@@ -55,25 +54,26 @@ class PythonCustomOperator(HostOperator):
         if self.invars is not None:
             for v in self.invars:
                 if isinstance(v, Field):
-                    for vd in self.input_discrete_fields[v].buffers:
+                    for vd in self.input_discrete_fields[v]:
                         dinvar.append(vd)
                 elif isinstance(v, Parameter):
                     dinparam.append(v)
         if self.outvars is not None:
             for v in self.outvars:
                 if isinstance(v, Field):
-                    for vd in self.output_discrete_fields[v].buffers:
+                    for vd in self.output_discrete_fields[v]:
                         doutvar.append(vd)
-                    self.ghost_exchanger.append(
-                        self.output_discrete_fields[v].build_ghost_exchanger())
+                    gh =  self.output_discrete_fields[v].build_ghost_exchanger()
+                    if gh is not None:
+                        self.ghost_exchanger.append(gh)
                 elif isinstance(v, Parameter):
                     doutparam.append(v)
-        self.dinvar, self.doutvar = dinvar, doutvar
-        self.dinparam, self.doutparam = dinparam, doutparam
+        self.dinvar, self.doutvar = tuple(dinvar), tuple(doutvar)
+        self.dinparam, self.doutparam = tuple(dinparam), tuple(doutparam)
 
     @op_apply
     def apply(self, **kwds):
         super(PythonCustomOperator, self).apply(**kwds)
-        self.doutvar = self.func(*(self.dinvar + self.dinparam + self.doutparam))
+        self.func(*(self.dinvar + self.dinparam + self.doutvar + self.doutparam))
         for gh_exch in self.ghost_exchanger:
             gh_exch.exchange_ghosts()

hysop/operator/custom.py

@@ -8,6 +8,14 @@ from hysop.topology.cartesian_descriptor import CartesianTopologyDescriptors
 
 
 class CustomOperator(ComputationalGraphNodeFrontend):
+    """
+    Function should take parameters in the following order: 
+      1. all input fields
+      2. all input parameters
+      3. all output fields
+      4. all output parameters
+    Note that discrete fields are passed as arguments to the custom function.
+    """
 
     @classmethod
     def implementations(cls):
@@ -28,6 +36,25 @@ class CustomOperator(ComputationalGraphNodeFrontend):
                        allow_none=True)
         check_instance(outvars, (tuple, list), values=(Field, Parameter),
                        allow_none=True)
-
+        from inspect import getargspec as signature # should be inspect.signature in python 3
+        nb_args = len(signature(func).args)
+        nb_in_f, nb_in_p, nb_out_f, nb_out_p = 0, 0, 0, 0
+        if invars is not None:
+            for v in invars:
+                if isinstance(v, Field):
+                    nb_in_f += 1
+                elif isinstance(v, Parameter):
+                    nb_in_p += 1
+        if outvars is not None:
+            for v in outvars:
+                if isinstance(v, Field):
+                    nb_out_f += 1
+                elif isinstance(v, Parameter):
+                    nb_out_p += 1
+        msg = "function arguments ({}) did not match given in/out ".format(signature(func))
+        msg += "fields and parameters ({} input fields, {} input params,".format(nb_in_f, nb_in_p)
+        msg += " {} output fields, {} output params).".format(nb_out_f, nb_out_p)
+        assert nb_args == nb_in_f + nb_in_p + nb_out_f + nb_out_p, msg
+            
         super(CustomOperator, self).__init__(
             func=func, invars=invars, outvars=outvars, **kwds)