Seal Phase4AE same-precision GPU numerical gate and audit limits

2026-09-30 07:50:57 +08:00
parent 92241aea02
commit 1eb4c52cf7
648 changed files with 51363 additions and 22 deletions
@@ -0,0 +1,35 @@
+{
+  "author_commit": "91bdd1e7dcf193f3e7ca5a8933497fcef63b7960",
+  "author_path": "/data/digital-drosophila/experiments/phase4ad-author-semantics/external-resources/model.py",
+  "author_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e",
+  "case_arrays_sha256": "f3a900e9032754619549005131283cbaf87fdaa9093887a90a295589dac590fb",
+  "case_spec_sha256": "90850d6968a7832e415d0966b57e216a65f5ba8f63e488e497148b6525806d79",
+  "common_interface_preserved": true,
+  "learning": false,
+  "original_poi_interface_adopted": false,
+  "precision": "float32",
+  "spec": {
+    "description": "256-source signed fan-in, labelled duplicate/loop; refractory requests and external writes.",
+    "dt_ms": 0.1,
+    "duration_ms": 60.0,
+    "model": {
+      "dt_ms": 0.1,
+      "membrane_tau_ms": 20.0,
+      "refractory_ms": 2.2,
+      "reset_potential_mv": -52.0,
+      "resting_potential_mv": -52.0,
+      "synaptic_delay_ms": 1.8,
+      "synaptic_tau_ms": 5.0,
+      "threshold_mv": -45.0,
+      "w_syn_mv_per_anatomical_synapse": 0.275
+    },
+    "name": "fanin_bursts",
+    "selection": null,
+    "steps": 600,
+    "trace_queue": true,
+    "validate_queue_proxy": true
+  },
+  "trace_queue": true,
+  "validate_queue_proxy": true,
+  "whole_brain": false
+}
@@ -0,0 +1,72 @@
+{
+  "c0": -0.00025935108198051754,
+  "cg": 0.004937935295309027,
+  "cv": 0.9950124791926823,
+  "gd": 0.9801986733067553,
+  "metadata": {
+    "constant_values_are_double": true,
+    "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.",
+    "g_expression": "gd * old_g",
+    "hex": {
+      "c0": "-0x1.0ff306a505980p-12",
+      "cg": "0x1.439cce9a65d5bp-8",
+      "cv": "0x1.fd7246927d28bp-1",
+      "gd": "0x1.f5dc99badec5bp-1",
+      "reset": "-0x1.a9fbe76c8b43ap-5",
+      "seed_volt": "-0x1.6872b020c49bap-5",
+      "threshold": "-0x1.70a3d70a3d70ap-5"
+    },
+    "names": {
+      "c0": "_lio_8",
+      "cg": "_lio_9",
+      "cv": "_lio_10",
+      "gd": "_lio_2"
+    },
+    "provenance": {
+      "c0": {
+        "code_object": "default_neurons_stateupdater_codeobject_2",
+        "name": "_lio_8",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "cg": {
+        "code_object": "default_neurons_stateupdater_codeobject_2",
+        "name": "_lio_9",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "cv": {
+        "code_object": "default_neurons_stateupdater_codeobject_2",
+        "name": "_lio_10",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "gd": {
+        "code_object": "default_neurons_stateupdater_codeobject_2",
+        "name": "_lio_2",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "reset": {
+        "code_object": "default_neurons_spike_resetter_codeobject_2",
+        "name": "v_rst",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "seed_volt": {
+        "source": "common request interface: unchanged v_th + 1 mV"
+      },
+      "threshold": {
+        "code_object": "default_neurons_spike_thresholder_codeobject_2",
+        "name": "v_th",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      }
+    },
+    "units": "SI volts and dimensionless coefficients",
+    "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))"
+  },
+  "reset": -0.052000000000000005,
+  "seed_volt": -0.044,
+  "threshold": -0.045
+}
@@ -0,0 +1,14 @@
+{
+  "backend": "Brian2 numpy runtime",
+  "packages": {
+    "brian2": "2.5.1",
+    "cython": "0.29.33",
+    "numpy": "1.22.3",
+    "pandas": "1.4.3",
+    "pyarrow": "11.0.0",
+    "scipy": "1.8.1",
+    "sympy": "1.12"
+  },
+  "platform": "Linux-5.15.0-194-generic-x86_64-with-glibc2.35",
+  "python": "3.10.12 (main, Aug 31 2026, 10:18:17) [GCC 11.4.0]"
+}
@@ -0,0 +1,72 @@
+{
+  "c0": -0.00025935108198051754,
+  "cg": 0.004937935295309027,
+  "cv": 0.9950124791926823,
+  "gd": 0.9801986733067553,
+  "metadata": {
+    "constant_values_are_double": true,
+    "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.",
+    "g_expression": "gd * old_g",
+    "hex": {
+      "c0": "-0x1.0ff306a505980p-12",
+      "cg": "0x1.439cce9a65d5bp-8",
+      "cv": "0x1.fd7246927d28bp-1",
+      "gd": "0x1.f5dc99badec5bp-1",
+      "reset": "-0x1.a9fbe76c8b43ap-5",
+      "seed_volt": "-0x1.6872b020c49bap-5",
+      "threshold": "-0x1.70a3d70a3d70ap-5"
+    },
+    "names": {
+      "c0": "_lio_8",
+      "cg": "_lio_9",
+      "cv": "_lio_10",
+      "gd": "_lio_2"
+    },
+    "provenance": {
+      "c0": {
+        "code_object": "default_neurons_stateupdater_codeobject_2",
+        "name": "_lio_8",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "cg": {
+        "code_object": "default_neurons_stateupdater_codeobject_2",
+        "name": "_lio_9",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "cv": {
+        "code_object": "default_neurons_stateupdater_codeobject_2",
+        "name": "_lio_10",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "gd": {
+        "code_object": "default_neurons_stateupdater_codeobject_2",
+        "name": "_lio_2",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "reset": {
+        "code_object": "default_neurons_spike_resetter_codeobject_2",
+        "name": "v_rst",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "seed_volt": {
+        "source": "common request interface: unchanged v_th + 1 mV"
+      },
+      "threshold": {
+        "code_object": "default_neurons_spike_thresholder_codeobject_2",
+        "name": "v_th",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      }
+    },
+    "units": "SI volts and dimensionless coefficients",
+    "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))"
+  },
+  "reset": -0.052000000000000005,
+  "seed_volt": -0.044,
+  "threshold": -0.045
+}
@@ -0,0 +1,162 @@
+[
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_neurons",
+    "order": 0,
+    "type": "NeuronGroup",
+    "when": "start"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_synapses",
+    "order": 0,
+    "type": "Synapses",
+    "when": "start"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "zz_external_arrivals",
+    "order": 0,
+    "type": "Synapses",
+    "when": "start"
+  },
+  {
+    "abstract_code": "not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n_g = g*exp(-dt*int(not_refractory)/tau)\n_v = g*tau*(-exp(dt*int(not_refractory)/t_mbr) + exp(dt*int(not_refractory)/tau))*exp(-dt*int(not_refractory)/t_mbr)*exp(-dt*int(not_refractory)/tau)/(t_mbr - tau) + v*exp(-dt*int(not_refractory)/t_mbr) + v_0 - v_0*exp(-dt*int(not_refractory)/t_mbr)\ng = _g\nv = _v",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    dt = _array_defaultclock_dt[0]\n    _lio_1 = (- dt) / tau\n    _lio_2 = exp(_lio_1)\n    _lio_3 = tau / (t_mbr - tau)\n    _lio_4 = dt / t_mbr\n    _lio_5 = dt / tau\n    _lio_6 = (- dt) / t_mbr\n    _lio_7 = v_0 - v_0\n    _lio_8 = v_0 - (v_0 * exp(_lio_6))\n    _lio_9 = ((_lio_3 * ((- exp(_lio_4)) + exp(_lio_5))) * exp(_lio_6)) * exp(_lio_1)\n    _lio_10 = exp(_lio_6)\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    g = _array_default_neurons_g.copy()\n    lastspike = _array_default_neurons_lastspike\n    rfc = _array_default_neurons_rfc\n    v = _array_default_neurons_v.copy()\n    t = _array_defaultclock_t[0]\n    not_refractory = _array_default_neurons_not_refractory.copy()\n    dt = _array_defaultclock_dt[0]\n    not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n    _g = _numpy.where(not_refractory, _lio_2 * g, g)\n    _v = _numpy.where(not_refractory, _lio_8 + ((_lio_9 * g) + (_lio_10 * v)), _lio_7 + v)\n    g[not_refractory] = _g[not_refractory]\n    v[not_refractory] = _v[not_refractory]\n    _array_default_neurons_g[:] = g\n    _array_default_neurons_not_refractory[:] = not_refractory\n    _array_default_neurons_v[:] = v\n",
+        "name": "default_neurons_stateupdater_codeobject"
+      }
+    ],
+    "name": "default_neurons_stateupdater",
+    "order": 0,
+    "type": "StateUpdater",
+    "when": "groups"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "oracle_common_requests",
+    "order": 0,
+    "type": "NetworkOperation",
+    "when": "before_thresholds"
+  },
+  {
+    "abstract_code": "_cond = (v > v_th) and not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _array_default_neurons__spikespace[-1] = 0\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    numpy_True = _numpy.bool_(True)\n    numpy_False = _numpy.bool_(False)\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    not_refractory = _array_default_neurons_not_refractory\n    v = _array_default_neurons_v\n    _cond = (v > v_th) & not_refractory\n    if _cond is True or _cond is numpy_True:\n        _events = _numpy.arange(N)\n    elif _cond is False or _cond is numpy_False:\n        _events = _numpy.array([])\n    else:\n        _events, = _cond.nonzero()\n    _array_default_neurons__spikespace[-1] = len(_events)\n    _array_default_neurons__spikespace[:len(_events)] = _events\n    # Set the neuron to refractory\n    _array_default_neurons_not_refractory[_events] = False\n    _array_default_neurons_lastspike[_events] = _array_defaultclock_t[0]\n",
+        "name": "default_neurons_spike_thresholder_codeobject"
+      }
+    ],
+    "name": "default_neurons_spike_thresholder",
+    "order": 0,
+    "type": "Thresholder",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _the_period    = _array_zz_external_sources__period_bins[0]\n    _timebin       = _array_defaultclock_timestep[0]\n    _n_spikes      = 0\n    _lastindex_before = _array_zz_external_sources__lastindex[0]\n    if _the_period > 0:\n        _timebin %= _the_period\n        # If there is a periodicity in the SpikeGenerator, we need to reset the\n        # lastindex when the period has passed\n        if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n            _lastindex_before = 0\n    _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n                                    _timebin, side='right')\n    _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n    _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n    _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n    _array_zz_external_sources__spikespace[-1] = _n_spikes\n",
+        "name": "zz_external_sources_codeobject"
+      }
+    ],
+    "name": "zz_external_sources",
+    "order": 0,
+    "type": "SpikeGeneratorGroup",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "_to_record_i = _source_i\n_to_record_t = _source_t",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _n_events = _array_default_neurons__spikespace[-1]\n    if _n_events > 0:\n        _events = _array_default_neurons__spikespace[:_n_events]\n        # Take subgroups into account\n        if _source_start != 0 or _source_stop != _source_N:\n            _events = _events[(_events >= _source_start) & (_events < _source_stop)]\n            _n_events = len(_events)\n        if _n_events > 0:\n            _vectorisation_idx = 1\n            _curlen = _array_spikemonitor_N[0]\n            _newlen = _curlen + _n_events\n            _owner.resize(_newlen)\n            _array_spikemonitor_N[0] = _newlen\n            _vectorisation_idx = _events\n            _idx = _events\n            _source_t = _array_defaultclock_t[0]\n            _source_i = _array_default_neurons_i[_idx]\n            _to_record_i = _source_i\n            _to_record_t = _source_t\n            _dynamic_array_spikemonitor_t[_curlen:_newlen] = _to_record_t\n            _dynamic_array_spikemonitor_i[_curlen:_newlen] = _to_record_i\n            _array_spikemonitor_count[_events - _source_start] += 1\n",
+        "name": "spikemonitor_codeobject"
+      }
+    ],
+    "name": "spikemonitor",
+    "order": 1,
+    "type": "SpikeMonitor",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "g += w\n",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\n",
+        "name": "default_synapses_pre_push_spikes"
+      },
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g += w\n        _postsynaptic_idx = _array_default_synapses__synaptic_post[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        w = _array_default_synapses_w[_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "default_synapses_pre_codeobject"
+      }
+    ],
+    "name": "default_synapses_pre",
+    "order": -1,
+    "type": "SynapticPathway",
+    "when": "synapses"
+  },
+  {
+    "abstract_code": "g_post += w\n",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\n",
+        "name": "zz_external_arrivals_pre_push_spikes"
+      },
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g_post += w\n        _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        w = _array_zz_external_arrivals_w[_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "zz_external_arrivals_pre_codeobject"
+      }
+    ],
+    "name": "zz_external_arrivals_pre",
+    "order": 0,
+    "type": "SynapticPathway",
+    "when": "synapses"
+  },
+  {
+    "abstract_code": "v = v_rst; w = 0; g = 0 * mV",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    w = 0\n    # vector code\n    _idx = _array_default_neurons__spikespace[:_array_default_neurons__spikespace[-1]]\n    _vectorisation_idx = _idx\n    v = v_rst\n    g = 0.0\n    _array_default_neurons_g[_idx] = g\n    _array_default_neurons_v[_idx] = v\n",
+        "name": "default_neurons_spike_resetter_codeobject"
+      }
+    ],
+    "name": "default_neurons_spike_resetter",
+    "order": 0,
+    "type": "Resetter",
+    "when": "resets"
+  },
+  {
+    "abstract_code": "_to_record_v = _source_v\n_to_record_g = _source_g\n_to_record_lastspike = _source_lastspike\n_to_record_not_refractory = _source_not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # Resize dynamic arrays\n    _new_len = len(_dynamic_array_oracle_end_state_t) + 1\n    _owner.resize(_new_len)\n    # Store values\n    _dynamic_array_oracle_end_state_t[-1] = _array_defaultclock_t[0]\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = _array_oracle_end_state__indices\n    _idx = _array_oracle_end_state__indices\n    _source_g = _array_default_neurons_g[_idx]\n    _source_not_refractory = _array_default_neurons_not_refractory[_idx]\n    _source_v = _array_default_neurons_v[_idx]\n    _source_lastspike = _array_default_neurons_lastspike[_idx]\n    _to_record_v = _source_v\n    _to_record_g = _source_g\n    _to_record_lastspike = _source_lastspike\n    _to_record_not_refractory = _source_not_refractory\n    _dynamic_array_oracle_end_state_v[-1, :] = _to_record_v\n    _dynamic_array_oracle_end_state_g[-1, :] = _to_record_g\n    _dynamic_array_oracle_end_state_lastspike[-1, :] = _to_record_lastspike\n    _dynamic_array_oracle_end_state_not_refractory[-1, :] = _to_record_not_refractory\n",
+        "name": "oracle_end_state_codeobject"
+      }
+    ],
+    "name": "oracle_end_state",
+    "order": 0,
+    "type": "StateMonitor",
+    "when": "end"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "zz_oracle_queue_installer",
+    "order": 1000000,
+    "type": "QueueInstaller",
+    "when": "end"
+  }
+]
@@ -0,0 +1,258 @@
+global_neuron_idx,local_index
+-257,0
+-256,1
+-255,2
+-254,3
+-253,4
+-252,5
+-251,6
+-250,7
+-249,8
+-248,9
+-247,10
+-246,11
+-245,12
+-244,13
+-243,14
+-242,15
+-241,16
+-240,17
+-239,18
+-238,19
+-237,20
+-236,21
+-235,22
+-234,23
+-233,24
+-232,25
+-231,26
+-230,27
+-229,28
+-228,29
+-227,30
+-226,31
+-225,32
+-224,33
+-223,34
+-222,35
+-221,36
+-220,37
+-219,38
+-218,39
+-217,40
+-216,41
+-215,42
+-214,43
+-213,44
+-212,45
+-211,46
+-210,47
+-209,48
+-208,49
+-207,50
+-206,51
+-205,52
+-204,53
+-203,54
+-202,55
+-201,56
+-200,57
+-199,58
+-198,59
+-197,60
+-196,61
+-195,62
+-194,63
+-193,64
+-192,65
+-191,66
+-190,67
+-189,68
+-188,69
+-187,70
+-186,71
+-185,72
+-184,73
+-183,74
+-182,75
+-181,76
+-180,77
+-179,78
+-178,79
+-177,80
+-176,81
+-175,82
+-174,83
+-173,84
+-172,85
+-171,86
+-170,87
+-169,88
+-168,89
+-167,90
+-166,91
+-165,92
+-164,93
+-163,94
+-162,95
+-161,96
+-160,97
+-159,98
+-158,99
+-157,100
+-156,101
+-155,102
+-154,103
+-153,104
+-152,105
+-151,106
+-150,107
+-149,108
+-148,109
+-147,110
+-146,111
+-145,112
+-144,113
+-143,114
+-142,115
+-141,116
+-140,117
+-139,118
+-138,119
+-137,120
+-136,121
+-135,122
+-134,123
+-133,124
+-132,125
+-131,126
+-130,127
+-129,128
+-128,129
+-127,130
+-126,131
+-125,132
+-124,133
+-123,134
+-122,135
+-121,136
+-120,137
+-119,138
+-118,139
+-117,140
+-116,141
+-115,142
+-114,143
+-113,144
+-112,145
+-111,146
+-110,147
+-109,148
+-108,149
+-107,150
+-106,151
+-105,152
+-104,153
+-103,154
+-102,155
+-101,156
+-100,157
+-99,158
+-98,159
+-97,160
+-96,161
+-95,162
+-94,163
+-93,164
+-92,165
+-91,166
+-90,167
+-89,168
+-88,169
+-87,170
+-86,171
+-85,172
+-84,173
+-83,174
+-82,175
+-81,176
+-80,177
+-79,178
+-78,179
+-77,180
+-76,181
+-75,182
+-74,183
+-73,184
+-72,185
+-71,186
+-70,187
+-69,188
+-68,189
+-67,190
+-66,191
+-65,192
+-64,193
+-63,194
+-62,195
+-61,196
+-60,197
+-59,198
+-58,199
+-57,200
+-56,201
+-55,202
+-54,203
+-53,204
+-52,205
+-51,206
+-50,207
+-49,208
+-48,209
+-47,210
+-46,211
+-45,212
+-44,213
+-43,214
+-42,215
+-41,216
+-40,217
+-39,218
+-38,219
+-37,220
+-36,221
+-35,222
+-34,223
+-33,224
+-32,225
+-31,226
+-30,227
+-29,228
+-28,229
+-27,230
+-26,231
+-25,232
+-24,233
+-23,234
+-22,235
+-21,236
+-20,237
+-19,238
+-18,239
+-17,240
+-16,241
+-15,242
+-14,243
+-13,244
+-12,245
+-11,246
+-10,247
+-9,248
+-8,249
+-7,250
+-6,251
+-5,252
+-4,253
+-3,254
+-2,255
+-1,256
@@ -0,0 +1,162 @@
+[
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_neurons",
+    "order": 0,
+    "type": "NeuronGroup",
+    "when": "start"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_synapses",
+    "order": 0,
+    "type": "Synapses",
+    "when": "start"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "zz_external_arrivals",
+    "order": 0,
+    "type": "Synapses",
+    "when": "start"
+  },
+  {
+    "abstract_code": "not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n_g = g*exp(-dt*int(not_refractory)/tau)\n_v = g*tau*(-exp(dt*int(not_refractory)/t_mbr) + exp(dt*int(not_refractory)/tau))*exp(-dt*int(not_refractory)/t_mbr)*exp(-dt*int(not_refractory)/tau)/(t_mbr - tau) + v*exp(-dt*int(not_refractory)/t_mbr) + v_0 - v_0*exp(-dt*int(not_refractory)/t_mbr)\ng = _g\nv = _v",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    dt = _array_defaultclock_dt[0]\n    _lio_1 = (- dt) / tau\n    _lio_2 = exp(_lio_1)\n    _lio_3 = tau / (t_mbr - tau)\n    _lio_4 = dt / t_mbr\n    _lio_5 = dt / tau\n    _lio_6 = (- dt) / t_mbr\n    _lio_7 = v_0 - v_0\n    _lio_8 = v_0 - (v_0 * exp(_lio_6))\n    _lio_9 = ((_lio_3 * ((- exp(_lio_4)) + exp(_lio_5))) * exp(_lio_6)) * exp(_lio_1)\n    _lio_10 = exp(_lio_6)\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    g = _array_default_neurons_g.copy()\n    lastspike = _array_default_neurons_lastspike\n    rfc = _array_default_neurons_rfc\n    v = _array_default_neurons_v.copy()\n    t = _array_defaultclock_t[0]\n    not_refractory = _array_default_neurons_not_refractory.copy()\n    dt = _array_defaultclock_dt[0]\n    not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n    _g = _numpy.where(not_refractory, _lio_2 * g, g)\n    _v = _numpy.where(not_refractory, _lio_8 + ((_lio_9 * g) + (_lio_10 * v)), _lio_7 + v)\n    g[not_refractory] = _g[not_refractory]\n    v[not_refractory] = _v[not_refractory]\n    _array_default_neurons_g[:] = g\n    _array_default_neurons_not_refractory[:] = not_refractory\n    _array_default_neurons_v[:] = v\n",
+        "name": "default_neurons_stateupdater_codeobject_2"
+      }
+    ],
+    "name": "default_neurons_stateupdater",
+    "order": 0,
+    "type": "StateUpdater",
+    "when": "groups"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "oracle_common_requests",
+    "order": 0,
+    "type": "NetworkOperation",
+    "when": "before_thresholds"
+  },
+  {
+    "abstract_code": "_cond = (v > v_th) and not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _array_default_neurons__spikespace[-1] = 0\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    numpy_True = _numpy.bool_(True)\n    numpy_False = _numpy.bool_(False)\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    not_refractory = _array_default_neurons_not_refractory\n    v = _array_default_neurons_v\n    _cond = (v > v_th) & not_refractory\n    if _cond is True or _cond is numpy_True:\n        _events = _numpy.arange(N)\n    elif _cond is False or _cond is numpy_False:\n        _events = _numpy.array([])\n    else:\n        _events, = _cond.nonzero()\n    _array_default_neurons__spikespace[-1] = len(_events)\n    _array_default_neurons__spikespace[:len(_events)] = _events\n    # Set the neuron to refractory\n    _array_default_neurons_not_refractory[_events] = False\n    _array_default_neurons_lastspike[_events] = _array_defaultclock_t[0]\n",
+        "name": "default_neurons_spike_thresholder_codeobject_2"
+      }
+    ],
+    "name": "default_neurons_spike_thresholder",
+    "order": 0,
+    "type": "Thresholder",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _the_period    = _array_zz_external_sources__period_bins[0]\n    _timebin       = _array_defaultclock_timestep[0]\n    _n_spikes      = 0\n    _lastindex_before = _array_zz_external_sources__lastindex[0]\n    if _the_period > 0:\n        _timebin %= _the_period\n        # If there is a periodicity in the SpikeGenerator, we need to reset the\n        # lastindex when the period has passed\n        if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n            _lastindex_before = 0\n    _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n                                    _timebin, side='right')\n    _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n    _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n    _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n    _array_zz_external_sources__spikespace[-1] = _n_spikes\n",
+        "name": "zz_external_sources_codeobject_2"
+      }
+    ],
+    "name": "zz_external_sources",
+    "order": 0,
+    "type": "SpikeGeneratorGroup",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "_to_record_i = _source_i\n_to_record_t = _source_t",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _n_events = _array_default_neurons__spikespace[-1]\n    if _n_events > 0:\n        _events = _array_default_neurons__spikespace[:_n_events]\n        # Take subgroups into account\n        if _source_start != 0 or _source_stop != _source_N:\n            _events = _events[(_events >= _source_start) & (_events < _source_stop)]\n            _n_events = len(_events)\n        if _n_events > 0:\n            _vectorisation_idx = 1\n            _curlen = _array_spikemonitor_N[0]\n            _newlen = _curlen + _n_events\n            _owner.resize(_newlen)\n            _array_spikemonitor_N[0] = _newlen\n            _vectorisation_idx = _events\n            _idx = _events\n            _source_t = _array_defaultclock_t[0]\n            _source_i = _array_default_neurons_i[_idx]\n            _to_record_i = _source_i\n            _to_record_t = _source_t\n            _dynamic_array_spikemonitor_t[_curlen:_newlen] = _to_record_t\n            _dynamic_array_spikemonitor_i[_curlen:_newlen] = _to_record_i\n            _array_spikemonitor_count[_events - _source_start] += 1\n",
+        "name": "spikemonitor_codeobject_1"
+      }
+    ],
+    "name": "spikemonitor",
+    "order": 1,
+    "type": "SpikeMonitor",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "g += w\n",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\n",
+        "name": "default_synapses_pre_push_spikes"
+      },
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g += w\n        _postsynaptic_idx = _array_default_synapses__synaptic_post[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        w = _array_default_synapses_w[_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "default_synapses_pre_codeobject_2"
+      }
+    ],
+    "name": "default_synapses_pre",
+    "order": -1,
+    "type": "SynapticPathway",
+    "when": "synapses"
+  },
+  {
+    "abstract_code": "g_post += w\n",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\n",
+        "name": "zz_external_arrivals_pre_push_spikes"
+      },
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g_post += w\n        _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        w = _array_zz_external_arrivals_w[_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "zz_external_arrivals_pre_codeobject_2"
+      }
+    ],
+    "name": "zz_external_arrivals_pre",
+    "order": 0,
+    "type": "SynapticPathway",
+    "when": "synapses"
+  },
+  {
+    "abstract_code": "v = v_rst; w = 0; g = 0 * mV",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    w = 0\n    # vector code\n    _idx = _array_default_neurons__spikespace[:_array_default_neurons__spikespace[-1]]\n    _vectorisation_idx = _idx\n    v = v_rst\n    g = 0.0\n    _array_default_neurons_g[_idx] = g\n    _array_default_neurons_v[_idx] = v\n",
+        "name": "default_neurons_spike_resetter_codeobject_2"
+      }
+    ],
+    "name": "default_neurons_spike_resetter",
+    "order": 0,
+    "type": "Resetter",
+    "when": "resets"
+  },
+  {
+    "abstract_code": "_to_record_v = _source_v\n_to_record_g = _source_g\n_to_record_lastspike = _source_lastspike\n_to_record_not_refractory = _source_not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # Resize dynamic arrays\n    _new_len = len(_dynamic_array_oracle_end_state_t) + 1\n    _owner.resize(_new_len)\n    # Store values\n    _dynamic_array_oracle_end_state_t[-1] = _array_defaultclock_t[0]\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = _array_oracle_end_state__indices\n    _idx = _array_oracle_end_state__indices\n    _source_g = _array_default_neurons_g[_idx]\n    _source_not_refractory = _array_default_neurons_not_refractory[_idx]\n    _source_v = _array_default_neurons_v[_idx]\n    _source_lastspike = _array_default_neurons_lastspike[_idx]\n    _to_record_v = _source_v\n    _to_record_g = _source_g\n    _to_record_lastspike = _source_lastspike\n    _to_record_not_refractory = _source_not_refractory\n    _dynamic_array_oracle_end_state_v[-1, :] = _to_record_v\n    _dynamic_array_oracle_end_state_g[-1, :] = _to_record_g\n    _dynamic_array_oracle_end_state_lastspike[-1, :] = _to_record_lastspike\n    _dynamic_array_oracle_end_state_not_refractory[-1, :] = _to_record_not_refractory\n",
+        "name": "oracle_end_state_codeobject_1"
+      }
+    ],
+    "name": "oracle_end_state",
+    "order": 0,
+    "type": "StateMonitor",
+    "when": "end"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "zz_oracle_queue_installer",
+    "order": 1000000,
+    "type": "QueueInstaller",
+    "when": "end"
+  }
+]
@@ -0,0 +1,48 @@
+{
+  "all_neurons_keep_original_rfc": true,
+  "completeness_sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20",
+  "connectivity_sha256": "87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86",
+  "dt_ms": 0.1,
+  "parameter_checks": {
+    "membrane_tau_ms": {
+      "author": 20.0,
+      "case": 20.0
+    },
+    "refractory_ms": {
+      "author": 2.2,
+      "case": 2.2
+    },
+    "reset_potential_mv": {
+      "author": -52.0,
+      "case": -52.0
+    },
+    "resting_potential_mv": {
+      "author": -52.0,
+      "case": -52.0
+    },
+    "synaptic_delay_ms": {
+      "author": 1.8,
+      "case": 1.8
+    },
+    "synaptic_tau_ms": {
+      "author": 5.0,
+      "case": 5.0
+    },
+    "threshold_mv": {
+      "author": -45.0,
+      "case": -45.0
+    },
+    "w_syn_mv_per_anatomical_synapse": {
+      "author": 0.275,
+      "case": 0.275
+    }
+  },
+  "poisson_helper_used": false,
+  "precision": "float32",
+  "queue_trace_enabled": true,
+  "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory",
+  "source_parameters_modified": false,
+  "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e",
+  "state_units": "SI volts, original dtype",
+  "steps": 600
+}
@@ -0,0 +1,14 @@
+{
+  "accepted_due_events": 1285,
+  "advance_calls": 600,
+  "all_due_events_preserved": true,
+  "due_events": 1545,
+  "installations": [
+    "default_synapses_pre_codeobject",
+    "default_synapses_pre_codeobject_2"
+  ],
+  "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering",
+  "peek_calls": 600,
+  "proxy_contract": "peek returns original object; advance and all other methods forward unchanged",
+  "trace_enabled": true
+}
@@ -0,0 +1,11 @@
+{
+  "schedule": [
+    "start",
+    "groups",
+    "thresholds",
+    "synapses",
+    "resets",
+    "end"
+  ],
+  "summary": "                    object                      |                  part of                  |       Clock dt       |       when        |  order  | active\n------------------------------------------------+-------------------------------------------+----------------------+-------------------+---------+-------\ndefault_neurons_stateupdater (StateUpdater)     | default_neurons (NeuronGroup)             | 100. us (every step) | groups            |       0 |  yes  \noracle_common_requests (NetworkOperation)       | --                                        | 100. us (every step) | before_thresholds |       0 |  yes  \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup)             | 100. us (every step) | thresholds        |       0 |  yes  \nzz_external_sources (SpikeGeneratorGroup)       | zz_external_sources (SpikeGeneratorGroup) | 100. us (every step) | thresholds        |       0 |  yes  \nspikemonitor (SpikeMonitor)                     | spikemonitor (SpikeMonitor)               | 100. us (every step) | thresholds        |       1 |  yes  \ndefault_synapses_pre (SynapticPathway)          | default_synapses (Synapses)               | 100. us (every step) | synapses          |      -1 |  yes  \nzz_external_arrivals_pre (SynapticPathway)      | zz_external_arrivals (Synapses)           | 100. us (every step) | synapses          |       0 |  yes  \ndefault_neurons_spike_resetter (Resetter)       | default_neurons (NeuronGroup)             | 100. us (every step) | resets            |       0 |  yes  \noracle_end_state (StateMonitor)                 | oracle_end_state (StateMonitor)           | 100. us (every step) | end               |       0 |  yes  \nzz_oracle_queue_installer (QueueInstaller)      | --                                        | 100. us (every step) | end               | 1000000 |  yes  "
+}
@@ -0,0 +1,33 @@
+{
+  "arrival_arrays_excluded": "An unwrapped queue is deliberately not observed",
+  "exact_arrays": {
+    "applicable_count": true,
+    "coefficients": true,
+    "counts": true,
+    "external_accepted": true,
+    "external_step": true,
+    "external_target": true,
+    "external_weights": true,
+    "fired": true,
+    "g": true,
+    "history": true,
+    "initial_g": true,
+    "initial_v": true,
+    "local_idx": true,
+    "neuron_idx": true,
+    "nodes": true,
+    "not_refractory": true,
+    "ref": true,
+    "ref_history": true,
+    "rejected_count": true,
+    "request_accepted": true,
+    "request_attempted": true,
+    "request_count": true,
+    "request_rejected": true,
+    "step": true,
+    "v": true,
+    "weights": true
+  },
+  "pass": true,
+  "performed": true
+}
@@ -0,0 +1,18 @@
+{
+  "applicable_requests": 1537,
+  "coefficient_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/coefficients.json",
+  "complete": true,
+  "due_arrivals": 1545,
+  "edges": 258,
+  "name": "fanin_bursts",
+  "nodes": 257,
+  "precision": "float32",
+  "queue_proxy_validated": true,
+  "queue_trace_enabled": true,
+  "rejected_requests": 512,
+  "requests": 2049,
+  "source_unchanged": true,
+  "spikes": 1539,
+  "state_file": "/data/digital-drosophila/experiments/phase4ae-author-runtime/oracle/fanin_bursts-float32/state.npz",
+  "steps": 600
+}
@@ -0,0 +1,72 @@
+{
+  "c0": -0.00025935108198051754,
+  "cg": 0.004937935295309027,
+  "cv": 0.9950124791926823,
+  "gd": 0.9801986733067553,
+  "metadata": {
+    "constant_values_are_double": true,
+    "float32_execution_note": "Brian NumPy scalar/array promotion and operation order must be matched separately; double coefficients alone do not assert float64 intermediate array arithmetic.",
+    "g_expression": "gd * old_g",
+    "hex": {
+      "c0": "-0x1.0ff306a505980p-12",
+      "cg": "0x1.439cce9a65d5bp-8",
+      "cv": "0x1.fd7246927d28bp-1",
+      "gd": "0x1.f5dc99badec5bp-1",
+      "reset": "-0x1.a9fbe76c8b43ap-5",
+      "seed_volt": "-0x1.6872b020c49bap-5",
+      "threshold": "-0x1.70a3d70a3d70ap-5"
+    },
+    "names": {
+      "c0": "_lio_8",
+      "cg": "_lio_9",
+      "cv": "_lio_10",
+      "gd": "_lio_2"
+    },
+    "provenance": {
+      "c0": {
+        "code_object": "default_neurons_stateupdater_codeobject_3",
+        "name": "_lio_8",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "cg": {
+        "code_object": "default_neurons_stateupdater_codeobject_3",
+        "name": "_lio_9",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "cv": {
+        "code_object": "default_neurons_stateupdater_codeobject_3",
+        "name": "_lio_10",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "gd": {
+        "code_object": "default_neurons_stateupdater_codeobject_3",
+        "name": "_lio_2",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "reset": {
+        "code_object": "default_neurons_spike_resetter_codeobject_3",
+        "name": "v_rst",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      },
+      "seed_volt": {
+        "source": "common request interface: unchanged v_th + 1 mV"
+      },
+      "threshold": {
+        "code_object": "default_neurons_spike_thresholder_codeobject_3",
+        "name": "v_th",
+        "namespace_dtype": "float64",
+        "source": "CodeObject.namespace"
+      }
+    },
+    "units": "SI volts and dimensionless coefficients",
+    "voltage_expression": "c0 + ((cg * old_g) + (cv * old_v))"
+  },
+  "reset": -0.052000000000000005,
+  "seed_volt": -0.044,
+  "threshold": -0.045
+}
@@ -0,0 +1,154 @@
+[
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_neurons",
+    "order": 0,
+    "type": "NeuronGroup",
+    "when": "start"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_synapses",
+    "order": 0,
+    "type": "Synapses",
+    "when": "start"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "zz_external_arrivals",
+    "order": 0,
+    "type": "Synapses",
+    "when": "start"
+  },
+  {
+    "abstract_code": "not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n_g = g*exp(-dt*int(not_refractory)/tau)\n_v = g*tau*(-exp(dt*int(not_refractory)/t_mbr) + exp(dt*int(not_refractory)/tau))*exp(-dt*int(not_refractory)/t_mbr)*exp(-dt*int(not_refractory)/tau)/(t_mbr - tau) + v*exp(-dt*int(not_refractory)/t_mbr) + v_0 - v_0*exp(-dt*int(not_refractory)/t_mbr)\ng = _g\nv = _v",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    dt = _array_defaultclock_dt[0]\n    _lio_1 = (- dt) / tau\n    _lio_2 = exp(_lio_1)\n    _lio_3 = tau / (t_mbr - tau)\n    _lio_4 = dt / t_mbr\n    _lio_5 = dt / tau\n    _lio_6 = (- dt) / t_mbr\n    _lio_7 = v_0 - v_0\n    _lio_8 = v_0 - (v_0 * exp(_lio_6))\n    _lio_9 = ((_lio_3 * ((- exp(_lio_4)) + exp(_lio_5))) * exp(_lio_6)) * exp(_lio_1)\n    _lio_10 = exp(_lio_6)\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    g = _array_default_neurons_g.copy()\n    lastspike = _array_default_neurons_lastspike\n    rfc = _array_default_neurons_rfc\n    v = _array_default_neurons_v.copy()\n    t = _array_defaultclock_t[0]\n    not_refractory = _array_default_neurons_not_refractory.copy()\n    dt = _array_defaultclock_dt[0]\n    not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n    _g = _numpy.where(not_refractory, _lio_2 * g, g)\n    _v = _numpy.where(not_refractory, _lio_8 + ((_lio_9 * g) + (_lio_10 * v)), _lio_7 + v)\n    g[not_refractory] = _g[not_refractory]\n    v[not_refractory] = _v[not_refractory]\n    _array_default_neurons_g[:] = g\n    _array_default_neurons_not_refractory[:] = not_refractory\n    _array_default_neurons_v[:] = v\n",
+        "name": "default_neurons_stateupdater_codeobject"
+      }
+    ],
+    "name": "default_neurons_stateupdater",
+    "order": 0,
+    "type": "StateUpdater",
+    "when": "groups"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "oracle_common_requests",
+    "order": 0,
+    "type": "NetworkOperation",
+    "when": "before_thresholds"
+  },
+  {
+    "abstract_code": "_cond = (v > v_th) and not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _array_default_neurons__spikespace[-1] = 0\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    numpy_True = _numpy.bool_(True)\n    numpy_False = _numpy.bool_(False)\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    not_refractory = _array_default_neurons_not_refractory\n    v = _array_default_neurons_v\n    _cond = (v > v_th) & not_refractory\n    if _cond is True or _cond is numpy_True:\n        _events = _numpy.arange(N)\n    elif _cond is False or _cond is numpy_False:\n        _events = _numpy.array([])\n    else:\n        _events, = _cond.nonzero()\n    _array_default_neurons__spikespace[-1] = len(_events)\n    _array_default_neurons__spikespace[:len(_events)] = _events\n    # Set the neuron to refractory\n    _array_default_neurons_not_refractory[_events] = False\n    _array_default_neurons_lastspike[_events] = _array_defaultclock_t[0]\n",
+        "name": "default_neurons_spike_thresholder_codeobject"
+      }
+    ],
+    "name": "default_neurons_spike_thresholder",
+    "order": 0,
+    "type": "Thresholder",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _the_period    = _array_zz_external_sources__period_bins[0]\n    _timebin       = _array_defaultclock_timestep[0]\n    _n_spikes      = 0\n    _lastindex_before = _array_zz_external_sources__lastindex[0]\n    if _the_period > 0:\n        _timebin %= _the_period\n        # If there is a periodicity in the SpikeGenerator, we need to reset the\n        # lastindex when the period has passed\n        if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n            _lastindex_before = 0\n    _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n                                    _timebin, side='right')\n    _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n    _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n    _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n    _array_zz_external_sources__spikespace[-1] = _n_spikes\n",
+        "name": "zz_external_sources_codeobject"
+      }
+    ],
+    "name": "zz_external_sources",
+    "order": 0,
+    "type": "SpikeGeneratorGroup",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "_to_record_i = _source_i\n_to_record_t = _source_t",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _n_events = _array_default_neurons__spikespace[-1]\n    if _n_events > 0:\n        _events = _array_default_neurons__spikespace[:_n_events]\n        # Take subgroups into account\n        if _source_start != 0 or _source_stop != _source_N:\n            _events = _events[(_events >= _source_start) & (_events < _source_stop)]\n            _n_events = len(_events)\n        if _n_events > 0:\n            _vectorisation_idx = 1\n            _curlen = _array_spikemonitor_N[0]\n            _newlen = _curlen + _n_events\n            _owner.resize(_newlen)\n            _array_spikemonitor_N[0] = _newlen\n            _vectorisation_idx = _events\n            _idx = _events\n            _source_t = _array_defaultclock_t[0]\n            _source_i = _array_default_neurons_i[_idx]\n            _to_record_i = _source_i\n            _to_record_t = _source_t\n            _dynamic_array_spikemonitor_t[_curlen:_newlen] = _to_record_t\n            _dynamic_array_spikemonitor_i[_curlen:_newlen] = _to_record_i\n            _array_spikemonitor_count[_events - _source_start] += 1\n",
+        "name": "spikemonitor_codeobject"
+      }
+    ],
+    "name": "spikemonitor",
+    "order": 1,
+    "type": "SpikeMonitor",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "g += w\n",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\n",
+        "name": "default_synapses_pre_push_spikes"
+      },
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g += w\n        _postsynaptic_idx = _array_default_synapses__synaptic_post[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        w = _array_default_synapses_w[_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "default_synapses_pre_codeobject"
+      }
+    ],
+    "name": "default_synapses_pre",
+    "order": -1,
+    "type": "SynapticPathway",
+    "when": "synapses"
+  },
+  {
+    "abstract_code": "g_post += w\n",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\n",
+        "name": "zz_external_arrivals_pre_push_spikes"
+      },
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g_post += w\n        _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        w = _array_zz_external_arrivals_w[_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "zz_external_arrivals_pre_codeobject"
+      }
+    ],
+    "name": "zz_external_arrivals_pre",
+    "order": 0,
+    "type": "SynapticPathway",
+    "when": "synapses"
+  },
+  {
+    "abstract_code": "v = v_rst; w = 0; g = 0 * mV",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    w = 0\n    # vector code\n    _idx = _array_default_neurons__spikespace[:_array_default_neurons__spikespace[-1]]\n    _vectorisation_idx = _idx\n    v = v_rst\n    g = 0.0\n    _array_default_neurons_g[_idx] = g\n    _array_default_neurons_v[_idx] = v\n",
+        "name": "default_neurons_spike_resetter_codeobject"
+      }
+    ],
+    "name": "default_neurons_spike_resetter",
+    "order": 0,
+    "type": "Resetter",
+    "when": "resets"
+  },
+  {
+    "abstract_code": "_to_record_v = _source_v\n_to_record_g = _source_g\n_to_record_lastspike = _source_lastspike\n_to_record_not_refractory = _source_not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # Resize dynamic arrays\n    _new_len = len(_dynamic_array_oracle_end_state_t) + 1\n    _owner.resize(_new_len)\n    # Store values\n    _dynamic_array_oracle_end_state_t[-1] = _array_defaultclock_t[0]\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = _array_oracle_end_state__indices\n    _idx = _array_oracle_end_state__indices\n    _source_g = _array_default_neurons_g[_idx]\n    _source_not_refractory = _array_default_neurons_not_refractory[_idx]\n    _source_v = _array_default_neurons_v[_idx]\n    _source_lastspike = _array_default_neurons_lastspike[_idx]\n    _to_record_v = _source_v\n    _to_record_g = _source_g\n    _to_record_lastspike = _source_lastspike\n    _to_record_not_refractory = _source_not_refractory\n    _dynamic_array_oracle_end_state_v[-1, :] = _to_record_v\n    _dynamic_array_oracle_end_state_g[-1, :] = _to_record_g\n    _dynamic_array_oracle_end_state_lastspike[-1, :] = _to_record_lastspike\n    _dynamic_array_oracle_end_state_not_refractory[-1, :] = _to_record_not_refractory\n",
+        "name": "oracle_end_state_codeobject"
+      }
+    ],
+    "name": "oracle_end_state",
+    "order": 0,
+    "type": "StateMonitor",
+    "when": "end"
+  }
+]
@@ -0,0 +1,258 @@
+global_neuron_idx,local_index
+-257,0
+-256,1
+-255,2
+-254,3
+-253,4
+-252,5
+-251,6
+-250,7
+-249,8
+-248,9
+-247,10
+-246,11
+-245,12
+-244,13
+-243,14
+-242,15
+-241,16
+-240,17
+-239,18
+-238,19
+-237,20
+-236,21
+-235,22
+-234,23
+-233,24
+-232,25
+-231,26
+-230,27
+-229,28
+-228,29
+-227,30
+-226,31
+-225,32
+-224,33
+-223,34
+-222,35
+-221,36
+-220,37
+-219,38
+-218,39
+-217,40
+-216,41
+-215,42
+-214,43
+-213,44
+-212,45
+-211,46
+-210,47
+-209,48
+-208,49
+-207,50
+-206,51
+-205,52
+-204,53
+-203,54
+-202,55
+-201,56
+-200,57
+-199,58
+-198,59
+-197,60
+-196,61
+-195,62
+-194,63
+-193,64
+-192,65
+-191,66
+-190,67
+-189,68
+-188,69
+-187,70
+-186,71
+-185,72
+-184,73
+-183,74
+-182,75
+-181,76
+-180,77
+-179,78
+-178,79
+-177,80
+-176,81
+-175,82
+-174,83
+-173,84
+-172,85
+-171,86
+-170,87
+-169,88
+-168,89
+-167,90
+-166,91
+-165,92
+-164,93
+-163,94
+-162,95
+-161,96
+-160,97
+-159,98
+-158,99
+-157,100
+-156,101
+-155,102
+-154,103
+-153,104
+-152,105
+-151,106
+-150,107
+-149,108
+-148,109
+-147,110
+-146,111
+-145,112
+-144,113
+-143,114
+-142,115
+-141,116
+-140,117
+-139,118
+-138,119
+-137,120
+-136,121
+-135,122
+-134,123
+-133,124
+-132,125
+-131,126
+-130,127
+-129,128
+-128,129
+-127,130
+-126,131
+-125,132
+-124,133
+-123,134
+-122,135
+-121,136
+-120,137
+-119,138
+-118,139
+-117,140
+-116,141
+-115,142
+-114,143
+-113,144
+-112,145
+-111,146
+-110,147
+-109,148
+-108,149
+-107,150
+-106,151
+-105,152
+-104,153
+-103,154
+-102,155
+-101,156
+-100,157
+-99,158
+-98,159
+-97,160
+-96,161
+-95,162
+-94,163
+-93,164
+-92,165
+-91,166
+-90,167
+-89,168
+-88,169
+-87,170
+-86,171
+-85,172
+-84,173
+-83,174
+-82,175
+-81,176
+-80,177
+-79,178
+-78,179
+-77,180
+-76,181
+-75,182
+-74,183
+-73,184
+-72,185
+-71,186
+-70,187
+-69,188
+-68,189
+-67,190
+-66,191
+-65,192
+-64,193
+-63,194
+-62,195
+-61,196
+-60,197
+-59,198
+-58,199
+-57,200
+-56,201
+-55,202
+-54,203
+-53,204
+-52,205
+-51,206
+-50,207
+-49,208
+-48,209
+-47,210
+-46,211
+-45,212
+-44,213
+-43,214
+-42,215
+-41,216
+-40,217
+-39,218
+-38,219
+-37,220
+-36,221
+-35,222
+-34,223
+-33,224
+-32,225
+-31,226
+-30,227
+-29,228
+-28,229
+-27,230
+-26,231
+-25,232
+-24,233
+-23,234
+-22,235
+-21,236
+-20,237
+-19,238
+-18,239
+-17,240
+-16,241
+-15,242
+-14,243
+-13,244
+-12,245
+-11,246
+-10,247
+-9,248
+-8,249
+-7,250
+-6,251
+-5,252
+-4,253
+-3,254
+-2,255
+-1,256
@@ -0,0 +1,154 @@
+[
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_neurons",
+    "order": 0,
+    "type": "NeuronGroup",
+    "when": "start"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "default_synapses",
+    "order": 0,
+    "type": "Synapses",
+    "when": "start"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "zz_external_arrivals",
+    "order": 0,
+    "type": "Synapses",
+    "when": "start"
+  },
+  {
+    "abstract_code": "not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n_g = g*exp(-dt*int(not_refractory)/tau)\n_v = g*tau*(-exp(dt*int(not_refractory)/t_mbr) + exp(dt*int(not_refractory)/tau))*exp(-dt*int(not_refractory)/t_mbr)*exp(-dt*int(not_refractory)/tau)/(t_mbr - tau) + v*exp(-dt*int(not_refractory)/t_mbr) + v_0 - v_0*exp(-dt*int(not_refractory)/t_mbr)\ng = _g\nv = _v",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    dt = _array_defaultclock_dt[0]\n    _lio_1 = (- dt) / tau\n    _lio_2 = exp(_lio_1)\n    _lio_3 = tau / (t_mbr - tau)\n    _lio_4 = dt / t_mbr\n    _lio_5 = dt / tau\n    _lio_6 = (- dt) / t_mbr\n    _lio_7 = v_0 - v_0\n    _lio_8 = v_0 - (v_0 * exp(_lio_6))\n    _lio_9 = ((_lio_3 * ((- exp(_lio_4)) + exp(_lio_5))) * exp(_lio_6)) * exp(_lio_1)\n    _lio_10 = exp(_lio_6)\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    g = _array_default_neurons_g.copy()\n    lastspike = _array_default_neurons_lastspike\n    rfc = _array_default_neurons_rfc\n    v = _array_default_neurons_v.copy()\n    t = _array_defaultclock_t[0]\n    not_refractory = _array_default_neurons_not_refractory.copy()\n    dt = _array_defaultclock_dt[0]\n    not_refractory = timestep(t - lastspike, dt) >= timestep(rfc, dt)\n    _g = _numpy.where(not_refractory, _lio_2 * g, g)\n    _v = _numpy.where(not_refractory, _lio_8 + ((_lio_9 * g) + (_lio_10 * v)), _lio_7 + v)\n    g[not_refractory] = _g[not_refractory]\n    v[not_refractory] = _v[not_refractory]\n    _array_default_neurons_g[:] = g\n    _array_default_neurons_not_refractory[:] = not_refractory\n    _array_default_neurons_v[:] = v\n",
+        "name": "default_neurons_stateupdater_codeobject_3"
+      }
+    ],
+    "name": "default_neurons_stateupdater",
+    "order": 0,
+    "type": "StateUpdater",
+    "when": "groups"
+  },
+  {
+    "active": true,
+    "code_objects": [],
+    "name": "oracle_common_requests",
+    "order": 0,
+    "type": "NetworkOperation",
+    "when": "before_thresholds"
+  },
+  {
+    "abstract_code": "_cond = (v > v_th) and not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _array_default_neurons__spikespace[-1] = 0\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    numpy_True = _numpy.bool_(True)\n    numpy_False = _numpy.bool_(False)\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = LazyArange(N)\n    not_refractory = _array_default_neurons_not_refractory\n    v = _array_default_neurons_v\n    _cond = (v > v_th) & not_refractory\n    if _cond is True or _cond is numpy_True:\n        _events = _numpy.arange(N)\n    elif _cond is False or _cond is numpy_False:\n        _events = _numpy.array([])\n    else:\n        _events, = _cond.nonzero()\n    _array_default_neurons__spikespace[-1] = len(_events)\n    _array_default_neurons__spikespace[:len(_events)] = _events\n    # Set the neuron to refractory\n    _array_default_neurons_not_refractory[_events] = False\n    _array_default_neurons_lastspike[_events] = _array_defaultclock_t[0]\n",
+        "name": "default_neurons_spike_thresholder_codeobject_3"
+      }
+    ],
+    "name": "default_neurons_spike_thresholder",
+    "order": 0,
+    "type": "Thresholder",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _the_period    = _array_zz_external_sources__period_bins[0]\n    _timebin       = _array_defaultclock_timestep[0]\n    _n_spikes      = 0\n    _lastindex_before = _array_zz_external_sources__lastindex[0]\n    if _the_period > 0:\n        _timebin %= _the_period\n        # If there is a periodicity in the SpikeGenerator, we need to reset the\n        # lastindex when the period has passed\n        if _lastindex_before > 0 and _array_zz_external_sources__timebins[_lastindex_before - 1] >= _timebin:\n            _lastindex_before = 0\n    _n_spikes = _numpy.searchsorted(_array_zz_external_sources__timebins[_lastindex_before:],\n                                    _timebin, side='right')\n    _array_zz_external_sources__lastindex[0] = _lastindex_before + _n_spikes\n    _indices = _array_zz_external_sources_neuron_index[_lastindex_before:_lastindex_before+_n_spikes]\n    _array_zz_external_sources__spikespace[:_n_spikes] = _indices\n    _array_zz_external_sources__spikespace[-1] = _n_spikes\n",
+        "name": "zz_external_sources_codeobject_3"
+      }
+    ],
+    "name": "zz_external_sources",
+    "order": 0,
+    "type": "SpikeGeneratorGroup",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "_to_record_i = _source_i\n_to_record_t = _source_t",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _n_events = _array_default_neurons__spikespace[-1]\n    if _n_events > 0:\n        _events = _array_default_neurons__spikespace[:_n_events]\n        # Take subgroups into account\n        if _source_start != 0 or _source_stop != _source_N:\n            _events = _events[(_events >= _source_start) & (_events < _source_stop)]\n            _n_events = len(_events)\n        if _n_events > 0:\n            _vectorisation_idx = 1\n            _curlen = _array_spikemonitor_N[0]\n            _newlen = _curlen + _n_events\n            _owner.resize(_newlen)\n            _array_spikemonitor_N[0] = _newlen\n            _vectorisation_idx = _events\n            _idx = _events\n            _source_t = _array_defaultclock_t[0]\n            _source_i = _array_default_neurons_i[_idx]\n            _to_record_i = _source_i\n            _to_record_t = _source_t\n            _dynamic_array_spikemonitor_t[_curlen:_newlen] = _to_record_t\n            _dynamic_array_spikemonitor_i[_curlen:_newlen] = _to_record_i\n            _array_spikemonitor_count[_events - _source_start] += 1\n",
+        "name": "spikemonitor_codeobject_1"
+      }
+    ],
+    "name": "spikemonitor",
+    "order": 1,
+    "type": "SpikeMonitor",
+    "when": "thresholds"
+  },
+  {
+    "abstract_code": "g += w\n",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\n",
+        "name": "default_synapses_pre_push_spikes"
+      },
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g += w\n        _postsynaptic_idx = _array_default_synapses__synaptic_post[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        w = _array_default_synapses_w[_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "default_synapses_pre_codeobject_3"
+      }
+    ],
+    "name": "default_synapses_pre",
+    "order": -1,
+    "type": "SynapticPathway",
+    "when": "synapses"
+  },
+  {
+    "abstract_code": "g_post += w\n",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.initialise_queue()\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _owner.push_spikes()\n",
+        "name": "zz_external_arrivals_pre_push_spikes"
+      },
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    _spiking_synapses = _queue.peek()\n    if len(_spiking_synapses):\n        # scalar code\n        # vector code\n        _idx = _spiking_synapses\n        _vectorisation_idx = _idx\n        #  Abstract code:  g_post += w\n        _postsynaptic_idx = _array_zz_external_arrivals__synaptic_post[_idx]\n        not_refractory = _array_default_neurons_not_refractory[_postsynaptic_idx]\n        w = _array_zz_external_arrivals_w[_idx]\n        _numpy.add.at(_array_default_neurons_g, _postsynaptic_idx[not_refractory], w[not_refractory])\n    # Advance the spike queue\n    _queue.advance()\n",
+        "name": "zz_external_arrivals_pre_codeobject_3"
+      }
+    ],
+    "name": "zz_external_arrivals_pre",
+    "order": 0,
+    "type": "SynapticPathway",
+    "when": "synapses"
+  },
+  {
+    "abstract_code": "v = v_rst; w = 0; g = 0 * mV",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # scalar code\n    _vectorisation_idx = 1\n    w = 0\n    # vector code\n    _idx = _array_default_neurons__spikespace[:_array_default_neurons__spikespace[-1]]\n    _vectorisation_idx = _idx\n    v = v_rst\n    g = 0.0\n    _array_default_neurons_g[_idx] = g\n    _array_default_neurons_v[_idx] = v\n",
+        "name": "default_neurons_spike_resetter_codeobject_3"
+      }
+    ],
+    "name": "default_neurons_spike_resetter",
+    "order": 0,
+    "type": "Resetter",
+    "when": "resets"
+  },
+  {
+    "abstract_code": "_to_record_v = _source_v\n_to_record_g = _source_g\n_to_record_lastspike = _source_lastspike\n_to_record_not_refractory = _source_not_refractory",
+    "active": true,
+    "code_objects": [
+      {
+        "generated_code": "after_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nbefore_run:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # EMPTY_CODE_BLOCK  -- overwrite in child template\nrun:\n    import numpy as _numpy\n    from brian2.codegen.runtime.numpy_rt.numpy_rt import LazyArange\n    # Resize dynamic arrays\n    _new_len = len(_dynamic_array_oracle_end_state_t) + 1\n    _owner.resize(_new_len)\n    # Store values\n    _dynamic_array_oracle_end_state_t[-1] = _array_defaultclock_t[0]\n    # scalar code\n    _vectorisation_idx = 1\n    # vector code\n    _vectorisation_idx = _array_oracle_end_state__indices\n    _idx = _array_oracle_end_state__indices\n    _source_g = _array_default_neurons_g[_idx]\n    _source_not_refractory = _array_default_neurons_not_refractory[_idx]\n    _source_v = _array_default_neurons_v[_idx]\n    _source_lastspike = _array_default_neurons_lastspike[_idx]\n    _to_record_v = _source_v\n    _to_record_g = _source_g\n    _to_record_lastspike = _source_lastspike\n    _to_record_not_refractory = _source_not_refractory\n    _dynamic_array_oracle_end_state_v[-1, :] = _to_record_v\n    _dynamic_array_oracle_end_state_g[-1, :] = _to_record_g\n    _dynamic_array_oracle_end_state_lastspike[-1, :] = _to_record_lastspike\n    _dynamic_array_oracle_end_state_not_refractory[-1, :] = _to_record_not_refractory\n",
+        "name": "oracle_end_state_codeobject_1"
+      }
+    ],
+    "name": "oracle_end_state",
+    "order": 0,
+    "type": "StateMonitor",
+    "when": "end"
+  }
+]
@@ -0,0 +1,48 @@
+{
+  "all_neurons_keep_original_rfc": true,
+  "completeness_sha256": "d8163907696aec1bf853ecccbe301c50efb4abd5b1c76b9a3dfa34f0e9e36c20",
+  "connectivity_sha256": "87dfbd207929725101477715d0684af71971d93cb279c3e195704b2b939b3f86",
+  "dt_ms": 0.1,
+  "parameter_checks": {
+    "membrane_tau_ms": {
+      "author": 20.0,
+      "case": 20.0
+    },
+    "refractory_ms": {
+      "author": 2.2,
+      "case": 2.2
+    },
+    "reset_potential_mv": {
+      "author": -52.0,
+      "case": -52.0
+    },
+    "resting_potential_mv": {
+      "author": -52.0,
+      "case": -52.0
+    },
+    "synaptic_delay_ms": {
+      "author": 1.8,
+      "case": 1.8
+    },
+    "synaptic_tau_ms": {
+      "author": 5.0,
+      "case": 5.0
+    },
+    "threshold_mv": {
+      "author": -45.0,
+      "case": -45.0
+    },
+    "w_syn_mv_per_anatomical_synapse": {
+      "author": 0.275,
+      "case": 0.275
+    }
+  },
+  "poisson_helper_used": false,
+  "precision": "float32",
+  "queue_trace_enabled": false,
+  "request_interface": "before_thresholds; v=v_th+1mV only if not_refractory",
+  "source_parameters_modified": false,
+  "source_sha256": "fc45837d7122c6ce2a7f3f2f23c515992e4b232aadb919efabb72337fac88e4e",
+  "state_units": "SI volts, original dtype",
+  "steps": 600
+}
@@ -0,0 +1,11 @@
+{
+  "accepted_due_events": 0,
+  "advance_calls": 0,
+  "all_due_events_preserved": null,
+  "due_events": 0,
+  "installations": [],
+  "ordering": "raw anatomical queue.peek local edge-index sequence; no sorting or filtering",
+  "peek_calls": 0,
+  "proxy_contract": "peek returns original object; advance and all other methods forward unchanged",
+  "trace_enabled": false
+}
@@ -0,0 +1,11 @@
+{
+  "schedule": [
+    "start",
+    "groups",
+    "thresholds",
+    "synapses",
+    "resets",
+    "end"
+  ],
+  "summary": "                    object                      |                  part of                  |       Clock dt       |       when        | order | active\n------------------------------------------------+-------------------------------------------+----------------------+-------------------+-------+-------\ndefault_neurons_stateupdater (StateUpdater)     | default_neurons (NeuronGroup)             | 100. us (every step) | groups            |     0 |  yes  \noracle_common_requests (NetworkOperation)       | --                                        | 100. us (every step) | before_thresholds |     0 |  yes  \ndefault_neurons_spike_thresholder (Thresholder) | default_neurons (NeuronGroup)             | 100. us (every step) | thresholds        |     0 |  yes  \nzz_external_sources (SpikeGeneratorGroup)       | zz_external_sources (SpikeGeneratorGroup) | 100. us (every step) | thresholds        |     0 |  yes  \nspikemonitor (SpikeMonitor)                     | spikemonitor (SpikeMonitor)               | 100. us (every step) | thresholds        |     1 |  yes  \ndefault_synapses_pre (SynapticPathway)          | default_synapses (Synapses)               | 100. us (every step) | synapses          |    -1 |  yes  \nzz_external_arrivals_pre (SynapticPathway)      | zz_external_arrivals (Synapses)           | 100. us (every step) | synapses          |     0 |  yes  \ndefault_neurons_spike_resetter (Resetter)       | default_neurons (NeuronGroup)             | 100. us (every step) | resets            |     0 |  yes  \noracle_end_state (StateMonitor)                 | oracle_end_state (StateMonitor)           | 100. us (every step) | end               |     0 |  yes  "
+}