Fix interactive parameters behavior (#54)

xentica/core/base.py

@@ -240,6 +240,9 @@ def __init__(self):
         self._declarations = set()
         self._unpacks = set()
         self._params = {}
+        self._emit_params = []
+        self._absorb_params = []
+        self._render_params = []
         self._coords_declared = False
 
     @staticmethod
@@ -289,9 +292,6 @@ def _translate_code(self, *funcs):
         self._declarations = set()
         self._unpacks = set()
         self._params = {}
-        self._emit_params = []
-        self._absorb_params = []
-        self._render_params = []
         self._coords_declared = False
         for func in funcs:
             func()
@@ -490,8 +490,6 @@ def build_render(self):
         """
         args = self.renderer.args
         body = self.renderer.render_code()
-        self._render_params = [param for param in self._params.values()]
-        args += [(param.ctype, param.name) for param in self._render_params]
         return self._elementwise_kernel("render", args, body)
 
     def index_to_coord(self, i):
@@ -636,7 +634,7 @@ def __init__(self, experiment_class):
                 if attr_name == 'seed':
                     continue
                 if hasattr(self.meta, attr_name):
-                    setattr(self.meta, attr_name, attr)
+                    self.meta.__dict__[attr_name].__set__(self, attr)
                     continue
                 setattr(self, attr_name, attr)
         # default simulation values
@@ -708,16 +706,16 @@ def step(self):
         # No way to get it correctly with PyCuda right now.
         block, grid = self.gpu.arrays.cells._block, self.gpu.arrays.cells._grid
         with self._lock:
-            args = [param for param in self._emit_params]
+            args = [param.dtype(param.value) for param in self._emit_params]
             self.gpu.kernels.emit(self.gpu.arrays.cells,
-                                  np.int32(self.cells_num),
                                   *args,
+                                  np.int32(self.cells_num),
                                   block=block, grid=grid)
-            args = [param for param in self._absorb_params]
+            args = [param.dtype(param.value) for param in self._absorb_params]
             self.gpu.kernels.absorb(self.gpu.arrays.cells,
                                     self.gpu.arrays.colors,
-                                    np.int32(self.cells_num),
                                     *args,
+                                    np.int32(self.cells_num),
                                     block=block, grid=grid)
             self.timestep += 1
 
@@ -741,8 +739,8 @@ def render(self):
         block, grid = self.gpu.arrays.img._block, self.gpu.arrays.img._grid
         with self._lock:
             args = self.renderer.get_args_vals(self)
+            args += [param.dtype(param.value) for param in self._render_params]
             args.append(np.int32(self.width * self.height))
-            args += [param for param in self._render_params]
             self.gpu.kernels.render(*args, block=block, grid=grid)
             return self.gpu.arrays.img.get().astype(np.uint8)
 

xentica/core/parameters.py

@@ -54,6 +54,7 @@ class DiamoebaExperiment(GOLExperiment):
     model = LifelikeCA(DiamoebaExperiment)
 
 """
+import numpy as np
 
 from xentica.core.variables import Constant
 from xentica.core.mixins import BscaDetectorMixin
@@ -80,6 +81,21 @@ def __init__(self, default=0, interactive=False):
         self._interactive = interactive
         self._declared = False
         self._name = "param" + str(id(self))
+        self._ctypes = {
+            int: 'int',
+            float: 'float',
+            bool: 'bool',
+        }
+        self._dtypes = {
+            int: np.int32,
+            float: np.float32,
+            bool: bool,
+        }
+
+    @property
+    def value(self):
+        """Get parameter's value directly."""
+        return self._value
 
     @property
     def name(self):
@@ -91,6 +107,16 @@ def name(self, val):
         """Set parameter's name."""
         self._name = val
 
+    @property
+    def ctype(self):
+        """Get parameter's C type."""
+        return self._ctypes.get(type(self._value), 'int32')
+
+    @property
+    def dtype(self):
+        """Get parameter's NumPy type."""
+        return self._dtypes.get(type(self._value), np.int32)
+
     def _declare_interactive(self):
         """Do necessary stuff to declare interactive parameter."""
         if self.bsca.is_parameter(self):