From fae3ea1cda0b1462b57e431a503a8719bbee703d Mon Sep 17 00:00:00 2001
From: Jannik Luboeinski <33398515+jlubo@users.noreply.github.com>
Date: Thu, 25 Apr 2024 09:03:49 +0200
Subject: [PATCH 1/2] ATRLIF neuron model (#846)

* added process and CPU process models of ATRLIF neuron; added a Jupyter notebook to demonstrate the properties of the ATRLIF neuron

* testing of the tutorial

* tests for process and model added; copyright notes added; cleanup

* codacy-related fixed

* comment formatting and copyright notices adjusted
---
 .gitignore                                    |   2 +
 src/lava/proc/atrlif/models.py                | 267 +++++++
 src/lava/proc/atrlif/process.py               | 138 ++++
 tests/lava/proc/atrlif/__init__.py            |   0
 tests/lava/proc/atrlif/test_models.py         | 696 ++++++++++++++++++
 tests/lava/proc/atrlif/test_process.py        |  43 ++
 tests/lava/tutorials/test_tutorials.py        |   8 +-
 .../tutorial12_adaptive_neurons.ipynb         | 329 +++++++++
 8 files changed, 1482 insertions(+), 1 deletion(-)
 create mode 100644 src/lava/proc/atrlif/models.py
 create mode 100644 src/lava/proc/atrlif/process.py
 create mode 100644 tests/lava/proc/atrlif/__init__.py
 create mode 100644 tests/lava/proc/atrlif/test_models.py
 create mode 100644 tests/lava/proc/atrlif/test_process.py
 create mode 100644 tutorials/in_depth/tutorial12_adaptive_neurons.ipynb

diff --git a/.gitignore b/.gitignore
index cd5d1d84b..7d71837a3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -145,3 +145,5 @@ dmypy.json
 .idea/
 .vscode/
 .history/
+.flakeheaven_cache/
+tutorials/in_depth/results/
diff --git a/src/lava/proc/atrlif/models.py b/src/lava/proc/atrlif/models.py
new file mode 100644
index 000000000..bb2aa1c9d
--- /dev/null
+++ b/src/lava/proc/atrlif/models.py
@@ -0,0 +1,267 @@
+# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024 Jannik Luboeinski
+# SPDX-License-Identifier: BSD-3-Clause
+# See: https://spdx.org/licenses/
+
+import numpy as np
+from lava.magma.core.sync.protocols.loihi_protocol import LoihiProtocol
+from lava.magma.core.model.py.ports import PyInPort, PyOutPort
+from lava.magma.core.model.py.type import LavaPyType
+from lava.magma.core.resources import CPU
+from lava.magma.core.decorator import implements, requires, tag
+from lava.magma.core.model.py.model import PyLoihiProcessModel
+
+from lava.proc.atrlif.process import ATRLIF
+
+
+@implements(proc=ATRLIF, protocol=LoihiProtocol)
+@requires(CPU)
+@tag("floating_pt")
+class PyATRLIFModelFloat(PyLoihiProcessModel):
+    """
+    Implementation of Adaptive Threshold and Refractoriness Leaky-Integrate-
+    and-Fire neuron process in floating-point precision. This short and simple
+    ProcessModel can be used for quick algorithmic prototyping, without
+    engaging with the nuances of a fixed-point implementation.
+    """
+    a_in: PyInPort = LavaPyType(PyInPort.VEC_DENSE, float)
+    s_out = None
+    i: np.ndarray = LavaPyType(np.ndarray, float)
+    v: np.ndarray = LavaPyType(np.ndarray, float)
+    theta: np.ndarray = LavaPyType(np.ndarray, float)
+    r: np.ndarray = LavaPyType(np.ndarray, float)
+    s: np.ndarray = LavaPyType(np.ndarray, bool)
+    bias_mant: np.ndarray = LavaPyType(np.ndarray, float)
+    bias_exp: np.ndarray = LavaPyType(np.ndarray, float)
+    delta_i: float = LavaPyType(float, float)
+    delta_v: float = LavaPyType(float, float)
+    delta_theta: float = LavaPyType(float, float)
+    delta_r: float = LavaPyType(float, float)
+    theta_0: float = LavaPyType(float, float)
+    theta_step: float = LavaPyType(float, float)
+    s_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, float)
+
+    def __init__(self, proc_params):
+        super(PyATRLIFModelFloat, self).__init__(proc_params)
+
+    def subthr_dynamics(self, activation_in: np.ndarray):
+        """
+        Sub-threshold dynamics for the model:
+          i[t] = (1-delta_i)*i[t-1] + x[t]
+          v[t] = (1-delta_v)*v[t-1] + i[t] + bias_mant
+          theta[t] = (1-delta_theta)*(theta[t-1] - theta_0) + theta_0
+          r[t] = (1-delta_r)*r[t-1]
+        """
+        self.i[:] = (1 - self.delta_i) * self.i + activation_in
+        self.v[:] = (1 - self.delta_v) * self.v + self.i + self.bias_mant
+        self.theta[:] = (1 - self.delta_theta) * (self.theta - self.theta_0) \
+            + self.theta_0
+        self.r[:] = (1 - self.delta_r) * self.r
+
+    def post_spike(self, spike_vector: np.ndarray):
+        """
+        Post spike/refractory behavior:
+          r[t] = r[t] + 2*theta[t]
+          theta[t] = theta[t] + theta_step
+        """
+        # For spiking neurons, set new values for refractory state and
+        # threshold
+        r_spiking = self.r[spike_vector]
+        theta_spiking = self.theta[spike_vector]
+        self.r[spike_vector] = r_spiking + 2 * theta_spiking
+        self.theta[spike_vector] = theta_spiking + self.theta_step
+
+    def run_spk(self):
+        """
+        The run function that performs the actual computation. Processes spike
+        events that occur if (v[t] - r[t]) >= theta[t].
+        """
+        # Receive synaptic input
+        a_in_data = self.a_in.recv()
+
+        # Perform the sub-threshold and spike computations
+        self.subthr_dynamics(activation_in=a_in_data)
+        self.s[:] = (self.v - self.r) >= self.theta
+        self.post_spike(spike_vector=self.s)
+        self.s_out.send(self.s)
+
+
+@implements(proc=ATRLIF, protocol=LoihiProtocol)
+@requires(CPU)
+@tag("bit_accurate_loihi", "fixed_pt")
+class PyATRLIFModelFixed(PyLoihiProcessModel):
+    """
+    Implementation of Adaptive Threshold and Refractoriness Leaky-Integrate-
+    and-Fire neuron process in fixed-point precision, bit-by-bit mimicking the
+    fixed-point computation behavior of Loihi 2.
+    """
+    a_in: PyInPort = LavaPyType(PyInPort.VEC_DENSE, np.int16, precision=16)
+    i: np.ndarray = LavaPyType(np.ndarray, np.int32, precision=24)
+    v: np.ndarray = LavaPyType(np.ndarray, np.int32, precision=24)
+    theta: np.ndarray = LavaPyType(np.ndarray, np.int32, precision=24)
+    r: np.ndarray = LavaPyType(np.ndarray, np.int32, precision=24)
+    s: np.ndarray = LavaPyType(np.ndarray, bool)
+    bias_mant: np.ndarray = LavaPyType(np.ndarray, np.int16, precision=13)
+    bias_exp: np.ndarray = LavaPyType(np.ndarray, np.int16, precision=3)
+    delta_i: int = LavaPyType(int, np.uint16, precision=12)
+    delta_v: int = LavaPyType(int, np.uint16, precision=12)
+    delta_theta: int = LavaPyType(int, np.uint16, precision=12)
+    delta_r: int = LavaPyType(int, np.uint16, precision=12)
+    theta_0: int = LavaPyType(int, np.uint16, precision=12)
+    theta_step: int = LavaPyType(int, np.uint16, precision=12)
+    s_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, np.int32, precision=24)
+
+    def __init__(self, proc_params):
+        super(PyATRLIFModelFixed, self).__init__(proc_params)
+
+        # The `ds_offset` constant enables setting decay constant values to
+        # exact 4096 = 2**12. Without it, the range of 12-bit unsigned
+        # `delta_i` is 0 to 4095.
+        self.ds_offset = 1
+        self.isthrscaled = False
+        self.effective_bias = 0
+        # State variables i and v are 24 bits wide
+        self.iv_bitwidth = 24
+        self.max_iv_val = 2**(self.iv_bitwidth - 1)
+        # Decays need an MSB alignment by 12 bits
+        self.decay_shift = 12
+        self.decay_unity = 2**self.decay_shift
+        # Threshold and incoming activation are MSB-aligned by 6 bits
+        self.theta_unity = 2**6
+        self.act_unity = 2**6
+
+    def subthr_dynamics(self, activation_in: np.ndarray):
+        """
+        Sub-threshold dynamics for the model:
+          i[t] = (1-delta_i)*i[t-1] + x[t]
+          v[t] = (1-delta_v)*v[t-1] + i[t] + bias_mant
+          theta[t] = (1-delta_theta)*(theta[t-1] - theta_0) + theta_0
+          r[t] = (1-delta_r)*r[t-1]
+        """
+        # Update current
+        # --------------
+        # Multiplication is done for left shifting, offset is added
+        decay_const_i = self.delta_i * self.decay_unity + self.ds_offset
+        # Below, i is promoted to int64 to avoid overflow of the product
+        # between i and decay constant beyond int32.
+        # Subsequent right shift by 12 brings us back within 24-bits (and
+        # hence, within 32-bits).
+        i_decayed = np.int64(self.i * (self.decay_unity - decay_const_i))
+        i_decayed = np.sign(i_decayed) * np.right_shift(
+            np.abs(i_decayed), self.decay_shift
+        )
+        # Multiplication is done for left shifting (to account for MSB
+        # alignment done by the hardware).
+        activation_in = activation_in * self.act_unity
+        # Add synaptic input to decayed current
+        i_updated = np.int32(i_decayed + activation_in)
+        # Check if value of current is within bounds of 24-bit. Overflows are
+        # handled by wrapping around modulo.
+        # 2 ** 23. E.g., (2 ** 23) + k becomes k and -(2**23 + k) becomes -k
+        wrapped_curr = np.where(
+            i_updated > self.max_iv_val,
+            i_updated - 2 * self.max_iv_val,
+            i_updated,
+        )
+        wrapped_curr = np.where(
+            wrapped_curr <= -self.max_iv_val,
+            i_updated + 2 * self.max_iv_val,
+            wrapped_curr,
+        )
+        self.i[:] = wrapped_curr
+
+        # Update voltage (proceeding similar to current update)
+        # -----------------------------------------------------
+        decay_const_v = self.delta_v * self.decay_unity
+        neg_voltage_limit = -np.int32(self.max_iv_val) + 1
+        pos_voltage_limit = np.int32(self.max_iv_val) - 1
+        v_decayed = np.int64(self.v) * np.int64(self.decay_unity
+                                                - decay_const_v)
+        v_decayed = np.sign(v_decayed) * np.right_shift(
+            np.abs(v_decayed), self.decay_shift
+        )
+        v_updated = np.int32(v_decayed + self.i + self.effective_bias)
+        self.v[:] = np.clip(v_updated, neg_voltage_limit, pos_voltage_limit)
+
+        # Update threshold (proceeding similar to current update)
+        # -------------------------------------------------------
+        decay_const_theta = self.delta_theta * self.decay_unity
+        theta_diff_decayed = np.int64(self.theta - self.theta_0) * \
+            np.int64(self.decay_unity - decay_const_theta)
+        theta_diff_decayed = np.sign(theta_diff_decayed) * np.right_shift(
+            np.abs(theta_diff_decayed), self.decay_shift
+        )
+        self.theta[:] = np.int32(theta_diff_decayed) + self.theta_0
+        # TODO do clipping here?
+
+        # Update refractoriness (decaying similar to current)
+        # ---------------------------------------------------
+        decay_const_r = self.delta_r * self.decay_unity
+        r_decayed = np.int64(self.r) * np.int64(self.decay_unity
+                                                - decay_const_r)
+        r_decayed = np.sign(r_decayed) * np.right_shift(
+            np.abs(r_decayed), self.decay_shift
+        )
+        self.r[:] = np.int32(r_decayed)
+        # TODO do clipping here?
+
+    def scale_bias(self):
+        """
+        Scale bias with bias exponent by taking into account sign of the
+        exponent.
+        """
+        # Create local copy of `bias_mant` with promoted dtype to prevent
+        # overflow when applying shift of `bias_exp`.
+        bias_mant = self.bias_mant.copy().astype(np.int32)
+        self.effective_bias = np.where(
+            self.bias_exp >= 0,
+            np.left_shift(bias_mant, self.bias_exp),
+            np.right_shift(bias_mant, -self.bias_exp),
+        )
+
+    def scale_threshold(self):
+        """
+        Scale threshold according to the way Loihi hardware scales it. In Loihi
+        hardware, threshold is left-shifted by 6-bits to MSB-align it with
+        other state variables of higher precision.
+        """
+        # Multiplication is done for left shifting
+        self.theta_0 = np.int32(self.theta_0 * self.theta_unity)
+        self.theta = np.full(self.theta.shape, self.theta_0)
+        self.theta_step = np.int32(self.theta_step * self.theta_unity)
+        self.isthrscaled = True
+
+    def post_spike(self, spike_vector: np.ndarray):
+        """
+        Post spike/refractory behavior:
+          r[t] = r[t] + 2*theta[t]
+          theta[t] = theta[t] + theta_step
+        """
+        # For spiking neurons, set new values for refractory state and
+        # threshold.
+        r_spiking = self.r[spike_vector]
+        theta_spiking = self.theta[spike_vector]
+        self.r[spike_vector] = r_spiking + 2 * theta_spiking
+        self.theta[spike_vector] = theta_spiking + self.theta_step
+
+    def run_spk(self):
+        """
+        The run function that performs the actual computation. Processes spike
+        events that occur if (v[t] - r[t]) >= theta[t].
+        """
+        # Receive synaptic input
+        a_in_data = self.a_in.recv()
+
+        # Compute effective bias
+        self.scale_bias()
+
+        # Compute scaled threshold-related variables only once, not every
+        # timestep (has to be done once after object construction).
+        if not self.isthrscaled:
+            self.scale_threshold()
+
+        # Perform the sub-threshold and spike computations
+        self.subthr_dynamics(activation_in=a_in_data)
+        self.s[:] = (self.v - self.r) >= self.theta
+        self.post_spike(spike_vector=self.s)
+        self.s_out.send(self.s)
diff --git a/src/lava/proc/atrlif/process.py b/src/lava/proc/atrlif/process.py
new file mode 100644
index 000000000..1f5bf8152
--- /dev/null
+++ b/src/lava/proc/atrlif/process.py
@@ -0,0 +1,138 @@
+# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024 Jannik Luboeinski
+# SPDX-License-Identifier: BSD-3-Clause
+# See: https://spdx.org/licenses/
+
+import numpy as np
+import typing as ty
+
+from lava.magma.core.process.process import AbstractProcess, LogConfig
+from lava.magma.core.process.variable import Var
+from lava.magma.core.process.ports.ports import InPort, OutPort
+
+
+class ATRLIF(AbstractProcess):
+    """
+    Adaptive Threshold and Refractoriness Leaky-Integrate-and-Fire Process.
+    With activation input port `a_in` and spike output port `s_out`.
+
+    Note that non-integer parameter values are supported, but can lead to
+    deviating results in models that employ fixed-point computation.
+
+    Dynamics (cf. https://github.com/lava-nc/lava-dl/blob/main/src/lava/lib/dl/
+                          slayer/neuron/alif.py,
+                  https://github.com/lava-nc/lava-dl/blob/main/tutorials/lava/
+                          lib/dl/slayer/neuron_dynamics/dynamics.ipynb):
+      i[t] = (1-delta_i)*i[t-1] + x[t]
+      v[t] = (1-delta_v)*v[t-1] + i[t] + bias
+      theta[t] = (1-delta_theta)*(theta[t-1] - theta_0) + theta_0
+      r[t] = (1-delta_r)*r[t-1]
+
+    Spike event:
+      s[t] = (v[t] - r[t]) >= theta[t]
+
+    Post spike event:
+      r[t] = r[t] + 2*theta[t]
+      theta[t] = theta[t] + theta_step
+
+    Parameters
+    ----------
+    shape : tuple(int)
+        Number and topology of LIF neurons.
+    i : float, list, numpy.ndarray, optional
+        Initial value of the neuron's current.
+    v : float, list, numpy.ndarray, optional
+        Initial value of the neuron's voltage (membrane potential).
+    theta : float, list, numpy.ndarray, optional
+        Initial value of the threshold
+    r : float, list, numpy.ndarray, optional
+        Initial value of the refractory state
+    s : bool, list, numpy.ndarray, optional
+        Initial spike state
+    delta_i : float, optional
+        Decay constant for current i.
+    delta_v : float, optional
+        Decay constant for voltage v.
+    delta_theta : float, optional
+        Decay constant for threshold theta.
+    delta_r : float, optional
+        Decay constant for refractory state r.
+    theta_0 : float, optional
+        Initial/baselien value of threshold theta.
+    theta_step : float, optional
+        Increase of threshold theta upon the occurrence of a spike.
+    bias_mant : float, list, numpy.ndarray, optional
+        Mantissa part of the neuron's bias.
+    bias_exp : float, list, numpy.ndarray, optional
+        Exponent part of the neuron's bias, if needed. Mostly for fixed-point
+        implementations. Ignored for floating-point implementations.
+
+    Example
+    -------
+    >>> atrlif = ATRLIF(shape=(200, 15), decay_theta=10, decay_v=5)
+    This will create 200x15 ATRLIF neurons that all have the same threshold
+    decay of 10 and voltage decay of 5.
+    """
+
+    def __init__(
+        self,
+        *,
+        shape: ty.Tuple[int, ...],
+        i: ty.Optional[ty.Union[float, list, np.ndarray]] = 0,
+        v: ty.Optional[ty.Union[float, list, np.ndarray]] = 0,
+        theta: ty.Optional[ty.Union[float, list, np.ndarray]] = 5,
+        r: ty.Optional[ty.Union[float, list, np.ndarray]] = 0,
+        s: ty.Optional[ty.Union[bool, list, np.ndarray]] = 0,
+        delta_i: ty.Optional[float] = 0.4,
+        delta_v: ty.Optional[float] = 0.4,
+        delta_theta: ty.Optional[float] = 0.2,
+        delta_r: ty.Optional[float] = 0.2,
+        theta_0: ty.Optional[float] = 5,
+        theta_step: ty.Optional[float] = 3.75,
+        bias_mant: ty.Optional[ty.Union[float, list, np.ndarray]] = 0,
+        bias_exp: ty.Optional[ty.Union[float, list, np.ndarray]] = 0,
+        name: ty.Optional[str] = None,
+        log_config: ty.Optional[LogConfig] = None
+    ) -> None:
+
+        super().__init__(
+            shape=shape,
+            i=i,
+            v=v,
+            theta=theta,
+            r=r,
+            s=s,
+            delta_i=delta_i,
+            delta_v=delta_v,
+            delta_theta=delta_theta,
+            delta_r=delta_r,
+            theta_0=theta_0,
+            theta_step=theta_step,
+            bias_mant=bias_mant,
+            bias_exp=bias_exp,
+            name=name,
+            log_config=log_config
+        )
+
+        # Ports
+        self.a_in = InPort(shape=shape)
+        self.s_out = OutPort(shape=shape)
+
+        # Bias
+        self.bias_mant = Var(shape=shape, init=bias_mant)
+        self.bias_exp = Var(shape=shape, init=bias_exp)
+
+        # Variables
+        self.i = Var(shape=shape, init=i)
+        self.v = Var(shape=shape, init=v)
+        self.theta = Var(shape=shape, init=theta)
+        self.r = Var(shape=shape, init=r)
+        self.s = Var(shape=shape, init=s)
+
+        # Parameters
+        self.delta_i = Var(shape=(1,), init=delta_i)
+        self.delta_v = Var(shape=(1,), init=delta_v)
+        self.delta_theta = Var(shape=(1,), init=delta_theta)
+        self.delta_r = Var(shape=(1,), init=delta_r)
+        self.theta_0 = Var(shape=(1,), init=theta_0)
+        self.theta_step = Var(shape=(1,), init=theta_step)
diff --git a/tests/lava/proc/atrlif/__init__.py b/tests/lava/proc/atrlif/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/lava/proc/atrlif/test_models.py b/tests/lava/proc/atrlif/test_models.py
new file mode 100644
index 000000000..6db21b91f
--- /dev/null
+++ b/tests/lava/proc/atrlif/test_models.py
@@ -0,0 +1,696 @@
+# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024 Jannik Luboeinski
+# SPDX-License-Identifier: BSD-3-Clause
+# See: https://spdx.org/licenses/
+
+import unittest
+import numpy as np
+
+from lava.magma.core.decorator import implements, requires, tag
+from lava.magma.core.model.py.model import PyLoihiProcessModel
+from lava.magma.core.model.py.ports import PyOutPort, PyInPort
+from lava.magma.core.model.py.type import LavaPyType
+from lava.magma.core.process.ports.ports import OutPort, InPort
+from lava.magma.core.process.process import AbstractProcess
+from lava.magma.core.process.variable import Var
+from lava.magma.core.resources import CPU
+from lava.magma.core.run_configs import RunConfig
+from lava.magma.core.run_conditions import RunSteps
+from lava.magma.core.sync.protocols.loihi_protocol import LoihiProtocol
+from lava.proc.atrlif.process import ATRLIF
+
+
+class AtrlifRunConfig(RunConfig):
+    """Run configuration selects appropriate ATRLIF ProcessModel based on tag:
+    floating point precision or Loihi bit-accurate fixed point precision"""
+    def __init__(self, custom_sync_domains=None, select_tag='fixed_pt'):
+        super().__init__(custom_sync_domains=custom_sync_domains)
+        self.select_tag = select_tag
+
+    def select(self, proc, proc_models):
+        for pm in proc_models:
+            if self.select_tag in pm.tags:
+                return pm
+        raise AssertionError("No legal ProcessModel found.")
+
+
+class VecSendProcess(AbstractProcess):
+    """
+    Process of a user-defined shape that sends an arbitrary vector
+
+    Parameters
+    ----------
+    shape: tuple, shape of the process
+    vec_to_send: np.ndarray, vector of spike values to send
+    send_at_times: np.ndarray, vector bools. Send the `vec_to_send` at times
+    when there is a True
+    """
+    def __init__(self, **kwargs):
+        super().__init__()
+        shape = kwargs.pop("shape", (1,))
+        vec_to_send = kwargs.pop("vec_to_send")
+        send_at_times = kwargs.pop("send_at_times")
+        num_steps = kwargs.pop("num_steps", 1)
+        self.shape = shape
+        self.num_steps = num_steps
+        self.vec_to_send = Var(shape=shape, init=vec_to_send)
+        self.send_at_times = Var(shape=(num_steps,), init=send_at_times)
+        self.s_out = OutPort(shape=shape)
+
+
+class VecRecvProcess(AbstractProcess):
+    """
+    Process that receives arbitrary vectors
+
+    Parameters
+    ----------
+    shape: tuple, shape of the process
+    """
+    def __init__(self, **kwargs):
+        super().__init__()
+        shape = kwargs.get("shape", (1,))
+        self.shape = shape
+        self.s_in = InPort(shape=(shape[1],))
+        self.spk_data = Var(shape=shape, init=0)  # This Var expands with time
+
+
+@implements(proc=VecSendProcess, protocol=LoihiProtocol)
+@requires(CPU)
+# Following tag is needed to discover the ProcessModel using AtrlifRunConfig
+@tag('floating_pt')
+class PyVecSendModelFloat(PyLoihiProcessModel):
+    s_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, float)
+    vec_to_send: np.ndarray = LavaPyType(np.ndarray, float)
+    send_at_times: np.ndarray = LavaPyType(np.ndarray, bool, precision=1)
+
+    def run_spk(self):
+        """
+        Send `spikes_to_send` if current time-step requires it
+        """
+        if self.send_at_times[self.time_step - 1]:
+            self.s_out.send(self.vec_to_send)
+        else:
+            self.s_out.send(np.zeros_like(self.vec_to_send))
+
+
+@implements(proc=VecSendProcess, protocol=LoihiProtocol)
+@requires(CPU)
+# Following tag is needed to discover the ProcessModel using AtrlifRunConfig
+@tag('fixed_pt')
+class PyVecSendModelFixed(PyLoihiProcessModel):
+    s_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, np.int16, precision=16)
+    vec_to_send: np.ndarray = LavaPyType(np.ndarray, np.int16, precision=16)
+    send_at_times: np.ndarray = LavaPyType(np.ndarray, bool, precision=1)
+
+    def run_spk(self):
+        """
+        Send `spikes_to_send` if current time-step requires it
+        """
+        if self.send_at_times[self.time_step - 1]:
+            self.s_out.send(self.vec_to_send)
+        else:
+            self.s_out.send(np.zeros_like(self.vec_to_send))
+
+
+@implements(proc=VecRecvProcess, protocol=LoihiProtocol)
+@requires(CPU)
+# Following tag is needed to discover the ProcessModel using AtrlifRunConfig
+@tag('floating_pt')
+class PySpkRecvModelFloat(PyLoihiProcessModel):
+    s_in: PyInPort = LavaPyType(PyInPort.VEC_DENSE, bool, precision=1)
+    spk_data: np.ndarray = LavaPyType(np.ndarray, float)
+
+    def run_spk(self):
+        """Receive spikes and store in an internal variable"""
+        spk_in = self.s_in.recv()
+        self.spk_data[self.time_step - 1, :] = spk_in
+
+
+@implements(proc=VecRecvProcess, protocol=LoihiProtocol)
+@requires(CPU)
+# Following tag is needed to discover the ProcessModel using AtrlifRunConfig
+@tag('fixed_pt')
+class PySpkRecvModelFixed(PyLoihiProcessModel):
+    s_in: PyInPort = LavaPyType(PyInPort.VEC_DENSE, bool, precision=1)
+    spk_data: np.ndarray = LavaPyType(np.ndarray, int, precision=1)
+
+    def run_spk(self):
+        """Receive spikes and store in an internal variable"""
+        spk_in = self.s_in.recv()
+        self.spk_data[self.time_step - 1, :] = spk_in
+
+
+class TestATRLIFProcessModelsFloat(unittest.TestCase):
+    """
+    Tests for floating point ProcessModels of ATRLIF, resembling the
+    existing tests for the LIF process.
+    """
+    def test_float_pm_no_decay(self):
+        """
+        Tests floating point ATRLIF ProcessModel with no current or voltage
+        decay and neurons driven by internal biases.
+        """
+        shape = (10,)
+        num_steps = 50
+        # Set up external input to 0
+        sps = VecSendProcess(shape=shape, num_steps=num_steps,
+                             vec_to_send=np.zeros(shape, dtype=float),
+                             send_at_times=np.ones((num_steps,), dtype=bool))
+        # `delta_i` and `delta_v` = 0 => bias driven neurons spike first after
+        # `theta_0 / bias` time steps, then less often due to the refractor-
+        # iness. For the test implementation below, `theta_0` has to be a
+        # multiple of `bias`.
+        bias = 2
+        theta_0 = 4
+        neur = ATRLIF(shape=shape,
+                      delta_i=0.,
+                      delta_v=0.,
+                      delta_theta=0.,
+                      delta_r=0.,
+                      theta_0=theta_0,
+                      theta=theta_0,
+                      theta_step=0.,
+                      bias_mant=bias * np.ones(shape, dtype=float))
+        # Receive neuron spikes
+        spr = VecRecvProcess(shape=(num_steps, shape[0]))
+        sps.s_out.connect(neur.a_in)
+        neur.s_out.connect(spr.s_in)
+        # Configure execution and run
+        rcnd = RunSteps(num_steps=num_steps)
+        rcfg = AtrlifRunConfig(select_tag='floating_pt')
+        neur.run(condition=rcnd, run_cfg=rcfg)
+        # Gather spike data and stop
+        spk_data_through_run = spr.spk_data.get()
+        neur.stop()
+        # Compute the number of time steps until the first spike
+        t_spike_0 = theta_0 // bias
+        # Compute the following number of time steps until the second spike
+        # (according to `bias * (t_spike_0 + t_spike_refr) - 2 * theta_0 >=
+        # theta_0`)
+        t_spike_refr = 3 * theta_0 // bias - t_spike_0
+        # Gold standard for the test
+        expected_spk_data = np.zeros((t_spike_0 + t_spike_refr + 1, shape[0]))
+        expected_spk_data[t_spike_0 - 1:t_spike_0 + t_spike_refr + 1:
+                          t_spike_refr, :] = 1.
+        spk_data_through_run_needed = \
+            spk_data_through_run[0:t_spike_0 + t_spike_refr + 1, :]
+        self.assertTrue(np.all(expected_spk_data
+                               == spk_data_through_run_needed))
+
+    def test_float_pm_impulse_delta_i(self):
+        """
+        Tests floating point ATRLIF ProcessModel's impulse response with no
+        voltage decay and input activation at the very first time-step.
+        """
+        # Use a single neuron
+        shape = (1,)
+        num_steps = 8
+        # Send activation of 128. at timestep = 1
+        sps = VecSendProcess(shape=shape, num_steps=num_steps,
+                             vec_to_send=(2 ** 7) * np.ones(shape,
+                                                            dtype=float),
+                             send_at_times=np.array([True, False, False,
+                                                     False, False, False,
+                                                     False, False]))
+        # Set up no bias, no voltage decay. Current decay = 0.5.
+        # Set up high constant threshold, such that there are no output spikes.
+        neur = ATRLIF(shape=shape,
+                      delta_i=0.5,
+                      delta_v=0.,
+                      delta_theta=0.,
+                      delta_r=0.,
+                      theta_0=256.,
+                      theta=256.,
+                      theta_step=0.,
+                      bias_mant=np.zeros(shape, dtype=float))
+        spr = VecRecvProcess(shape=(num_steps, shape[0]))
+        sps.s_out.connect(neur.a_in)
+        neur.s_out.connect(spr.s_in)
+        # Configure to run 1 step at a time
+        rcnd = RunSteps(num_steps=1)
+        rcfg = AtrlifRunConfig(select_tag='floating_pt')
+        neur_i = []
+        # Run 1 timestep at a time and collect state variable i
+        for _ in range(num_steps):
+            neur.run(condition=rcnd, run_cfg=rcfg)
+            neur_i.append(neur.i.get()[0])
+        neur.stop()
+        # Gold standard for testing: current decay of 0.5 should halve the
+        # current every time-step
+        expected_i_timeseries = [2. ** (7 - j) for j in range(8)]
+        self.assertListEqual(expected_i_timeseries, neur_i)
+
+    def test_float_pm_impulse_delta_v(self):
+        """
+        Tests floating point ATRLIF ProcessModel's impulse response with no
+        current decay and input activation at the very first time-step.
+        """
+        # Use a single neuron
+        shape = (1,)
+        num_steps = 8
+        # Send activation of 128. at timestep = 1
+        sps = VecSendProcess(shape=shape, num_steps=num_steps,
+                             vec_to_send=(2 ** 7) * np.ones(shape,
+                                                            dtype=float),
+                             send_at_times=np.array([True, False, False,
+                                                     False, False, False,
+                                                     False, False]))
+        # Set up no bias, no current decay. Voltage decay = 0.5.
+        # Set up high constant threshold, such that there are no output spikes.
+        neur = ATRLIF(shape=shape,
+                      delta_i=0.,
+                      delta_v=0.5,
+                      delta_theta=0.,
+                      delta_r=0.,
+                      theta_0=256.,
+                      theta=256.,
+                      theta_step=0.,
+                      bias_mant=np.zeros(shape, dtype=float))
+        spr = VecRecvProcess(shape=(num_steps, shape[0]))
+        sps.s_out.connect(neur.a_in)
+        neur.s_out.connect(spr.s_in)
+        # Configure to run 1 step at a time
+        rcnd = RunSteps(num_steps=1)
+        rcfg = AtrlifRunConfig(select_tag='floating_pt')
+        neur_v = []
+        # Run 1 timestep at a time and collect state variable v
+        for _ in range(num_steps):
+            neur.run(condition=rcnd, run_cfg=rcfg)
+            neur_v.append(neur.v.get()[0])
+        neur.stop()
+        # Gold standard for testing: voltage decay of 0.5 should integrate
+        # the voltage from 128. to 255., with steps of 64., 32., 16., etc.
+        expected_v_timeseries = [128., 192., 224., 240.,
+                                 248., 252., 254., 255.]
+        self.assertListEqual(expected_v_timeseries, neur_v)
+
+    def test_float_pm_instant_theta_decay(self):
+        """
+        Tests floating point ATRLIF ProcessModel's behavior for instant decay
+        of the threshold variable in the presence of constant bias.
+        """
+        # Use a single neuron
+        shape = (1,)
+        num_steps = 20
+        # Set up external input to 0
+        sps = VecSendProcess(shape=shape, num_steps=num_steps,
+                             vec_to_send=np.zeros(shape, dtype=float),
+                             send_at_times=np.ones((num_steps,), dtype=bool))
+        # `delta_i` and `delta_v` = 0 => bias driven neurons spike first after
+        # `theta_0 / bias` time steps, then less often due to the refractor-
+        # iness. For the test implementation below, `theta_0` has to be a
+        # multiple of `bias`. Following a spike, the threshold `theta` is
+        # increased tremendously (by 10.), but this remains without effect
+        # due to the instant decay (`delta_theta=1.`).
+        bias = 2
+        theta_0 = 4
+        neur = ATRLIF(shape=shape,
+                      delta_i=0.,
+                      delta_v=0.,
+                      delta_theta=1.,
+                      delta_r=0.,
+                      theta_0=theta_0,
+                      theta=theta_0,
+                      theta_step=10.,
+                      bias_mant=bias * np.ones(shape, dtype=float))
+        # Receive neuron spikes
+        spr = VecRecvProcess(shape=(num_steps, shape[0]))
+        sps.s_out.connect(neur.a_in)
+        neur.s_out.connect(spr.s_in)
+        # Configure execution and run
+        rcnd = RunSteps(num_steps=num_steps)
+        rcfg = AtrlifRunConfig(select_tag='floating_pt')
+        neur.run(condition=rcnd, run_cfg=rcfg)
+        # Gather spike data and stop
+        spk_data_through_run = spr.spk_data.get()
+        neur.stop()
+        # Compute the number of time steps until the first spike
+        t_spike_0 = theta_0 // bias
+        # Compute the following number of time steps until the second spike
+        # (according to `bias * (t_spike_0 + t_spike_refr) - 2 * theta_0 >=
+        # theta_0`)
+        t_spike_refr = 3 * theta_0 // bias - t_spike_0
+        # Gold standard for the test
+        expected_spk_data = np.zeros((t_spike_0 + t_spike_refr + 1, shape[0]))
+        expected_spk_data[t_spike_0 - 1:t_spike_0 + t_spike_refr + 1:
+                          t_spike_refr, :] = 1.
+        spk_data_through_run_needed = \
+            spk_data_through_run[0:t_spike_0 + t_spike_refr + 1, :]
+        self.assertTrue(np.all(expected_spk_data
+                               == spk_data_through_run_needed))
+
+    def test_float_pm_instant_r_decay(self):
+        """
+        Tests floating point ATRLIF ProcessModel's behavior for instant decay
+        of the refractory variable in the presence of constant bias.
+        """
+        # Use a single neuron
+        shape = (1,)
+        num_steps = 20
+        # Set up external input to 0
+        sps = VecSendProcess(shape=shape, num_steps=num_steps,
+                             vec_to_send=np.zeros(shape, dtype=float),
+                             send_at_times=np.ones((num_steps,), dtype=bool))
+        # `delta_i` and `delta_v` = 0 => bias driven neurons spike first after
+        # `theta_0 / bias` time steps. Following a spike, the threshold `theta`
+        # is automatically increased by `2 * theta`, but this remains without
+        # effect due to the instant decay (`delta_r=1.`).
+        bias = 8
+        theta_0 = 16
+        neur = ATRLIF(shape=shape,
+                      delta_i=0.,
+                      delta_v=0.,
+                      delta_theta=0.,
+                      delta_r=1.,
+                      theta_0=theta_0,
+                      theta=theta_0,
+                      theta_step=0.,
+                      bias_mant=bias * np.ones(shape, dtype=float))
+        # Receive neuron spikes
+        spr = VecRecvProcess(shape=(num_steps, shape[0]))
+        sps.s_out.connect(neur.a_in)
+        neur.s_out.connect(spr.s_in)
+        # Configure execution and run
+        rcnd = RunSteps(num_steps=num_steps)
+        rcfg = AtrlifRunConfig(select_tag='floating_pt')
+        neur.run(condition=rcnd, run_cfg=rcfg)
+        # Gather spike data and stop
+        spk_data_through_run = spr.spk_data.get()
+        neur.stop()
+        # Compute the number of time steps until the first spike
+        t_spike_0 = theta_0 // bias
+        # Compute the following number of time steps until the second spike
+        # (according to `bias * (t_spike_0 + t_spike_refr) >= theta_0`)
+        t_spike_refr = theta_0 // bias - t_spike_0 + 1
+        # Gold standard for the test
+        expected_spk_data = np.zeros((t_spike_0 + t_spike_refr + 1, shape[0]))
+        expected_spk_data[t_spike_0 - 1:t_spike_0 + t_spike_refr + 1:
+                          t_spike_refr, :] = 1.
+        spk_data_through_run_needed = \
+            spk_data_through_run[0:t_spike_0 + t_spike_refr + 1, :]
+        self.assertTrue(np.all(expected_spk_data
+                               == spk_data_through_run_needed))
+
+
+class TestATRLIFProcessModelsFixed(unittest.TestCase):
+    """
+    Tests for fixed point ProcessModels of ATRLIF (which are bit-accurate
+    with Loihi hardware), resembling the existing tests for the LIF process.
+    """
+    def test_bitacc_pm_no_decay(self):
+        """
+        Tests fixed point ATRLIF ProcessModel (bit-accurate
+        with Loihi hardware) with no current or voltage
+        decay and neurons driven by internal biases.
+        """
+        shape = (10,)
+        num_steps = 50
+        # Set up external input to 0
+        sps = VecSendProcess(shape=shape, num_steps=num_steps,
+                             vec_to_send=np.zeros(shape, dtype=np.int16),
+                             send_at_times=np.ones((num_steps,), dtype=bool))
+        # Set up bias = 2 * 2**6 = 128 and threshold = 8<<6
+        # `delta_i` and `delta_v` = 0 => bias driven neurons spike first after
+        # `theta_0 / bias` time steps, then less often due to the refractor-
+        # iness. For the test implementation below, `theta_0` has to be a
+        # multiple of `bias`.
+        bias = 4
+        theta_0 = 8
+        neur = ATRLIF(shape=shape,
+                      delta_i=0,
+                      delta_v=0,
+                      delta_theta=0,
+                      delta_r=0,
+                      theta_0=theta_0,
+                      theta=theta_0,
+                      theta_step=0,
+                      bias_mant=bias * np.ones(shape, dtype=np.int32),
+                      bias_exp=6 * np.ones(shape, dtype=np.int32))
+        # Receive neuron spikes
+        spr = VecRecvProcess(shape=(num_steps, shape[0]))
+        sps.s_out.connect(neur.a_in)
+        neur.s_out.connect(spr.s_in)
+        # Configure execution and run
+        rcnd = RunSteps(num_steps=num_steps)
+        rcfg = AtrlifRunConfig(select_tag='fixed_pt')
+        neur.run(condition=rcnd, run_cfg=rcfg)
+        # Gather spike data and stop
+        spk_data_through_run = spr.spk_data.get()
+        neur.stop()
+        # Compute the number of time steps until the first spike
+        t_spike_0 = theta_0 // bias
+        # Compute the following number of time steps until the second spike
+        # (according to `bias * (t_spike_0 + t_spike_refr) - 2 * theta_0 >=
+        # theta_0`)
+        t_spike_refr = 3 * theta_0 // bias - t_spike_0
+        # Gold standard for the test
+        expected_spk_data = np.zeros((t_spike_0 + t_spike_refr + 1, shape[0]))
+        expected_spk_data[t_spike_0 - 1:t_spike_0 + t_spike_refr + 1:
+                          t_spike_refr, :] = 1.
+        spk_data_through_run_needed = \
+            spk_data_through_run[0:t_spike_0 + t_spike_refr + 1, :]
+        self.assertTrue(np.all(expected_spk_data
+                               == spk_data_through_run_needed))
+
+    def test_bitacc_pm_impulse_delta_i(self):
+        """
+        Tests fixed point ATRLIF ProcessModel's impulse response with no
+        voltage decay and input activation at the very first time-step.
+        """
+        # Use a single neuron
+        shape = (1,)
+        num_steps = 8
+        # Send activation of 128. at timestep = 1
+        sps = VecSendProcess(shape=shape, num_steps=num_steps,
+                             vec_to_send=128 * np.ones(shape, dtype=np.int32),
+                             send_at_times=np.array([True, False, False,
+                                                     False, False, False,
+                                                     False, False]))
+        # Set up no bias, no voltage decay. Current decay is a 12-bit
+        # unsigned variable in Loihi hardware. Therefore, 2**-12 is the
+        # equivalent of 1. The subtracted 1 is added by default in the
+        # hardware via the `ds_offset` setting, thereby finally giving
+        # `delta_i = 2048 = 0.5 * 2**12`.
+        # Set up threshold high, such that there are no output spikes. By
+        # default the threshold value here is left-shifted by 6.
+        neur = ATRLIF(shape=shape,
+                      delta_i=0.5 - (2**-12),
+                      delta_v=0,
+                      delta_theta=0,
+                      delta_r=0,
+                      theta_0=256 * np.ones(shape, dtype=np.int32),
+                      theta=256 * np.ones(shape, dtype=np.int32),
+                      theta_step=0,
+                      bias_mant=np.zeros(shape, dtype=np.int16),
+                      bias_exp=np.ones(shape, dtype=np.int16))
+        spr = VecRecvProcess(shape=(num_steps, shape[0]))
+        sps.s_out.connect(neur.a_in)
+        neur.s_out.connect(spr.s_in)
+        # Configure to run 1 step at a time
+        rcnd = RunSteps(num_steps=1)
+        rcfg = AtrlifRunConfig(select_tag='fixed_pt')
+        neur_i = []
+        # Run 1 timestep at a time and collect state variable i
+        for _ in range(num_steps):
+            neur.run(condition=rcnd, run_cfg=rcfg)
+            neur_i.append(neur.i.get().astype(np.int32)[0])
+        neur.stop()
+        # Gold standard for testing: current decay of 0.5 should halve the
+        # current every time-step.
+        expected_i_timeseries = [1 << (13 - j) for j in range(8)]
+        # Gold standard for floating point equivalent of the current,
+        # which would be all Loihi-bit-accurate values right shifted by 6 bits
+        expected_float_i = [1 << (7 - j) for j in range(8)]
+        self.assertListEqual(expected_i_timeseries, neur_i)
+        self.assertListEqual(expected_float_i, np.right_shift(np.array(
+            neur_i), 6).tolist())
+
+    def test_bitacc_pm_impulse_delta_v(self):
+        """
+        Tests fixed point ATRLIF ProcessModel's impulse response with no
+        current decay and input activation at the very first time-step.
+        """
+        # Use a single neuron
+        shape = (1,)
+        num_steps = 8
+        # Send activation of 128. at timestep = 1
+        sps = VecSendProcess(shape=shape, num_steps=num_steps,
+                             vec_to_send=128 * np.ones(shape, dtype=np.int32),
+                             send_at_times=np.array([True, False, False,
+                                                     False, False, False,
+                                                     False, False]))
+        # Set up no bias, no current decay.
+        # Set up threshold high, such that there are no output spikes.
+        # Threshold provided here is left-shifted by 6-bits.
+        neur = ATRLIF(shape=shape,
+                      delta_i=0,
+                      delta_v=0.5,
+                      delta_theta=0,
+                      delta_r=0,
+                      theta_0=256 * np.ones(shape, dtype=np.int32),
+                      theta=256 * np.ones(shape, dtype=np.int32),
+                      theta_step=0,
+                      bias_mant=np.zeros(shape, dtype=np.int16),
+                      bias_exp=np.ones(shape, dtype=np.int16))
+        spr = VecRecvProcess(shape=(num_steps, shape[0]))
+        sps.s_out.connect(neur.a_in)
+        neur.s_out.connect(spr.s_in)
+        # Configure to run 1 step at a time
+        rcnd = RunSteps(num_steps=1)
+        rcfg = AtrlifRunConfig(select_tag='fixed_pt')
+        neur_v = []
+        # Run 1 timestep at a time and collect state variable u
+        for _ in range(num_steps):
+            neur.run(condition=rcnd, run_cfg=rcfg)
+            neur_v.append(neur.v.get().astype(np.int32)[0])
+        neur.stop()
+        # Gold standard for testing: with a voltage decay of 2048, voltage
+        # should integrate from 128<<6 to 255<<6. But it is slightly smaller,
+        # because current decay is not exactly 0. Due to the default
+        # ds_offset = 1 setting in the hardware, current decay = 1. So
+        # voltage is slightly smaller than 128<<6 to 255<<6.
+        expected_v_timeseries = [8192, 12286, 14331, 15351, 15859, 16111,
+                                 16235, 16295]
+        # Gold standard for floating point equivalent of the voltage,
+        # which would be all Loihi-bit-accurate values right shifted by 6 bits
+        expected_float_v = [128, 192, 224, 240, 248, 252, 254, 255]
+        neur_v_float = np.right_shift(np.array(neur_v), 6)
+        neur_v_float[1:] += 1  # This compensates the drift caused by ds_offset
+        self.assertListEqual(expected_v_timeseries, neur_v)
+        self.assertListEqual(expected_float_v, neur_v_float.tolist())
+
+    def test_bitacc_pm_scaling_of_bias(self):
+        """
+        Tests fixed point ATRLIF ProcessModel's scaling of threshold.
+        """
+        bias_mant = 2 ** 12 - 1
+        bias_exp = 5
+        # Set up high threshold and high bias current to check for potential
+        # overflow in effective bias in single neuron.
+        neur = ATRLIF(shape=(1,),
+                      delta_i=0,
+                      delta_v=0.5,
+                      delta_theta=0,
+                      delta_r=0,
+                      theta_0=2 ** 17,
+                      theta=2 ** 17,
+                      theta_step=0,
+                      bias_mant=bias_mant,
+                      bias_exp=bias_exp)
+
+        rcnd = RunSteps(num_steps=1)
+        rcfg = AtrlifRunConfig(select_tag='fixed_pt')
+
+        neur.run(condition=rcnd, run_cfg=rcfg)
+        neur_v = neur.v.get()[0]
+        neur.stop()
+
+        # Check if neur_v has correct value.
+        self.assertEqual(neur_v, bias_mant * 2 ** bias_exp)
+
+    def test_fixed_pm_instant_theta_decay(self):
+        """
+        Tests fixed point ATRLIF ProcessModel's behavior for instant decay
+        of the threshold variable in the presence of constant bias.
+        """
+        # Use a single neuron
+        shape = (1,)
+        num_steps = 20
+        # Set up external input to 0
+        sps = VecSendProcess(shape=shape, num_steps=num_steps,
+                             vec_to_send=np.zeros(shape, dtype=float),
+                             send_at_times=np.ones((num_steps,), dtype=bool))
+        # `delta_i` and `delta_v` = 0 => bias driven neurons spike first after
+        # `theta_0 / bias` time steps, then less often due to the refractor-
+        # iness. For the test implementation below, `theta_0` has to be a
+        # multiple of `bias`. Following a spike, the threshold `theta` is
+        # increased tremendously (by 10.), but this remains without effect
+        # due to the instant decay (`delta_theta=1.`).
+        bias = 2
+        theta_0 = 4
+        neur = ATRLIF(shape=shape,
+                      delta_i=0,
+                      delta_v=0,
+                      delta_theta=1,
+                      delta_r=0,
+                      theta_0=theta_0,
+                      theta=theta_0,
+                      theta_step=10,
+                      bias_mant=bias * np.ones(shape, dtype=float))
+        # Receive neuron spikes
+        spr = VecRecvProcess(shape=(num_steps, shape[0]))
+        sps.s_out.connect(neur.a_in)
+        neur.s_out.connect(spr.s_in)
+        # Configure execution and run
+        rcnd = RunSteps(num_steps=num_steps)
+        rcfg = AtrlifRunConfig(select_tag='floating_pt')
+        neur.run(condition=rcnd, run_cfg=rcfg)
+        # Gather spike data and stop
+        spk_data_through_run = spr.spk_data.get()
+        neur.stop()
+        # Compute the number of time steps until the first spike
+        t_spike_0 = theta_0 // bias
+        # Compute the following number of time steps until the second spike
+        # (according to `bias * (t_spike_0 + t_spike_refr) - 2 * theta_0 >=
+        # theta_0`)
+        t_spike_refr = 3 * theta_0 // bias - t_spike_0
+        # Gold standard for the test
+        expected_spk_data = np.zeros((t_spike_0 + t_spike_refr + 1, shape[0]))
+        expected_spk_data[t_spike_0 - 1:t_spike_0 + t_spike_refr + 1:
+                          t_spike_refr, :] = 1.
+        spk_data_through_run_needed = \
+            spk_data_through_run[0:t_spike_0 + t_spike_refr + 1, :]
+        self.assertTrue(np.all(expected_spk_data
+                               == spk_data_through_run_needed))
+
+    def test_fixed_pm_instant_r_decay(self):
+        """
+        Tests fixed point ATRLIF ProcessModel's behavior for instant decay
+        of the refractory variable in the presence of constant bias.
+        """
+        # Use a single neuron
+        shape = (1,)
+        num_steps = 20
+        # Set up external input to 0
+        sps = VecSendProcess(shape=shape, num_steps=num_steps,
+                             vec_to_send=np.zeros(shape, dtype=float),
+                             send_at_times=np.ones((num_steps,), dtype=bool))
+        # `delta_i` and `delta_v` = 0 => bias driven neurons spike first after
+        # `theta_0 / bias` time steps. Following a spike, the threshold `theta`
+        # is automatically increased by `2 * theta`, but this remains without
+        # effect due to the instant decay (`delta_r=1`).
+        bias = 8
+        theta_0 = 16
+        neur = ATRLIF(shape=shape,
+                      delta_i=0,
+                      delta_v=0,
+                      delta_theta=0,
+                      delta_r=1,
+                      theta_0=theta_0,
+                      theta=theta_0,
+                      theta_step=0,
+                      bias_mant=bias * np.ones(shape, dtype=float))
+        # Receive neuron spikes
+        spr = VecRecvProcess(shape=(num_steps, shape[0]))
+        sps.s_out.connect(neur.a_in)
+        neur.s_out.connect(spr.s_in)
+        # Configure execution and run
+        rcnd = RunSteps(num_steps=num_steps)
+        rcfg = AtrlifRunConfig(select_tag='floating_pt')
+        neur.run(condition=rcnd, run_cfg=rcfg)
+        # Gather spike data and stop
+        spk_data_through_run = spr.spk_data.get()
+        neur.stop()
+        # Compute the number of time steps until the first spike
+        t_spike_0 = theta_0 // bias
+        # Compute the following number of time steps until the second spike
+        # (according to `bias * (t_spike_0 + t_spike_refr) >= theta_0`)
+        t_spike_refr = theta_0 // bias - t_spike_0 + 1
+        # Gold standard for the test
+        expected_spk_data = np.zeros((t_spike_0 + t_spike_refr + 1, shape[0]))
+        expected_spk_data[t_spike_0 - 1:t_spike_0 + t_spike_refr + 1:
+                          t_spike_refr, :] = 1.
+        spk_data_through_run_needed = \
+            spk_data_through_run[0:t_spike_0 + t_spike_refr + 1, :]
+        self.assertTrue(np.all(expected_spk_data
+                               == spk_data_through_run_needed))
diff --git a/tests/lava/proc/atrlif/test_process.py b/tests/lava/proc/atrlif/test_process.py
new file mode 100644
index 000000000..c0a16e94a
--- /dev/null
+++ b/tests/lava/proc/atrlif/test_process.py
@@ -0,0 +1,43 @@
+# Copyright (C) 2024 Intel Corporation
+# Copyright (C) 2024 Jannik Luboeinski
+# SPDX-License-Identifier: BSD-3-Clause
+# See: https://spdx.org/licenses/
+
+import unittest
+import numpy as np
+from lava.proc.atrlif.process import ATRLIF
+
+
+class TestATRLIFProcess(unittest.TestCase):
+    """Tests for ATRLIF class"""
+    def test_init(self):
+        """Tests instantiation of ATRLIF neuron"""
+        N = 100
+        delta_i = 0.6
+        delta_v = 0.6
+        delta_theta = 0.4
+        delta_r = 0.4
+        theta_0 = 4
+        theta_step = 2
+        bias_mant = 2 * np.ones((N,), dtype=float)
+        bias_exp = np.ones((N,), dtype=float)
+        name = "ATRLIF"
+
+        neur = ATRLIF(shape=(N,),
+                      delta_i=delta_i,
+                      delta_v=delta_v,
+                      delta_theta=delta_theta,
+                      delta_r=delta_r,
+                      theta_0=theta_0,
+                      theta=theta_0,
+                      theta_step=theta_step,
+                      bias_mant=bias_mant,
+                      bias_exp=bias_exp,
+                      name=name)
+
+        self.assertEqual(neur.proc_params["shape"], (N,))
+        self.assertEqual(neur.delta_i.init, delta_i)
+        self.assertEqual(neur.delta_v.init, delta_v)
+        self.assertListEqual(neur.bias_mant.init.tolist(), bias_mant.tolist())
+        self.assertListEqual(neur.bias_exp.init.tolist(), bias_exp.tolist())
+        self.assertEqual(neur.name, name)
diff --git a/tests/lava/tutorials/test_tutorials.py b/tests/lava/tutorials/test_tutorials.py
index 3f752c081..53996e692 100644
--- a/tests/lava/tutorials/test_tutorials.py
+++ b/tests/lava/tutorials/test_tutorials.py
@@ -1,4 +1,5 @@
-# Copyright (C) 2022 Intel Corporation
+# Copyright (C) 2022-2024 Intel Corporation
+# Copyright (C) 2024 Jannik Luboeinski
 # SPDX-License-Identifier: BSD-3-Clause
 # See: https://spdx.org/licenses/
 
@@ -285,6 +286,11 @@ def test_in_depth_11_serialization(self):
         """Test tutorial serialization."""
         self._run_notebook("tutorial11_serialization.ipynb")
 
+    @unittest.skipIf(system_name != "linux", "Tests work on linux")
+    def test_in_depth_12_adaptive_neurons(self):
+        """Test tutorial adaptive_neurons."""
+        self._run_notebook("tutorial12_adaptive_neurons.ipynb")
+
     @unittest.skipIf(system_name != "linux", "Tests work on linux")
     def test_in_depth_clp_01(self):
         """Test tutorial CLP 01."""
diff --git a/tutorials/in_depth/tutorial12_adaptive_neurons.ipynb b/tutorials/in_depth/tutorial12_adaptive_neurons.ipynb
new file mode 100644
index 000000000..6dc80a662
--- /dev/null
+++ b/tutorials/in_depth/tutorial12_adaptive_neurons.ipynb
@@ -0,0 +1,329 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*Copyright (C) 2024 Jannik Luboeinski*<br>\n",
+    "*SPDX-License-Identifier: BSD-3-Clause*<br>\n",
+    "*See: https://spdx.org/licenses/*\n",
+    "\n",
+    "---\n",
+    "\n",
+    "# ATRLIF neuron in different implementations\n",
+    "_A Leaky Integrate-and-Fire neuron with adaptive threshold and adaptive refractoriness._"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import general modules\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import os\n",
+    "\n",
+    "# Import Lava core modules\n",
+    "from lava.magma.core.run_configs import Loihi2SimCfg, Loihi2HwCfg\n",
+    "from lava.magma.core.run_conditions import RunSteps\n",
+    "\n",
+    "# Import Lava monitors\n",
+    "from lava.proc.monitor.process import Monitor\n",
+    "\n",
+    "# Import ATRLIF process\n",
+    "from lava.proc.atrlif.process import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Simulation test function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def simulation_test(run_config, label, bias_mant=3, bias_exp=0, **kwargs):\n",
+    "    '''\n",
+    "    Function to simulate and monitor a population of ATRLIF neurons.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    run_config : `AbstractLoihiSimRunCfg`\n",
+    "        Run configuratrion object for Lava.\n",
+    "    label : `str`\n",
+    "        Label for the current simulation.\n",
+    "    bias_mant : `float`, optional\n",
+    "        Mantissa part of neuron's bias. Equals `bias` for floating-point implementation.\n",
+    "    bias_exp : `int`, optional\n",
+    "        Exponent part of neuron's bias, if needed. Ignored in floating-point implementation.\n",
+    "    **kwargs : `dict`\n",
+    "        Additional keyword arguments (cf. 'atrlif_process.py').\n",
+    "    '''\n",
+    "\n",
+    "    # Initialization\n",
+    "    n_neurons = 1 # the number of neurons\n",
+    "    num_steps = 20 # the number of timesteps\n",
+    "    output_period = 1 # the sampling period (in timesteps)\n",
+    "    num_samples = num_steps // output_period + 1 # the number of samples\n",
+    "    atrlif = ATRLIF(shape=(n_neurons,), bias_mant=bias_mant, bias_exp=bias_exp, **kwargs)\n",
+    "    \n",
+    "    # Set monitors for the different variables\n",
+    "    voltage_mon = Monitor()\n",
+    "    voltage_mon.probe(atrlif.v, num_samples)\n",
+    "    refractory_mon = Monitor()\n",
+    "    refractory_mon.probe(atrlif.r, num_samples)\n",
+    "    threshold_mon = Monitor()\n",
+    "    threshold_mon.probe(atrlif.theta, num_samples)\n",
+    "    spike_mon = Monitor()\n",
+    "    spike_mon.probe(atrlif.s_out, num_samples)\n",
+    "    \n",
+    "    # Run the simulation\n",
+    "    atrlif.run(condition=RunSteps(num_steps=num_samples, blocking=True), run_cfg=run_config)\n",
+    "    \n",
+    "    # Retrieve process name\n",
+    "    process_name = atrlif.v.process.name\n",
+    "    \n",
+    "    # Collect samples\n",
+    "    data_v = voltage_mon.get_data()[process_name]['v']\n",
+    "    data_r = refractory_mon.get_data()[process_name]['r']\n",
+    "    data_theta = threshold_mon.get_data()[process_name]['theta']\n",
+    "    data_s = spike_mon.get_data()[process_name]['s_out']\n",
+    "    \n",
+    "    # Stop the simulation\n",
+    "    atrlif.stop()\n",
+    "    \n",
+    "    # Normalize data from fixed-point implementation (right shifting by `bias_exp`)\n",
+    "    if bias_exp > 0:\n",
+    "        data_v = data_v * 2**(-bias_exp)\n",
+    "        data_r = data_r * 2**(-bias_exp)\n",
+    "        data_theta = data_theta * 2**(-bias_exp)\n",
+    "        \n",
+    "    # Save voltage and spike data\n",
+    "    header = \"t\"\n",
+    "    for var in [\"v\", \"r\", \"theta\", \"s\"]:\n",
+    "        for n in range(n_neurons):\n",
+    "            header += f\"\\t{var}_{n}\"\n",
+    "    times = np.arange(0, len(data_v))\n",
+    "    os.makedirs(\"./results\", exist_ok=True)\n",
+    "    np.savetxt(f\"./results/atrlif_v_{label}.txt\",\n",
+    "               np.column_stack([times, data_v, data_r, data_theta, data_s]), \n",
+    "               fmt=\"%.0f\"+n_neurons*\"\\t%.4f\\t%.4f\\t%.4f\"+n_neurons*\"\\t%.0f\", \n",
+    "               header=header)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plotting function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot(data_stacked_1, data_stacked_2, framework_name_1, framework_name_2, X_cols, store_path = \"figure.svg\"):\n",
+    "    '''\n",
+    "    Function to plot the results from two different paradigms.\n",
+    "    Based on https://github.com/jlubo/memory-consolidation-stc/blob/main/analysis/plotSimResultsComparisonMeanSEM.py.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    data_stacked_1 : `numpy.ndarray`\n",
+    "        Data array of first paradigm. First column contains the time, the other columns contain the data specified via `X_cols`.\n",
+    "    data_stacked_2 : `numpy.ndarray`\n",
+    "        Data array of second paradigm. First column contains the time, the other columns contain the data specified via `X_cols`.\n",
+    "    framework_name_1 : `str`\n",
+    "        Name of the first framework/paradigm.\n",
+    "    framework_name_2 : `str`\n",
+    "        Name of the second framework/paradigm.\n",
+    "    X_cols : `dict` of `int`\n",
+    "        Dictionary specifying the data columns to be plotted.\n",
+    "    store_path : `str`, optional\n",
+    "        Path to store the resulting graphics file.\n",
+    "    '''\n",
+    "    \n",
+    "    # Figure setting\n",
+    "    fig, axes = plt.subplots(nrows=2, ncols=1, sharex=True, figsize=(8, 8), height_ratios=[1.0, 0.4])\n",
+    "    \n",
+    "    # Plot membrane voltage, effective voltage, and threshold dynamics\n",
+    "    axes[0].set_ylabel(f\"Membrane dynamics (mV)\")\n",
+    "    axes[0].plot(data_stacked_1[:,0], data_stacked_1[:,X_cols[\"theta\"]], color=\"#aaeeaa\", label=f\"Threshold {framework_name_1}\", marker='None', zorder=9)\n",
+    "    axes[0].plot(data_stacked_2[:,0], data_stacked_2[:,X_cols[\"theta\"]], color=\"#556655\", linestyle='dotted', label=f\"Threshold {framework_name_2}\", marker='None', zorder=10)\n",
+    "    axes[0].legend()\n",
+    "    axes[0].plot(data_stacked_1[:,0], (data_stacked_1[:,X_cols[\"voltage\"]]-data_stacked_1[:,X_cols[\"ref\"]]), color=\"#ff0000\", label=f\"Effective voltage {framework_name_1}\", marker='None', zorder=9)\n",
+    "    axes[0].plot(data_stacked_2[:,0], (data_stacked_2[:,X_cols[\"voltage\"]]-data_stacked_2[:,X_cols[\"ref\"]]), color=\"#330000\", linestyle='dashed', label=f\"Effective voltage {framework_name_2}\", marker='None', zorder=10)\n",
+    "    axes[0].legend()\n",
+    "    # Set x-ticks (to integer values only)\n",
+    "    axes[0].set_xticks(np.arange(min(data_stacked_1[:,0]), np.ceil(max(data_stacked_1[:,0])) + 1, step=2))\n",
+    "    axes[0].set_xticks(np.arange(min(data_stacked_1[:,0]), np.ceil(max(data_stacked_1[:,0])) + 1, step=1), minor=True)\n",
+    "\n",
+    "    # Plot spikes\n",
+    "    axes[1].set_xlabel(\"Time (steps)\")\n",
+    "    axes[1].set_ylabel(f\"Spikes\")\n",
+    "    # Get logical masks\n",
+    "    mask_1 = data_stacked_1[:,X_cols[\"spike\"]] > 0.5\n",
+    "    mask_2 = data_stacked_2[:,X_cols[\"spike\"]] > 0.5\n",
+    "    axes[1].plot(data_stacked_1[:,0][mask_1], data_stacked_1[:,X_cols[\"spike\"]][mask_1], color=\"#ff0000\", marker='o', \n",
+    "                 linestyle='none', label=framework_name_1, zorder=9)\n",
+    "    axes[1].plot(data_stacked_2[:,0][mask_2], data_stacked_2[:,X_cols[\"spike\"]][mask_2], color=\"#330000\", marker='o', markerfacecolor='none', \n",
+    "                 linestyle='none', label=framework_name_2, zorder=10)\n",
+    "    axes[1].tick_params(left = False, labelleft = False)\n",
+    "    axes[1].legend()\n",
+    "\n",
+    "    # Save figure as vector graphics\n",
+    "    fig.savefig(store_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Running the simulations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PyATRLIFModelFloat initialized\n",
+      "PyATRLIFModelFixed initialized\n",
+      "PyATRLIFModelFloat initialized\n",
+      "PyATRLIFModelFixed initialized\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Simulate with default values in floating- and fixed-point implementation\n",
+    "simulation_test(Loihi2SimCfg(select_tag=\"floating_pt\"),\n",
+    "                \"cpu-float\")\n",
+    "simulation_test(Loihi2SimCfg(select_tag=\"fixed_pt\"),\n",
+    "                \"cpu-fixed\",\n",
+    "                bias_exp=6)\n",
+    "\n",
+    "# Simulate with constant threshold dynamics in floating- and fixed-point implementation\n",
+    "simulation_test(Loihi2SimCfg(select_tag=\"floating_pt\"),\n",
+    "                \"cpu-float_theta_const\",\n",
+    "                delta_theta=0,\n",
+    "                theta_step=0)\n",
+    "simulation_test(Loihi2SimCfg(select_tag=\"fixed_pt\"),\n",
+    "                \"cpu-fixed_theta_const\",\n",
+    "                delta_theta=0,\n",
+    "                theta_step=0,\n",
+    "                bias_exp=6)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plotting the results from default setting\n",
+    "_The membrane voltage minus the value of the refractory state yields the effective voltage, which is compared against the threshold value to determine spiking._\n",
+    "\n",
+    "_The dynamics of the threshold hampers spiking if the last spike occurred not too long ago._"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data_stacked_cpu_float = np.loadtxt(f'./results/atrlif_v_cpu-float.txt')\n",
+    "data_stacked_cpu_fixed = np.loadtxt(f'./results/atrlif_v_cpu-fixed.txt')\n",
+    "\n",
+    "plot(data_stacked_cpu_float, data_stacked_cpu_fixed, \"CPU floating-pt.\", \"CPU fixed-pt.\", \n",
+    "     {\"voltage\": 1, \"ref\": 2, \"theta\": 3, \"spike\": 4},\n",
+    "     store_path = f\"./results/atrlif_cpu-float_cpu-fixed.svg\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plotting the results from constant threshold setting\n",
+    "_The membrane voltage minus the value of the refractory state yields the effective voltage, which is compared against the threshold value to determine spiking._\n",
+    "\n",
+    "_Here, the threshold value remains constant, which essentially yields the dynamics of a standard LIF neuron (with refractoriness)._"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data_stacked_cpu_float = np.loadtxt(f'./results/atrlif_v_cpu-float_theta_const.txt')\n",
+    "data_stacked_cpu_fixed = np.loadtxt(f'./results/atrlif_v_cpu-fixed_theta_const.txt')\n",
+    "\n",
+    "plot(data_stacked_cpu_float, data_stacked_cpu_fixed, \"CPU floating-pt.\", \"CPU fixed-pt.\", \n",
+    "     {\"voltage\": 1, \"ref\": 2, \"theta\": 3, \"spike\": 4},\n",
+    "     store_path = f\"./results/atrlif_theta_const_cpu-float_cpu-fixed.svg\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

From 2f3e0f8d65fdf753adab72b9b94caebf9a7b8f1c Mon Sep 17 00:00:00 2001
From: Zeyu Liu <liuzeyu@usc.edu>
Date: Thu, 25 Apr 2024 03:06:01 -0700
Subject: [PATCH 2/2] Add the models and process of conv_in_time in
 src/lava/proc/conv_in_time (#833)

* add the models and process of conv_in_time in src/lava/proc/conv_in_time

* remove unused library

* remove Trailing whitespace

* add unittest for conv in time and related pytorch ground truth

* add fixed_pt version of conv in time

* change input to spike_input

* add from lava.proc.conv import utils

* remove unwanted comments

* fixed some linting errors

* Start all comments with upper case character & change the year for all copyright headers to 2024 for new files

* remove whitespace

* continuation line under-indented

* Trailing whitespace

* shorten variables names

---------

Co-authored-by: bamsumit <bam_sumit@hotmail.com>
Co-authored-by: PhilippPlank <32519998+PhilippPlank@users.noreply.github.com>
---
 src/lava/proc/conv_in_time/models.py          | 99 +++++++++++++++++++
 src/lava/proc/conv_in_time/process.py         | 86 ++++++++++++++++
 tests/lava/proc/conv_in_time/__init__.py      |  0
 .../lava/proc/conv_in_time/gts/q_weights.npy  |  3 +
 .../proc/conv_in_time/gts/spike_input.npy     |  3 +
 .../proc/conv_in_time/gts/torch_output.npy    |  3 +
 tests/lava/proc/conv_in_time/test_process.py  | 80 +++++++++++++++
 7 files changed, 274 insertions(+)
 create mode 100644 src/lava/proc/conv_in_time/models.py
 create mode 100644 src/lava/proc/conv_in_time/process.py
 create mode 100644 tests/lava/proc/conv_in_time/__init__.py
 create mode 100644 tests/lava/proc/conv_in_time/gts/q_weights.npy
 create mode 100644 tests/lava/proc/conv_in_time/gts/spike_input.npy
 create mode 100644 tests/lava/proc/conv_in_time/gts/torch_output.npy
 create mode 100644 tests/lava/proc/conv_in_time/test_process.py

diff --git a/src/lava/proc/conv_in_time/models.py b/src/lava/proc/conv_in_time/models.py
new file mode 100644
index 000000000..68b603d4a
--- /dev/null
+++ b/src/lava/proc/conv_in_time/models.py
@@ -0,0 +1,99 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+# See: https://spdx.org/licenses/
+
+import numpy as np
+
+from lava.magma.core.sync.protocols.loihi_protocol import LoihiProtocol
+from lava.magma.core.model.py.ports import PyInPort, PyOutPort
+from lava.magma.core.model.py.type import LavaPyType
+from lava.magma.core.resources import CPU
+from lava.magma.core.decorator import implements, requires, tag
+from lava.magma.core.model.py.model import PyLoihiProcessModel
+from lava.proc.conv_in_time.process import ConvInTime
+from lava.proc.conv import utils
+
+
+class AbstractPyConvInTimeModel(PyLoihiProcessModel):
+    """Abstract Conn In Time Process with Dense synaptic connections
+    which incorporates delays into the Conv Process.
+    """
+    weights: np.ndarray = None
+    a_buff: np.ndarray = None
+    kernel_size: int = None
+
+    num_message_bits: np.ndarray = LavaPyType(np.ndarray, np.int8, precision=5)
+
+    def calc_act(self, s_in) -> np.ndarray:
+        """
+        Calculate the activation buff by inverse the order in
+        the kernel. Taking k=3 as an example, the a_buff will be
+        weights[2] * s_in, weights[1] * s_in, weights[0] * s_in
+        """
+
+        # The change of the shape is shown below:
+        # sum([K, n_out, n_in] * [n_in,], axis=-1) = [K, n_out] -> [n_out, K]
+        kernel_size = self.weights.shape[0]
+        for i in range(kernel_size):
+            self.a_buff[:, i] += np.sum(
+                self.weights[kernel_size - i - 1] * s_in, axis=-1).T
+
+    def update_act(self, s_in):
+        """
+        Updates the activations for the connection.
+        Clears first column of a_buff and rolls them to the last column.
+        Finally, calculates the activations for the current time step and adds
+        them to a_buff.
+        This order of operations ensures that delays of 0 correspond to
+        the next time step.
+        """
+        self.a_buff[:, 0] = 0
+        self.a_buff = np.roll(self.a_buff, -1)
+        self.calc_act(s_in)
+
+    def run_spk(self):
+        # The a_out sent on a each timestep is a buffered value from dendritic
+        # accumulation at timestep t-1. This prevents deadlocking in
+        # networks with recurrent connectivity structures.
+        self.a_out.send(self.a_buff[:, 0])
+        if self.num_message_bits.item() > 0:
+            s_in = self.s_in.recv()
+        else:
+            s_in = self.s_in.recv().astype(bool)
+        self.update_act(s_in)
+
+
+@implements(proc=ConvInTime, protocol=LoihiProtocol)
+@requires(CPU)
+@tag("floating_pt")
+class PyConvInTimeFloat(AbstractPyConvInTimeModel):
+    """Implementation of Conn In Time Process with Dense synaptic connections in
+    floating point precision. This short and simple ProcessModel can be used
+    for quick algorithmic prototyping, without engaging with the nuances of a
+    fixed point implementation. DelayDense incorporates delays into the Conn
+    Process.
+    """
+    s_in: PyInPort = LavaPyType(PyInPort.VEC_DENSE, bool, precision=1)
+    a_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, float)
+    a_buff: np.ndarray = LavaPyType(np.ndarray, float)
+    # The weights is a 3D matrix of form (kernel_size,
+    # num_flat_output_neurons, num_flat_input_neurons) in C-order (row major).
+    weights: np.ndarray = LavaPyType(np.ndarray, float)
+    num_message_bits: np.ndarray = LavaPyType(np.ndarray, int, precision=5)
+
+
+@implements(proc=ConvInTime, protocol=LoihiProtocol)
+@requires(CPU)
+@tag("fixed_pt")
+class PyConvInTimeFixed(AbstractPyConvInTimeModel):
+    """Conv In Time with fixed point synapse implementation."""
+    s_in: PyInPort = LavaPyType(PyInPort.VEC_DENSE, bool, precision=1)
+    a_out: PyOutPort = LavaPyType(PyOutPort.VEC_DENSE, float)
+    a_buff: np.ndarray = LavaPyType(np.ndarray, float)
+    # The weights is a 3D matrix of form (kernel_size,
+    # num_flat_output_neurons, num_flat_input_neurons) in C-order (row major).
+    weights: np.ndarray = LavaPyType(np.ndarray, float)
+    num_message_bits: np.ndarray = LavaPyType(np.ndarray, int, precision=5)
+
+    def clamp_precision(self, x: np.ndarray) -> np.ndarray:
+        return utils.signed_clamp(x, bits=24)
diff --git a/src/lava/proc/conv_in_time/process.py b/src/lava/proc/conv_in_time/process.py
new file mode 100644
index 000000000..ec54d657f
--- /dev/null
+++ b/src/lava/proc/conv_in_time/process.py
@@ -0,0 +1,86 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+# See: https://spdx.org/licenses/
+
+import numpy as np
+import typing as ty
+
+from lava.magma.core.process.process import AbstractProcess, LogConfig
+from lava.magma.core.process.variable import Var
+from lava.magma.core.process.ports.ports import InPort, OutPort
+
+
+class ConvInTime(AbstractProcess):
+    """Connection Process that mimics a convolution of the incoming
+    events/spikes with a kernel in the time dimension. Realizes the
+    following abstract behavior: a_out[t] = weights[t-1] * s_in[t-1]
+    + weights[t] * s_in[t] + weights[t+1] * s_in[t+1]
+
+    Parameters
+    ----------
+    weights : numpy.ndarray
+        3D connection weight matrix of form (kernel_size,
+        num_flat_output_neurons, num_flat_input_neurons)
+        in C-order (row major).
+
+    weight_exp : int, optional
+        Shared weight exponent of base 2 used to scale magnitude of
+        weights, if needed. Mostly for fixed point implementations.
+        Unnecessary for floating point implementations.
+        Default value is 0.
+
+    num_weight_bits : int, optional
+        Shared weight width/precision used by weight. Mostly for fixed
+        point implementations. Unnecessary for floating point
+        implementations.
+        Default is for weights to use full 8 bit precision.
+
+    sign_mode : SignMode, optional
+        Shared indicator whether synapse is of type SignMode.NULL,
+        SignMode.MIXED, SignMode.EXCITATORY, or SignMode.INHIBITORY. If
+        SignMode.MIXED, the sign of the weight is
+        included in the weight bits and the fixed point weight used for
+        inference is scaled by 2.
+        Unnecessary for floating point implementations.
+
+        In the fixed point implementation, weights are scaled according to
+        the following equations:
+        w_scale = 8 - num_weight_bits + weight_exp + isMixed()
+        weights = weights * (2 ** w_scale)
+
+    num_message_bits : int, optional
+        Determines whether the Dense Process deals with the incoming
+        spikes as binary spikes (num_message_bits = 0) or as graded
+        spikes (num_message_bits > 0). Default is 0.
+        """
+    def __init__(self,
+                 *,
+                 weights: np.ndarray,
+                 name: ty.Optional[str] = None,
+                 num_message_bits: ty.Optional[int] = 0,
+                 log_config: ty.Optional[LogConfig] = None,
+                 **kwargs) -> None:
+
+        super().__init__(weights=weights,
+                         num_message_bits=num_message_bits,
+                         name=name,
+                         log_config=log_config,
+                         **kwargs)
+
+        self._validate_weights(weights)
+        # [kernel_size, n_flat_output_neurons, n_flat_input_neurons]
+        shape = weights.shape
+        # Ports
+        self.s_in = InPort(shape=(shape[2],))
+        self.a_out = OutPort(shape=(shape[1],))
+
+        # Variables
+        self.weights = Var(shape=shape, init=weights)
+        self.a_buff = Var(shape=(shape[1], shape[0]), init=0)
+        self.num_message_bits = Var(shape=(1,), init=num_message_bits)
+
+    @staticmethod
+    def _validate_weights(weights: np.ndarray) -> None:
+        if len(np.shape(weights)) != 3:
+            raise ValueError("Dense Process 'weights' expects a 3D matrix, "
+                             f"got {weights}.")
diff --git a/tests/lava/proc/conv_in_time/__init__.py b/tests/lava/proc/conv_in_time/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/lava/proc/conv_in_time/gts/q_weights.npy b/tests/lava/proc/conv_in_time/gts/q_weights.npy
new file mode 100644
index 000000000..b061a7b57
--- /dev/null
+++ b/tests/lava/proc/conv_in_time/gts/q_weights.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f78fb71a436122ae8bfccf4f0e13ce081758b5069029dc725c5291bef23f9872
+size 368
diff --git a/tests/lava/proc/conv_in_time/gts/spike_input.npy b/tests/lava/proc/conv_in_time/gts/spike_input.npy
new file mode 100644
index 000000000..c67692abc
--- /dev/null
+++ b/tests/lava/proc/conv_in_time/gts/spike_input.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1121fc20bb641224327eaec7eb25719cd27a4186ad5b1afb307aadcf7778582
+size 288
diff --git a/tests/lava/proc/conv_in_time/gts/torch_output.npy b/tests/lava/proc/conv_in_time/gts/torch_output.npy
new file mode 100644
index 000000000..1d108c072
--- /dev/null
+++ b/tests/lava/proc/conv_in_time/gts/torch_output.npy
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8de545175d4d511091d54b13cf0b1ed82b97104591d8b89596dd2a3069a509c4
+size 288
diff --git a/tests/lava/proc/conv_in_time/test_process.py b/tests/lava/proc/conv_in_time/test_process.py
new file mode 100644
index 000000000..33ec3ca70
--- /dev/null
+++ b/tests/lava/proc/conv_in_time/test_process.py
@@ -0,0 +1,80 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+# See: https://spdx.org/licenses/
+
+import unittest
+import os
+import numpy as np
+from lava.proc.conv_in_time.process import ConvInTime
+from lava.proc import io
+
+from lava.magma.core.run_conditions import RunSteps
+from lava.magma.core.run_configs import Loihi1SimCfg
+from lava.proc.conv import utils
+
+if utils.TORCH_IS_AVAILABLE:
+    import torch
+    import torch.nn as nn
+    compare = True
+    # In this case, the test compares against random torch ground truth
+else:
+    compare = False
+    # In this case, the test compares against saved torch ground truth
+
+
+class TestConvInTimeProcess(unittest.TestCase):
+    """Tests for Conv class"""
+    def test_init(self) -> None:
+        """Tests instantiation of Conv In Time"""
+        num_steps = 10
+        kernel_size = 3
+        n_in = 2
+        n_out = 5
+        if compare:
+            spike_input = np.random.choice(
+                [0, 1],
+                size=(n_in, num_steps))
+            weights = np.random.randint(256, size=[kernel_size,
+                                                   n_out,
+                                                   n_in]) - 128
+        else:
+            spike_input = np.load(os.path.join(os.path.dirname(__file__),
+                                               "gts/spike_input.npy"))
+            weights = np.load(os.path.join(os.path.dirname(__file__),
+                                           "gts/q_weights.npy"))
+        sender = io.source.RingBuffer(data=spike_input)
+        conv_in_time = ConvInTime(weights=weights, name='conv_in_time')
+
+        receiver = io.sink.RingBuffer(
+            shape=(n_out,),
+            buffer=num_steps + 1)
+
+        sender.s_out.connect(conv_in_time.s_in)
+        conv_in_time.a_out.connect(receiver.a_in)
+
+        run_condition = RunSteps(num_steps=num_steps + 1)
+        run_cfg = Loihi1SimCfg(select_tag="floating_pt")
+
+        conv_in_time.run(condition=run_condition, run_cfg=run_cfg)
+        output = receiver.data.get()
+        conv_in_time.stop()
+
+        if compare:
+            tensor_input = torch.tensor(spike_input, dtype=torch.float32)
+            tensor_weights = torch.tensor(weights, dtype=torch.float32)
+            conv_layer = nn.Conv1d(
+                in_channels=n_in,
+                out_channels=n_out,
+                kernel_size=kernel_size, bias=False)
+            # Permute the weights to match the torch format
+            conv_layer.weight = nn.Parameter(tensor_weights.permute(1, 2, 0))
+            torch_output = conv_layer(
+                tensor_input.unsqueeze(0)).squeeze(0).detach().numpy()
+        else:
+            torch_output = np.load(os.path.join(os.path.dirname(__file__),
+                                                "gts/torch_output.npy"))
+
+        self.assertEqual(output.shape, (n_out, num_steps + 1))
+        # After kernel_size timesteps,
+        # the output should be the same as the torch output
+        assert np.allclose(output[:, kernel_size:], torch_output)