ANNarchy 5.0.2__tar.gz → 5.0.3__tar.gz

{annarchy-5.0.2 → annarchy-5.0.3}/ANNarchy/__init__.py

@@ -58,6 +58,7 @@ from .models.Synapses import (
 from .extensions import *
 from .intern.ConfigManagement import setup
 from .intern import Messages
+from .core.CTypes import float32, float64
 
 # Cython modules
 try:
@@ -89,7 +90,7 @@ atexit.register(clear)
 
 # Version
 __version__ = "5.0"
-__release__ = "5.0.2"
+__release__ = "5.0.3"
 
 # Deprecated imports from this module:
 _deprecated = {

{annarchy-5.0.2 → annarchy-5.0.3}/ANNarchy/core/Attributes.py

@@ -4,11 +4,9 @@
 """
 
 from dataclasses import dataclass
-from ANNarchy.core.Random import RandomDistribution
-
-# Parameters
-
+from .Random import RandomDistribution
 
+# Parameters are attributes which does not change during simulate
 @dataclass
 class Parameter:
     """
@@ -48,7 +46,7 @@ class Parameter:
     type: str = "float"
 
 
-# Variables
+# Variables are attributes which does change during simulate via equations
 @dataclass
 class Variable:
     """

annarchy-5.0.3/ANNarchy/core/CTypes.py

@@ -0,0 +1,74 @@
+"""
+:copyright: Copyright 2013 - now, see AUTHORS.
+:license: GPLv2, see LICENSE for details.
+"""
+from dataclasses import dataclass
+
+class CTypeBase:
+    """
+    Base class for CTypes used in our framework. All functions should be
+    overloaded by the deriving classes, otherwise an exception is raised.
+    """
+    @property
+    def cpp_decl_type(self) -> str:
+        "Returns data type used int the C++ simulation code as string."
+        raise NotImplementedError
+
+    @property
+    def py_decl_type(self) -> str:
+        "Returns data type used in the nanobind interface to the C++ simulation code as string."
+        raise NotImplementedError
+
+    @property
+    def bits(self) -> int:
+        "Returns number of bits, raises exception if not implemented by child type."
+        raise NotImplementedError
+
+#
+#   Floating-point precision type
+#
+@dataclass(frozen=True)
+class FloatType(CTypeBase):
+    """
+    Floating-point data type.
+    """
+    exp: int
+    mantissa: int
+
+    FP32 = (8, 23)
+    FP64 = (11, 52)
+
+    @property
+    def cpp_decl_type(self) -> str:
+        "Returns data type used int the C++ simulation code as string."
+        if (self.exp, self.mantissa) == FloatType.FP32:
+            return "float"
+
+        if (self.exp, self.mantissa) == FloatType.FP64:
+            return "double"
+
+        raise ValueError(
+           f"Unsupported float format: exp={self.exp}, mantissa={self.mantissa}"
+        )
+
+    @property
+    def py_decl_type(self) -> str:
+        "Returns data type used in the nanobind interface to the C++ simulation code as string."
+        if (self.exp, self.mantissa) == FloatType.FP32:
+            # ANNarchy4.x behavior force to double always
+            return "double"
+
+        if (self.exp, self.mantissa) == FloatType.FP64:
+            return "double"
+
+        raise ValueError(
+           f"Unsupported float format: exp={self.exp}, mantissa={self.mantissa}"
+        )
+
+    @property
+    def bits(self) -> int:
+        return 1 + self.exp + self.mantissa
+
+# Some pre-defined types
+float32 = FloatType(8, 23)
+float64 = FloatType(11, 52)

{annarchy-5.0.2 → annarchy-5.0.3}/ANNarchy/core/ConnectorMethods.py

@@ -843,7 +843,12 @@ def connect_from_file(
             lil.w = [[float(data["w"])]]
         elif isinstance(data["w"], (np.ndarray,)) and data["w"].size == 1:
             single_w = True
-            lil.w = [[float(data["w"])]]
+            try:
+                lil.w = [[float(data["w"])]]
+            except TypeError:
+                # newer NumPy versions, throw an TypeError exception:
+                # "only 0-dimensional arrays can be converted to Python scalars"
+                lil.w = [[float(data["w"][0][0])]]
         else:
             lil.w = data["w"]
 

{annarchy-5.0.2 → annarchy-5.0.3}/ANNarchy/core/Monitor.py

@@ -555,13 +555,13 @@ class Monitor:
         """Returns the value of a variable with the given name."""
 
         if isinstance(self.object, PopulationView):
-            return self._get_population(self.object, name, keep)
+            return self._get_population(name, keep)
 
         elif isinstance(self.object, Population):
             if not reshape or name == "spike":
-                return self._get_population(self.object, name, keep)
+                return self._get_population(name, keep)
             return np.reshape(
-                self._get_population(self.object, name, keep),
+                self._get_population(name, keep),
                 (-1,) + self.object.geometry,
             )
 
@@ -658,7 +658,7 @@ class Monitor:
                 "Monitor.save: File type not recognized (Must be .hdf5 or .npy)."
             )
 
-    def _get_population(self, pop, name, keep):
+    def _get_population(self, name, keep):
         try:
             data = getattr(self.cyInstance, name)
             if not keep:

{annarchy-5.0.2 → annarchy-5.0.3}/ANNarchy/core/Network.py

@@ -526,6 +526,7 @@ class Network(metaclass=NetworkMeta):
         annarchy_json: str = "",
         silent: bool = False,
         debug_build: bool = False,
+        trace_calls: str = None,
         profile_enabled: bool = False,
     ) -> None:
         """
@@ -539,12 +540,17 @@ class Network(metaclass=NetworkMeta):
         :param annarchy_json: compiler flags etc are stored in a .json file normally placed in the home directory. With this flag one can directly assign a file location.
         :param silent: defines if the "Compiling... OK" should be printed.
 
+        The following arguments are mostly intended for debugging purposes:
+
+        :param debug_build: creates a debug version of ANNarchy, which logs the creation of objects and some other data (default: False).
+        :param trace_calls: if set to *init*, *simulate*, or *both* simulation calls inside of the C++ kernel are logged to console (default: None).
         """
         Compiler.compile(
             directory=directory,
             clean=clean,
             silent=silent,
             debug_build=debug_build,
+            trace_calls=trace_calls,
             add_sources=add_sources,
             extra_libs=extra_libs,
             compiler=compiler,
@@ -1000,7 +1006,7 @@ class Network(metaclass=NetworkMeta):
         * `dt`: simulation step size in milliseconds (default: 1.0).
         * `paradigm`: parallel framework for code generation. Accepted values: "openmp" or "cuda" (default: "openmp").
         * `method`: default method to numerize the ODEs. Default is the explicit forward Euler method ('explicit').
-        * `precision`: default floating precision for variables in ANNarchy. Accepted values: "float" or "double" (default: "double")
+        * `dtype`: default data type used for attributes in ANNarchy. Accepted values, available on the top-level of the ANNarchy package: float32 or float64 (default: float64).
         * `structural_plasticity`: allows synapses to be dynamically added/removed during the simulation (default: False).
         * `seed`: the seed (integer) to be used in the random number generators (default = None is equivalent to time(NULL)).
         * `num_threads`: number of treads used by openMP (overrides the environment variable ``OMP_NUM_THREADS`` when set, default = None).
@@ -1019,6 +1025,9 @@ class Network(metaclass=NetworkMeta):
         * `show_time`: if True, initialization times are shown. Attention: verbose should be set to True additionally.
         * `disable_shared_library_time_offset`: by default False. If set to True, the shared library generated by ANNarchy will not be extended by time offset.
         """
+        # ANNarchy 4.x interface
+        if 'precision' in kwargs.keys():
+            Messages.error("The precision flag has been replaced by 'dtype'. Note that the arguments has changed too!")
 
         # RNG-related arguments are treated differently
         rng_changed = False

{annarchy-5.0.2 → annarchy-5.0.3}/ANNarchy/core/Population.py

@@ -226,7 +226,7 @@ class Population:
         Instantiates the population after compilation of the C++ simulation core.
         The function should solely called by Compiler._instantiate().
 
-        :param module: cython module (ANNarchyCore instance)
+        :param module: nanobind module (ANNarchyWrapper instance)
         """
         if NetworkManager().get_network(net_id=self.net_id)._profiler is not None:
             import time
@@ -489,37 +489,28 @@ class Population:
                         )
 
                 elif isinstance(value, list):
+                    setattr(self.cyInstance, attribute, value)
+                    # Attributes need to be updated during next simulate() call.
                     if _check_paradigm("cuda", self.net_id):
-                        # See `ANNarchy.parser.Extraction.extract_boundsflags` for more details
-                        if ctype == "char":
-                            value = [str(1) if x else str(0) for x in value]
-                        setattr(self.cyInstance, attribute, value)
                         setattr(self.cyInstance, attribute + "_host_to_device", True)
-                    else:
-                        setattr(self.cyInstance, attribute, value)
 
                 else:
+                    setattr(
+                        self.cyInstance,
+                        attribute,
+                        [value for _ in range(self.size)],
+                    )
+                    # Attributes need to be updated during next simulate() call.
                     if _check_paradigm("cuda", self.net_id):
-                        # See `ANNarchy.parser.Extraction.extract_boundsflags` for more details
-                        if ctype == "char":
-                            value = str(1) if value else str(0)
-                        setattr(
-                            self.cyInstance,
-                            attribute,
-                            [value for _ in range(self.size)],
-                        )
                         setattr(self.cyInstance, attribute + "_host_to_device", True)
-                    else:
-                        setattr(
-                            self.cyInstance,
-                            attribute,
-                            [value for _ in range(self.size)],
-                        )
 
             else:
+                if not np.isscalar(value):
+                    raise ValueError(f"Population (name={self.name}): Expected single value for global attribute '{attribute}' but received {type(value)}.")
+
                 setattr(self.cyInstance, attribute, value)
                 if _check_paradigm("cuda", self.net_id):
-                    # Variables need to be updated during next simulate() call.
+                    # Attributes need to be updated during next simulate() call.
                     if attribute in [
                         attr["name"]
                         for attr in self.neuron_type.description["variables"]

{annarchy-5.0.2 → annarchy-5.0.3}/ANNarchy/core/Projection.py

@@ -360,7 +360,7 @@ class Projection:
         Instantiates the projection after compilation. The function should be
         called by Compiler._instantiate().
 
-        :param module:  cython module (ANNarchyCore instance)
+        :param module:  nanobind module (ANNarchyWrapper instance)
         """
         if NetworkManager().get_network(net_id=self.net_id)._profiler is not None:
             import time
@@ -404,7 +404,7 @@ class Projection:
 
         Returns True, if the connector was successfully instantiated. Potential errors are kept by  Python exceptions. If the Cython connector call fails (return False) the most likely reason is that there was not enough memory available.
 
-        :param module:  cython module (ANNarchyCore instance)
+        :param module:  nanobind wrapper (ANNarchyWrapper instance)
 
         """
         # Local import to prevent circular import (HD: 28th June 2021)

{annarchy-5.0.2 → annarchy-5.0.3}/ANNarchy/extensions/bold/AccProjection.py

@@ -103,7 +103,7 @@ class AccProjection(SpecificProjection):
     void start(int baseline_period) {
         init_baseline_period=baseline_period;
         time_for_init_baseline = t + baseline_period;
-    #ifdef _DEBUG
+    #ifndef NDEBUG
         std::cout << "ProjStruct%(id_proj)s: set new baseline period from step " << t << " to step " << time_for_init_baseline << std::endl;
     #endif
     }
@@ -270,7 +270,7 @@ class AccProjection(SpecificProjection):
     void start(int baseline_period) {
         init_baseline_period=baseline_period;
         time_for_init_baseline = t + baseline_period;
-    #ifdef _DEBUG
+    #ifndef NDEBUG
         std::cout << "ProjStruct%(id_proj)s: set new baseline period from step " << t << " to step " << time_for_init_baseline << std::endl;
     #endif
     }

{annarchy-5.0.2 → annarchy-5.0.3}/ANNarchy/extensions/convolution/ConvolveTemplate.py

@@ -141,7 +141,7 @@ convolve_template_cuda = {
     # no read-back is required
     "host_device_transfer": """
         if (pre_coords_dirty) {
-        #ifdef _DEBUG
+        #ifndef NDEBUG
             std::cout << "ProjStruct%(id_proj)s (convolution): update device coords." << std::endl;
         #endif
             auto flat_coords = transform_2d_to_1d<int>(pre_coords);
@@ -174,7 +174,7 @@ conv_filter_template = {
     // Local parameter w
     %(type_w)s get_w() { return w; }
     void set_w(%(type_w)s value) {
-    #ifdef _DEBUG
+    #ifndef NDEBUG
         std::cout << "ProjStruct%(id_proj)s (convolution): set new filter on host" << std::endl;
     #endif
         w = value;
@@ -183,7 +183,7 @@ conv_filter_template = {
 """,
         "host_device_transfer": """
         if ( host_w_dirty ) {
-        #ifdef _DEBUG
+        #ifndef NDEBUG
             std::cout << "ProjStruct%(id_proj)s (convolution): update device filter." << std::endl;
         #endif
             auto flat_data = transform_%(pre_dim)sd_to_1d<%(ctype)s>(w);
@@ -234,7 +234,7 @@ void convolution_proj%(id_proj)s(RunConfig cfg, %(float_prec)s* __restrict__ psp
             pop%(id_post)s->gpu__sum_%(target)s, proj%(id_proj)s->gpu_pre_coords, proj%(id_proj)s->gpu_w%(pre_variables_call)s
         );
 
-    #ifdef _DEBUG
+    #ifndef NDEBUG
         auto proj%(id_proj)s_conv_err = cudaDeviceSynchronize();
         if ( proj%(id_proj)s_conv_err != cudaSuccess) {
             std::cout << "Convolution projection %(id_proj)s - psp: " << cudaGetErrorString( proj%(id_proj)s_conv_err ) << std::endl;
@@ -269,7 +269,7 @@ cuda_convolution_bank_of_filter = {
             pop%(id_post)s->gpu__sum_%(target)s, proj%(id_proj)s->gpu_pre_coords, proj%(id_proj)s->gpu_w%(pre_variables_call)s
         );
 
-    #ifdef _DEBUG
+    #ifndef NDEBUG
         auto proj%(id_proj)s_conv_err = cudaDeviceSynchronize();
         if ( proj%(id_proj)s_conv_err != cudaSuccess) {
             std::cout << "Convolution projection %(id_proj)s - psp: " << cudaGetErrorString( proj%(id_proj)s_conv_err ) << std::endl;
@@ -319,7 +319,7 @@ void convolution_proj%(id_proj)s(RunConfig cfg, %(float_prec)s* psp, const int*
             pop%(id_post)s->gpu__sum_%(target)s, proj%(id_proj)s->gpu_pre_coords, proj%(id_proj)s->gpu_w%(pre_variables_call)s
         );
 
-    #ifdef _DEBUG
+    #ifndef NDEBUG
         auto proj%(id_proj)s_conv_err = cudaDeviceSynchronize();
         if ( proj%(id_proj)s_conv_err != cudaSuccess) {
             std::cout << "Convolution projection %(id_proj)s - psp: " << cudaGetErrorString( proj%(id_proj)s_conv_err ) << std::endl;
@@ -379,7 +379,7 @@ void convolution_proj%(id_proj)s(RunConfig cfg, %(float_prec)s* psp, const int*
             pop%(id_post)s->gpu__sum_%(target)s, proj%(id_proj)s->gpu_pre_coords, proj%(id_proj)s->gpu_w%(pre_variables_call)s
         );
 
-    #ifdef _DEBUG
+    #ifndef NDEBUG
         auto proj%(id_proj)s_conv_err = cudaDeviceSynchronize();
         if ( proj%(id_proj)s_conv_err != cudaSuccess) {
             std::cout << "Convolution projection %(id_proj)s - psp: " << cudaGetErrorString( proj%(id_proj)s_conv_err ) << std::endl;

{annarchy-5.0.2 → annarchy-5.0.3}/ANNarchy/extensions/convolution/PoolingTemplate.py

@@ -112,7 +112,7 @@ pooling_template_cuda = {
     # no read-back is required
     "host_device_transfer": """
         if (pre_coords_dirty) {
-        #ifdef _DEBUG
+        #ifndef NDEBUG
             std::cout << "ProjStruct%(id_proj)s (pooling): update device coords." << std::endl;
         #endif
             auto err = cudaGetLastError();
@@ -418,7 +418,7 @@ cuda_pooling_code_3d = {
     if (proj%(id_proj)s->_transmission && pop%(id_post)s->_active ) {
         pooling_proj%(id_proj)s(RunConfig(%(size_post)s, 1, 0, proj%(id_proj)s->stream), pop%(id_post)s->gpu__sum_%(target)s, proj%(id_proj)s->gpu_pre_coords, pop%(id_pre)s->gpu_%(pre_var)s );
 
-    #ifdef _DEBUG
+    #ifndef NDEBUG
         auto proj%(id_proj)s_pool_err = cudaDeviceSynchronize();
         if ( proj%(id_proj)s_pool_err != cudaSuccess) {
             std::cout << "Pooling projection %(id_proj)s - psp: " << cudaGetErrorString( proj%(id_proj)s_pool_err ) << std::endl;

{annarchy-5.0.2 → annarchy-5.0.3}/ANNarchy/extensions/image/ImagePopulation.py

@@ -5,13 +5,13 @@
 
 from ANNarchy.core.Population import Population
 from ANNarchy.core.Neuron import Neuron
+
 from ANNarchy.intern.ConfigManagement import ConfigManager
-from ANNarchy.generator.Compiler import extra_libs
 from ANNarchy.intern import Messages
 
 try:
     from PIL import Image
-except:
+except ImportError:
     Messages.warning(
         "The Python Image Library (pillow) is not installed on your system, unable to create ImagePopulations."
     )
@@ -184,10 +184,6 @@ class VideoPopulation(ImagePopulation):
 
     def _generate(self):
         "Code generation"
-        # Add corresponding libs to the Makefile
-        extra_libs.append(
-            "`pkg-config opencv" + str(self.opencv_version) + " --cflags --libs`"
-        )
 
         # Include opencv
         self._specific_template["include_additional"] = """#include <opencv2/opencv.hpp>

{annarchy-5.0.2 → annarchy-5.0.3}/ANNarchy/generator/CmdLineArgParser.py

@@ -149,6 +149,9 @@ class CmdLineArgParser(object):
         if options.num_threads is not None:
             ConfigManagement._update_global_config("num_threads", options.num_threads)
 
+        if options.debug is not False:
+            ConfigManagement._update_global_config("debug", options.debug)
+
         if options.visible_cores is not None:
             try:
                 core_list = [int(x) for x in options.visible_cores.split(",")]