From 38a6785d9856a27e7fca3f3df0c388a8c1d0fa41 Mon Sep 17 00:00:00 2001
From: Corentin <111868204+corentinlger@users.noreply.github.com>
Date: Thu, 4 Jul 2024 11:11:25 +0200
Subject: [PATCH 1/7] Add new experimental directory with simple and
 prey_predator braitenberg envs (#87)

* Add first version of refactored braitenberg env

* Add utils file

* Update way of computing forces in environment + Add general physics engine file

* Add first elements of tutorial on how to create an environment in a notebook

* Update braitenberg notebook and add new prey/predator braitenberg environment

* Delete new notebooks on refactored envs and associated files

* Add simple and prey_predator braitenberg envs in experimental directory

* Add first steps of sensorimotor functions refactoring

* Add first draft version of selective sensors braitenberg env

* Refactor simple braitenberg env and add utils file for all environments

* Update base env by removing intermediate state classes

* Remove duplicate code and add markdown comments

* Remove uncessary files

* Update simple braitenberg notebook

* Add behavior refactoring in simple braitenberg env

* Update simple braitenberg env and notebook with new init functions

* Add default values to init functions and update prey_pred notebook
---
 requirements.txt                              |   1 +
 .../experimental/environments/base_env.py     |  46 ++
 .../environments/braitenberg/render.py        | 109 +++
 .../environments/braitenberg/simple.py        | 633 ++++++++++++++++++
 .../environments/particle_lenia/simple.py     |   1 +
 .../environments/physics_engine.py            | 150 +++++
 vivarium/experimental/environments/utils.py   |  37 +
 .../notebooks/prey_predator_braitenberg.ipynb | 385 +++++++++++
 .../notebooks/simple_braitenberg.ipynb        | 359 ++++++++++
 9 files changed, 1721 insertions(+)
 create mode 100644 vivarium/experimental/environments/base_env.py
 create mode 100644 vivarium/experimental/environments/braitenberg/render.py
 create mode 100644 vivarium/experimental/environments/braitenberg/simple.py
 create mode 100644 vivarium/experimental/environments/particle_lenia/simple.py
 create mode 100644 vivarium/experimental/environments/physics_engine.py
 create mode 100644 vivarium/experimental/environments/utils.py
 create mode 100644 vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb
 create mode 100644 vivarium/experimental/notebooks/simple_braitenberg.ipynb

diff --git a/requirements.txt b/requirements.txt
index ef50d69..5d96872 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -3,6 +3,7 @@ jax==0.4.23
 jaxlib==0.4.23
 jax-md==0.2.8
 scipy==1.12.0
+flax
 
 # Interface
 panel==1.3.8
diff --git a/vivarium/experimental/environments/base_env.py b/vivarium/experimental/environments/base_env.py
new file mode 100644
index 0000000..bdb3687
--- /dev/null
+++ b/vivarium/experimental/environments/base_env.py
@@ -0,0 +1,46 @@
+import logging as lg
+
+from functools import partial
+from typing import Tuple
+
+import jax.numpy as jnp
+
+from jax import  jit
+from flax import struct
+
+
+@struct.dataclass
+class BaseState:
+    time: jnp.int32
+    box_size: jnp.int32
+   
+
+class BaseEnv:
+    def __init__(self):
+        raise(NotImplementedError)
+
+    def init_state(self) -> BaseState:
+        raise(NotImplementedError)
+
+    @partial(jit, static_argnums=(0,))
+    def _step(self, state: BaseState, neighbors: jnp.array) -> Tuple[BaseState, jnp.array]:
+        raise(NotImplementedError)
+    
+    def step(self, state: BaseState) -> BaseState:
+        current_state = state
+        state, neighbors = self._step(current_state, self.neighbors)
+
+        if self.neighbors.did_buffer_overflow:
+            # reallocate neighbors and run the simulation from current_state
+            lg.warning('BUFFER OVERFLOW: rebuilding neighbors')
+            neighbors = self.allocate_neighbors(state)
+            assert not neighbors.did_buffer_overflow
+
+        self.neighbors = neighbors
+        return state
+
+    def allocate_neighbors(self, state, position=None):
+        position = state.entities.position.center if position is None else position
+        neighbors = self.neighbor_fn.allocate(position)
+        return neighbors
+    
\ No newline at end of file
diff --git a/vivarium/experimental/environments/braitenberg/render.py b/vivarium/experimental/environments/braitenberg/render.py
new file mode 100644
index 0000000..a3c8e64
--- /dev/null
+++ b/vivarium/experimental/environments/braitenberg/render.py
@@ -0,0 +1,109 @@
+import time
+from IPython.display import display, clear_output
+
+import jax.numpy as jnp
+import numpy as np
+import matplotlib.pyplot as plt 
+import matplotlib.colors as colors
+
+from vivarium.experimental.environments.utils import normal
+
+
+def _string_to_rgb(color_str):
+    return jnp.array(list(colors.to_rgb(color_str)))
+
+# Functions to render the current state
+def render(state):
+    box_size = state.box_size
+    max_agents = state.max_agents
+
+    plt.figure(figsize=(6, 6))
+    plt.xlim(0, box_size)
+    plt.xlim(0, box_size)
+
+    exists_agents, exists_objects = state.entities.exists[:max_agents], state.entities.exists[max_agents:] 
+    exists_agents = jnp.where(exists_agents != 0)
+    exists_objects = jnp.where(exists_objects != 0)
+
+    agents_pos = state.entities.position.center[:max_agents][exists_agents]
+    agents_theta = state.entities.position.orientation[:max_agents][exists_agents][exists_agents]
+    agents_diameter = state.entities.diameter[:max_agents][exists_agents][exists_agents]
+    objects_pos = state.entities.position.center[max_agents:][exists_objects]
+    object_diameter = state.entities.diameter[max_agents:][exists_objects]
+
+    x_agents, y_agents = agents_pos[:, 0], agents_pos[:, 1]
+    agents_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in state.agents.color[exists_agents]]
+    x_objects, y_objects = objects_pos[:, 0], objects_pos[:, 1]
+    object_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in state.objects.color[exists_objects]]
+
+    n = normal(agents_theta)
+
+    arrow_length = 3  
+    size_scale = 30  
+    dx = arrow_length * n[:, 0]
+    dy = arrow_length *  n[:, 1]
+    plt.quiver(x_agents, y_agents, dx, dy, color=agents_colors_rgba, scale=1, scale_units='xy', headwidth=0.8, angles='xy', width=0.01)
+    plt.scatter(x_agents, y_agents, c=agents_colors_rgba, s=agents_diameter*size_scale, label='agents')
+    plt.scatter(x_objects, y_objects, c=object_colors_rgba, s=object_diameter*size_scale, label='objects')
+
+    plt.title('State')
+    plt.xlabel('X Position')
+    plt.ylabel('Y Position')
+    plt.legend()
+
+    plt.show()
+
+# Function to render a state hystory
+def render_history(state_history, pause=0.001, skip_frames=1):
+    box_size = state_history[0].box_size
+    max_agents = state_history[0].max_agents
+    fig, ax = plt.subplots(figsize=(6, 6))
+    ax.set_xlim(0, box_size)
+    ax.set_ylim(0, box_size)
+
+    for t in range(0, len(state_history), skip_frames):
+        # Because weird saving at the moment, we don't save the state but all its sub-elements
+        entities = state_history[t].entities
+        agents = state_history[t].agents
+        objects = state_history[t].objects
+
+        exists_agents, exists_objects = entities.exists[:max_agents], entities.exists[max_agents:] 
+        exists_agents = jnp.where(exists_agents != 0)
+        exists_objects = jnp.where(exists_objects != 0)
+
+        agents_pos = entities.position.center[:max_agents][exists_agents]
+        agents_theta = entities.position.orientation[:max_agents][exists_agents][exists_agents]
+        agents_diameter = entities.diameter[:max_agents][exists_agents][exists_agents]
+        objects_pos = entities.position.center[max_agents:][exists_objects]
+        object_diameter = entities.diameter[max_agents:][exists_objects]
+
+        x_agents, y_agents = agents_pos[:, 0], agents_pos[:, 1]
+        agents_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in agents.color[exists_agents]]
+        x_objects, y_objects = objects_pos[:, 0], objects_pos[:, 1]
+        object_colors_rgba = [colors.to_rgba(np.array(c), alpha=1.) for c in objects.color[exists_objects]]
+
+        n = normal(agents_theta)
+
+        arrow_length = 3  
+        size_scale = 30 
+        dx = arrow_length * n[:, 0]
+        dy = arrow_length *  n[:, 1]
+
+        ax.clear()
+        ax.set_xlim(0, box_size)
+        ax.set_ylim(0, box_size)
+        
+        ax.quiver(x_agents, y_agents, dx, dy, color=agents_colors_rgba, scale=1, scale_units='xy', headwidth=0.8, angles='xy', width=0.01)
+        ax.scatter(x_agents, y_agents, c=agents_colors_rgba, s=agents_diameter*size_scale, label='agents')
+        ax.scatter(x_objects, y_objects, c=object_colors_rgba, s=object_diameter*size_scale, label='objects')
+
+        ax.set_title(f'Timestep: {t}')
+        ax.set_xlabel('X Position')
+        ax.set_ylabel('Y Position')
+        ax.legend()
+        
+        display(fig)
+        clear_output(wait=True)
+        time.sleep(pause)
+
+    plt.close(fig)
diff --git a/vivarium/experimental/environments/braitenberg/simple.py b/vivarium/experimental/environments/braitenberg/simple.py
new file mode 100644
index 0000000..7f63e6e
--- /dev/null
+++ b/vivarium/experimental/environments/braitenberg/simple.py
@@ -0,0 +1,633 @@
+import logging as lg
+
+from enum import Enum
+from functools import partial
+from typing import Tuple
+
+import numpy as np
+import jax.numpy as jnp
+
+from jax import vmap, jit
+from jax import random, ops, lax
+
+from flax import struct
+from jax_md.rigid_body import RigidBody
+from jax_md import simulate 
+from jax_md import space, rigid_body, partition, quantity
+
+from vivarium.experimental.environments.utils import normal, distance, relative_position 
+from vivarium.experimental.environments.base_env import BaseState, BaseEnv
+from vivarium.experimental.environments.physics_engine import total_collision_energy, friction_force, dynamics_fn
+
+
+### Define the constants and the classes of the environment to store its state ###
+SPACE_NDIMS = 2
+
+class EntityType(Enum):
+    AGENT = 0
+    OBJECT = 1
+
+# Already incorporates position, momentum, force, mass and velocity
+@struct.dataclass
+class EntityState(simulate.NVEState):
+    entity_type: jnp.array
+    entity_idx: jnp.array
+    diameter: jnp.array
+    friction: jnp.array
+    exists: jnp.array
+    
+@struct.dataclass
+class ParticleState:
+    ent_idx: jnp.array
+    color: jnp.array
+
+@struct.dataclass
+class AgentState(ParticleState):
+    prox: jnp.array
+    motor: jnp.array
+    proximity_map_dist: jnp.array
+    proximity_map_theta: jnp.array
+    behavior: jnp.array
+    params: jnp.array
+    wheel_diameter: jnp.array
+    speed_mul: jnp.array
+    max_speed: jnp.array
+    theta_mul: jnp.array    
+    proxs_dist_max: jnp.array
+    proxs_cos_min: jnp.array
+
+@struct.dataclass
+class ObjectState(ParticleState):
+    pass
+
+@struct.dataclass
+class State(BaseState):
+    max_agents: jnp.int32
+    max_objects: jnp.int32
+    neighbor_radius: jnp.float32
+    dt: jnp.float32  # Give a more explicit name
+    collision_alpha: jnp.float32
+    collision_eps: jnp.float32
+    entities: EntityState
+    agents: AgentState
+    objects: ObjectState    
+
+
+### Define helper functions used to step from one state to the next one ###
+
+#--- 1 Functions to compute the proximeter of braitenberg agents ---#
+proximity_map = vmap(relative_position, (0, 0))
+
+def sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists):
+    """
+    Compute the proximeter activations (left, right) induced by the presence of an entity
+    :param dist: distance from the agent to the entity
+    :param relative_theta: angle of the entity in the reference frame of the agent (front direction at angle 0)
+    :param dist_max: Max distance of the proximiter (will return 0. above this distance)
+    :param cos_min: Field of view as a cosinus (e.g. cos_min = 0 means a pi/4 FoV on each proximeter, so pi/2 in total)
+    :return: left and right proximeter activation in a jnp array with shape (2,)
+    """
+    cos_dir = jnp.cos(relative_theta)
+    prox = 1. - (dist / dist_max)
+    in_view = jnp.logical_and(dist < dist_max, cos_dir > cos_min)
+    at_left = jnp.logical_and(True, jnp.sin(relative_theta) >= 0)
+    left = in_view * at_left * prox
+    right = in_view * (1. - at_left) * prox
+    return jnp.array([left, right]) * target_exists  # i.e. 0 if target does not exist
+
+sensor_fn = vmap(sensor_fn, (0, 0, 0, 0, 0))
+
+def sensor(dist, relative_theta, dist_max, cos_min, max_agents, senders, target_exists):
+    """Return the sensor values of all agents
+
+    :param dist: relative distances between agents and targets
+    :param relative_theta: relative angles between agents and targets
+    :param dist_max: maximum range of proximeters
+    :param cos_min: cosinus of proximeters angles
+    :param max_agents: number of agents
+    :param senders: indexes of agents sensing the environment
+    :param target_exists: mask to indicate which sensed entities exist or not 
+    :return: proximeter activations
+    """
+    raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exists)
+    # Computes the maximum within the proximeter activations of agents on all their neigbhors.
+    proxs = ops.segment_max(
+        raw_proxs,
+        senders,    
+        max_agents)
+    
+    return proxs
+
+def compute_prox(state, agents_neighs_idx, target_exists_mask, displacement):
+    """
+    Set agents' proximeter activations
+    :param state: full simulation State
+    :param agents_neighs_idx: Neighbor representation, where sources are only agents. Matrix of shape (2, n_pairs),
+    where n_pairs is the number of neighbor entity pairs where sources (first row) are agent indexes.
+    :param target_exists_mask: Specify which target entities exist. Vector with shape (n_entities,).
+    target_exists_mask[i] is True (resp. False) if entity of index i in state.entities exists (resp. don't exist).
+    :return:
+    """
+    body = state.entities.position
+    mask = target_exists_mask[agents_neighs_idx[1, :]]   
+    senders, receivers = agents_neighs_idx
+    Ra = body.center[senders]
+    Rb = body.center[receivers]
+    dR = - space.map_bond(displacement)(Ra, Rb)  # Looks like it should be opposite, but don't understand why
+
+    # Create distance and angle maps between entities
+    dist, theta = proximity_map(dR, body.orientation[senders])
+    proximity_map_dist = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))
+    proximity_map_dist = proximity_map_dist.at[senders, receivers].set(dist)
+    proximity_map_theta = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))
+    proximity_map_theta = proximity_map_theta.at[senders, receivers].set(theta)
+
+    prox = sensor(dist, theta, state.agents.proxs_dist_max[senders],
+                    state.agents.proxs_cos_min[senders], len(state.agents.ent_idx), senders, mask)
+    
+    return prox, proximity_map_dist, proximity_map_theta
+
+
+#--- 2 Functions to compute the motor activations of braitenberg agents ---#
+class Behaviors(Enum):
+    FEAR = 0
+    AGGRESSION = 1
+    LOVE = 2
+    SHY = 3
+    NOOP = 4
+    MANUAL = 5
+
+behavior_params = {
+    Behaviors.FEAR.value: jnp.array(
+        [[1., 0., 0.], 
+         [0., 1., 0.]]),
+    Behaviors.AGGRESSION.value: jnp.array(
+        [[0., 1., 0.], 
+         [1., 0., 0.]]),
+    Behaviors.LOVE.value: jnp.array(
+        [[-1., 0., 1.], 
+         [0., -1., 1.]]),
+    Behaviors.SHY.value: jnp.array(
+        [[0., -1., 1.], 
+         [-1., 0., 1.]]),
+    Behaviors.NOOP.value: jnp.array(
+        [[0., 0., 0.], 
+         [0., 0., 0.]]),
+}
+
+def behavior_to_params(behavior):
+    """Return the params associated to a behavior.
+
+    :param behavior: behavior id (int)
+    :return: params
+    """
+    return behavior_params[behavior]
+
+def linear_behavior(proxs, params):
+    """Compute the activation of motors with a linear combination of proximeters and parameters
+
+    :param proxs: proximeter values of an agent
+    :param params: parameters of an agent (mapping proxs to motor values)
+    :return: motor values
+    """
+    return params.dot(jnp.hstack((proxs, 1.)))
+
+v_linear_behavior = vmap(linear_behavior, in_axes=(0, 0))
+                    
+def compute_motor(proxs, params, behaviors, motors):
+    """Compute new motor values. If behavior is manual, keep same motor values. Else, compute new values with proximeters and params.
+
+    :param proxs: proximeters of all agents
+    :param params: parameters mapping proximeters to new motor values
+    :param behaviors: array of behaviors
+    :param motors: current motor values
+    :return: new motor values
+    """
+    manual = jnp.where(behaviors == Behaviors.MANUAL.value, 1, 0)
+    manual_mask = jnp.broadcast_to(jnp.expand_dims(manual, axis=1), motors.shape)
+    linear_motor_values = v_linear_behavior(proxs, params)
+    motor_values = linear_motor_values * (1 - manual_mask) + motors * manual_mask
+    return motor_values
+
+def lr_2_fwd_rot(left_spd, right_spd, base_length, wheel_diameter):
+    """Return the forward and angular speeds according the the speeds of left and right wheels
+
+    :param left_spd: left wheel speed
+    :param right_spd: right wheel speed
+    :param base_length: distance between two wheels (diameter of the agent)
+    :param wheel_diameter: diameter of wheels
+    :return: forward and angular speeds
+    """
+    fwd = (wheel_diameter / 4.) * (left_spd + right_spd)
+    rot = 0.5 * (wheel_diameter / base_length) * (right_spd - left_spd)
+    return fwd, rot
+
+def fwd_rot_2_lr(fwd, rot, base_length, wheel_diameter):
+    """Return the left and right wheels speeds according to the forward and angular speeds
+
+    :param fwd: forward speed
+    :param rot: angular speed
+    :param base_length: distance between wheels (diameter of agent)
+    :param wheel_diameter: diameter of wheels
+    :return: left wheel speed, right wheel speed
+    """
+    left = ((2.0 * fwd) - (rot * base_length)) / wheel_diameter
+    right = ((2.0 * fwd) + (rot * base_length)) / wheel_diameter
+    return left, right
+
+def motor_command(wheel_activation, base_length, wheel_diameter):
+    """Return the forward and angular speed according to wheels speeds
+
+    :param wheel_activation: wheels speeds
+    :param base_length: distance between wheels
+    :param wheel_diameter: wheel diameters
+    :return: forward and angular speeds
+    """
+    fwd, rot = lr_2_fwd_rot(wheel_activation[0], wheel_activation[1], base_length, wheel_diameter)
+    return fwd, rot
+
+motor_command = vmap(motor_command, (0, 0, 0))
+
+
+#--- 3 Functions to compute the different forces in the environment ---#
+# TODO : Refactor the code in order to simply the definition of a total force fn incorporating different forces
+def braintenberg_force_fn(displacement):
+    """Return the force function of the environment
+
+    :param displacement: displacement function to compute distances between entities
+    :return: force function
+    """
+    coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement))
+
+    def collision_force(state, neighbor, exists_mask):
+        """Returns the collision force function of the environment
+
+        :param state: state
+        :param neighbor: neighbor maps of entities
+        :param exists_mask: mask on existing entities
+        :return: collision force function
+        """
+        return coll_force_fn(
+            state.entities.position.center,
+            neighbor=neighbor,
+            exists_mask=exists_mask,
+            diameter=state.entities.diameter,
+            epsilon=state.collision_eps,
+            alpha=state.collision_alpha
+            )
+
+    def motor_force(state, exists_mask):
+        """Returns the motor force function of the environment
+
+        :param state: state
+        :param exists_mask: mask on existing entities
+        :return: motor force function
+        """
+        agent_idx = state.agents.ent_idx
+
+        body = rigid_body.RigidBody(
+            center=state.entities.position.center[agent_idx],
+            orientation=state.entities.position.orientation[agent_idx]
+            )
+        
+        n = normal(body.orientation)
+
+        fwd, rot = motor_command(
+            state.agents.motor,
+            state.entities.diameter[agent_idx],
+            state.agents.wheel_diameter
+            )
+        # `a_max` arg is deprecated in recent versions of jax, replaced by `max`
+        fwd = jnp.clip(fwd, a_max=state.agents.max_speed)
+
+        cur_vel = state.entities.momentum.center[agent_idx] / state.entities.mass.center[agent_idx]
+        cur_fwd_vel = vmap(jnp.dot)(cur_vel, n)
+        cur_rot_vel = state.entities.momentum.orientation[agent_idx] / state.entities.mass.orientation[agent_idx]
+        
+        fwd_delta = fwd - cur_fwd_vel
+        rot_delta = rot - cur_rot_vel
+
+        fwd_force = n * jnp.tile(fwd_delta, (SPACE_NDIMS, 1)).T * jnp.tile(state.agents.speed_mul, (SPACE_NDIMS, 1)).T
+        rot_force = rot_delta * state.agents.theta_mul
+
+        center=jnp.zeros_like(state.entities.position.center).at[agent_idx].set(fwd_force)
+        orientation=jnp.zeros_like(state.entities.position.orientation).at[agent_idx].set(rot_force)
+
+        # apply mask to make non existing agents stand still
+        orientation = jnp.where(exists_mask, orientation, 0.)
+        # Because position has SPACE_NDMS dims, need to stack the mask to give it the same shape as center
+        exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1)
+        center = jnp.where(exists_mask, center, 0.)
+
+        return rigid_body.RigidBody(center=center,
+                                    orientation=orientation)
+    
+    def force_fn(state, neighbor, exists_mask):
+        """Returns the total force applied on the environment
+
+        :param state: state
+        :param neighbor: neighbor map
+        :param exists_mask: existing entities mask
+        :return: total force
+        """
+        mf = motor_force(state, exists_mask)
+        cf = collision_force(state, neighbor, exists_mask)
+        ff = friction_force(state, exists_mask)
+        
+        center = cf + ff + mf.center
+        orientation = mf.orientation
+        return rigid_body.RigidBody(center=center, orientation=orientation)
+
+    return force_fn
+
+#--- 4 Define the environment class with its different functions (step ...) ---#
+class BraitenbergEnv(BaseEnv):
+    def __init__(self, state, seed=42):
+        self.seed = seed
+        self.init_key = random.PRNGKey(seed)
+        self.displacement, self.shift = space.periodic(state.box_size)
+        self.init_fn, self.apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn)
+        self.neighbor_fn = partition.neighbor_list(
+            self.displacement, 
+            state.box_size,
+            r_cutoff=state.neighbor_radius,
+            dr_threshold=10.,
+            capacity_multiplier=1.5,
+            format=partition.Sparse
+        )
+
+        self.neighbors, self.agents_neighs_idx = self.allocate_neighbors(state)
+
+    def distance(self, point1, point2):
+            return distance(self.displacement, point1, point2)
+    
+    @partial(jit, static_argnums=(0,))
+    def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]:
+        # 1 : Compute agents proximeter
+        exists_mask = jnp.where(state.entities.exists == 1, 1, 0)
+        prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=self.displacement)
+
+        # 2 : Compute motor activations according to new proximeter values
+        motor = compute_motor(prox, state.agents.params, state.agents.behavior, state.agents.motor)
+        agents = state.agents.replace(
+            prox=prox, 
+            proximity_map_dist=proximity_dist_map, 
+            proximity_map_theta=proximity_dist_theta,
+            motor=motor
+        )
+
+        # 3 : Update the state with new agents proximeter and motor values
+        state = state.replace(agents=agents)
+
+        # 4 : Move the entities by applying forces on them (collision, friction and motor forces for agents)
+        entities = self.apply_physics(state, neighbors)
+        state = state.replace(time=state.time+1, entities=entities)
+
+        # 5 : Update neighbors
+        neighbors = neighbors.update(state.entities.position.center)
+        return state, neighbors
+    
+    def step(self, state: State) -> State:
+        if state.entities.momentum is None:
+             state = self.init_fn(state, self.init_key)
+        current_state = state
+        state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx)
+        if self.neighbors.did_buffer_overflow:
+            # reallocate neighbors and run the simulation from current_state
+            lg.warning(f'NEIGHBORS BUFFER OVERFLOW at step {state.time}: rebuilding neighbors')
+            neighbors, self.agents_neighs_idx = self.allocate_neighbors(state)
+            assert not neighbors.did_buffer_overflow
+
+        self.neighbors = neighbors
+        return state
+
+    def allocate_neighbors(self, state, position=None):
+        neighbors = super().allocate_neighbors(state, position)
+
+        # Also update the neighbor idx of agents (not the cleanest to attribute it to with self here)
+        ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value
+        agents_neighs_idx = neighbors.idx[:, ag_idx]
+        
+        return neighbors, agents_neighs_idx
+
+#--- 5 Define helper functions to initialize a state #
+SEED = 0
+MAX_AGENTS = 10
+MAX_OBJECTS = 2
+N_DIMS = 2
+BOX_SIZE = 100
+DIAMETER = 5.0
+FRICTION = 0.1
+MASS_CENTER = 1.0
+MASS_ORIENTATION = 0.125
+NEIGHBOR_RADIUS = 100.0
+COLLISION_ALPHA = 0.5
+COLLISION_EPS = 0.1
+DT = 0.1
+WHEEL_DIAMETER = 2.0
+SPEED_MUL = 1.0
+MAX_SPEED = 10.0
+THETA_MUL = 1.0
+PROX_DIST_MAX = 40.0
+PROX_COS_MIN = 0.0
+AGENTS_COLOR = jnp.array([0.0, 0.0, 1.0])
+OBJECTS_COLOR = jnp.array([1.0, 0.0, 0.0])
+BEHAVIOR = Behaviors.AGGRESSION.value
+
+def init_state(
+    box_size=BOX_SIZE,
+    dt=DT,
+    max_agents=MAX_AGENTS,
+    max_objects=MAX_OBJECTS,
+    neighbor_radius=NEIGHBOR_RADIUS,
+    collision_alpha=COLLISION_ALPHA,
+    collision_eps=COLLISION_EPS,
+    n_dims=N_DIMS,
+    seed=SEED,
+    diameter=DIAMETER,
+    friction=FRICTION,
+    mass_center=MASS_CENTER,
+    mass_orientation=MASS_ORIENTATION,
+    existing_agents=None,
+    existing_objects=None,
+    behavior=BEHAVIOR,
+    wheel_diameter=WHEEL_DIAMETER,
+    speed_mul=SPEED_MUL,
+    max_speed=MAX_SPEED,
+    theta_mul=THETA_MUL,
+    prox_dist_max=PROX_DIST_MAX,
+    prox_cos_min=PROX_COS_MIN,
+    agents_color=AGENTS_COLOR,
+    objects_color=OBJECTS_COLOR
+) -> State:
+
+    key = random.PRNGKey(seed)
+    key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)
+
+    entities = init_entities(
+        max_objects=max_objects,
+        max_agents=max_agents,
+        n_dims=n_dims,
+        box_size=box_size,
+        existing_agents=existing_agents,
+        existing_objects=existing_objects,
+        mass_center=mass_center,
+        mass_orientation=mass_orientation,
+        diameter=diameter,
+        friction=friction,
+        key_agents_pos=key_agents_pos,
+        key_objects_pos=key_objects_pos,
+        key_orientations=key_orientations
+    )
+        
+    agents = init_agents(
+        max_agents=max_agents,
+        behavior=behavior,
+        wheel_diameter=wheel_diameter,
+        speed_mul=speed_mul,
+        max_speed=max_speed,
+        theta_mul=theta_mul, 
+        prox_dist_max=prox_dist_max,
+        prox_cos_min=prox_cos_min,
+        agents_color=agents_color
+
+    )
+
+    objects = init_objects(
+        max_agents=max_agents,
+        max_objects=max_objects,
+        objects_color=objects_color
+    )
+
+    state = init_complete_state(
+        entities=entities, 
+        agents=agents, 
+        objects=objects,
+        box_size=box_size,
+        max_agents=max_agents,
+        max_objects=max_objects,
+        neighbor_radius=neighbor_radius,
+        collision_alpha=collision_alpha,
+        collision_eps=collision_eps,
+        dt=dt
+    )
+
+    return state
+
+def init_entities(
+    max_agents=MAX_AGENTS,
+    max_objects=MAX_OBJECTS,
+    n_dims=N_DIMS,
+    box_size=BOX_SIZE,
+    existing_agents=None,
+    existing_objects=None,
+    mass_center=MASS_CENTER,
+    mass_orientation=MASS_ORIENTATION,
+    diameter=DIAMETER,
+    friction=FRICTION,
+    key_agents_pos=random.PRNGKey(SEED),
+    key_objects_pos=random.PRNGKey(SEED+1),
+    key_orientations=random.PRNGKey(SEED+2)
+):
+    existing_agents = max_agents if not existing_agents else existing_agents
+    existing_objects = max_objects if not existing_objects else existing_objects
+    n_entities = max_agents + max_objects # we store the entities data in jax arrays of length max_agents + max_objects 
+    # Assign random positions to each entity in the environment
+    agents_positions = random.uniform(key_agents_pos, (max_agents, n_dims)) * box_size
+    objects_positions = random.uniform(key_objects_pos, (max_objects, n_dims)) * box_size
+    positions = jnp.concatenate((agents_positions, objects_positions))
+    # Assign random orientations between 0 and 2*pi to each entity
+    orientations = random.uniform(key_orientations, (n_entities,)) * 2 * jnp.pi
+    # Assign types to the entities
+    agents_entities = jnp.full(max_agents, EntityType.AGENT.value)
+    object_entities = jnp.full(max_objects, EntityType.OBJECT.value)
+    entity_types = jnp.concatenate((agents_entities, object_entities), dtype=int)
+    # Define arrays with existing entities
+    exists_agents = jnp.concatenate((jnp.ones((existing_agents)), jnp.zeros((max_agents - existing_agents))))
+    exists_objects = jnp.concatenate((jnp.ones((existing_objects)), jnp.zeros((max_objects - existing_objects))))
+    exists = jnp.concatenate((exists_agents, exists_objects), dtype=int)
+
+    return EntityState(
+        position=RigidBody(center=positions, orientation=orientations),
+        momentum=None,
+        force=RigidBody(center=jnp.zeros((n_entities, 2)), orientation=jnp.zeros(n_entities)),
+        mass=RigidBody(center=jnp.full((n_entities, 1), mass_center), orientation=jnp.full((n_entities), mass_orientation)),
+        entity_type=entity_types,
+        entity_idx = jnp.array(list(range(max_agents)) + list(range(max_objects))),
+        diameter=jnp.full((n_entities), diameter),
+        friction=jnp.full((n_entities), friction),
+        exists=exists
+    )
+
+def init_agents(
+    max_agents=MAX_AGENTS,
+    behavior=BEHAVIOR,
+    wheel_diameter=WHEEL_DIAMETER,
+    speed_mul=SPEED_MUL,
+    max_speed=MAX_SPEED,
+    theta_mul=THETA_MUL,
+    prox_dist_max=PROX_DIST_MAX,
+    prox_cos_min=PROX_COS_MIN,
+    agents_color=AGENTS_COLOR
+):
+    # Need to use a np array because jax jax array can't be the key of a dict (for fn behaviors_to_params)
+    np_behaviors = np.full((max_agents), behavior)
+    params = jnp.array([behavior_to_params(behavior) for behavior in np_behaviors])
+    behaviors = jnp.array(np_behaviors)
+    return AgentState(
+        # idx in the entities (ent_idx) state to map agents information in the different data structures
+        ent_idx=jnp.arange(max_agents, dtype=int), 
+        prox=jnp.zeros((max_agents, 2)),
+        motor=jnp.zeros((max_agents, 2)),
+        behavior=behaviors,
+        params=params,
+        wheel_diameter=jnp.full((max_agents), wheel_diameter),
+        speed_mul=jnp.full((max_agents), speed_mul),
+        max_speed=jnp.full((max_agents), max_speed),
+        theta_mul=jnp.full((max_agents), theta_mul),
+        proxs_dist_max=jnp.full((max_agents), prox_dist_max),
+        proxs_cos_min=jnp.full((max_agents), prox_cos_min),
+        proximity_map_dist=jnp.zeros((max_agents, 1)),
+        proximity_map_theta=jnp.zeros((max_agents, 1)),
+        color=jnp.tile(agents_color, (max_agents, 1))
+    )
+
+def init_objects(
+    max_agents=MAX_AGENTS,
+    max_objects=MAX_OBJECTS,
+    objects_color=OBJECTS_COLOR
+):
+    # Entities idx of objects
+    start_idx, stop_idx = max_agents, max_agents + max_objects 
+    objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int)
+
+    return ObjectState(
+        ent_idx=objects_ent_idx,
+        color=jnp.tile(objects_color, (max_objects, 1))
+    )
+
+def init_complete_state(
+    entities=None,
+    agents=None,
+    objects=None,
+    box_size=BOX_SIZE,
+    max_agents=MAX_AGENTS,
+    max_objects=MAX_OBJECTS,
+    neighbor_radius=NEIGHBOR_RADIUS,
+    collision_alpha=COLLISION_ALPHA,
+    collision_eps=COLLISION_EPS,
+    dt=DT
+):
+    return State(
+        time=0,
+        box_size=box_size,
+        max_agents=max_agents,
+        max_objects=max_objects,
+        neighbor_radius=neighbor_radius,
+        collision_alpha=collision_alpha,
+        collision_eps=collision_eps,
+        dt=dt,
+        entities=entities,
+        agents=agents,
+        objects=objects
+    )   
diff --git a/vivarium/experimental/environments/particle_lenia/simple.py b/vivarium/experimental/environments/particle_lenia/simple.py
new file mode 100644
index 0000000..f87f5c1
--- /dev/null
+++ b/vivarium/experimental/environments/particle_lenia/simple.py
@@ -0,0 +1 @@
+# TODO
\ No newline at end of file
diff --git a/vivarium/experimental/environments/physics_engine.py b/vivarium/experimental/environments/physics_engine.py
new file mode 100644
index 0000000..6613d51
--- /dev/null
+++ b/vivarium/experimental/environments/physics_engine.py
@@ -0,0 +1,150 @@
+from functools import partial
+
+import jax
+import jax.numpy as jnp
+
+from jax import vmap, lax
+from jax_md import rigid_body, util, simulate, energy, quantity
+f32 = util.f32
+
+
+SPACE_NDIMS = 2
+
+# Helper functions for collisions
+def collision_energy(displacement_fn, r_a, r_b, l_a, l_b, epsilon, alpha, mask):
+    """Compute the collision energy between a pair of particles
+
+    :param displacement_fn: displacement function of jax_md 
+    :param r_a: position of particle a 
+    :param r_b: position of particle b 
+    :param l_a: diameter of particle a 
+    :param l_b: diameter of particle b 
+    :param epsilon: interaction energy scale 
+    :param alpha: interaction stiffness
+    :param mask: set the energy to 0 if one of the particles is masked 
+    :return: collision energy between both particles
+    """
+    dist = jnp.linalg.norm(displacement_fn(r_a, r_b))
+    sigma = (l_a + l_b) / 2
+    e = energy.soft_sphere(dist, sigma=sigma, epsilon=epsilon, alpha=f32(alpha))
+    return jnp.where(mask, e, 0.)
+
+collision_energy = vmap(collision_energy, (None, 0, 0, 0, 0, None, None, 0))
+
+def total_collision_energy(positions, diameter, neighbor, displacement, exists_mask, epsilon, alpha):
+    """Compute the collision energy between all neighboring pairs of particles in the system 
+
+    :param positions: positions of all the particles 
+    :param diameter: diameters of all the particles 
+    :param neighbor: neighbor array of the system
+    :param displacement: dipalcement function of jax_md
+    :param exists_mask: mask to specify which particles exist 
+    :param epsilon: interaction energy scale between two particles
+    :param alpha: interaction stiffness between two particles
+    :return: sum of all collisions energies of the system 
+    """
+    diameter = lax.stop_gradient(diameter)
+    senders, receivers = neighbor.idx
+
+    r_senders = positions[senders]
+    r_receivers = positions[receivers]
+    l_senders = diameter[senders]
+    l_receivers = diameter[receivers]
+
+    # Set collision energy to zero if the sender or receiver is non existing
+    mask = exists_mask[senders] * exists_mask[receivers]
+    energies = collision_energy(displacement,
+                                 r_senders,
+                                 r_receivers,
+                                 l_senders,
+                                 l_receivers,
+                                 epsilon,
+                                 alpha,
+                                 mask)
+    return jnp.sum(energies)
+
+# Functions to compute the verlet force on the whole system
+def friction_force(state, exists_mask):
+    cur_vel = state.entities.momentum.center / state.entities.mass.center
+    # stack the mask to give it the same shape as cur_vel (that has 2 rows for forward and angular velocities) 
+    mask = jnp.stack([exists_mask] * 2, axis=1) 
+    cur_vel = jnp.where(mask, cur_vel, 0.)
+    return - jnp.tile(state.entities.friction, (SPACE_NDIMS, 1)).T * cur_vel
+
+def collision_force(state, neighbor, exists_mask, displacement):
+    coll_force_fn = quantity.force(
+        total_collision_energy(
+            positions=state.entities.position.center,
+            displacement=displacement,
+            neighbor=neighbor,
+            exists_mask=exists_mask,
+            diameter=state.entities.diameter,
+            epsilon=state.collision_eps,
+            alpha=state.collision_alpha
+            )
+    )
+
+    return coll_force_fn
+
+
+def verlet_force_fn(displacement):
+    coll_force_fn = quantity.force(partial(total_collision_energy, displacement=displacement))
+
+    def collision_force(state, neighbor, exists_mask):
+        return coll_force_fn(
+            state.entities.position.center,
+            neighbor=neighbor,
+            exists_mask=exists_mask,
+            diameter=state.entities.diameter,
+            epsilon=state.collision_eps,
+            alpha=state.collision_alpha
+            )
+
+    def force_fn(state, neighbor, exists_mask):
+        cf = collision_force(state, neighbor, exists_mask)
+        ff = friction_force(state, exists_mask)
+        center = cf + ff
+        return rigid_body.RigidBody(center=center, orientation=0)
+
+    return force_fn
+
+
+def dynamics_fn(displacement, shift, force_fn=None):
+    force_fn = force_fn(displacement) if force_fn else verlet_force_fn(displacement)
+    
+    def init_fn(state, key, kT=0.):
+        key, _ = jax.random.split(key)
+        assert state.entities.momentum is None
+        assert not jnp.any(state.entities.force.center) and not jnp.any(state.entities.force.orientation)
+
+        state = state.replace(entities=simulate.initialize_momenta(state.entities, key, kT))
+        return state
+    
+    def mask_momentum(entity_state, exists_mask):
+        """
+        Set the momentum values to zeros for non existing entities
+        :param entity_state: entity_state
+        :param exists_mask: bool array specifying which entities exist or not
+        :return: entity_state: new entities state state with masked momentum values
+        """
+        orientation = jnp.where(exists_mask, entity_state.momentum.orientation, 0)
+        exists_mask = jnp.stack([exists_mask] * SPACE_NDIMS, axis=1)
+        center = jnp.where(exists_mask, entity_state.momentum.center, 0)
+        momentum = rigid_body.RigidBody(center=center, orientation=orientation)
+        return entity_state.set(momentum=momentum)
+
+    def step_fn(state, neighbor):
+        exists_mask = (state.entities.exists == 1)  # Only existing entities have effect on others
+        dt_2 = state.dt / 2.
+        # Compute forces
+        force = force_fn(state, neighbor, exists_mask)
+        # Compute changes on entities
+        entity_state = simulate.momentum_step(state.entities, dt_2)
+        # TODO : why do we used dt and not dt/2 in the line below ? 
+        entity_state = simulate.position_step(entity_state, shift, dt_2, neighbor=neighbor)
+        entity_state = entity_state.replace(force=force)
+        entity_state = simulate.momentum_step(entity_state, dt_2)
+        entity_state = mask_momentum(entity_state, exists_mask)
+        return entity_state
+
+    return init_fn, step_fn
diff --git a/vivarium/experimental/environments/utils.py b/vivarium/experimental/environments/utils.py
new file mode 100644
index 0000000..466c4e7
--- /dev/null
+++ b/vivarium/experimental/environments/utils.py
@@ -0,0 +1,37 @@
+import jax.numpy as jnp
+from jax import vmap 
+
+@vmap 
+def normal(theta):
+    """Returns the cos and the sin of an angle
+
+    :param theta: angle in radians
+    :return: cos and sin
+    """
+    return jnp.array([jnp.cos(theta), jnp.sin(theta)])
+
+def distance(displacement_fn, point1, point2):
+    """Returns the distance between two points
+
+    :param displacement_fn: displacement function (typically a jax_md.space function)
+    :param point1: point 1
+    :param point2: point 2
+    :return: distance between the two points
+    """
+    diff = displacement_fn(point1, point2)
+    squared_diff = jnp.sum(jnp.square(diff))
+    return jnp.sqrt(squared_diff)
+
+def relative_position(displ, theta):
+    """
+    Compute the relative distance and angle from a source particle to a target particle
+    :param displ: Displacement vector (jnp arrray with shape (2,) from source to target
+    :param theta: Orientation of the source particle (in the reference frame of the map)
+    :return: dist: distance from source to target.
+    relative_theta: relative angle of the target in the reference frame of the source particle (front direction at angle 0)
+    """
+    dist = jnp.linalg.norm(displ)
+    norm_displ = displ / dist
+    theta_displ = jnp.arccos(norm_displ[0]) * jnp.sign(jnp.arcsin(norm_displ[1]))
+    relative_theta = theta_displ - theta
+    return dist, relative_theta
\ No newline at end of file
diff --git a/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb b/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb
new file mode 100644
index 0000000..5ce035c
--- /dev/null
+++ b/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb
@@ -0,0 +1,385 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Prey predator braitenberg notebook\n",
+    "\n",
+    "This notebook showcases how to add new features on top on a pre-existing vivarium environment. Here, we will focus on implementing a prey predator braitenberg environment !"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports\n",
+    "\n",
+    "First, let's import Classes and functions from the environment you want to build features on, as well as standard jax elements to build new features in our environment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-07-04 11:03:15.059320: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from enum import Enum\n",
+    "from functools import partial\n",
+    "from typing import Tuple\n",
+    "\n",
+    "import numpy as np\n",
+    "import jax.numpy as jnp\n",
+    "\n",
+    "from jax import vmap, jit\n",
+    "from flax import struct\n",
+    "\n",
+    "from vivarium.experimental.environments.braitenberg.simple import BraitenbergEnv, AgentState, State, EntityType, init_complete_state, init_entities, init_objects\n",
+    "from vivarium.experimental.environments.braitenberg.simple import compute_motor, compute_prox, behavior_to_params, Behaviors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Define the states classes of prey predator env \n",
+    "\n",
+    "Define the new classes and constants of the environment. We will just add a new field agent_type (prey or predator) for all of our agents, so whe can differenciate them when we run the simulation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class AgentType(Enum):\n",
+    "    PREY = 0\n",
+    "    PREDATOR = 1\n",
+    "\n",
+    "@struct.dataclass\n",
+    "class AgentState(AgentState):\n",
+    "    agent_type: jnp.array"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Create the new state\n",
+    "\n",
+    "First we'll create a new state for the prey predator environment. It will be pretty similar to the one of the simple braitenberg env, but we will just add a new field agent_type to our agents. Additionally, we'll use different colors and behaviors for the prey and predators."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# parameter values\n",
+    "n_preys = 25\n",
+    "n_predators = 25\n",
+    "max_agents = n_preys + n_predators\n",
+    "pred_eating_range = 10\n",
+    "\n",
+    "box_size = 200\n",
+    "wheel_diameter = 2.0\n",
+    "speed_mul = 1.0\n",
+    "max_speed = 10.0\n",
+    "theta_mul = 1.0\n",
+    "prox_dist_max = 40.0\n",
+    "prox_cos_min = 0.0\n",
+    "box_size = 200\n",
+    "max_obj = 25\n",
+    "\n",
+    "prey_color = jnp.array([0.0, 0.0, 1.0])\n",
+    "predator_color = jnp.array([1.0, 0.0, 0.0])\n",
+    "objects_color = jnp.array([0., 1., 0.])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# construct fields for our agents dataclass\n",
+    "np_behaviors = np.hstack((np.full(n_preys, Behaviors.FEAR.value), np.full(n_predators, Behaviors.AGGRESSION.value)))\n",
+    "params = jnp.array([behavior_to_params(behavior) for behavior in np_behaviors])\n",
+    "behaviors = jnp.array(np_behaviors)\n",
+    "agent_types = jnp.hstack((jnp.full(n_preys, AgentType.PREY.value), jnp.full(n_predators, AgentType.PREDATOR.value)))\n",
+    "agents_colors = jnp.concatenate((jnp.tile(prey_color, (n_preys, 1)), jnp.tile(predator_color, (n_predators, 1))), axis=0)\n",
+    "\n",
+    "agents = AgentState(\n",
+    "    # idx in the entities (ent_idx) state to map agents information in the different data structures\n",
+    "    ent_idx=jnp.arange(max_agents, dtype=int),\n",
+    "    agent_type=agent_types, \n",
+    "    prox=jnp.zeros((max_agents, 2)),\n",
+    "    motor=jnp.zeros((max_agents, 2)),\n",
+    "    behavior=behaviors,\n",
+    "    params=params,\n",
+    "    wheel_diameter=jnp.full((max_agents), wheel_diameter),\n",
+    "    speed_mul=jnp.full((max_agents), speed_mul),\n",
+    "    max_speed=jnp.full((max_agents), max_speed),\n",
+    "    theta_mul=jnp.full((max_agents), theta_mul),\n",
+    "    proxs_dist_max=jnp.full((max_agents), prox_dist_max),\n",
+    "    proxs_cos_min=jnp.full((max_agents), prox_cos_min),\n",
+    "    proximity_map_dist=jnp.zeros((max_agents, 1)),\n",
+    "    proximity_map_theta=jnp.zeros((max_agents, 1)),\n",
+    "    color=agents_colors\n",
+    "    )\n",
+    "\n",
+    "# create entities and objects with helper functions\n",
+    "entities = init_entities(max_agents=max_agents, max_objects=max_obj, box_size=box_size)\n",
+    "objects = init_objects(max_objects=max_obj, objects_color=objects_color)\n",
+    "\n",
+    "# create the final state with all the elements\n",
+    "state = init_complete_state(\n",
+    "    entities=entities,\n",
+    "    agents=agents,\n",
+    "    objects=objects,\n",
+    "    box_size=box_size,\n",
+    "    max_agents=max_agents,\n",
+    "    max_objects=max_obj\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Define prey predator env class \n",
+    "\n",
+    "Now that we created our new state, we need to create the environment class where we'll implement the logic of the simulation. It will inherit from the simple Braitenberg env, so we will only have to overwrite a few methods and create some new ones to make our prey predator environment. \n",
+    "\n",
+    "First, we need to overwrite the \\_\\_init__() function to allow specifying new parameters about preys and predators (the pred_eating_range in our case).\n",
+    "\n",
+    "Finally, we just have to write functions to implement our new desired features (here the predators will kill the preys next to them), and add them in the _step() function !"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class PreyPredBraitenbergEnv(BraitenbergEnv):\n",
+    "    def __init__(\n",
+    "            self,\n",
+    "            state,\n",
+    "            pred_eating_range\n",
+    "    ):  \n",
+    "        super().__init__(state=state)\n",
+    "        # Add idx utils to simplify conversions between entities and agent states\n",
+    "        self.agents_idx = jnp.where(state.entities.entity_type == EntityType.AGENT.value)\n",
+    "        self.prey_idx = jnp.where(state.agents.agent_type == AgentType.PREY.value)\n",
+    "        self.pred_idx = jnp.where(state.agents.agent_type == AgentType.PREDATOR.value)\n",
+    "        self.pred_eating_range = pred_eating_range\n",
+    "\n",
+    "    # Add a function to detect if a prey will be eaten by a predator in the current step\n",
+    "    def can_all_be_eaten(self, R_prey, R_predators, predator_exist):\n",
+    "        # Could maybe create this as a method in the class, or above idk\n",
+    "        distance_to_all_preds = vmap(self.distance, in_axes=(None, 0))\n",
+    "\n",
+    "        # Same for this, the only pb is that the fn above needs the displacement arg, so can't define it in the cell above \n",
+    "        def can_be_eaten(R_prey, R_predators, predator_exist):\n",
+    "            dist_to_preds = distance_to_all_preds(R_prey, R_predators)\n",
+    "            in_range = jnp.where(dist_to_preds < self.pred_eating_range, 1, 0)\n",
+    "            # Could also return which agent ate the other one (e.g to increase their energy) \n",
+    "            will_be_eaten_by = in_range * predator_exist\n",
+    "            eaten_or_not = jnp.where(jnp.sum(will_be_eaten_by) > 0., 1, 0)\n",
+    "            return eaten_or_not\n",
+    "        \n",
+    "        can_be_eaten = vmap(can_be_eaten, in_axes=(0, None, None))\n",
+    "        \n",
+    "        return can_be_eaten(R_prey, R_predators, predator_exist)\n",
+    "    \n",
+    "    # Add functions so predators eat preys\n",
+    "    def eat_preys(self, state):\n",
+    "        # See which preys can be eaten by predators and update the exists array accordingly\n",
+    "        R = state.entities.position.center\n",
+    "        exist = state.entities.exists\n",
+    "        prey_idx = self.prey_idx\n",
+    "        pred_idx = self.pred_idx\n",
+    "\n",
+    "        agents_ent_idx = state.agents.ent_idx\n",
+    "        predator_exist = exist[agents_ent_idx][pred_idx]\n",
+    "        can_be_eaten_idx = self.can_all_be_eaten(R[prey_idx], R[pred_idx], predator_exist)\n",
+    "\n",
+    "        # Kill the agents that are being eaten\n",
+    "        exist_prey = exist[agents_ent_idx[prey_idx]]\n",
+    "        new_exists_prey = jnp.where(can_be_eaten_idx == 1, 0, exist_prey)\n",
+    "        exist = exist.at[agents_ent_idx[prey_idx]].set(new_exists_prey)\n",
+    "\n",
+    "        return exist\n",
+    "\n",
+    "    # Add the eat_preys function in the _step loop\n",
+    "    @partial(jit, static_argnums=(0,))\n",
+    "    def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]:\n",
+    "        # 1 Compute which agents are being eaten\n",
+    "        exist = self.eat_preys(state)\n",
+    "        entities = state.entities.replace(exists=exist)\n",
+    "\n",
+    "        # 2 Compute the proximeter of agents\n",
+    "        exists_mask = jnp.where(entities.exists == 1, 1, 0)\n",
+    "        prox, proximity_dist_map, proximity_dist_theta = compute_prox(state, agents_neighs_idx, target_exists_mask=exists_mask, displacement=self.displacement)\n",
+    "        motor = compute_motor(prox, state.agents.params, state.agents.behavior, state.agents.motor)\n",
+    "        agents = state.agents.replace(\n",
+    "            prox=prox, \n",
+    "            proximity_map_dist=proximity_dist_map, \n",
+    "            proximity_map_theta=proximity_dist_theta,\n",
+    "            motor=motor\n",
+    "        )\n",
+    "\n",
+    "        # 3 Update the state with the new agent and entities states\n",
+    "        state = state.replace(\n",
+    "            agents=agents,\n",
+    "            entities=entities\n",
+    "        )\n",
+    "\n",
+    "        # 4 Apply physics forces to the environment state\n",
+    "        entities = self.apply_physics(state, neighbors)\n",
+    "        state = state.replace(\n",
+    "            time=state.time+1,\n",
+    "            entities=entities,\n",
+    "        )\n",
+    "\n",
+    "        # 5 Update the neighbors according to the new positions\n",
+    "        neighbors = neighbors.update(state.entities.position.center)\n",
+    "        return state, neighbors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Create env and render its state\n",
+    "\n",
+    "We define the colors in our environment this way: \n",
+    "\n",
+    "- Prey agents: blue\n",
+    "- Predator agents: red\n",
+    "- Objects: green"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from vivarium.experimental.environments.braitenberg.render import render, render_history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "env = PreyPredBraitenbergEnv(\n",
+    "    state=state,\n",
+    "    pred_eating_range=pred_eating_range\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render(state)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Run a simulation on a few timesteps"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_steps = 2000\n",
+    "\n",
+    "hist = []\n",
+    "for i in range(n_steps):\n",
+    "    state = env.step(state)\n",
+    "    hist.append(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render_history(hist, skip_frames=10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The rendering function is quite laggy, but we can see that prey agents are now being eaten by predator ones ! "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/vivarium/experimental/notebooks/simple_braitenberg.ipynb b/vivarium/experimental/notebooks/simple_braitenberg.ipynb
new file mode 100644
index 0000000..082fec4
--- /dev/null
+++ b/vivarium/experimental/notebooks/simple_braitenberg.ipynb
@@ -0,0 +1,359 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os \n",
+    "os.environ['jax_cpu'] = \"CPU\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-07-03 16:30:26.129142: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "\n",
+    "from vivarium.experimental.environments.braitenberg.simple import BraitenbergEnv, init_state\n",
+    "from vivarium.experimental.environments.braitenberg.render import render, render_history"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Init and launch a simulation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "state = init_state()\n",
+    "env = BraitenbergEnv(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_steps = 1000\n",
+    "hist = []\n",
+    "\n",
+    "for i in range(n_steps):\n",
+    "    state = env.step(state)\n",
+    "    hist.append(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render_history(hist, skip_frames=10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Scale the size of the simulation\n",
+    "\n",
+    "Launch a simulation with a bigger box size, as well as more agents and objects."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "state = init_state(\n",
+    "    box_size=1000,\n",
+    "    max_agents=100,\n",
+    "    max_objects=50,\n",
+    "    existing_agents=90,\n",
+    "    existing_objects=30,\n",
+    "    prox_dist_max=100\n",
+    ") \n",
+    " \n",
+    "env = BraitenbergEnv(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:root:NEIGHBORS BUFFER OVERFLOW at step 3846: rebuilding neighbors\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Simulation ran in 9.619100965999905 for 20000 timesteps\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "n_steps = 20_000\n",
+    "\n",
+    "hist = []\n",
+    "\n",
+    "start = time.perf_counter()\n",
+    "for i in range(n_steps):\n",
+    "    state = env.step(state) \n",
+    "    hist.append(state)\n",
+    "end = time.perf_counter()\n",
+    "\n",
+    "w_rebuilding_time = end - start\n",
+    "print(f\"Simulation ran in {w_rebuilding_time} for {n_steps} timesteps\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render_history(hist, skip_frames=100)\n",
+    "# (Need to update the rendering of the env because the sizes aren't accurate)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test neighbors rebuilding time\n",
+    "\n",
+    "In the last run we see that there is a rebuilding of neighbors. To test (really roughly) how long it took, we just reduce the prox_dist_max of agents (set it to 10 which is really small). This way the original neighbor lists are the same, and because most of the agents will remain static and there won't be neighbor buffer overflow. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Simulation ran in 8.236717653999904 for 20000 timesteps\n"
+     ]
+    }
+   ],
+   "source": [
+    "state = init_state(\n",
+    "    box_size=1000,\n",
+    "    max_agents=100,\n",
+    "    max_objects=50,\n",
+    "    existing_agents=90,\n",
+    "    existing_objects=30,\n",
+    "    prox_dist_max=10\n",
+    ") \n",
+    " \n",
+    "env = BraitenbergEnv(state)\n",
+    "hist = []\n",
+    "\n",
+    "start = time.perf_counter()\n",
+    "for i in range(n_steps):\n",
+    "    state = env.step(state) \n",
+    "    hist.append(state)\n",
+    "end = time.perf_counter()\n",
+    "\n",
+    "wo_rebuilding_time = end - start\n",
+    "print(f\"Simulation ran in {wo_rebuilding_time} for {n_steps} timesteps\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Use manual mode"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import jax.numpy as jnp\n",
+    "from vivarium.experimental.environments.braitenberg.simple import Behaviors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "state = init_state() \n",
+    "env = BraitenbergEnv(state)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will set the behavior of our first 5 agents to manual. It means their motor values will stay the same regardless of their proximeter activations and params. To better dinstinguish them from other vehicles, we will set their color to green and their motors to 1 (they will go forward)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "behaviors = state.agents.behavior.at[0:5].set(Behaviors.MANUAL.value)\n",
+    "colors = state.agents.color.at[0:5].set(jnp.array([0., 1., 0.]))\n",
+    "motors = state.agents.motor.at[0:5].set(jnp.array([1., 1.]))\n",
+    "\n",
+    "agents = state.agents.replace(behavior=behaviors, color=colors, motor=motors)\n",
+    "state = state.replace(agents=agents)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_steps = 10_000\n",
+    "hist = []\n",
+    "\n",
+    "for i in range(n_steps):\n",
+    "    old_motors = state.agents.motor\n",
+    "    state = env.step(state)\n",
+    "    new_motors = state.agents.motor\n",
+    "    hist.append(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render_history(hist, skip_frames=50)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 0b0a66c92572964eb98df6ccf67570efb8e1bb7f Mon Sep 17 00:00:00 2001
From: Corentin <111868204+corentinlger@users.noreply.github.com>
Date: Tue, 9 Jul 2024 16:06:19 +0200
Subject: [PATCH 2/7] Corentin/selective sensors (#88)

* Add first version of refactored braitenberg env

* Add utils file

* Update way of computing forces in environment + Add general physics engine file

* Add first elements of tutorial on how to create an environment in a notebook

* Update braitenberg notebook and add new prey/predator braitenberg environment

* Delete new notebooks on refactored envs and associated files

* Add simple and prey_predator braitenberg envs in experimental directory

* Add first steps of sensorimotor functions refactoring

* Add first draft version of selective sensors braitenberg env

* Refactor simple braitenberg env and add utils file for all environments

* Update base env by removing intermediate state classes

* Remove duplicate code and add markdown comments

* Remove uncessary files

* Update simple braitenberg notebook

* Add selective sensors environment with old env interface

* Add manual mode in selective sensors and add some documentation

* Clean selective sensors imports and add notebook documentation

* Revert changes on non selective sensors environments
---
 .../notebooks/selective_sensors.ipynb         | 814 ++++++++++++++++++
 1 file changed, 814 insertions(+)
 create mode 100644 vivarium/experimental/notebooks/selective_sensors.ipynb

diff --git a/vivarium/experimental/notebooks/selective_sensors.ipynb b/vivarium/experimental/notebooks/selective_sensors.ipynb
new file mode 100644
index 0000000..aee523f
--- /dev/null
+++ b/vivarium/experimental/notebooks/selective_sensors.ipynb
@@ -0,0 +1,814 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Quick tutorial to explain how to create a environment with braitenberg vehicles equiped with selective sensors (still a draft so comments of the notebook won't be complete yet)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-07-09 15:48:58.727097: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import logging as lg\n",
+    "\n",
+    "from enum import Enum\n",
+    "from functools import partial\n",
+    "from typing import Tuple\n",
+    "\n",
+    "import numpy as np\n",
+    "import jax.numpy as jnp\n",
+    "\n",
+    "from jax import vmap, jit\n",
+    "from jax import random, ops, lax\n",
+    "\n",
+    "from flax import struct\n",
+    "from jax_md.rigid_body import RigidBody\n",
+    "from jax_md import simulate \n",
+    "from jax_md import space, rigid_body, partition, quantity\n",
+    "\n",
+    "from vivarium.experimental.environments.utils import normal, distance \n",
+    "from vivarium.experimental.environments.base_env import BaseState, BaseEnv\n",
+    "from vivarium.experimental.environments.physics_engine import total_collision_energy, friction_force, dynamics_fn\n",
+    "from vivarium.experimental.environments.braitenberg.simple import relative_position, proximity_map, sensor_fn, sensor\n",
+    "from vivarium.experimental.environments.braitenberg.simple import Behaviors, behavior_to_params, linear_behavior\n",
+    "from vivarium.experimental.environments.braitenberg.simple import lr_2_fwd_rot, fwd_rot_2_lr, motor_command\n",
+    "from vivarium.experimental.environments.braitenberg.simple import braintenberg_force_fn"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the classes and helper functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add entity sensed type as a field in entities + sensed in agents. The agents sense the \"sensed type\" of the entities. In our case, there will be preys, predators, ressources and poison."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "### Define the constants and the classes of the environment to store its state ###\n",
+    "SPACE_NDIMS = 2\n",
+    "\n",
+    "class EntityType(Enum):\n",
+    "    AGENT = 0\n",
+    "    OBJECT = 1\n",
+    "\n",
+    "class EntitySensedType(Enum):\n",
+    "    PREY = 0\n",
+    "    PRED = 1\n",
+    "    RESSOURCE = 2\n",
+    "    POISON = 3\n",
+    "\n",
+    "# Already incorporates position, momentum, force, mass and velocity\n",
+    "@struct.dataclass\n",
+    "class EntityState(simulate.NVEState):\n",
+    "    entity_type: jnp.array\n",
+    "    ent_sensed_type: jnp.array\n",
+    "    entity_idx: jnp.array\n",
+    "    diameter: jnp.array\n",
+    "    friction: jnp.array\n",
+    "    exists: jnp.array\n",
+    "    \n",
+    "@struct.dataclass\n",
+    "class ParticleState:\n",
+    "    ent_idx: jnp.array\n",
+    "    color: jnp.array\n",
+    "\n",
+    "@struct.dataclass\n",
+    "class AgentState(ParticleState):\n",
+    "    prox: jnp.array\n",
+    "    motor: jnp.array\n",
+    "    proximity_map_dist: jnp.array\n",
+    "    proximity_map_theta: jnp.array\n",
+    "    behavior: jnp.array\n",
+    "    params: jnp.array\n",
+    "    sensed: jnp.array\n",
+    "    wheel_diameter: jnp.array\n",
+    "    speed_mul: jnp.array\n",
+    "    max_speed: jnp.array\n",
+    "    theta_mul: jnp.array    \n",
+    "    proxs_dist_max: jnp.array\n",
+    "    proxs_cos_min: jnp.array\n",
+    "\n",
+    "@struct.dataclass\n",
+    "class ObjectState(ParticleState):\n",
+    "    pass\n",
+    "\n",
+    "@struct.dataclass\n",
+    "class State(BaseState):\n",
+    "    max_agents: jnp.int32\n",
+    "    max_objects: jnp.int32\n",
+    "    neighbor_radius: jnp.float32\n",
+    "    dt: jnp.float32  # Give a more explicit name\n",
+    "    collision_alpha: jnp.float32\n",
+    "    collision_eps: jnp.float32\n",
+    "    entities: EntityState\n",
+    "    agents: AgentState\n",
+    "    objects: ObjectState    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Define get_relative_displacement"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO : Refactor the code bc pretty ugly to have 4 arguments returned here\n",
+    "def get_relative_displacement(state, agents_neighs_idx, displacement_fn):\n",
+    "    body = state.entities.position\n",
+    "    senders, receivers = agents_neighs_idx\n",
+    "    Ra = body.center[senders]\n",
+    "    Rb = body.center[receivers]\n",
+    "    dR = - space.map_bond(displacement_fn)(Ra, Rb)  # Looks like it should be opposite, but don't understand why\n",
+    "\n",
+    "    dist, theta = proximity_map(dR, body.orientation[senders])\n",
+    "    proximity_map_dist = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))\n",
+    "    proximity_map_dist = proximity_map_dist.at[senders, receivers].set(dist)\n",
+    "    proximity_map_theta = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))\n",
+    "    proximity_map_theta = proximity_map_theta.at[senders, receivers].set(theta)\n",
+    "    return dist, theta, proximity_map_dist, proximity_map_theta\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "to compute motors, only use linear behaviors (don't vmap it) because we vmap the functions to compute agents proxiemters and motors at a higher level \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_motor(proxs, params, behaviors, motors):\n",
+    "    \"\"\"Compute new motor values. If behavior is manual, keep same motor values. Else, compute new values with proximeters and params.\n",
+    "\n",
+    "    :param proxs: proximeters of all agents\n",
+    "    :param params: parameters mapping proximeters to new motor values\n",
+    "    :param behaviors: array of behaviors\n",
+    "    :param motors: current motor values\n",
+    "    :return: new motor values\n",
+    "    \"\"\"\n",
+    "    manual = jnp.where(behaviors == Behaviors.MANUAL.value, 1, 0)\n",
+    "    manual_mask = manual\n",
+    "    linear_motor_values = linear_behavior(proxs, params)\n",
+    "    motor_values = linear_motor_values * (1 - manual_mask) + motors * manual_mask\n",
+    "    return motor_values"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add Mask sensors and don't change functions\n",
+    "\n",
+    "- mask_sensors: mask sensors according to sensed entity type for an agent\n",
+    "- don't change: return agent raw_proxs (surely return either the masked or the same prox array according to a sensed e type)\n",
+    "\n",
+    "Then for each agent, we iterate on all of his behaviors. For each behavior, we iterate on each possible sensed entity type. If the entity is sensed, we keep the raw proximeters of the agent as they are currently. If it is not, we mask the proximeters of the specific (non sensed) entity type."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def mask_sensors(state, agent_raw_proxs, ent_type_id, ent_target_idx):\n",
+    "    mask = jnp.where(state.entities.ent_sensed_type[ent_target_idx] == ent_type_id, 0, 1)\n",
+    "    mask = jnp.expand_dims(mask, 1)\n",
+    "    mask = jnp.broadcast_to(mask, agent_raw_proxs.shape)\n",
+    "    return agent_raw_proxs * mask\n",
+    "\n",
+    "def dont_change(state, agent_raw_proxs, ent_type_id, ent_target_idx):\n",
+    "    return agent_raw_proxs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add compute_behavior_prox, compute_behavior_proxs_motors, compute_agent_proxs_motors\n",
+    "\n",
+    "- compute_behavior_prox: compute the proxs for one behavior (enumerate through all the sensed entities on this particular behavior)\n",
+    "- compute_behavior_proxs_motors: use fn above to compute the proxs and compute the motor values according to the behavior\n",
+    "- #vmap compute_all_behavior_proxs_motors:  computes this for all the behaviors of an agent\n",
+    "- compute_agent_proxs_motors: compute the proximeters and motor values of an agent for all its behaviors. Just return mean motor value\n",
+    "- #vmap compute_all_agents_proxs_motors: computes this for all agents (vmap over params, sensed and agent_raw_proxs) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO : Use a fori_loop on this later\n",
+    "def compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed_entities):\n",
+    "    for ent_type_id, sensed in enumerate(sensed_entities):\n",
+    "        # need the lax.cond because you don't want to change the proxs if you perceive the entity\n",
+    "        # but you want to mask the raw proxs if you don't detect it\n",
+    "        agent_raw_proxs = lax.cond(sensed, dont_change, mask_sensors, state, agent_raw_proxs, ent_type_id, ent_target_idx)\n",
+    "    proxs = jnp.max(agent_raw_proxs, axis=0)\n",
+    "    return proxs\n",
+    "\n",
+    "def compute_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_target_idx):\n",
+    "    behavior_prox = compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed)\n",
+    "    behavior_motors = compute_motor(behavior_prox, params, behavior, motor)\n",
+    "    return behavior_prox, behavior_motors\n",
+    "\n",
+    "# vmap on params, sensed and behavior (parallelize on all agents behaviors at once, but not motorrs because are the same)\n",
+    "compute_all_behavior_proxs_motors = vmap(compute_behavior_proxs_motors, in_axes=(None, 0, 0, 0, None, None, None))\n",
+    "\n",
+    "def compute_agent_proxs_motors(state, agent_idx, params, sensed, behavior, motor, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers):\n",
+    "    behavior = jnp.expand_dims(behavior, axis=1)\n",
+    "    ent_ag_idx = ag_idx_dense_senders[agent_idx]\n",
+    "    ent_target_idx = ag_idx_dense_receivers[agent_idx]\n",
+    "    agent_raw_proxs = raw_proxs[ent_ag_idx]\n",
+    "\n",
+    "    # vmap on params, sensed, behaviors and motorss (vmap on all agents)\n",
+    "    agent_proxs, agent_motors = compute_all_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_target_idx)\n",
+    "    mean_agent_motors = jnp.mean(agent_motors, axis=0)\n",
+    "\n",
+    "    return agent_proxs, mean_agent_motors\n",
+    "\n",
+    "compute_all_agents_proxs_motors = vmap(compute_agent_proxs_motors, in_axes=(None, 0, 0, 0, 0, 0, None, None, None))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add classical braitenberg force fn"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the main environment class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "#--- 4 Define the environment class with its different functions (step ...) ---#\n",
+    "class SelectiveSensorsEnv(BaseEnv):\n",
+    "    def __init__(self, state, seed=42):\n",
+    "        self.seed = seed\n",
+    "        self.init_key = random.PRNGKey(seed)\n",
+    "        self.displacement, self.shift = space.periodic(state.box_size)\n",
+    "        self.init_fn, self.apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn)\n",
+    "        self.neighbor_fn = partition.neighbor_list(\n",
+    "            self.displacement, \n",
+    "            state.box_size,\n",
+    "            r_cutoff=state.neighbor_radius,\n",
+    "            dr_threshold=10.,\n",
+    "            capacity_multiplier=1.5,\n",
+    "            format=partition.Sparse\n",
+    "        )\n",
+    "\n",
+    "        self.neighbors = self.allocate_neighbors(state)\n",
+    "        # self.neighbors, self.agents_neighs_idx = self.allocate_neighbors(state)\n",
+    "\n",
+    "    def distance(self, point1, point2):\n",
+    "            return distance(self.displacement, point1, point2)\n",
+    "    \n",
+    "    ### Add ag_idx_dense !!! \n",
+    "    @partial(jit, static_argnums=(0,))\n",
+    "    def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array, ag_idx_dense: jnp.array) -> Tuple[State, jnp.array]:\n",
+    "        # Differences : compute raw proxs for all agents first \n",
+    "        dist, relative_theta, proximity_dist_map, proximity_dist_theta = get_relative_displacement(state, agents_neighs_idx, displacement_fn=self.displacement)\n",
+    "        senders, receivers = agents_neighs_idx\n",
+    "\n",
+    "        dist_max = state.agents.proxs_dist_max[senders]\n",
+    "        cos_min = state.agents.proxs_cos_min[senders]\n",
+    "        targer_exist_mask = state.entities.exists[agents_neighs_idx[1, :]]\n",
+    "        raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, targer_exist_mask)\n",
+    "\n",
+    "        # 2: Use dense idx for neighborhoods to vmap all of this\n",
+    "        # TODO : Could even just pass ag_idx_dense in the fn and do this inside\n",
+    "        ag_idx_dense_senders, ag_idx_dense_receivers = ag_idx_dense\n",
+    "\n",
+    "        agent_proxs, mean_agent_motors = compute_all_agents_proxs_motors(\n",
+    "            state,\n",
+    "            state.agents.ent_idx,\n",
+    "            state.agents.params,\n",
+    "            state.agents.sensed,\n",
+    "            state.agents.behavior,\n",
+    "            state.agents.motor,\n",
+    "            raw_proxs,\n",
+    "            ag_idx_dense_senders,\n",
+    "            ag_idx_dense_receivers,\n",
+    "        )\n",
+    "\n",
+    "        agents = state.agents.replace(\n",
+    "            prox=agent_proxs, \n",
+    "            proximity_map_dist=proximity_dist_map, \n",
+    "            proximity_map_theta=proximity_dist_theta,\n",
+    "            motor=mean_agent_motors\n",
+    "        )\n",
+    "\n",
+    "        # Last block unchanged\n",
+    "        state = state.replace(agents=agents)\n",
+    "        entities = self.apply_physics(state, neighbors)\n",
+    "        state = state.replace(time=state.time+1, entities=entities)\n",
+    "        neighbors = neighbors.update(state.entities.position.center)\n",
+    "\n",
+    "        return state, neighbors\n",
+    "    \n",
+    "    def step(self, state: State) -> State:\n",
+    "        if state.entities.momentum is None:\n",
+    "             state = self.init_fn(state, self.init_key)\n",
+    "             \n",
+    "        current_state = state\n",
+    "        state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx, self.agents_idx_dense)\n",
+    "\n",
+    "        if self.neighbors.did_buffer_overflow:\n",
+    "            # reallocate neighbors and run the simulation from current_state\n",
+    "            lg.warning(f'NEIGHBORS BUFFER OVERFLOW at step {state.time}: rebuilding neighbors')\n",
+    "            neighbors = self.allocate_neighbors(state)\n",
+    "            assert not neighbors.did_buffer_overflow\n",
+    "\n",
+    "        self.neighbors = neighbors\n",
+    "        return state\n",
+    "        \n",
+    "    def allocate_neighbors(self, state, position=None):\n",
+    "        position = state.entities.position.center if position is None else position\n",
+    "        neighbors = self.neighbor_fn.allocate(position)\n",
+    "\n",
+    "        # Also update the neighbor idx of agents (not the cleanest to attribute it to with self here)\n",
+    "        ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value\n",
+    "        self.agents_neighs_idx = neighbors.idx[:, ag_idx]\n",
+    "        agents_idx_dense_senders = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[0, :], idx)).flatten() for idx in jnp.arange(state.max_agents)])\n",
+    "        # agents_idx_dense_receivers = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[1, :], idx)).flatten() for idx in jnp.arange(self.max_agents)])\n",
+    "        agents_idx_dense_receivers = self.agents_neighs_idx[1, :][agents_idx_dense_senders]\n",
+    "        # self.agents_idx_dense = jnp.array([jnp.where(self.agents_neighs_idx[0, :] == idx).flatten() for idx in range(self.max_agents)])\n",
+    "        self.agents_idx_dense = agents_idx_dense_senders, agents_idx_dense_receivers\n",
+    "        return neighbors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the state"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seed = 0\n",
+    "max_agents = 10\n",
+    "max_objects = 10\n",
+    "n_dims = 2\n",
+    "box_size = 100\n",
+    "diameter = 5.0\n",
+    "friction = 0.1\n",
+    "mass_center = 1.0\n",
+    "mass_orientation = 0.125\n",
+    "neighbor_radius = 100.0\n",
+    "collision_alpha = 0.5\n",
+    "collision_eps = 0.1\n",
+    "dt = 0.1\n",
+    "wheel_diameter = 2.0\n",
+    "speed_mul = 1.0\n",
+    "max_speed = 10.0\n",
+    "theta_mul = 1.0\n",
+    "prox_dist_max = 40.0\n",
+    "prox_cos_min = 0.0\n",
+    "behavior = Behaviors.AGGRESSION.value\n",
+    "behaviors=Behaviors.AGGRESSION.value\n",
+    "existing_agents = None\n",
+    "existing_objects = None\n",
+    "\n",
+    "n_preys = 5\n",
+    "n_preds = 5\n",
+    "n_ress = 5\n",
+    "n_pois = 5\n",
+    "\n",
+    "key = random.PRNGKey(seed)\n",
+    "key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Entities"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "existing_agents = max_agents if not existing_agents else existing_agents\n",
+    "existing_objects = max_objects if not existing_objects else existing_objects\n",
+    "\n",
+    "n_entities = max_agents + max_objects # we store the entities data in jax arrays of length max_agents + max_objects \n",
+    "# Assign random positions to each entity in the environment\n",
+    "agents_positions = random.uniform(key_agents_pos, (max_agents, n_dims)) * box_size\n",
+    "objects_positions = random.uniform(key_objects_pos, (max_objects, n_dims)) * box_size\n",
+    "positions = jnp.concatenate((agents_positions, objects_positions))\n",
+    "# Assign random orientations between 0 and 2*pi to each entity\n",
+    "orientations = random.uniform(key_orientations, (n_entities,)) * 2 * jnp.pi\n",
+    "# Assign types to the entities\n",
+    "agents_entities = jnp.full(max_agents, EntityType.AGENT.value)\n",
+    "object_entities = jnp.full(max_objects, EntityType.OBJECT.value)\n",
+    "entity_types = jnp.concatenate((agents_entities, object_entities), dtype=int)\n",
+    "# Define arrays with existing entities\n",
+    "exists_agents = jnp.concatenate((jnp.ones((existing_agents)), jnp.zeros((max_agents - existing_agents))))\n",
+    "exists_objects = jnp.concatenate((jnp.ones((existing_objects)), jnp.zeros((max_objects - existing_objects))))\n",
+    "exists = jnp.concatenate((exists_agents, exists_objects), dtype=int)\n",
+    "\n",
+    "### TODO : Actually find a way to init this later\n",
+    "sensed_ent_types = jnp.concatenate([\n",
+    "    jnp.full(n_preys, EntitySensedType.PREY.value),\n",
+    "    jnp.full(n_preds, EntitySensedType.PRED.value),\n",
+    "    jnp.full(n_ress, EntitySensedType.RESSOURCE.value),\n",
+    "    jnp.full(n_pois, EntitySensedType.POISON.value),\n",
+    "])\n",
+    "\n",
+    "ent_sensed_types = jnp.zeros(n_entities)\n",
+    "\n",
+    "entities =  EntityState(\n",
+    "    position=RigidBody(center=positions, orientation=orientations),\n",
+    "    momentum=None,\n",
+    "    force=RigidBody(center=jnp.zeros((n_entities, 2)), orientation=jnp.zeros(n_entities)),\n",
+    "    mass=RigidBody(center=jnp.full((n_entities, 1), mass_center), orientation=jnp.full((n_entities), mass_orientation)),\n",
+    "    entity_type=entity_types,\n",
+    "    ent_sensed_type=sensed_ent_types,\n",
+    "    entity_idx = jnp.array(list(range(max_agents)) + list(range(max_objects))),\n",
+    "    diameter=jnp.full((n_entities), diameter),\n",
+    "    friction=jnp.full((n_entities), friction),\n",
+    "    exists=exists\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Agents"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(5, 2, 2, 3) (5, 2, 4)\n",
+      "(5, 2, 2, 3) (5, 2, 4)\n",
+      "(10, 2, 2, 3) (10, 2, 4) (10, 2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Prey behaviors\n",
+    "love = behavior_to_params(Behaviors.LOVE.value)\n",
+    "fear = behavior_to_params(Behaviors.FEAR.value)\n",
+    "sensed_love = jnp.array([1, 0, 1, 0])\n",
+    "sensed_fear = jnp.array([0, 1, 0, 1])\n",
+    "prey_params = jnp.array([love, fear])\n",
+    "prey_sensed = jnp.array([sensed_love, sensed_fear])\n",
+    "\n",
+    "# Do like if we had batches of params and sensed entities for all agents\n",
+    "prey_batch_params = jnp.tile(prey_params[None], (n_preys, 1, 1 ,1))\n",
+    "prey_batch_sensed = jnp.tile(prey_sensed[None], (n_preys, 1, 1))\n",
+    "print(prey_batch_params.shape, prey_batch_sensed.shape)\n",
+    "\n",
+    "prey_behaviors = jnp.array([Behaviors.LOVE.value, Behaviors.FEAR.value])\n",
+    "prey_batch_behaviors = jnp.tile(prey_behaviors[None], (n_preys, 1))\n",
+    "\n",
+    "# Pred behaviors\n",
+    "aggr = behavior_to_params(Behaviors.AGGRESSION.value)\n",
+    "fear = behavior_to_params(Behaviors.FEAR.value)\n",
+    "sensed_aggr = jnp.array([1, 0, 0, 0])\n",
+    "sensed_fear = jnp.array([0, 0, 0, 1])\n",
+    "pred_params = jnp.array([aggr, fear])\n",
+    "pred_sensed = jnp.array([sensed_aggr, sensed_fear])\n",
+    "\n",
+    "# Do like if we had batches of params and sensed entities for all agents\n",
+    "pred_batch_params = jnp.tile(pred_params[None], (n_preys, 1, 1 ,1))\n",
+    "pred_batch_sensed = jnp.tile(pred_sensed[None], (n_preys, 1, 1))\n",
+    "print(pred_batch_params.shape, pred_batch_sensed.shape)\n",
+    "\n",
+    "pred_behaviors = jnp.array([Behaviors.AGGRESSION.value, Behaviors.FEAR.value])\n",
+    "pred_batch_behaviors = jnp.tile(pred_behaviors[None], (n_preds, 1))\n",
+    "\n",
+    "\n",
+    "params = jnp.concatenate([prey_batch_params, pred_batch_params], axis=0)\n",
+    "sensed = jnp.concatenate([prey_batch_sensed, pred_batch_sensed], axis=0)\n",
+    "behaviors  = jnp.concatenate([prey_batch_behaviors, pred_batch_behaviors], axis=0)\n",
+    "print(params.shape, sensed.shape, behaviors.shape)\n",
+    "\n",
+    "\n",
+    "prey_color = jnp.array([0., 0., 1.])\n",
+    "pred_color = jnp.array([1., 0., 0.])\n",
+    "\n",
+    "prey_color=jnp.tile(prey_color, (n_preys, 1))\n",
+    "pred_color=jnp.tile(pred_color, (n_preds, 1))\n",
+    "\n",
+    "agent_colors = jnp.concatenate([\n",
+    "    prey_color,\n",
+    "    pred_color\n",
+    "])\n",
+    "\n",
+    "agents =  AgentState(\n",
+    "    # idx in the entities (ent_idx) state to map agents information in the different data structures\n",
+    "    ent_idx=jnp.arange(max_agents, dtype=int), \n",
+    "    prox=jnp.zeros((max_agents, 2)),\n",
+    "    motor=jnp.zeros((max_agents, 2)),\n",
+    "    behavior=behaviors,\n",
+    "    params=params,\n",
+    "    sensed=sensed,\n",
+    "    wheel_diameter=jnp.full((max_agents), wheel_diameter),\n",
+    "    speed_mul=jnp.full((max_agents), speed_mul),\n",
+    "    max_speed=jnp.full((max_agents), max_speed),\n",
+    "    theta_mul=jnp.full((max_agents), theta_mul),\n",
+    "    proxs_dist_max=jnp.full((max_agents), prox_dist_max),\n",
+    "    proxs_cos_min=jnp.full((max_agents), prox_cos_min),\n",
+    "    proximity_map_dist=jnp.zeros((max_agents, 1)),\n",
+    "    proximity_map_theta=jnp.zeros((max_agents, 1)),\n",
+    "    color=jnp.tile(agent_colors, (max_agents, 1))\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Objects"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Entities idx of objects\n",
+    "start_idx, stop_idx = max_agents, max_agents + max_objects \n",
+    "objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int)\n",
+    "\n",
+    "res_color = jnp.array([0., 1., 0.])\n",
+    "pois_color = jnp.array([1., 0., 1.])\n",
+    "\n",
+    "res_color=jnp.tile(res_color, (n_preys, 1))\n",
+    "pois_color=jnp.tile(pois_color, (n_preds, 1))\n",
+    "\n",
+    "objects_colors = jnp.concatenate([\n",
+    "    res_color,\n",
+    "    pois_color\n",
+    "])\n",
+    "\n",
+    "objects =  ObjectState(\n",
+    "    ent_idx=objects_ent_idx,\n",
+    "    color=jnp.tile(objects_colors, (max_objects, 1))\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### State"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "state =  State(\n",
+    "    time=0,\n",
+    "    box_size=box_size,\n",
+    "    max_agents=max_agents,\n",
+    "    max_objects=max_objects,\n",
+    "    neighbor_radius=neighbor_radius,\n",
+    "    collision_alpha=collision_alpha,\n",
+    "    collision_eps=collision_eps,\n",
+    "    dt=dt,\n",
+    "    entities=entities,\n",
+    "    agents=agents,\n",
+    "    objects=objects\n",
+    ")   "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test the simulation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from vivarium.experimental.environments.braitenberg.render import render, render_history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "env = SelectiveSensorsEnv(state)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Autonomous behaviors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_steps = 10_000\n",
+    "hist = []\n",
+    "\n",
+    "for i in range(n_steps):\n",
+    "    state = env.step(state)\n",
+    "    hist.append(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render_history(hist, skip_frames=50)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Test manual behavior for an agent\n",
+    "\n",
+    "Need to set all of its behaviors to manual."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ag_idx = 9\n",
+    "manual_behaviors = jnp.array([Behaviors.MANUAL.value, Behaviors.MANUAL.value,])\n",
+    "manual_color = jnp.array([0., 0., 0.])\n",
+    "manual_motors = jnp.array([1., 1.])\n",
+    "\n",
+    "behaviors = state.agents.behavior.at[ag_idx].set(manual_behaviors)\n",
+    "colors = state.agents.color.at[ag_idx].set(manual_color)\n",
+    "motors = state.agents.motor.at[ag_idx].set(manual_motors)\n",
+    "\n",
+    "agents = state.agents.replace(behavior=behaviors, color=colors, motor=motors)\n",
+    "state = state.replace(agents=agents)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_steps = 5_000\n",
+    "hist = []\n",
+    "\n",
+    "for i in range(n_steps):\n",
+    "    state = env.step(state)\n",
+    "    hist.append(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render_history(hist, skip_frames=50)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 00f401977249df0b8770476d9df98fc6d637ced7 Mon Sep 17 00:00:00 2001
From: corentinlger <corentin.lger@gmail.com>
Date: Fri, 2 Aug 2024 15:53:59 +0200
Subject: [PATCH 3/7] Simplify _step function in prey_predator env

---
 .../notebooks/prey_predator_braitenberg.ipynb | 78 +++++++++++++++++--
 1 file changed, 72 insertions(+), 6 deletions(-)

diff --git a/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb b/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb
index 5ce035c..9911de3 100644
--- a/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb
+++ b/vivarium/experimental/notebooks/prey_predator_braitenberg.ipynb
@@ -27,7 +27,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "2024-07-04 11:03:15.059320: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n"
+      "2024-08-02 15:52:56.509482: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n"
      ]
     }
    ],
@@ -258,6 +258,72 @@
     "        return state, neighbors"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class PreyPredBraitenbergEnv(BraitenbergEnv):\n",
+    "    def __init__(\n",
+    "            self,\n",
+    "            state,\n",
+    "            pred_eating_range\n",
+    "    ):  \n",
+    "        super().__init__(state=state)\n",
+    "        # Add idx utils to simplify conversions between entities and agent states\n",
+    "        self.agents_idx = jnp.where(state.entities.entity_type == EntityType.AGENT.value)\n",
+    "        self.prey_idx = jnp.where(state.agents.agent_type == AgentType.PREY.value)\n",
+    "        self.pred_idx = jnp.where(state.agents.agent_type == AgentType.PREDATOR.value)\n",
+    "        self.pred_eating_range = pred_eating_range\n",
+    "\n",
+    "    # Add a function to detect if a prey will be eaten by a predator in the current step\n",
+    "    def can_all_be_eaten(self, R_prey, R_predators, predator_exist):\n",
+    "        # Could maybe create this as a method in the class, or above idk\n",
+    "        distance_to_all_preds = vmap(self.distance, in_axes=(None, 0))\n",
+    "\n",
+    "        # Same for this, the only pb is that the fn above needs the displacement arg, so can't define it in the cell above \n",
+    "        def can_be_eaten(R_prey, R_predators, predator_exist):\n",
+    "            dist_to_preds = distance_to_all_preds(R_prey, R_predators)\n",
+    "            in_range = jnp.where(dist_to_preds < self.pred_eating_range, 1, 0)\n",
+    "            # Could also return which agent ate the other one (e.g to increase their energy) \n",
+    "            will_be_eaten_by = in_range * predator_exist\n",
+    "            eaten_or_not = jnp.where(jnp.sum(will_be_eaten_by) > 0., 1, 0)\n",
+    "            return eaten_or_not\n",
+    "        \n",
+    "        can_be_eaten = vmap(can_be_eaten, in_axes=(0, None, None))\n",
+    "        \n",
+    "        return can_be_eaten(R_prey, R_predators, predator_exist)\n",
+    "    \n",
+    "    # Add functions so predators eat preys\n",
+    "    def eat_preys(self, state):\n",
+    "        # See which preys can be eaten by predators and update the exists array accordingly\n",
+    "        R = state.entities.position.center\n",
+    "        exist = state.entities.exists\n",
+    "        prey_idx = self.prey_idx\n",
+    "        pred_idx = self.pred_idx\n",
+    "\n",
+    "        agents_ent_idx = state.agents.ent_idx\n",
+    "        predator_exist = exist[agents_ent_idx][pred_idx]\n",
+    "        can_be_eaten_idx = self.can_all_be_eaten(R[prey_idx], R[pred_idx], predator_exist)\n",
+    "\n",
+    "        # Kill the agents that are being eaten\n",
+    "        exist_prey = exist[agents_ent_idx[prey_idx]]\n",
+    "        new_exists_prey = jnp.where(can_be_eaten_idx == 1, 0, exist_prey)\n",
+    "        exist = exist.at[agents_ent_idx[prey_idx]].set(new_exists_prey)\n",
+    "\n",
+    "        return exist\n",
+    "\n",
+    "    # Add the eat_preys function in the _step loop\n",
+    "    @partial(jit, static_argnums=(0,))\n",
+    "    def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array) -> Tuple[State, jnp.array]:\n",
+    "        # 1 Compute which agents are being eaten\n",
+    "        exist = self.eat_preys(state)\n",
+    "        entities = state.entities.replace(exists=exist)\n",
+    "        state = state.replace(entities=entities)\n",
+    "        return super()._step(state, neighbors, agents_neighs_idx)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -273,7 +339,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -282,7 +348,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -294,7 +360,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -321,7 +387,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -335,7 +401,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {

From b09396c5a9812947cd6ffcc77e9075734c52bbbb Mon Sep 17 00:00:00 2001
From: corentinlger <corentin.lger@gmail.com>
Date: Fri, 2 Aug 2024 15:56:54 +0200
Subject: [PATCH 4/7] Remove empty environment file

---
 vivarium/experimental/environments/particle_lenia/simple.py | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 vivarium/experimental/environments/particle_lenia/simple.py

diff --git a/vivarium/experimental/environments/particle_lenia/simple.py b/vivarium/experimental/environments/particle_lenia/simple.py
deleted file mode 100644
index f87f5c1..0000000
--- a/vivarium/experimental/environments/particle_lenia/simple.py
+++ /dev/null
@@ -1 +0,0 @@
-# TODO
\ No newline at end of file

From 8dd4ee6c83575a2dcc98d59b42cafb1c9c0827f9 Mon Sep 17 00:00:00 2001
From: Corentin <111868204+corentinlger@users.noreply.github.com>
Date: Wed, 7 Aug 2024 15:58:05 +0200
Subject: [PATCH 5/7] Add Selective sensors notebook (#90)

* Add first version of refactored braitenberg env

* Add utils file

* Update way of computing forces in environment + Add general physics engine file

* Add first elements of tutorial on how to create an environment in a notebook

* Update braitenberg notebook and add new prey/predator braitenberg environment

* Delete new notebooks on refactored envs and associated files

* Add simple and prey_predator braitenberg envs in experimental directory

* Add first steps of sensorimotor functions refactoring

* Add first draft version of selective sensors braitenberg env

* Refactor simple braitenberg env and add utils file for all environments

* Update base env by removing intermediate state classes

* Remove duplicate code and add markdown comments

* Remove uncessary files

* Update simple braitenberg notebook

* Add selective sensors environment with old env interface

* Add manual mode in selective sensors and add some documentation

* Clean selective sensors imports and add notebook documentation

* Revert changes on non selective sensors environments

* Add first draft of selective sensing with occlusion or not

* Clean the notebook and improve documentation

* Add helper functions to define selective sensing behaviors

* Improve init functions and add next development steps

* Add experimental directory with refactored environments (#89)

* Add new experimental directory with simple and prey_predator braitenberg envs (#87)

* Add first version of refactored braitenberg env

* Add utils file

* Update way of computing forces in environment + Add general physics engine file

* Add first elements of tutorial on how to create an environment in a notebook

* Update braitenberg notebook and add new prey/predator braitenberg environment

* Delete new notebooks on refactored envs and associated files

* Add simple and prey_predator braitenberg envs in experimental directory

* Add first steps of sensorimotor functions refactoring

* Add first draft version of selective sensors braitenberg env

* Refactor simple braitenberg env and add utils file for all environments

* Update base env by removing intermediate state classes

* Remove duplicate code and add markdown comments

* Remove uncessary files

* Update simple braitenberg notebook

* Add behavior refactoring in simple braitenberg env

* Update simple braitenberg env and notebook with new init functions

* Add default values to init functions and update prey_pred notebook

* Corentin/selective sensors (#88)

* Add first version of refactored braitenberg env

* Add utils file

* Update way of computing forces in environment + Add general physics engine file

* Add first elements of tutorial on how to create an environment in a notebook

* Update braitenberg notebook and add new prey/predator braitenberg environment

* Delete new notebooks on refactored envs and associated files

* Add simple and prey_predator braitenberg envs in experimental directory

* Add first steps of sensorimotor functions refactoring

* Add first draft version of selective sensors braitenberg env

* Refactor simple braitenberg env and add utils file for all environments

* Update base env by removing intermediate state classes

* Remove duplicate code and add markdown comments

* Remove uncessary files

* Update simple braitenberg notebook

* Add selective sensors environment with old env interface

* Add manual mode in selective sensors and add some documentation

* Clean selective sensors imports and add notebook documentation

* Revert changes on non selective sensors environments

* Simplify _step function in prey_predator env

* Remove empty environment file

* Update README

* Fix occlusion sensors bug and add docstrings

* Clean neighbor mechanism in Env class

* Clean Env class and functions, add dostrings and documentation

* Add helper init functions for the state

* Delete old selective sensing notebook

* Fix typos
---
 .../environments/particle_lenia/simple.py     |    1 +
 .../occlusion_choice_selective_sensing.ipynb  | 1374 +++++++++++++++++
 .../notebooks/selective_sensors.ipynb         |  814 ----------
 3 files changed, 1375 insertions(+), 814 deletions(-)
 create mode 100644 vivarium/experimental/environments/particle_lenia/simple.py
 create mode 100644 vivarium/experimental/notebooks/occlusion_choice_selective_sensing.ipynb
 delete mode 100644 vivarium/experimental/notebooks/selective_sensors.ipynb

diff --git a/vivarium/experimental/environments/particle_lenia/simple.py b/vivarium/experimental/environments/particle_lenia/simple.py
new file mode 100644
index 0000000..f87f5c1
--- /dev/null
+++ b/vivarium/experimental/environments/particle_lenia/simple.py
@@ -0,0 +1 @@
+# TODO
\ No newline at end of file
diff --git a/vivarium/experimental/notebooks/occlusion_choice_selective_sensing.ipynb b/vivarium/experimental/notebooks/occlusion_choice_selective_sensing.ipynb
new file mode 100644
index 0000000..4b6853a
--- /dev/null
+++ b/vivarium/experimental/notebooks/occlusion_choice_selective_sensing.ipynb
@@ -0,0 +1,1374 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Quick tutorial to explain how to create a environment with braitenberg vehicles equiped with selective sensors (still a draft so comments of the notebook won't be complete yet)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import logging as lg\n",
+    "\n",
+    "from enum import Enum\n",
+    "from functools import partial\n",
+    "from typing import Tuple\n",
+    "\n",
+    "import jax\n",
+    "import numpy as np\n",
+    "import jax.numpy as jnp\n",
+    "import matplotlib.colors as mcolors\n",
+    "\n",
+    "from jax import vmap, jit\n",
+    "from jax import random, ops, lax\n",
+    "\n",
+    "from flax import struct\n",
+    "from jax_md.rigid_body import RigidBody\n",
+    "from jax_md import simulate \n",
+    "from jax_md import space, rigid_body, partition, quantity\n",
+    "\n",
+    "from vivarium.experimental.environments.utils import normal, distance \n",
+    "from vivarium.experimental.environments.base_env import BaseState, BaseEnv\n",
+    "from vivarium.experimental.environments.physics_engine import total_collision_energy, friction_force, dynamics_fn\n",
+    "from vivarium.experimental.environments.braitenberg.simple import relative_position, proximity_map, sensor_fn, sensor\n",
+    "from vivarium.experimental.environments.braitenberg.simple import Behaviors, behavior_to_params, linear_behavior\n",
+    "from vivarium.experimental.environments.braitenberg.simple import lr_2_fwd_rot, fwd_rot_2_lr, motor_command\n",
+    "from vivarium.experimental.environments.braitenberg.simple import braintenberg_force_fn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Used for jax.debug.breakpoint in a jupyter notebook\n",
+    "class FakeStdin:\n",
+    "  def readline(self):\n",
+    "    return input()\n",
+    "  \n",
+    "# Usage : \n",
+    "# jax.debug.breakpoint(backend=\"cli\", stdin=FakeStdin())\n",
+    "\n",
+    "# See this issue : https://github.com/google/jax/issues/11880"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the classes and helper functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add entity sensed type as a field in entities + sensed in agents. The agents sense the \"sensed type\" of the entities. In our case, there will be preys, predators, ressources and poison."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "### Define the constants and the classes of the environment to store its state ###\n",
+    "SPACE_NDIMS = 2\n",
+    "\n",
+    "class EntityType(Enum):\n",
+    "    AGENT = 0\n",
+    "    OBJECT = 1\n",
+    "\n",
+    "# Already incorporates position, momentum, force, mass and velocity\n",
+    "@struct.dataclass\n",
+    "class EntityState(simulate.NVEState):\n",
+    "    entity_type: jnp.array\n",
+    "    ent_subtype: jnp.array\n",
+    "    entity_idx: jnp.array\n",
+    "    diameter: jnp.array\n",
+    "    friction: jnp.array\n",
+    "    exists: jnp.array\n",
+    "    \n",
+    "@struct.dataclass\n",
+    "class ParticleState:\n",
+    "    ent_idx: jnp.array\n",
+    "    color: jnp.array\n",
+    "\n",
+    "@struct.dataclass\n",
+    "class AgentState(ParticleState):\n",
+    "    prox: jnp.array\n",
+    "    motor: jnp.array\n",
+    "    proximity_map_dist: jnp.array\n",
+    "    proximity_map_theta: jnp.array\n",
+    "    behavior: jnp.array\n",
+    "    params: jnp.array\n",
+    "    sensed: jnp.array\n",
+    "    wheel_diameter: jnp.array\n",
+    "    speed_mul: jnp.array\n",
+    "    max_speed: jnp.array\n",
+    "    theta_mul: jnp.array    \n",
+    "    proxs_dist_max: jnp.array\n",
+    "    proxs_cos_min: jnp.array\n",
+    "\n",
+    "@struct.dataclass\n",
+    "class ObjectState(ParticleState):\n",
+    "    pass\n",
+    "\n",
+    "@struct.dataclass\n",
+    "class State(BaseState):\n",
+    "    max_agents: jnp.int32\n",
+    "    max_objects: jnp.int32\n",
+    "    neighbor_radius: jnp.float32\n",
+    "    dt: jnp.float32  # Give a more explicit name\n",
+    "    collision_alpha: jnp.float32\n",
+    "    collision_eps: jnp.float32\n",
+    "    ent_sub_types: dict\n",
+    "    entities: EntityState\n",
+    "    agents: AgentState\n",
+    "    objects: ObjectState    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Define get_relative_displacement"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO : Should refactor the function to split the returns\n",
+    "def get_relative_displacement(state, agents_neighs_idx, displacement_fn):\n",
+    "    \"\"\"Get all infos relative to distance and orientation between all agents and their neighbors\n",
+    "\n",
+    "    :param state: state\n",
+    "    :param agents_neighs_idx: idx all agents neighbors\n",
+    "    :param displacement_fn: jax md function enabling to know the distance between points\n",
+    "    :return: distance array, angles array, distance map for all agents, angles map for all agents\n",
+    "    \"\"\"\n",
+    "    body = state.entities.position\n",
+    "    senders, receivers = agents_neighs_idx\n",
+    "    Ra = body.center[senders]\n",
+    "    Rb = body.center[receivers]\n",
+    "    dR = - space.map_bond(displacement_fn)(Ra, Rb)  # Looks like it should be opposite, but don't understand why\n",
+    "\n",
+    "    dist, theta = proximity_map(dR, body.orientation[senders])\n",
+    "    proximity_map_dist = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))\n",
+    "    proximity_map_dist = proximity_map_dist.at[senders, receivers].set(dist)\n",
+    "    proximity_map_theta = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))\n",
+    "    proximity_map_theta = proximity_map_theta.at[senders, receivers].set(theta)\n",
+    "    return dist, theta, proximity_map_dist, proximity_map_theta"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "to compute motors, only use linear behaviors (don't vmap it) because we vmap the functions to compute agents proxiemters and motors at a higher level \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def linear_behavior(proxs, params):\n",
+    "    \"\"\"Compute the activation of motors with a linear combination of proximeters and parameters\n",
+    "\n",
+    "    :param proxs: proximeter values of an agent\n",
+    "    :param params: parameters of an agent (mapping proxs to motor values)\n",
+    "    :return: motor values\n",
+    "    \"\"\"\n",
+    "    return params.dot(jnp.hstack((proxs, 1.)))\n",
+    "\n",
+    "def compute_motor(proxs, params, behaviors, motors):\n",
+    "    \"\"\"Compute new motor values. If behavior is manual, keep same motor values. Else, compute new values with proximeters and params.\n",
+    "\n",
+    "    :param proxs: proximeters of all agents\n",
+    "    :param params: parameters mapping proximeters to new motor values\n",
+    "    :param behaviors: array of behaviors\n",
+    "    :param motors: current motor values\n",
+    "    :return: new motor values\n",
+    "    \"\"\"\n",
+    "    manual = jnp.where(behaviors == Behaviors.MANUAL.value, 1, 0)\n",
+    "    manual_mask = manual\n",
+    "    linear_motor_values = linear_behavior(proxs, params)\n",
+    "    motor_values = linear_motor_values * (1 - manual_mask) + motors * manual_mask\n",
+    "    return motor_values"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1 : Add functions to compute the proximeters and motors of agents with occlusion\n",
+    "\n",
+    "Logic for computing sensors and motors: \n",
+    "\n",
+    "- We get the raw proxs\n",
+    "- We get the ent types of the two detected entities (left and right)\n",
+    "- For each behavior, we updated the proxs according to the detected and the sensed entities (e.g sensed entities = [0, 1, 0 , 0] : only sense ent of type 1)\n",
+    "- We then compute the motor values for each behavior and do a mean of them "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create functions to update the two proximeter of an agent for a specific behavior \n",
+    "\n",
+    "- We already have the two closest proximeters in this case\n",
+    "- We want to compute the value of motors associated to a behavior for these proxs\n",
+    "- We can sense different type of entities \n",
+    "- The two proximeters are each associated to a specific entity type\n",
+    "- So if the specific entity type is detected, the proximeter value is kept \n",
+    "- Else it is set to 0 so it won't have effect on the motor values \n",
+    "- To do so we use a mask (mask of 1's, if an entity is detected we set it to 0 with a multiplication)\n",
+    "- So if the mask is already set to 0 (i.e the ent is detected), the masked value will still be 0 even if you multiply it by 1\n",
+    "- Then we update the proximeter values with a jnp.where"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def update_mask(mask, left_n_right_types, ent_type):\n",
+    "    \"\"\"Update a mask of \n",
+    "\n",
+    "    :param mask: mask that will be applied on sensors of agents\n",
+    "    :param left_n_right_types: types of left adn right sensed entities\n",
+    "    :param ent_type: entity subtype (e.g 1 for predators)\n",
+    "    :return: mask\n",
+    "    \"\"\"\n",
+    "    cur = jnp.where(left_n_right_types == ent_type, 0, 1)\n",
+    "    mask *= cur\n",
+    "    return mask\n",
+    "\n",
+    "def keep_mask(mask, left_n_right_types, ent_type):\n",
+    "    \"\"\"Return the mask unchanged\n",
+    "\n",
+    "    :param mask: mask\n",
+    "    :param left_n_right_types: left_n_right_types\n",
+    "    :param ent_type: ent_type\n",
+    "    :return: mask\n",
+    "    \"\"\"\n",
+    "    return mask\n",
+    "\n",
+    "def mask_proxs_occlusion(proxs, left_n_right_types, ent_sensed_arr):\n",
+    "    \"\"\"Mask the proximeters of agents with occlusion\n",
+    "\n",
+    "    :param proxs: proxiemters of agents without occlusion (shape = (2,))\n",
+    "    :param e_sensed_types: types of both entities sensed at left and right (shape=(2,))\n",
+    "    :param ent_sensed_arr: mask of sensed subtypes by the agent (e.g jnp.array([0, 1, 0, 1]) if sense only entities of subtype 1 and 4)\n",
+    "    :return: updated proximeters according to sensed_subtypes\n",
+    "    \"\"\"\n",
+    "    mask = jnp.array([1, 1])\n",
+    "    # Iterate on the array of sensed entities mask\n",
+    "    for ent_type, sensed in enumerate(ent_sensed_arr):\n",
+    "        # If an entity is sensed, update the mask, else keep it as it is\n",
+    "        mask = jax.lax.cond(sensed, update_mask, keep_mask, mask, left_n_right_types, ent_type)\n",
+    "    # Update the mask with 0s where the mask is, else keep the prox value\n",
+    "    proxs = jnp.where(mask, 0, proxs)\n",
+    "    return proxs\n",
+    "\n",
+    "# Example :\n",
+    "# ent_sensed_arr = jnp.array([0, 1, 0, 0, 1])\n",
+    "# proxs = jnp.array([0.8, 0.2])\n",
+    "# e_sensed_types = jnp.array([4, 4]) # Modify these values to check it works\n",
+    "# print(mask_proxs_occlusion(proxs, e_sensed_types, ent_sensed_arr))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create a function to compute the motor values for a specific behavior \n",
+    "\n",
+    "- Convert the idx of the detected entitites (associated to the values of the two proximeters) into their types\n",
+    "- Mask their sensors with the function presented above \n",
+    "- Compute the motors with the updated sensors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_behavior_motors(state, params, sensed_mask, behavior, motor, agent_proxs, sensed_ent_idx):\n",
+    "    \"\"\"_summary_\n",
+    "\n",
+    "    :param state: state\n",
+    "    :param params: behavior params params\n",
+    "    :param sensed_mask: sensed_mask for this behavior\n",
+    "    :param behavior: behavior\n",
+    "    :param motor: motor values\n",
+    "    :param agent_proxs: agent proximeters (unmasked)\n",
+    "    :param sensed_ent_idx: idx of left and right entities sensed \n",
+    "    :return: right motor values for this behavior \n",
+    "    \"\"\"\n",
+    "    left_n_right_types = state.entities.ent_subtype[sensed_ent_idx]\n",
+    "    behavior_proxs = mask_proxs_occlusion(agent_proxs, left_n_right_types, sensed_mask)\n",
+    "    motors = compute_motor(behavior_proxs, params, behaviors=behavior, motors=motor)\n",
+    "    return motors\n",
+    "\n",
+    "# See for the vectorizing idx because already in a vmaped function here\n",
+    "compute_all_behavior_motors = vmap(compute_behavior_motors, in_axes=(None, 0, 0, 0, None, None, None))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def linear_behavior(proxs, params):\n",
+    "    \"\"\"Compute the activation of motors with a linear combination of proximeters and parameters\n",
+    "\n",
+    "    :param proxs: proximeter values of an agent\n",
+    "    :param params: parameters of an agent (mapping proxs to motor values)\n",
+    "    :return: motor values\n",
+    "    \"\"\"\n",
+    "    return params.dot(jnp.hstack((proxs, 1.)))\n",
+    "\n",
+    "def compute_motor(proxs, params, behaviors, motors):\n",
+    "    \"\"\"Compute new motor values. If behavior is manual, keep same motor values. Else, compute new values with proximeters and params.\n",
+    "\n",
+    "    :param proxs: proximeters of all agents\n",
+    "    :param params: parameters mapping proximeters to new motor values\n",
+    "    :param behaviors: array of behaviors\n",
+    "    :param motors: current motor values\n",
+    "    :return: new motor values\n",
+    "    \"\"\"\n",
+    "    manual = jnp.where(behaviors == Behaviors.MANUAL.value, 1, 0)\n",
+    "    manual_mask = manual\n",
+    "    linear_motor_values = linear_behavior(proxs, params)\n",
+    "    motor_values = linear_motor_values * (1 - manual_mask) + motors * manual_mask\n",
+    "    return motor_values"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create a function to compute the motor values each agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_occlusion_proxs_motors(state, agent_idx, params, sensed, behaviors, motor, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers):\n",
+    "    \"\"\"_summary_\n",
+    "\n",
+    "    :param state: state\n",
+    "    :param agent_idx: agent idx in entities\n",
+    "    :param params: params arrays for all agent's behaviors\n",
+    "    :param sensed: sensed mask arrays for all agent's behaviors\n",
+    "    :param behaviors: agent behaviors array\n",
+    "    :param motor: agent motors\n",
+    "    :param raw_proxs: raw_proximeters for all agents (shape=(n_agents * (n_entities - 1), 2))\n",
+    "    :param ag_idx_dense_senders: ag_idx_dense_senders to get the idx of raw proxs (shape=(2, n_agents * (n_entities - 1))\n",
+    "    :param ag_idx_dense_receivers: ag_idx_dense_receivers (shape=(n_agents, n_entities - 1))\n",
+    "    :return: _description_\n",
+    "    \"\"\"\n",
+    "    behavior = jnp.expand_dims(behaviors, axis=1) \n",
+    "    # Compute the neighbors idx of the agent and get its raw proximeters (of shape (n_entities -1 , 2))\n",
+    "    ent_ag_neighs_idx = ag_idx_dense_senders[agent_idx]\n",
+    "    agent_raw_proxs = raw_proxs[ent_ag_neighs_idx]\n",
+    "\n",
+    "    # Get the max and arg max of these proximeters on axis 0, gives results of shape (2,)\n",
+    "    agent_proxs = jnp.max(agent_raw_proxs, axis=0)\n",
+    "    argmax = jnp.argmax(agent_raw_proxs, axis=0)\n",
+    "    # Get the real entity idx of the left and right sensed entities from dense neighborhoods\n",
+    "    sensed_ent_idx = ag_idx_dense_receivers[agent_idx][argmax]\n",
+    "    \n",
+    "    # Compute the motor values for all behaviors and do a mean on it\n",
+    "    motor_values = compute_all_behavior_motors(state, params, sensed, behavior, motor, agent_proxs, sensed_ent_idx)\n",
+    "    motors = jnp.mean(motor_values, axis=0)\n",
+    "\n",
+    "    return agent_proxs, motors\n",
+    "\n",
+    "compute_all_agents_proxs_motors_occl = vmap(compute_occlusion_proxs_motors, in_axes=(None, 0, 0, 0, 0, 0, None, None, None))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2 : Add functions to compute the proximeters and motors of agents without occlusion"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add Mask sensors and don't change functions\n",
+    "\n",
+    "- mask_sensors: mask sensors according to sensed entity type for an agent\n",
+    "- don't change: return agent raw_proxs (surely return either the masked or the same prox array according to a sensed e type)\n",
+    "\n",
+    "Then for each agent, we iterate on all of his behaviors. For each behavior, we iterate on each possible sensed entity type. If the entity is sensed, we keep the raw proximeters of the agent as they are currently. If it is not, we mask the proximeters of the specific (non sensed) entity type."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def mask_sensors(state, agent_raw_proxs, ent_type_id, ent_neighbors_idx):\n",
+    "    \"\"\"Mask the raw proximeters of agents for a specific entity type \n",
+    "\n",
+    "    :param state: state\n",
+    "    :param agent_raw_proxs: raw_proximeters of agent (shape=(n_entities - 1), 2)\n",
+    "    :param ent_type_id: entity subtype id (e.g 0 for PREYS)\n",
+    "    :param ent_neighbors_idx: idx of agent neighbors in entities arrays\n",
+    "    :return: updated agent raw proximeters\n",
+    "    \"\"\"\n",
+    "    mask = jnp.where(state.entities.ent_subtype[ent_neighbors_idx] == ent_type_id, 0, 1)\n",
+    "    mask = jnp.expand_dims(mask, 1)\n",
+    "    mask = jnp.broadcast_to(mask, agent_raw_proxs.shape)\n",
+    "    return agent_raw_proxs * mask\n",
+    "\n",
+    "def dont_change(state, agent_raw_proxs, ent_type_id, ent_neighbors_idx):\n",
+    "    \"\"\"Leave the agent raw_proximeters unchanged\n",
+    "\n",
+    "    :param state: state\n",
+    "    :param agent_raw_proxs: agent_raw_proxs\n",
+    "    :param ent_type_id: ent_type_id\n",
+    "    :param ent_neighbors_idx: ent_neighbors_idx\n",
+    "    :return: agent_raw_proxs\n",
+    "    \"\"\"\n",
+    "    return agent_raw_proxs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add compute_behavior_prox, compute_behavior_proxs_motors, compute_agent_proxs_motors\n",
+    "\n",
+    "- compute_behavior_prox: compute the proxs for one behavior (enumerate through all the sensed entities on this particular behavior)\n",
+    "- compute_behavior_proxs_motors: use fn above to compute the proxs and compute the motor values according to the behavior\n",
+    "- -vmap compute_all_behavior_proxs_motors:  computes this for all the behaviors of an agent\n",
+    "- compute_agent_proxs_motors: compute the proximeters and motor values of an agent for all its behaviors. Just return mean motor value\n",
+    "- -vmap compute_all_agents_proxs_motors: computes this for all agents (vmap over params, sensed and agent_raw_proxs) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_behavior_prox(state, agent_raw_proxs, ent_neighbors_idx, sensed_entities):\n",
+    "    \"\"\"Compute the proximeters for a specific behavior\n",
+    "\n",
+    "    :param state: state\n",
+    "    :param agent_raw_proxs: agent raw proximeters\n",
+    "    :param ent_neighbors_idx: idx of agent neighbors\n",
+    "    :param sensed_entities: array of sensed entities\n",
+    "    :return: updated proximeters\n",
+    "    \"\"\"\n",
+    "    # iterate over all the types in sensed_entities and return if they are sensed or not\n",
+    "    for ent_type_id, sensed in enumerate(sensed_entities):\n",
+    "        # change the proxs if you don't perceive the entity, else leave them unchanged\n",
+    "        agent_raw_proxs = lax.cond(sensed, dont_change, mask_sensors, state, agent_raw_proxs, ent_type_id, ent_neighbors_idx)\n",
+    "    # Compute the final proxs with a max on the updated raw_proxs\n",
+    "    proxs = jnp.max(agent_raw_proxs, axis=0)\n",
+    "    return proxs\n",
+    "\n",
+    "def compute_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_neighbors_idx):\n",
+    "    \"\"\"Return the proximeters and the motors for a specific behavior\n",
+    "\n",
+    "    :param state: state\n",
+    "    :param params: params of the behavior\n",
+    "    :param sensed: sensed mask of the behavior\n",
+    "    :param behavior: behavior\n",
+    "    :param motor: motor values\n",
+    "    :param agent_raw_proxs: agent_raw_proxs\n",
+    "    :param ent_neighbors_idx: ent_neighbors_idx\n",
+    "    :return: behavior proximeters, behavior motors\n",
+    "    \"\"\"\n",
+    "    behavior_prox = compute_behavior_prox(state, agent_raw_proxs, ent_neighbors_idx, sensed)\n",
+    "    behavior_motors = compute_motor(behavior_prox, params, behavior, motor)\n",
+    "    return behavior_prox, behavior_motors\n",
+    "\n",
+    "# vmap on params, sensed and behavior (parallelize on all agents behaviors at once, but not motorrs because are the same)\n",
+    "compute_all_behavior_proxs_motors = vmap(compute_behavior_proxs_motors, in_axes=(None, 0, 0, 0, None, None, None))\n",
+    "\n",
+    "def compute_agent_proxs_motors(state, agent_idx, params, sensed, behavior, motor, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers):\n",
+    "    \"\"\"Compute the agent proximeters and motors for all behaviors\n",
+    "\n",
+    "    :param state: state\n",
+    "    :param agent_idx: idx of the agent in entities\n",
+    "    :param params: array of params for all behaviors\n",
+    "    :param sensed: array of sensed mask for all behaviors\n",
+    "    :param behavior: array of behaviors\n",
+    "    :param motor: motor values\n",
+    "    :param raw_proxs: raw_proximeters of all agents\n",
+    "    :param ag_idx_dense_senders: ag_idx_dense_senders to get the idx of raw proxs (shape=(2, n_agents * (n_entities - 1))\n",
+    "    :param ag_idx_dense_receivers: ag_idx_dense_receivers (shape=(n_agents, n_entities - 1))\n",
+    "    :return: array of agent_proximeters, mean of behavior motors\n",
+    "    \"\"\"\n",
+    "    behavior = jnp.expand_dims(behavior, axis=1)\n",
+    "    ent_ag_idx = ag_idx_dense_senders[agent_idx]\n",
+    "    ent_neighbors_idx = ag_idx_dense_receivers[agent_idx]\n",
+    "    agent_raw_proxs = raw_proxs[ent_ag_idx]\n",
+    "\n",
+    "    # vmap on params, sensed, behaviors and motorss (vmap on all agents)\n",
+    "    agent_proxs, agent_motors = compute_all_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_neighbors_idx)\n",
+    "    mean_agent_motors = jnp.mean(agent_motors, axis=0)\n",
+    "\n",
+    "    return agent_proxs, mean_agent_motors\n",
+    "\n",
+    "compute_all_agents_proxs_motors = vmap(compute_agent_proxs_motors, in_axes=(None, 0, 0, 0, 0, 0, None, None, None))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Add classical braitenberg force fn"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the main environment class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@struct.dataclass\n",
+    "class Neighbors:\n",
+    "    neighbors: jnp.array\n",
+    "    agents_neighs_idx: jnp.array\n",
+    "    agents_idx_dense: jnp.array\n",
+    "\n",
+    "\n",
+    "#--- 4 Define the environment class with its different functions (step ...) ---#\n",
+    "class SelectiveSensorsEnv(BaseEnv):\n",
+    "    def __init__(self, state, occlusion=True, seed=42):\n",
+    "        \"\"\"Init the selective sensors braitenberg env \n",
+    "\n",
+    "        :param state: simulation state already complete\n",
+    "        :param occlusion: wether to use sensors with occlusion or not, defaults to True\n",
+    "        :param seed: random seed, defaults to 42\n",
+    "        \"\"\"\n",
+    "        self.seed = seed\n",
+    "        self.occlusion = occlusion\n",
+    "        self.compute_all_agents_proxs_motors = self.choose_agent_prox_motor_function()\n",
+    "        self.init_key = random.PRNGKey(seed)\n",
+    "        self.displacement, self.shift = space.periodic(state.box_size)\n",
+    "        self.init_fn, self.apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn)\n",
+    "        self.neighbor_fn = partition.neighbor_list(\n",
+    "            self.displacement, \n",
+    "            state.box_size,\n",
+    "            r_cutoff=state.neighbor_radius,\n",
+    "            dr_threshold=10.,\n",
+    "            capacity_multiplier=1.5,\n",
+    "            format=partition.Sparse\n",
+    "        )\n",
+    "        self.neighbors_storage = self.allocate_neighbors(state)\n",
+    "\n",
+    "    def distance(self, point1, point2):\n",
+    "        \"\"\"Returns the distance between two points\n",
+    "\n",
+    "        :param point1: point1 coordinates\n",
+    "        :param point2: point1 coordinates\n",
+    "        :return: distance between two points\n",
+    "        \"\"\"\n",
+    "        return distance(self.displacement, point1, point2)\n",
+    "    \n",
+    "    # At the moment doesn't work because the _step function isn't recompiled \n",
+    "    def choose_agent_prox_motor_function(self):\n",
+    "        \"\"\"Returns the function to compute the proximeters and the motors with or without occlusion\n",
+    "\n",
+    "        :return: compute_all_agents_proxs_motors function\n",
+    "        \"\"\"\n",
+    "        if self.occlusion:\n",
+    "            prox_motor_function = compute_all_agents_proxs_motors_occl\n",
+    "        else:\n",
+    "            prox_motor_function = compute_all_agents_proxs_motors\n",
+    "        return prox_motor_function\n",
+    "    \n",
+    "    @partial(jit, static_argnums=(0,))\n",
+    "    def _step(self, state: State, neighbors_storage: Neighbors) -> Tuple[State, jnp.array]:\n",
+    "        \"\"\"Do 1 jitted step in the environment and return the updated state\n",
+    "\n",
+    "        :param state: current state\n",
+    "        :param neighbors_storage: class storing all neighbors information\n",
+    "        :return: new sttae\n",
+    "        \"\"\"\n",
+    "\n",
+    "        # Retrieve different neighbors format\n",
+    "        neighbors = neighbors_storage.neighbors\n",
+    "        agents_neighs_idx = neighbors_storage.agents_neighs_idx\n",
+    "        ag_idx_dense = neighbors_storage.agents_idx_dense\n",
+    "        # Differences : compute raw proxs for all agents first \n",
+    "        dist, relative_theta, proximity_dist_map, proximity_dist_theta = get_relative_displacement(state, agents_neighs_idx, displacement_fn=self.displacement)\n",
+    "        senders, receivers = agents_neighs_idx\n",
+    "\n",
+    "        dist_max = state.agents.proxs_dist_max[senders]\n",
+    "        cos_min = state.agents.proxs_cos_min[senders]\n",
+    "        target_exist_mask = state.entities.exists[agents_neighs_idx[1, :]]\n",
+    "        raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, target_exist_mask)\n",
+    "\n",
+    "        # Could even just pass ag_idx_dense in the fn and do this inside\n",
+    "        ag_idx_dense_senders, ag_idx_dense_receivers = ag_idx_dense\n",
+    "\n",
+    "        agent_proxs, mean_agent_motors = self.compute_all_agents_proxs_motors(\n",
+    "            state,\n",
+    "            state.agents.ent_idx,\n",
+    "            state.agents.params,\n",
+    "            state.agents.sensed,\n",
+    "            state.agents.behavior,\n",
+    "            state.agents.motor,\n",
+    "            raw_proxs,\n",
+    "            ag_idx_dense_senders,\n",
+    "            ag_idx_dense_receivers,\n",
+    "        )\n",
+    "\n",
+    "        agents = state.agents.replace(\n",
+    "            prox=agent_proxs, \n",
+    "            proximity_map_dist=proximity_dist_map, \n",
+    "            proximity_map_theta=proximity_dist_theta,\n",
+    "            motor=mean_agent_motors\n",
+    "        )\n",
+    "\n",
+    "        # Last block unchanged\n",
+    "        state = state.replace(agents=agents)\n",
+    "        entities = self.apply_physics(state, neighbors)\n",
+    "        state = state.replace(time=state.time+1, entities=entities)\n",
+    "        neighbors = neighbors.update(state.entities.position.center)\n",
+    "\n",
+    "        return state, neighbors\n",
+    "    \n",
+    "    def step(self, state: State) -> State:\n",
+    "        \"\"\"Do 1 step in the environment and return the updated state. This function also handles the neighbors mechanism and hence isn't jitted\n",
+    "\n",
+    "        :param state: current state\n",
+    "        :return: next state\n",
+    "        \"\"\"\n",
+    "        # Because momentum is initialized to None, need to initialize it with init_fn from jax_md\n",
+    "        if state.entities.momentum is None:\n",
+    "             state = self.init_fn(state, self.init_key)\n",
+    "            \n",
+    "        # Compute next state\n",
+    "        current_state = state\n",
+    "        state, neighbors = self._step(current_state, self.neighbors_storage)\n",
+    "\n",
+    "        # Check if neighbors buffer overflowed\n",
+    "        if neighbors.did_buffer_overflow:\n",
+    "            # reallocate neighbors and run the simulation from current_state\n",
+    "            lg.warning(f'NEIGHBORS BUFFER OVERFLOW at step {state.time}: rebuilding neighbors')\n",
+    "            self.neighbors_storage = self.allocate_neighbors(state)\n",
+    "            assert not neighbors.did_buffer_overflow\n",
+    "\n",
+    "        return state\n",
+    "\n",
+    "    def allocate_neighbors(self, state, position=None):\n",
+    "        \"\"\"Allocate the neighbors according to the state\n",
+    "\n",
+    "        :param state: state\n",
+    "        :param position: position of entities in the state, defaults to None\n",
+    "        :return: Neighbors object with neighbors (sparse representation), idx of agent's neighbors, neighbors (dense representation) \n",
+    "        \"\"\"\n",
+    "        # get the sparse representation of neighbors (shape=(n_neighbors_pairs, 2))\n",
+    "        position = state.entities.position.center if position is None else position\n",
+    "        neighbors = self.neighbor_fn.allocate(position)\n",
+    "\n",
+    "        # Also update the neighbor idx of agents\n",
+    "        ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value\n",
+    "        agents_neighs_idx = neighbors.idx[:, ag_idx]\n",
+    "\n",
+    "        # Give the idx of the agents in sparse representation, under a dense representation (used to get the raw proxs in compute motors function)\n",
+    "        agents_idx_dense_senders = jnp.array([jnp.argwhere(jnp.equal(agents_neighs_idx[0, :], idx)).flatten() for idx in jnp.arange(state.max_agents)]) \n",
+    "        # Note: jnp.argwhere(jnp.equal(self.agents_neighs_idx[0, :], idx)).flatten() ~ jnp.where(agents_idx[0, :] == idx)\n",
+    "        \n",
+    "        # Give the idx of the agent neighbors in dense representation\n",
+    "        agents_idx_dense_receivers = agents_neighs_idx[1, :][agents_idx_dense_senders]\n",
+    "        agents_idx_dense = agents_idx_dense_senders, agents_idx_dense_receivers\n",
+    "\n",
+    "        neighbor_storage = Neighbors(neighbors=neighbors, agents_neighs_idx=agents_neighs_idx, agents_idx_dense=agents_idx_dense)\n",
+    "        return neighbor_storage\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the state\n",
+    "\n",
+    "First define helper functions to create agents selctive sensing behaviors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Helper function to transform a color string into rgb with matplotlib colors\n",
+    "def _string_to_rgb(color_str):\n",
+    "    return jnp.array(list(mcolors.to_rgb(color_str)))\n",
+    "\n",
+    "# Helper functions to define behaviors of agents in selecting sensing case\n",
+    "def define_behavior_map(behavior, sensed_mask):\n",
+    "    params = behavior_to_params(behavior)\n",
+    "    sensed_mask = jnp.array([sensed_mask])\n",
+    "\n",
+    "    behavior_map = {\n",
+    "        'behavior': behavior,\n",
+    "        'params': params,\n",
+    "        'sensed_mask': sensed_mask\n",
+    "    }\n",
+    "    return behavior_map\n",
+    "\n",
+    "def stack_behaviors(behaviors_dict_list):\n",
+    "    # init variables\n",
+    "    n_behaviors = len(behaviors_dict_list)\n",
+    "    sensed_length = behaviors_dict_list[0]['sensed_mask'].shape[1]\n",
+    "\n",
+    "    params = np.zeros((n_behaviors, 2, 3)) # (2, 3) = params.shape\n",
+    "    sensed_mask = np.zeros((n_behaviors, sensed_length))\n",
+    "    behaviors = np.zeros((n_behaviors,))\n",
+    "\n",
+    "    # iterate in the list of behaviors and update params and mask\n",
+    "    for i in range(n_behaviors):\n",
+    "        assert behaviors_dict_list[i]['sensed_mask'].shape[1] == sensed_length\n",
+    "        params[i] = behaviors_dict_list[i]['params']\n",
+    "        sensed_mask[i] = behaviors_dict_list[i]['sensed_mask']\n",
+    "        behaviors[i] = behaviors_dict_list[i]['behavior']\n",
+    "\n",
+    "    stacked_behavior_map = {\n",
+    "        'behaviors': behaviors,\n",
+    "        'params': params,\n",
+    "        'sensed_mask': sensed_mask\n",
+    "    }\n",
+    "\n",
+    "    return stacked_behavior_map\n",
+    "\n",
+    "def get_agents_params_and_sensed_arr(agents_stacked_behaviors_list):\n",
+    "    n_agents = len(agents_stacked_behaviors_list)\n",
+    "    params_shape = agents_stacked_behaviors_list[0]['params'].shape\n",
+    "    sensed_shape = agents_stacked_behaviors_list[0]['sensed_mask'].shape\n",
+    "    behaviors_shape = agents_stacked_behaviors_list[0]['behaviors'].shape\n",
+    "    # Init arrays w right shapes\n",
+    "    params = np.zeros((n_agents, *params_shape))\n",
+    "    sensed = np.zeros((n_agents, *sensed_shape))\n",
+    "    behaviors = np.zeros((n_agents, *behaviors_shape))\n",
+    "\n",
+    "    for i in range(n_agents):\n",
+    "        assert agents_stacked_behaviors_list[i]['params'].shape == params_shape\n",
+    "        assert agents_stacked_behaviors_list[i]['sensed_mask'].shape == sensed_shape\n",
+    "        assert agents_stacked_behaviors_list[i]['behaviors'].shape == behaviors_shape\n",
+    "        params[i] = agents_stacked_behaviors_list[i]['params']\n",
+    "        sensed[i] = agents_stacked_behaviors_list[i]['sensed_mask']\n",
+    "        behaviors[i] = agents_stacked_behaviors_list[i]['behaviors']\n",
+    "\n",
+    "    params = jnp.array(params)\n",
+    "    sensed = jnp.array(sensed)\n",
+    "    behaviors = jnp.array(behaviors)\n",
+    "\n",
+    "    return params, sensed, behaviors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seed = 0\n",
+    "n_dims = 2\n",
+    "box_size = 100\n",
+    "diameter = 5.0\n",
+    "friction = 0.1\n",
+    "mass_center = 1.0\n",
+    "mass_orientation = 0.125\n",
+    "neighbor_radius = 100.0\n",
+    "collision_alpha = 0.5\n",
+    "collision_eps = 0.1\n",
+    "dt = 0.1\n",
+    "wheel_diameter = 2.0\n",
+    "speed_mul = 1.0\n",
+    "max_speed = 10.0\n",
+    "theta_mul = 1.0\n",
+    "prox_dist_max = 40.0\n",
+    "prox_cos_min = 0.0\n",
+    "existing_agents = None\n",
+    "existing_objects = None\n",
+    "\n",
+    "entities_sbutypes = ['PREYS', 'PREDS', 'RESSOURCES', 'POISON']\n",
+    "n_preys, preys_color = 5, 'blue'\n",
+    "n_preds, preds_color = 5, 'red'\n",
+    "n_ressources, ressources_color = 5, 'green'\n",
+    "n_poison, poison_color = 5, 'purple'\n",
+    "\n",
+    "preys_data = {\n",
+    "    'type': 'AGENT',\n",
+    "    'num': n_preys,\n",
+    "    'color': 'blue',\n",
+    "    'selective_behaviors': {\n",
+    "        'love': {'beh': 'LOVE', 'sensed': ['PREYS', 'RESSOURCES']},\n",
+    "        'fear': {'beh': 'FEAR', 'sensed': ['PREDS', 'POISON']}\n",
+    "    }}\n",
+    "\n",
+    "preds_data = {\n",
+    "    'type': 'AGENT',\n",
+    "    'num': 5,\n",
+    "    'color': 'red',\n",
+    "    'selective_behaviors': {\n",
+    "        'aggr': {'beh': 'AGGRESSION','sensed': ['PREYS']},\n",
+    "        'fear': {'beh': 'FEAR','sensed': ['POISON']\n",
+    "        }\n",
+    "    }}\n",
+    "\n",
+    "ressources_data = {\n",
+    "    'type': 'OBJECT',\n",
+    "    'num': 5,\n",
+    "    'color': 'green'}\n",
+    "\n",
+    "poison_data = {\n",
+    "    'type': 'OBJECT',\n",
+    "    'num': 5,\n",
+    "    'color': 'purple'}\n",
+    "\n",
+    "entities_data = {\n",
+    "    'EntitySubTypes': entities_sbutypes,\n",
+    "    'Entities': {\n",
+    "        'PREYS': preys_data,\n",
+    "        'PREDS': preds_data,\n",
+    "        'RESSOURCES': ressources_data,\n",
+    "        'POISON': poison_data\n",
+    "    }}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Entities\n",
+    "\n",
+    "Compared to simple Braitenberg env, just need to add a field ent_subtypes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def init_entities(\n",
+    "    max_agents,\n",
+    "    max_objects,\n",
+    "    ent_sub_types,\n",
+    "    n_dims=n_dims,\n",
+    "    box_size=box_size,\n",
+    "    existing_agents=None,\n",
+    "    existing_objects=None,\n",
+    "    mass_center=mass_center,\n",
+    "    mass_orientation=mass_orientation,\n",
+    "    diameter=diameter,\n",
+    "    friction=friction,\n",
+    "    key_agents_pos=random.PRNGKey(seed),\n",
+    "    key_objects_pos=random.PRNGKey(seed+1),\n",
+    "    key_orientations=random.PRNGKey(seed+2)\n",
+    "):\n",
+    "    \"\"\"Init the sub entities state\"\"\"\n",
+    "    existing_agents = max_agents if not existing_agents else existing_agents\n",
+    "    existing_objects = max_objects if not existing_objects else existing_objects\n",
+    "\n",
+    "    n_entities = max_agents + max_objects # we store the entities data in jax arrays of length max_agents + max_objects \n",
+    "    # Assign random positions to each entity in the environment\n",
+    "    agents_positions = random.uniform(key_agents_pos, (max_agents, n_dims)) * box_size\n",
+    "    objects_positions = random.uniform(key_objects_pos, (max_objects, n_dims)) * box_size\n",
+    "    positions = jnp.concatenate((agents_positions, objects_positions))\n",
+    "    # Assign random orientations between 0 and 2*pi to each entity\n",
+    "    orientations = random.uniform(key_orientations, (n_entities,)) * 2 * jnp.pi\n",
+    "    # Assign types to the entities\n",
+    "    agents_entities = jnp.full(max_agents, EntityType.AGENT.value)\n",
+    "    object_entities = jnp.full(max_objects, EntityType.OBJECT.value)\n",
+    "    entity_types = jnp.concatenate((agents_entities, object_entities), dtype=int)\n",
+    "    # Define arrays with existing entities\n",
+    "    exists_agents = jnp.concatenate((jnp.ones((existing_agents)), jnp.zeros((max_agents - existing_agents))))\n",
+    "    exists_objects = jnp.concatenate((jnp.ones((existing_objects)), jnp.zeros((max_objects - existing_objects))))\n",
+    "    exists = jnp.concatenate((exists_agents, exists_objects), dtype=int)\n",
+    "\n",
+    "    # Works because dictionaries are ordered in Python\n",
+    "    ent_subtypes = np.zeros(n_entities)\n",
+    "    cur_idx = 0\n",
+    "    for subtype_id, n_subtype in ent_sub_types.values():\n",
+    "        ent_subtypes[cur_idx:cur_idx+n_subtype] = subtype_id\n",
+    "        cur_idx += n_subtype\n",
+    "    ent_subtypes = jnp.array(ent_subtypes, dtype=int) \n",
+    "\n",
+    "    return EntityState(\n",
+    "        position=RigidBody(center=positions, orientation=orientations),\n",
+    "        momentum=None,\n",
+    "        force=RigidBody(center=jnp.zeros((n_entities, 2)), orientation=jnp.zeros(n_entities)),\n",
+    "        mass=RigidBody(center=jnp.full((n_entities, 1), mass_center), orientation=jnp.full((n_entities), mass_orientation)),\n",
+    "        entity_type=entity_types,\n",
+    "        ent_subtype=ent_subtypes,\n",
+    "        entity_idx = jnp.array(list(range(max_agents)) + list(range(max_objects))),\n",
+    "        diameter=jnp.full((n_entities), diameter),\n",
+    "        friction=jnp.full((n_entities), friction),\n",
+    "        exists=exists\n",
+    "    )\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Agents\n",
+    "\n",
+    "Now this section becomes pretty different. We need to have several behaviors for each agent. \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def init_agents(\n",
+    "    max_agents,\n",
+    "    params,\n",
+    "    sensed,\n",
+    "    behaviors,\n",
+    "    agents_color,\n",
+    "    wheel_diameter=wheel_diameter,\n",
+    "    speed_mul=speed_mul,\n",
+    "    max_speed=max_speed,\n",
+    "    theta_mul=theta_mul,\n",
+    "    prox_dist_max=prox_dist_max,\n",
+    "    prox_cos_min=prox_cos_min\n",
+    "):\n",
+    "    \"\"\"Init the sub agents state\"\"\"\n",
+    "    return AgentState(\n",
+    "        # idx in the entities (ent_idx) state to map agents information in the different data structures\n",
+    "        ent_idx=jnp.arange(max_agents, dtype=int), \n",
+    "        prox=jnp.zeros((max_agents, 2)),\n",
+    "        motor=jnp.zeros((max_agents, 2)),\n",
+    "        behavior=behaviors,\n",
+    "        params=params,\n",
+    "        sensed=sensed,\n",
+    "        wheel_diameter=jnp.full((max_agents), wheel_diameter),\n",
+    "        speed_mul=jnp.full((max_agents), speed_mul),\n",
+    "        max_speed=jnp.full((max_agents), max_speed),\n",
+    "        theta_mul=jnp.full((max_agents), theta_mul),\n",
+    "        proxs_dist_max=jnp.full((max_agents), prox_dist_max),\n",
+    "        proxs_cos_min=jnp.full((max_agents), prox_cos_min),\n",
+    "        proximity_map_dist=jnp.zeros((max_agents, 1)),\n",
+    "        proximity_map_theta=jnp.zeros((max_agents, 1)),\n",
+    "        color=agents_color\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def init_objects(\n",
+    "    max_agents,\n",
+    "    max_objects,\n",
+    "    objects_color\n",
+    "):\n",
+    "    \"\"\"Init the sub objects state\"\"\"\n",
+    "    start_idx, stop_idx = max_agents, max_agents + max_objects \n",
+    "    objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int)\n",
+    "\n",
+    "    return ObjectState(\n",
+    "        ent_idx=objects_ent_idx,\n",
+    "        color=objects_color\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### State"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def init_complete_state(\n",
+    "    entities,\n",
+    "    agents,\n",
+    "    objects,\n",
+    "    max_agents,\n",
+    "    max_objects,\n",
+    "    total_ent_sub_types,\n",
+    "    box_size=box_size,\n",
+    "    neighbor_radius=neighbor_radius,\n",
+    "    collision_alpha=collision_alpha,\n",
+    "    collision_eps=collision_eps,\n",
+    "    dt=dt,\n",
+    "):\n",
+    "    \"\"\"Init the complete state\"\"\"\n",
+    "    return  State(\n",
+    "        time=0,\n",
+    "        dt=dt,\n",
+    "        box_size=box_size,\n",
+    "        max_agents=max_agents,\n",
+    "        max_objects=max_objects,\n",
+    "        neighbor_radius=neighbor_radius,\n",
+    "        collision_alpha=collision_alpha,\n",
+    "        collision_eps=collision_eps,\n",
+    "        entities=entities,\n",
+    "        agents=agents,\n",
+    "        objects=objects,\n",
+    "        ent_sub_types=total_ent_sub_types\n",
+    "    )   "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "def init_state(\n",
+    "    entities_data,\n",
+    "    box_size=box_size,\n",
+    "    dt=dt,\n",
+    "    neighbor_radius=neighbor_radius,\n",
+    "    collision_alpha=collision_alpha,\n",
+    "    collision_eps=collision_eps,\n",
+    "    n_dims=n_dims,\n",
+    "    seed=seed,\n",
+    "    diameter=diameter,\n",
+    "    friction=friction,\n",
+    "    mass_center=mass_center,\n",
+    "    mass_orientation=mass_orientation,\n",
+    "    existing_agents=None,\n",
+    "    existing_objects=None,\n",
+    "    wheel_diameter=wheel_diameter,\n",
+    "    speed_mul=speed_mul,\n",
+    "    max_speed=max_speed,\n",
+    "    theta_mul=theta_mul,\n",
+    "    prox_dist_max=prox_dist_max,\n",
+    "    prox_cos_min=prox_cos_min,\n",
+    ") -> State:\n",
+    "    key = random.PRNGKey(seed)\n",
+    "    key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)\n",
+    "    \n",
+    "    # create an enum for entities subtypes\n",
+    "    ent_sub_types = entities_data['EntitySubTypes']\n",
+    "    ent_sub_types_enum = Enum('ent_sub_types_enum', {ent_sub_types[i]: i for i in range(len(ent_sub_types))}) \n",
+    "    ent_data = entities_data['Entities']\n",
+    "\n",
+    "    # create max agents and max objects\n",
+    "    max_agents = 0\n",
+    "    max_objects = 0 \n",
+    "\n",
+    "    # create agent and objects dictionaries \n",
+    "    agents_data = {}\n",
+    "    objects_data = {}\n",
+    "\n",
+    "    # iterate over the entities subtypes\n",
+    "    for ent_sub_type in ent_sub_types:\n",
+    "        # get their data in the ent_data\n",
+    "        data = ent_data[ent_sub_type]\n",
+    "        color_str = data['color']\n",
+    "        color = _string_to_rgb(color_str)\n",
+    "        n = data['num']\n",
+    "\n",
+    "        # Check if the entity is an agent or an object\n",
+    "        if data['type'] == 'AGENT':\n",
+    "            max_agents += n\n",
+    "            behavior_list = []\n",
+    "            # create a behavior list for all behaviors of the agent\n",
+    "            for beh_name, behavior_data in data['selective_behaviors'].items():\n",
+    "                beh_name = behavior_data['beh']\n",
+    "                behavior_id = Behaviors[beh_name].value\n",
+    "                # Init an empty mask\n",
+    "                sensed_mask = np.zeros((len(ent_sub_types, )))\n",
+    "                for sensed_type in behavior_data['sensed']:\n",
+    "                    # Iteratively update it with specific sensed values\n",
+    "                    sensed_id = ent_sub_types_enum[sensed_type].value\n",
+    "                    sensed_mask[sensed_id] = 1\n",
+    "                beh = define_behavior_map(behavior_id, sensed_mask)\n",
+    "                behavior_list.append(beh)\n",
+    "            # stack the elements of the behavior list and update the agents_data dictionary\n",
+    "            stacked_behaviors = stack_behaviors(behavior_list)\n",
+    "            agents_data[ent_sub_type] = {'n': n, 'color': color, 'stacked_behs': stacked_behaviors}\n",
+    "\n",
+    "        # only updated object counters and color if entity is an object\n",
+    "        elif data['type'] == 'OBJECT':\n",
+    "            max_objects += n\n",
+    "            objects_data[ent_sub_type] = {'n': n, 'color': color}\n",
+    "\n",
+    "    # Create the params, sensed, behaviors and colors arrays \n",
+    "\n",
+    "    # init empty lists\n",
+    "    colors = []\n",
+    "    agents_stacked_behaviors_list = []\n",
+    "    total_ent_sub_types = {}\n",
+    "    for agent_type, data in agents_data.items():\n",
+    "        n = data['n']\n",
+    "        stacked_behavior = data['stacked_behs']\n",
+    "        n_stacked_behavior = list([stacked_behavior] * n)\n",
+    "        tiled_color = list(np.tile(data['color'], (n, 1)))\n",
+    "        # update the lists with behaviors and color elements\n",
+    "        agents_stacked_behaviors_list = agents_stacked_behaviors_list + n_stacked_behavior\n",
+    "        colors = colors + tiled_color\n",
+    "        total_ent_sub_types[agent_type] = (ent_sub_types_enum[agent_type].value, n)\n",
+    "\n",
+    "    # create the final jnp arrays\n",
+    "    agents_colors = jnp.concatenate(jnp.array([colors]), axis=0)\n",
+    "    params, sensed, behaviors = get_agents_params_and_sensed_arr(agents_stacked_behaviors_list)\n",
+    "\n",
+    "    # do the same for objects colors\n",
+    "    colors = []\n",
+    "    for objecy_type, data in objects_data.items():\n",
+    "        n = data['n']\n",
+    "        tiled_color = list(np.tile(data['color'], (n, 1)))\n",
+    "        colors = colors + tiled_color\n",
+    "        total_ent_sub_types[objecy_type] = (ent_sub_types_enum[objecy_type].value, n)\n",
+    "\n",
+    "    objects_colors = jnp.concatenate(jnp.array([colors]), axis=0)\n",
+    "    # print(total_ent_sub_types)\n",
+    "\n",
+    "    # Init sub states and total state\n",
+    "    entities = init_entities(max_agents=max_agents, max_objects=max_objects, ent_sub_types=total_ent_sub_types)\n",
+    "    agents = init_agents(max_agents=max_agents, behaviors=behaviors, params=params, sensed=sensed, agents_color=agents_colors)\n",
+    "    objects = init_objects(max_agents=max_agents, max_objects=max_objects, objects_color=objects_colors)\n",
+    "    state = init_complete_state(entities=entities, agents=agents, objects=objects, max_agents=max_agents, max_objects=max_objects, total_ent_sub_types=total_ent_sub_types)\n",
+    "    return state\n",
+    "\n",
+    "state = init_state(entities_data=entities_data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Recap of the state\n",
+    "\n",
+    "### Agents\n",
+    "\n",
+    "Preys:\n",
+    "- Love: other preys and ressources\n",
+    "- Fear: predators and poison\n",
+    "- Color: Blue\n",
+    "\n",
+    "Predators:\n",
+    "- Aggression: preys\n",
+    "- Fear: Poison\n",
+    "- Color: Red\n",
+    "\n",
+    "### Objects\n",
+    "\n",
+    "Ressources\n",
+    "- Color: green\n",
+    "\n",
+    "Poison\n",
+    "- Color: purple"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test the simulation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from vivarium.experimental.environments.braitenberg.render import render, render_history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "env = SelectiveSensorsEnv(state, occlusion=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_steps = 5_000\n",
+    "hist = []\n",
+    "\n",
+    "for i in range(n_steps):\n",
+    "    state = env.step(state)\n",
+    "    hist.append(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAikAAAIjCAYAAADGCIt4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABnh0lEQVR4nO3dd3xN9/8H8Ne592bcJJIQWQgJgtgjqD0aq2iNVpEaVbRq1Gip9lutLqPaKilKS1CK9me0WjSN0VIi9t4hQQYiW9a95/fHaW7dSsi999zck+T1/D7u4+uedd/3ptxXPusIoiiKICIiIlIYla0LICIiIioMQwoREREpEkMKERERKRJDChERESkSQwoREREpEkMKERERKRJDChERESkSQwoREREpEkMKERERKRJDClEZMnLkSPj7+9u6DCIiWTCkECmcIAjFeuzdu9fWpT7RkiVLEB4ebusynmjMmDEQBAF9+vR5ZF9GRgYmT56MatWqwcHBAUFBQVi6dOkjx4WHhxf5s0pISHjk+J9//hnNmzeHo6Mjqlevjvfffx/5+flWeX9EpYXG1gUQ0eOtXbvW6PmaNWsQERHxyPagoCCsWLECer2+JMszyZIlS1C5cmWMHDnS1qUU6ciRIwgPD4ejo+Mj+3Q6HXr06IEjR45g/PjxCAwMxK5du/D666/j/v37eOeddx4558MPP0RAQIDRNnd3d6PnO3bsQL9+/dC5c2csXrwYp0+fxscff4ykpKRCAxBRuSESUakyfvx4sbT+1W3QoIHYqVMnW5dRJL1eL7Zp00YcNWqUWKNGDbF3795G+zdt2iQCEL/77juj7QMHDhQdHR3FxMREw7ZVq1aJAMTo6Ognvm79+vXFJk2aiHl5eYZt7777rigIgnj+/HkL3xVR6cXuHqIy5L9jUq5fvw5BELBgwQJ8/fXXqFmzJpycnNC9e3fExcVBFEV89NFHqFatGrRaLZ577jkkJyc/ct0dO3agQ4cOcHZ2RoUKFdC7d2+cPXvW6JiEhAS8/PLLhm4QX19fPPfcc7h+/ToAwN/fH2fPnsW+ffsM3R6dO3c2nJ+SkoLJkyfDz88PDg4OqF27NubNm2fUMvTw+/nyyy9Ro0YNaLVadOrUCWfOnDGqJy8vDxcuXEB8fHyxP7+1a9fizJkz+OSTTwrd/9dffwEABg8ebLR98ODByM7OxrZt2wo9Lz09HTqdrtB9586dw7lz5zB27FhoNP82br/++usQRRE//fRTsesnKmvY3UNUDqxbtw65ubmYOHEikpOTMX/+fAwaNAhdu3bF3r17MWPGDFy5cgWLFy/Gm2++iZUrVxrOXbt2LUaMGIEePXpg3rx5yMrKwtKlS9G+fXscP37cEIoGDhyIs2fPYuLEifD390dSUhIiIiIQGxsLf39/LFy4EBMnToSLiwveffddAIC3tzcAICsrC506dcKtW7fw6quvonr16vj7778xc+ZMxMfHY+HChUbvZ82aNUhPT8f48eORnZ2Nr776Cl27dsXp06cN17x16xaCgoIwYsSIYo2DSU9Px4wZM/DOO+/Ax8en0GNycnKgVqthb29vtN3JyQkAcPToUYwZM8ZoX5cuXZCRkQF7e3v06NEDn3/+OQIDAw37jx8/DgAIDg42Oq9KlSqoVq2aYT9RuWTrphwiMs3juntGjBgh1qhRw/A8JiZGBCB6enqKKSkphu0zZ84UATzSxTBkyBDR3t5ezM7OFkVRFNPT00V3d3dxzJgxRq+TkJAgurm5Gbbfv39fBCB+9tlnj629qO6ejz76SHR2dhYvXbpktP3tt98W1Wq1GBsba/R+tFqtePPmTcNxUVFRIgBxypQpj7z3ESNGPLamAm+++aYYEBBgeO+Fdfd8/vnnIgDxr7/+eqROAGKfPn0M2zZu3CiOHDlSXL16tbhlyxbxf//7n+jk5CRWrlzZ8H5EURQ/++wzEYDRtgItW7YUn3rqqWLVT1QWsbuHqBx44YUX4ObmZnjeunVrAMBLL71k1MXQunVr5Obm4tatWwCAiIgIpKSkYMiQIbh7967hoVar0bp1a+zZswcAoNVqYW9vj7179+L+/fsm1/fjjz+iQ4cOqFixotHrhISEQKfT4c8//zQ6vl+/fqhatarheatWrdC6dWv89ttvhm3+/v4QRbFYrSiXLl3CV199hc8++wwODg5FHjd06FC4ublh1KhRiIiIwPXr17F8+XIsWbIEAPDgwQPDsYMGDcKqVaswfPhw9OvXDx999BF27dqFe/fuGXUnFZxT2Os6OjoaXZOovGF3D1E5UL16daPnBYHFz8+v0O0FQePy5csAgK5duxZ6XVdXVwDSF+y8efMwbdo0eHt746mnnkKfPn0wfPjwIrtOHnb58mWcOnUKnp6ehe5PSkoyev5wd0mBOnXqYNOmTU98rcK88cYbaNu2LQYOHPjY43x8fPDzzz9j2LBh6N69OwDpM1i8eDFGjBgBFxeXx57fvn17tG7dGn/88Ydhm1arBSB1Jf1Xdna2YT9RecSQQlQOqNVqk7aLoggAhkGra9euLTRsPNwKM3nyZPTt2xdbt27Frl278N5772HOnDnYvXs3mjVr9tj69Ho9unXrhunTpxe6v06dOo893xK7d+/Gzp07sXnzZsMgXwDIz8/HgwcPcP36dVSqVMkQyDp27Ihr167h9OnTyMzMRJMmTXD79u1i1+nn54eLFy8anvv6+gIA4uPjHwmN8fHxaNWqlaVvkajUYkghoiLVqlULAODl5YWQkJBiHT9t2jRMmzYNly9fRtOmTfH555/j+++/ByAtTFfUeRkZGcV6DeDfFp6HXbp0yazVdmNjYwEAAwYMeGTfrVu3EBAQgC+//BKTJ082bFer1WjatKnheUHLSHHqv3btmlGLUcF1jhw5YhRIbt++jZs3b2Ls2LGmvB2iMoVjUoioSD169ICrqys+/fRT5OXlPbL/zp07AKTZOdnZ2Ub7atWqhQoVKhh1Yzg7OyMlJeWR6wwaNAgHDx7Erl27HtmXkpLyyMqrW7duNYybAYDDhw8jKioKvXr1Mmwr7hTkrl27YsuWLY88PD09ERwcjC1btqBv375Fnn/nzh3MmzcPjRs3NgopBZ/Nw3777TccPXoUPXv2NGxr0KAB6tWrh+XLlxtNU166dCkEQcDzzz//2PqJyjK2pBBRkVxdXbF06VIMGzYMzZs3x+DBg+Hp6YnY2Fj8+uuvaNeuHcLCwnDp0iU8/fTTGDRoEOrXrw+NRoMtW7YgMTHRaE2RFi1aYOnSpfj4449Ru3ZteHl5oWvXrnjrrbfw888/o0+fPhg5ciRatGiBzMxMnD59Gj/99BOuX7+OypUrG65Tu3ZttG/fHuPGjUNOTg4WLlwIDw8Po+6i4k5Brl69+iNjdgCp+8rb2xv9+vUz2t6pUye0adMGtWvXRkJCApYvX46MjAxs374dKtW/v/e1bdsWzZo1Q3BwMNzc3HDs2DGsXLkSfn5+j6xM+9lnn+HZZ59F9+7dMXjwYJw5cwZhYWEYPXo0goKCivvjIipzGFKI6LGGDh2KKlWqYO7cufjss8+Qk5ODqlWrokOHDnj55ZcBSOMshgwZgsjISKxduxYajQb16tXDpk2bjAajzpo1Czdu3MD8+fORnp6OTp06oWvXrnBycsK+ffvw6aef4scff8SaNWvg6uqKOnXqYPbs2UYzkwBg+PDhUKlUWLhwIZKSktCqVSuEhYUZxndYU4sWLfDjjz/i1q1bcHV1Rbdu3fDRRx+hZs2aRse9+OKL+PXXX/H7778jKysLvr6+GDNmDN5//33DWi4F+vTpg82bN2P27NmYOHEiPD098c4772DWrFlWfz9ESiaIBSPkiIgU7vr16wgICMBnn32GN99809blEJGVcUwKERERKRJDChERESkSQwoREREpkk1Dyp9//om+ffuiSpUqEAQBW7duNdoviiJmzZoFX19faLVahISEPLI+QnJyMkJDQ+Hq6gp3d3e88soryMjIKMF3QUQlpWCpe45HISofbBpSClZr/PrrrwvdP3/+fCxatAjLli1DVFQUnJ2d0aNHD6P1GEJDQ3H27FlERERg+/bt+PPPP7n4ERERURmgmNk9giBgy5YthjUJRFFElSpVMG3aNMNvTampqfD29kZ4eDgGDx6M8+fPo379+oiOjjbc5nznzp145plncPPmTVSpUsVWb4eIiIgspNh1UmJiYpCQkGC0gqObmxtat26NgwcPYvDgwTh48CDc3d0NAQWQlqVWqVSIiopC//79C712Tk6O0SqYer0eycnJ8PDwKHLZbiIiInqUKIpIT09HlSpVjBY0lINiQ0pCQgIAPLLokbe3t2FfQkICvLy8jPZrNBpUqlTJcExh5syZg9mzZ8tcMRERUfkVFxeHatWqyXpNxYYUa5o5cyamTp1qeJ6amorq1asjLi7OcKdTIiJr2rcPePZZea51/z4g8y+wRMWWlpYGPz8/VKhQQfZrKzakFNwWPjEx0Wip68TERMNdQ318fJCUlGR0Xn5+PpKTkwu9rXwBBwcHODg4PLLd1dWVIYWISkTLllKw0OvNv4YgAEFBgLu7bGURmc0awyUUm70DAgLg4+ODyMhIw7a0tDRERUWhTZs2AIA2bdogJSUFR48eNRyze/du6PV6tG7dusRrJiIqLh8f4LnnAI2FvypOmCBPPURKZNOWlIyMDFy5csXwPCYmBidOnEClSpVQvXp1TJ48GR9//DECAwMREBCA9957D1WqVDHMAAoKCkLPnj0xZswYLFu2DHl5eZgwYQIGDx7MmT1EpHgTJgBbtph/vlYLvPSSfPUQKY1NQ8qRI0fQpUsXw/OCcSIFt1afPn06MjMzMXbsWKSkpKB9+/bYuXMnHB0dDeesW7cOEyZMwNNPPw2VSoWBAwdi0aJFJf5eiIhM1aWL1O1z/DiQn2/auYIATJkCWGEYAJFiKGadFFtKS0uDm5sbUlNTOSaFiEpUYqIUVOLjix9UVCqgb1/g//4PUKutW5+t6XQ65OXl2bqMck2tVkOj0RQ55sSa36GKHThLRFQeeHsDBw8CPXoAZ88+fjBtwb7QUODbb8t+QMnIyMDNmzfB36Vtz8nJCb6+vrC3ty/R12VIISKysapVgehoYP164KuvgNOnpQBSMK1YpwNEEejVC8jLk8aylPB3RYnT6XS4efMmnJyc4OnpyYU2bUQUReTm5uLOnTuIiYlBYGCg7Au2PQ5DChGRAmi1wCuvAKNGAVFRwN690vondnZA5cpAv36Avz+QkQHMmgW0amXjgq0sLy8PoijC09MTWq3W1uWUa1qtFnZ2drhx4wZyc3ONxoVaG0MKEZGCCALw1FPSozAuLtKMnhMngH+WjCrTzG1BEUUp7G3fDty9Kz338AB69gQ6dJA+Zyq+kmw9eRhDChFRKdO8OXD+vPG2lOwU3Ey7iczcTFRwqAA/Vz9UcCh/U39ycoC1a4FFi6RuM43m30AiisCcOUC9esDEicDLL0stWKRcDClERKVQvXqAXi/i75sH8PXhr/HT+Z+Qr/93epCD2gFDGw3FhFYT0Ny3uQ0rLTn37kmzng4e/Hc8T2Ezpi5elMb1fPst8Ntv0sJ6pEyKXXGWiIiKFpt6A8ErWqDDqg6PBBQAyNHlYO2ptWixvAU6h3fGncw7Nqq0ZKSnA507A4cPS88fd7sBUZQep08D7dsDycklUiKZgSGFiKiUuXD3AoJXBON04mkAeCSgFCjYfiD2AFquaImbaTdLrMaS9vLLUheYTlf8c/LzgevXgRdftFpZNiUIArZu3WrrMizCkEJEVIrcybyDbmu74f6D+8gXi7f6W76Yj1tpt9Dj+x5Iz0m3coUl7+pVaWE7UwJKAZ0O+OMP4ORJ+esiyzGkEFHpEB8P/PUX8OuvwL59QGysrSuyiQV/L0B8ejx0omnfyPliPs7fOY8Vx1ZYqTLbWbbMsoXtNBpg6VL56tm5cyfat28Pd3d3eHh4oE+fPrh69aph/99//42mTZvC0dERwcHB2Lp1KwRBwIkTJwzHnDlzBr169YKLiwu8vb0xbNgw3L1717C/c+fOmDRpEqZPn45KlSrBx8cHH3zwgWG/v78/AKB///4QBMHw/OTJk+jSpQsqVKgAV1dXtGjRAkeOHJHvzcuMIYWIlEuvB37/HXj2WWnFs44dgT59pMEHNWoATz8NbN1q+o1vSqns/Gx8c/QbkwPKwxYfXgy9+JgBG6VMXh6wYoV5rSgF8vOB1auBzEx5asrMzMTUqVNx5MgRREZGQqVSoX///tDr9UhLS0Pfvn3RqFEjHDt2DB999BFmzJhhdH5KSgq6du2KZs2a4ciRI9i5cycSExMxaNAgo+NWr14NZ2dnREVFYf78+fjwww8REREBAIiOjgYArFq1CvHx8YbnoaGhqFatGqKjo3H06FG8/fbbsLOzk+eNWwFn9xCRMsXGAr17A2fOSL/qFrY0+r59wO7dUmD59VegQYOSr7ME/Xj2R6TmpJp9vggR11Ou449rf6B7re4yVmY7SUlAqvkfiUF2NhAXJ82astTAgQONnq9cuRKenp44d+4c9u/fD0EQsGLFCjg6OqJ+/fq4desWxowZYzg+LCwMzZo1w6effmp0DT8/P1y6dAl16tQBADRu3Bjvv/8+ACAwMBBhYWGIjIxEt27d4OnpCQBwd3eHz0PTl2JjY/HWW2+h3j9vNDAw0PI3bEVsSSEi5blyBQgOBi5ckJ4X1VJS8OvzzZvS6mcKbraWw86rO6EWLLthj53KDjsu75CpIttLS5PvWnKEHQC4fPkyhgwZgpo1a8LV1dXQ1RIbG4uLFy+icePGRqu2tvrP8sEnT57Enj174OLiYngUhIqHu40aN25sdJ6vry+SkpIeW9vUqVMxevRohISEYO7cuUbXUyKGFCJSlvv3gW7dpHmhxe3G0emABw+ku/TFxVm3Phu6m3nXoq4eQGpNSc4uO3NunZ3lu5aLizzX6du3L5KTk7FixQpERUUhKioKAJCbm1us8zMyMtC3b1+cOHHC6HH58mV07NjRcNx/u2kEQYD+cXOvAXzwwQc4e/Ysevfujd27d6N+/frYsmWLie+w5DCkEJGyfPON1NVj6iADnU76Vfizz6xTlwLIdZM9AWVnTXgvL0COW8mo1dKwJ0vdu3cPFy9exP/+9z88/fTTCAoKwv379w3769ati9OnTyMnJ8ewrWC8SIHmzZvj7Nmz8Pf3R+3atY0eziakMjs7O+gK+XtUp04dTJkyBb///jsGDBiAVatWmfFOSwZDChEph04HhIU9fiWuJ52/cqV0F74yyNPZ0+LuHgDw0HrIUI0yODoCoaHSsCVzaTTAwIGAu7vl9VSsWBEeHh5Yvnw5rly5gt27d2Pq1KmG/UOHDoVer8fYsWNx/vx57Nq1CwsWLADwbwgdP348kpOTMWTIEERHR+Pq1avYtWsXXn755UJDR1H8/f0RGRmJhIQE3L9/Hw8ePMCECROwd+9e3LhxAwcOHEB0dDSCgoIsf+NWwpBCRMqxYwdw65Zl18jKAtatk6cehelbp6/F3T35+nw8W/dZmSpShtdft2yCV34+MH68PLWoVCps2LABR48eRcOGDTFlyhR89lDrnqurK3755RecOHECTZs2xbvvvotZs2YBgGGcSpUqVXDgwAHodDp0794djRo1wuTJk+Hu7m7Sjf4+//xzREREwM/PD82aNYNarca9e/cwfPhw1KlTB4MGDUKvXr0we/Zsed68FQiiWNiQ+fIlLS0Nbm5uSE1Nhaurq63LISq/pk6VWlLy8sy/hkoFPP88sHGjfHUpRK4uF1W/qIq7WXeffHAhBAgI9AjEhfEXZOs6spbs7GzExMQgICDAaJBpUdq3l+56bGpY0WiAoCBpMTdbfSTr1q3Dyy+/jNTUVGgVesfDx/08rPkdypYUIlKO5OTCpxqbQq+X7jRXBtmr7TEueJxFXT4TW01UfEAxx8aNQOXKpnX7qNVAhQrSUjsl+ZGsWbMG+/fvR0xMDLZu3YoZM2Zg0KBBig0otsSQQkTKYcmyoQ+zZICCwk1tMxUBFQOgUZn2HjWCBsFVgvFKs1esVJltVa0K/Pmn9P/F+c9IrQY8PaVzata0fn0PS0hIwEsvvYSgoCBMmTIFL7zwApYvX16yRZQSDClEpBz/LEBlEY1GmvJRRrk7uiNiWAR8XHyKHVTUghq1PWrj16G/QmtXdn9bDwyUlsqZMgVwc5O2PTyEo6C1xMUFmDABOHYMaNiw5OucPn06rl+/buhC+fLLL+Hk5FTyhZQCDClEpBz16lm+xH1+PjBggDz1KJS/uz+OjDmCDtU7AECRYaWgW6hPnT449MoheDrLEAIVrnJlaRZ6fLy01P2AAdLdFDp0APr3l5bQT0gAFi4EfH1tXS09SdltEyWi0kGvB3bulG5Fa2cH1KoFxMSYPw3Zx0e6v08Z5+3ijd0jduNM0hksjV6KVSdW4UH+A8N+VwdXjGk+Bq8Fv4balWrbsFLb0GqB4cOlB5VeDClEZDvZ2dLS98HBwDPPSNvq1gVeMXPchEolzSUtw2NS/quhV0N83ftrfNnzS9zJvIP03HS4OrjC08kTdmrl3jiOqDjKz99kIlIeR0egaVPjbcOGAevXA3v3mrbqrEYj3WBw8mQZCyw97NX2qOoqw5KpZYRe1CPiagS2X9qOew/uQYSISo6V0LN2TzwT+AzUKpkGaZNVMaQQkbLY2QGbN0v34Tl8uHjdPmq11E20Y4d8N2ChUikzNxPfHP0Giw8vxvWU69CoNBBFESJEqAQVlhxZgqoVqmJCqwl4veXrcHXg2lhKxoGzRKQ8rq7A7t1St49GYzxF42FqtTRlo39/4NAhjoQs5+LT49FuZTu8+fubuJFyA4C0wq5O1EEv6pGvlwZl30q/hXd3v4tWK1oZjiNlYkghImXSaoHly6Vl8j/5BKhWzXh/5crAzJnAjRvAjz/Kc+MVKrXuP7iPjuEdcTbpLMR//vc4elGPq/evov2q9kjMSCyhKoG9e/dCEASkpKRYdEx5wZBCRMrm5QW8/TYQFycNtL1zB3jwQPr/jz4C/PxsXSEpQOjmUMTcj0G+WPwp7Pn6fCRkJOD5Tc9bsTLTtW3bFvHx8XArWOzFQqU59DCkEFHp4eAgtaAU414uVH6cv3MeO67sMOvmi/n6fOyP24/oW9FWqMw89vb28PHxKZO3LzAVQwoREZVqy44ss+h+RhqVBkuOLJGtnpycHEyaNAleXl5wdHRE+/btER1tHIIOHDiAxo0bw9HREU899RTOnDlj2FdYy8f+/fvRoUMHaLVa+Pn5YdKkScjMzDR6zRkzZsDPzw8ODg6oXbs2vvvuO1y/fh1dunQBAFSsWBGCIGDkyJEAgJ9++gmNGjWCVquFh4cHQkJCjK6pBAwpRKXc7dvA779LwzJ+/VW6myvvbU7lRa4uFytPrDSrFaVAvj4f60+vR3pOuiw1TZ8+Hf/3f/+H1atX49ixY6hduzZ69OiB5ORkwzFvvfUWPv/8c0RHR8PT0xN9+/ZFXhF3/7569Sp69uyJgQMH4tSpU9i4cSP279+PCRMmGI4ZPnw4fvjhByxatAjnz5/HN998AxcXF/j5+eH//u//AAAXL15EfHw8vvrqK8THx2PIkCEYNWoUzp8/j71792LAgAEQFfaPB6cgE5VCoihNfgkLA37++dFZuvXrA5MmAaGhnJFLZVtSZhIycjMsvk6uLhc3024iyDPIoutkZmZi6dKlCA8PR69evQAAK1asQEREBL777ju0bNkSAPD++++jW7duAIDVq1ejWrVq2LJlCwYNGvTINefMmYPQ0FBM/mcNoMDAQCxatAidOnXC0qVLERsbi02bNiEiIgIhISEAgJoP3TWxUqVKAAAvLy+4/zPA/OrVq8jPz8eAAQNQo0YNAECjRo0seu/WwJYUolImKQlo3RoICQG2by98GZHz54Fx46Q7wkZElHyNRCVFrtYPAEjLSbP4GlevXkVeXh7atWtn2GZnZ4dWrVrh/Pnzhm1t2rQx/LlSpUqoW7eu0f6HnTx5EuHh4XBxcTE8evToAb1ej5iYGJw4cQJqtRqdOnUqdp1NmjTB008/jUaNGuGFF17AihUrcP/+fTPesXUxpBCVIvHxQKtWwPHj0vOi7sUnitIjIwPo1QvYsqXkaiQqSS728jUVVnCoINu15JSRkYFXX30VJ06cMDxOnjyJy5cvo1atWtBqTb+ztVqtRkREBHbs2IH69etj8eLFqFu3LmJiYqzwDszHkEJUSmRnAz17SsuGFPdGwXq99Bg8GIhWzuQFItl4OXvByc7J4utoVBpUc6325AOfoFatWrC3t8eBAwcM2/Ly8hAdHY369esbth06dMjw5/v37+PSpUsICiq8q6l58+Y4d+4cateu/cjD3t4ejRo1gl6vx759+wo9397eHgCg+89tJgRBQLt27TB79mwcP34c9vb22KKw32gYUohKiY0bgVOnih9QCoiidAuc99+3Tl1EtuSgccDIJiOhUZk/xFKj0mBww8GyLJHv7OyMcePG4a233sLOnTtx7tw5jBkzBllZWXjloRtnfvjhh4iMjMSZM2cwcuRIVK5cGf369Sv0mjNmzMDff/+NCRMm4MSJE7h8+TK2bdtmGDjr7++PESNGYNSoUdi6dStiYmKwd+9ebNq0CQBQo0YNCIKA7du3486dO8jIyEBUVBQ+/fRTHDlyBLGxsdi8eTPu3LlTZFCyFYYUolJi0aKiV4d/Ep0O2LkTUFhLLpEsxrUcZ1jy3hz5+nyMbzletnrmzp2LgQMHYtiwYWjevDmuXLmCXbt2oWLFikbHvPHGG2jRogUSEhLwyy+/GFo8/qtx48bYt28fLl26hA4dOqBZs2aYNWsWqlSpYjhm6dKleP755/H666+jXr16GDNmjGE6cdWqVTF79my8/fbb8Pb2xoQJE+Dq6oo///wTzzzzDOrUqYP//e9/+Pzzzw2DfZVCEJU238gG0tLS4ObmhtTUVLi68mZTpDxHjwLBwZZdQ60Gpk0D5s2TpyYia8rOzkZMTAwCAgLgWIzF+0LWhGDf9X0mrTgLAGpBjea+zRE1Okoxi6ft2rULvXr1QnZ2dpHBpaQ97udhze9QTkEmKgX27ZNaUYpzQ+Ci6HRAZKRMBR07BmzaJE01ys0FKlYE2reXbvSnkH9UqXz5YeAPaLmiJW6l3yp2q4pG0MDDyQObX9ysmICSmJiIbdu2ITAwUDEBxZYYUohKgZQUqSXEkpACAPfuWXCyTgesXy/1Ox05It2dGJAGvahU0qItHh7S3OcJEwBvb8uKJTKBp7Mn/nz5T3Rf2x2Xky9DLz7+L4taUKOaWzVEDIuQZcCsXJ555hmkp6djyRL5VsAtzRhSiKwoMzcT5+6cw/3s+3BQO8DHxQd1POqY/FubRqa/qWb/YpaVBQwZIq0cVzAw5uERvAWzBu7dA+bMAVasAHbtApo0saheIlNUd6uOqNFRWBS1CEuOLEFCRgI0Ko2hZaXgz5WdKmNc8Di80foNeDh52LhqY0ePHrV1CYrCkEJkBefunMPS6KVYeWIlsvKyjPY19GqISa0mYWijoXC2dy7W9by8TJ/V81+CAPj4mHFiXh7w3HPSErfAk5tzdDrg7l2gQwcgKgpQ2GwBKtvcHN3wXqf3MLPDTGy/tB2/XPwF9x7cgyiKqORUCb1q90L/ev1hp7azdalUDAwpRDLKzs/GqG2j8MOZH4x+g3vY2aSzGLt9LKb9Pg3fD/gez9Z99onX/Wf1bIsNHmzGSf/7nzSYxZQx9jqd1PrSowdw5QrHqZDZzJ3boVFp0K9eP/Sr10/egsopW82x4RRkIpk8yHuAkDUh2Hh2IwAUOXhPhPSXPSM3A/029MOak2uKvGZGBvDll8CMGUCDBtK4FHM5OgIvvfSYAwr7Ryg9XRprYs4/UDodEBcHbN5s+rlU7qn/+Y89NzfXxpUQAGRlSS3CdnYl2wLFlhQiGYiiiNDNoTh48+ATB+wZzvknrIzaNgpVK1TF0zWfNuzT6aQGiKtXgWHDgClTpBk+nTubV59aDYwcCVR43KrfoghcuwacOQNcvCjd+OfiReDBA/NetOCFFy82swmHyjONRgMnJyfcuXMHdnZ2UJm7SBBZRBRFZGVlISkpCe7u7obwWFK4Tgq4TgpZ7kDsAbRf1d6sc1VQoaF3Q5x49cRjB9SKojRxZvly0xo2NBrAzw84fBioXLmYJ+XmAr//LjW9pKYW/8WKcv48UK+e5dehciU3NxcxMTHQWzqtjSzm7u4OHx+fQv+N4jopRAr3dfTXRY5BeRI99DiVeArRt6PRqmqrIo8TBKnnJTUV2LCheNdWqwFfX+CPP0wIKIA0hqRPHyAnx4STHuPiRYYUMpm9vT0CAwPZ5WNjdnZ2Jd6CUoAhhchCSZlJ+PHcjxYty61RaRB2OAxr+hc9PgWQWkXWrZPGp8yfLw0ZKWyRt4I1VXr3llpezFqyRKeT7mooh7Q0ea5D5Y5KpSrWirNUNrGTj8hCf934y6KAAkiDbHdd3VWsY1UqacJNQgLw3XdA48b/rqMiCFIgmT5duk/Ptm0WrKmmVss3K+exg2GIiArHlhQiC93Pvi/LdVKzTRv74eQEjBolPURRavRwcDD/JoSFqllT6qqxdOhazZry1ENE5QpbUogspBbk6atVq8y/jiAAWq3MAQUAXn3VsvNVKqBZM6m5h4jIRAwpRBaq7GTKiNSiVdJWkuU6shoxwrIuH70emDRJvnqIqFxhSCGyUJeALnC2K97y9kVRC2oMqj9IpopkVLGi1J9kThONWg14egIvvih/XURULjCkEFnIxd4Fo5qNgkZl/hAvnajDa8GvyViVjD7/HGjRwrTlblUqwM4O+PVXqR+KiMgMDClEMhgXPM7sGT5qQY2uAV0R6BEoc1Uy0WqlOxq3aSOFjyfdwVmjAVxcpMXgWrYsmRqJqExiSCGSQZBnEGa2n2nyeSpBBSc7J4T1CrNCVTKqWFFaEW7BAqBGDWmb5qGWo4Lw4ugIjB4NHD8u3QWZiMgCXBYfXBaf5KEX9Xht+2tYcWxFsY5XC2po7bTYEboD7aubt6S+Tej10l2RN24EEhOlJfQrVQLat5duNMS/Q0TlijW/QxlSwJBC8hFFEQv+XoAP//wQGbkZUEEFPYyXgy1YPr+pT1Os7b8WDb0a2qhaIiLLWfM7lN09RDISBAFvtXsLCdMS8G3fb9HQ2ziA2KvtEdooFIdHH8bxV48zoBARPQZbUsCWFLKunPwcpOakwl5tD1cHV6gE/m5ARGUH74JMVIo5aBzgpfGydRlERKUOf6UjIiIiRWJIISIiIkViSCEiIiJFYkghIiIiRWJIISIiIkViSCEiIiJFYkghIiIiRWJIISIiIkViSCEiIiJFYkghIiIiRWJIISIiIkViSCEiIiJFYkghIiIiRWJIISIiIkViSCEiIiJFYkghIiIiRWJIISIiIkViSCEiIiJFYkghIiIiRVJ0SNHpdHjvvfcQEBAArVaLWrVq4aOPPoIoioZjRFHErFmz4OvrC61Wi5CQEFy+fNmGVRMREZEcFB1S5s2bh6VLlyIsLAznz5/HvHnzMH/+fCxevNhwzPz587Fo0SIsW7YMUVFRcHZ2Ro8ePZCdnW3DyomIiMhSgvhws4TC9OnTB97e3vjuu+8M2wYOHAitVovvv/8eoiiiSpUqmDZtGt58800AQGpqKry9vREeHo7BgwcX63XS0tLg5uaG1NRUuLq6WuW9EBERlUXW/A5VdEtK27ZtERkZiUuXLgEATp48if3796NXr14AgJiYGCQkJCAkJMRwjpubG1q3bo2DBw8Wed2cnBykpaUZPYiIiEhZNLYu4HHefvttpKWloV69elCr1dDpdPjkk08QGhoKAEhISAAAeHt7G53n7e1t2FeYOXPmYPbs2dYrnIiIiCym6JaUTZs2Yd26dVi/fj2OHTuG1atXY8GCBVi9erVF1505cyZSU1MNj7i4OJkqJiIiIrkouiXlrbfewttvv20YW9KoUSPcuHEDc+bMwYgRI+Dj4wMASExMhK+vr+G8xMRENG3atMjrOjg4wMHBwaq1ExERkWUU3ZKSlZUFlcq4RLVaDb1eDwAICAiAj48PIiMjDfvT0tIQFRWFNm3alGitREREJC9Ft6T07dsXn3zyCapXr44GDRrg+PHj+OKLLzBq1CgAgCAImDx5Mj7++GMEBgYiICAA7733HqpUqYJ+/frZtngiIiKyiKJDyuLFi/Hee+/h9ddfR1JSEqpUqYJXX30Vs2bNMhwzffp0ZGZmYuzYsUhJSUH79u2xc+dOODo62rByIiIispSi10kpKVwnhYiIyDzldp0UIiIiKr8YUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkTS2LoCIiIjkF38sHgknEpCdkg07Jzu4VnNFre61oLZX27q0YmNIISIiKiPyHuTh7MaziFoUhYTjCQAAQS1A1IkAAG0lLYLHBaPF2BZwq+5my1KLRRBFUbR1EbaWlpYGNzc3pKamwtXV1dblEBERmeze5Xv4vvv3SLmeAkElQNQX/vUuqAUIgoBnVz6LJsOaWPy61vwOZUsKERFRKXfv0j18+9S3yE3PBYAiAwoAiDoRIkRsHb4VeZl5CH4tuKTKNJniB87eunULL730Ejw8PKDVatGoUSMcOXLEsF8URcyaNQu+vr7QarUICQnB5cuXbVgxERFRyclJz8Ha7muRk54Dfb7epHN/ff1XXPvjmpUqs5yiQ8r9+/fRrl072NnZYceOHTh37hw+//xzVKxY0XDM/PnzsWjRIixbtgxRUVFwdnZGjx49kJ2dbcPKiYiISsaptaeQGpsKMd/00RuCIGDvB3vlL0omiu7umTdvHvz8/LBq1SrDtoCAAMOfRVHEwoUL8b///Q/PPfccAGDNmjXw9vbG1q1bMXjw4BKvmYiIqKSIooioRVHmn68XEXcgDklnkuDV0EvGyuSh6JaUn3/+GcHBwXjhhRfg5eWFZs2aYcWKFYb9MTExSEhIQEhIiGGbm5sbWrdujYMHDxZ53ZycHKSlpRk9iIiISpvY/bG4d/EeYMEUGJVGheil0fIVJSNFh5Rr165h6dKlCAwMxK5duzBu3DhMmjQJq1evBgAkJEjTq7y9vY3O8/b2NuwrzJw5c+Dm5mZ4+Pn5We9NEBERWcmtw7cgqASLrqHP1+Pm3zdlqkheig4per0ezZs3x6effopmzZph7NixGDNmDJYtW2bRdWfOnInU1FTDIy4uTqaKiYiISk52SjYEtWUhBQAe3H8gQzXyU3RI8fX1Rf369Y22BQUFITY2FgDg4+MDAEhMTDQ6JjEx0bCvMA4ODnB1dTV6EBERlTYaB41FXT2G6zgqc4iqokNKu3btcPHiRaNtly5dQo0aNQBIg2h9fHwQGRlp2J+WloaoqCi0adOmRGslIiIqaRWqVIBeZ9q04/8SVAJcqynzl3VFh5QpU6bg0KFD+PTTT3HlyhWsX78ey5cvx/jx4wFIU6cmT56Mjz/+GD///DNOnz6N4cOHo0qVKujXr59tiyciIrKyev3rWXwvHlEvoslwy1eetQZltu/8o2XLltiyZQtmzpyJDz/8EAEBAVi4cCFCQ0MNx0yfPh2ZmZkYO3YsUlJS0L59e+zcuROOjo42rJyIiMj6tBW1aDS0EU6tPWXyQm4FHNwc0GBQA5krkwfv3QPeu4eIiEqv+GPxWN5iuVnnCmoBbaa1Qbd53cx+fWt+hyq6u4eIiIgez7e5LzrP7mzyeYJGgHdjb3Sa1Un2muTCkEJERFTKdXyvI9q+1bbYxwtqAV4NvPDSzpdg72xvxcosw5BCRERUygmCgG7zu+G58OfgHuAubdP8Z/0UQXpotBq0fL0lRu0fBWcv5xKv1RQckwKOSSEiorJD1Iu4FnkN0V9HI/5oPHLScqDRauDm54amo5qi8UuN4VDBQbbXs+Z3qKJn9xAREZFpBJWAWt1qoVa3WrYuxWLs7iEiIiJFYkghIiIiRWJIISIiIkUya0xKZGQkIiMjkZSUBL3eeIW7lStXylIYERERlW8mh5TZs2fjww8/RHBwMHx9fSEIlt8imoiIiOi/TA4py5YtQ3h4OIYNG2aNeoiIiIgAmDEmJTc3F23bFn9VOyIiIiJzmBxSRo8ejfXr11ujFiIiIiIDk7t7srOzsXz5cvzxxx9o3Lgx7OzsjPZ/8cUXshVHRERE5ZfJIeXUqVNo2rQpAODMmTNG+ziIloiIiORickjZs2ePNeogIiIiMmLRYm43b97EzZs35aqFiIiIyMDkkKLX6/Hhhx/Czc0NNWrUQI0aNeDu7o6PPvrokYXdiIiIiMxlcnfPu+++i++++w5z585Fu3btAAD79+/HBx98gOzsbHzyySeyF0lERETljyCKomjKCVWqVMGyZcvw7LPPGm3ftm0bXn/9ddy6dUvWAktCWloa3NzckJqaCldXV1uXQ0REVGpY8zvU5O6e5ORk1KtX75Ht9erVQ3JysixFEREREZkcUpo0aYKwsLBHtoeFhaFJkyayFEVERERk8piU+fPno3fv3vjjjz/Qpk0bAMDBgwcRFxeH3377TfYCiYiIqHwyuSWlU6dOuHTpEvr374+UlBSkpKRgwIABuHjxIjp06GCNGomIiKgcMnngbFnEgbNERETmseZ3aLG6e06dOoWGDRtCpVLh1KlTjz22cePGshRGRERE5VuxQkrTpk2RkJAALy8vNG3aFIIgoLAGGEEQoNPpZC+SiIiIyp9ihZSYmBh4enoa/kxERERkbcUKKTVq1DD8+caNG2jbti00GuNT8/Pz8ffffxsdS0RERGQuk2f3dOnSpdBF21JTU9GlSxdZiiIiIiIyOaSIoghBEB7Zfu/ePTg7O8tSFBEREVGxF3MbMGAAAGlw7MiRI+Hg4GDYp9PpcOrUKbRt21b+ComIiKhcKnZIcXNzAyC1pFSoUAFardawz97eHk899RTGjBkjf4VERERULhU7pKxatQoA4O/vjzfffJNdO0RERGRVXHEWXHGWiIjIXDZfcbZ58+aIjIxExYoV0axZs0IHzhY4duyYbMURERFR+VWskPLcc88ZBsr269fPmvUQERERAWB3DwB29xAREZnLmt+hJq+TEhcXh5s3bxqeHz58GJMnT8by5ctlLYyIiIjKN5NDytChQ7Fnzx4AQEJCAkJCQnD48GG8++67+PDDD2UvkIiIiMonk0PKmTNn0KpVKwDApk2b0KhRI/z9999Yt24dwsPD5a6PiIiIyimTQ0peXp5hEO0ff/yBZ599FgBQr149xMfHy1sdERERlVsmh5QGDRpg2bJl+OuvvxAREYGePXsCAG7fvg0PDw/ZCyQiIqLyyeSQMm/ePHzzzTfo3LkzhgwZgiZNmgAAfv75Z0M3EBEREZGlzJqCrNPpkJaWhooVKxq2Xb9+HU5OTvDy8pK1wJLAKchERETmsfmKs/+lVquRn5+P/fv3AwDq1q0Lf39/OesiIiKics7k7p7MzEyMGjUKvr6+6NixIzp27IgqVarglVdeQVZWljVqJCIionLI5JAydepU7Nu3D7/88gtSUlKQkpKCbdu2Yd++fZg2bZo1aiQiIqJyyOQxKZUrV8ZPP/2Ezp07G23fs2cPBg0ahDt37shZX4ngmBTl0Yt6pGSnIDM3E64OrnB1cH3sjS2JiMg2FDUmJSsrC97e3o9s9/LyYncPWezC3QtYGr0UK0+sREZuhmG7j4sPXg9+HaObj4ZvBV8bVkhERCXF5JaUp59+Gh4eHlizZg0cHR0BAA8ePMCIESOQnJyMP/74wyqFWhNbUmwvMSMRw7YMQ8S1CGgEDfLF/EeOUQkqCBAwsulIhD0TBkeNow0qJSKihymqJWXhwoXo0aMHqlWrZlgj5eTJk3B0dMSuXbtkLY7Kh2v3r6FTeCckZCQAQKEBBZC6gABg1YlVOHvnLH5/6XdUcKhQYnUSEVHJMmudlKysLKxfvx7nz58HAAQFBSE0NBRarVb2AksCW1JsJ/lBMlquaInY1Fjk6wsPJ4VRC2p0DeiK30J/g0Zl1kx6IiKSgWJaUg4dOoRffvkFubm56Nq1K0aPHi1rMVT+zN0/FzdSbkAn6kw6TyfqEHEtAhvPbERo41ArVUdERLZU7CnIP/30E9q1a4evvvoK3377Lfr06YMFCxZYszYq4x7kPcDyo8tNDigFVIIKYYfDZK6KiIiUotghZc6cORgzZgxSU1Nx//59fPzxx/j000+tWRuVcZvObkJqTqrZ5+tFPQ7dOoSTCSdlrIqIiJSi2CHl4sWLePPNN6FWqwEA06ZNQ3p6OpKSkqxWHJVt2y5ug0oweT1BIxqVBtsubpOpIiIiUpJif0NkZWUZDYixt7eHo6MjMjIyHnMWUdESMhIMM3bMJUDA3ay7MlVERERKYtLA2W+//RYuLi6G5/n5+QgPD0flypUN2yZNmiRfdVSmWRpQ5L4OEREpS7FDSvXq1bFixQqjbT4+Pli7dq3huSAIDClUbJWdKkOAABEmz4I3ECGiomNFGasiIiKlKHZIuX79uhXLoPKoW81u+O3ybxZdI1+fj5CaITJVRERESmLZqEUiC4xoOgIOagezzxcgoK5HXXSs0VHGqoiISCkYUshm3B3dMazJMItWjJ3UehLvjkxEVEYxpJBNvdPhHVSwrwC1oDbpPI1KgwZeDTCiyQgrVUZERLZW7JBy+/Zta9ZB5ZS/uz92vrQTWjttsYOKRtCgaoWq2PXSLjjbO1u5QiIqTfQ6PW4fvY0ru67g8o7LuBl1E/nZxb8vGClLsdvZGzRogK+//hpDhw61Zj1UDrWq2gqHXjmEvj/0RUxKDNSCutCl8jUqDfL1+WhdrTW2vLgFns6eNqiWiJQoMykTx747huiwaKTfTjfa5+juiBavtkCLV1ugYgBnA5Ymxb4L8pIlSzBjxgz07NkT33zzDSpVqmTt2koM74KsDDq9Djuu7EDY4TD8fvV3o6nJGpUGgxsOxviW49G6amuOQyEig0NfHULEmxEQ9SJEfeFfaYJagKgX0WZqG3Sb3w2Civ+GyMWa36HFDikAEBMTg1deeQXnzp3DihUr0LdvX1mLsRWGFOW5nX4bcalxyMzLhKuDK2pVrIWKWv4GRETGIt+JxP45+4t/ggDUf6E+nv/heQYVmSgmpBQICwvDlClTEBQUBI3GuMfo2LFjshVXUhhSiIhKnyPfHMGvr/1q1rlt32qLbvO7yVxR+WTN71CT537euHEDmzdvRsWKFfHcc889ElKIiIisLe9BHv6Y8YfZ5x/8/CBaT2oN12r8xVTJTEoYK1aswLRp0xASEoKzZ8/C05MDF4lsIS0nDbfSbiEzLxMV7Cugmms1znSicuXcj+eQk5pj/gUE4OiKo+gyu4t8RZHsih1SevbsicOHDyMsLAzDhw+3Zk1EVAhRFHHo5iF8Hf01Np7diHz9v9MqHTWOGNZ4GF5v+Tqa+jS1XZFEJSRqURQElVDkQNknEXUijiw5go7/6wi1nWnrNFHJKXZI0el0OHXqFKpVq2bNeoioEHGpcRiwaQCO3D5imIr9sOz8bKw6sQorjq1AV/+u2PjCRlR2qlzE1YhKt7ysPMQfjbf4Oll3s3D3wl14N/KWoSqyhmIv5hYREcGAQmQDl+5dQvCKYJyIPwEAjwSUAgXb/7zxJ1quaInb6VyAkcqmB8kPZLtW9v1s2a5F8uOy+EQKdjfrLrqt7YbkrGTki8VbNTNfzMfNtJvo8X0PZORmWLlCopKn0sj31SXntUh+/OkQKdiCvxfgVtqtYgeUAvn6fJxNOosVR1dYqTIi29FW0sq2xonWQyvLdcg6GFKIFCo7PxvfHP2m0FsEFNfiw4uhF/UyVkVke2p7NQKfCYSgtiCoCIBHXQ941PGQrzCSHUMKkUL9dO4npGSnmH2+CBExKTGIvBYpX1FECtFyQkuIOvNm9hRoPYm32FA6hhQihdp5ZWex7wxdFI1Kgx1XdshUEZFy1OpWC2413Mzu9tFoNWg8rLHMVZHcGFKIFOpu1l2LunoK3HtwT4ZqiJRFUAnot7qfFFLMyCl9lvWBQwUH+QsjWTGkEJVxgjn/ghOVAv6d/DHwh4FQqVUmtah0/6I7mgxrYsXKSC6lKqTMnTsXgiBg8uTJhm3Z2dkYP348PDw84OLigoEDByIxMdF2RRLJxNPZ0+LuHgDw0HJgIJVd9Z+vj+GRw1GxlnSX9MKmFBcMsHXxdcHzm55HmyltSrRGMl+pCSnR0dH45ptv0LixcR/ilClT8Msvv+DHH3/Evn37cPv2bQwYMMBGVRLJp3dgb4u7e/L1+ehTp49MFREpU42ONTDh4gSM2DMCdfvVhcru3682QSXAv7M/Xtz6IqbETkGDFxrYsFIyVam4hXFGRgZCQ0OxYsUKfPzxx4btqamp+O6777B+/Xp07doVALBq1SoEBQXh0KFDeOqpp2xVMpHFBgQNQCVtJSQ/SDbrfAECalWqhc7+neUtjEiBBEEKI/6d/SGKInIzciHqRDi4Osi2pgqVvFLRkjJ+/Hj07t0bISEhRtuPHj2KvLw8o+316tVD9erVcfDgwSKvl5OTg7S0NKMHkdLYq+0xLnicRV0+E1tN5BRLKncEQYBDBQc4ujsyoJRyig8pGzZswLFjxzBnzpxH9iUkJMDe3h7u7u5G2729vZGQkFDkNefMmQM3NzfDw8/PT+6yiWQxrc00+Lv7Q6MyrdFTLajRzLcZRjcfbaXKiIisT9EhJS4uDm+88QbWrVsHR0dH2a47c+ZMpKamGh5xcXGyXZtIThW1FRExLAJezl7FblFRC2rUqlQLO0J3wMnOycoVEhFZj6JDytGjR5GUlITmzZtDo9FAo9Fg3759WLRoETQaDby9vZGbm4uUlBSj8xITE+Hj41PkdR0cHODq6mr0IFKqgIoBODLmCNr5tQOAIltVNIK0vWftnogaHQUvZ68Sq5GIyBoUPXD26aefxunTp422vfzyy6hXrx5mzJgBPz8/2NnZITIyEgMHDgQAXLx4EbGxsWjThlPMqOzwreCLfS/vw8mEk1h6ZClWn1yN7Px/bzHvYu+C0c1G47Xg11C3cl0bVkpEJB9BFEXLbn5Qwjp37oymTZti4cKFAIBx48bht99+Q3h4OFxdXTFx4kQAwN9//13sa6alpcHNzQ2pqalsVaFSITs/G0mZSUjPSYergyu8Xbxhr7a3dVlEVA5Z8ztU0S0pxfHll19CpVJh4MCByMnJQY8ePbBkyRJbl0VkVY4aR1R3q27rMoiIrKrUtaRYA1tSiIiIzGPN71BFD5wlIiKi8oshhYiIiBSJIYWIiIgUiSGFqJTR6YDs7CcfR0RU2jGkEJUyZ88CavNv50NEVGowpBCVMqdOAXZ2tq6CiMj6GFKISplz52xdARFRySj1i7kRlQd37wL37gGiCBw/butqiIhKBltSiBTqwQMgPBxo3hzw9ATq1QOCgoCdO6Vt4eHSMUREZRVDCpECrVkD+PgAL78MnDz56P6TJ6V9Pj7A2rUlXx8RUUlgSCFSmLlzgREjgLQ06ble/+gxBdvS0oDhw4H580uuPiKiksKQQqQg4eHAzJmmnzdjhtT6QkRUljCkEClEVhYwaZL550+YIF2DiKisYEghUogffgDS080/Pz0d2LhRvnqIiGyNIYVIAUQR+OorQGXB30iVSrqGKMpXFxGRLTGkEClAYiJw+nThg2SLS6+XZv0kJspXFxGRLTGkECnA3bvyXSs5Wb5rERHZEkMKURnD7h4iKisYUogUwMNDvmtVqiTftYiIbIkhhUgBfHyA+vUBQTD/GoIANGggXYuIqCxgSCFSAEGwbI0UQOrmeeMNy4IOEZGSMKQQKURoKKDVmn++szMwdKh89RAR2RpDCpFCuLgAX3xh/vlffCEFFSKisoIhhUhBXn0VmDXL9PM++AAYO1b2coiIbIohhUhhZs8Gli6Vun4EofAxJgXbtVrgm2+A998v+TqJiKyNIYVIgV57TVo59uuvgbp1H91ft660LzGRLShEVHYJosiln9LS0uDm5obU1FS4urrauhwiI6IIxMX9u5JspUqAnx9n8RCRMljzO1Qj69WISHaCAFSvLj2IiMoTdvcQERGRIrElhYiIDNJupeHYimO4sPUCsu5kQRRFOHk4oU7fOmjxagu413C3dYlUjnBMCjgmhYgo+UoyIqZH4OK2iwAAUW/81SCoBYh6EYHPBCJkXgi8GnjZokxSII5JISIiq4k7GId1z6xDbnruI+GkgKiTtl/ZeQXX917HkJ+HIKBrQEmWSeUQx6QQEZVjSWeT8H3375GblmsIIo8j6kTkP8jH+t7rcfvI7RKokMozhhQionJKFEX8NOgn5D3IK7IFpdDz9CJ0eTpsGrgJep3eihVSeceQQkRUTsX+FYs75+4UqwXlv0SdiNTYVFzZecUKlRFJGFKIiMqpw18fhkpj/teAoBZwOOywjBURGWNIISIqh3Izc3H+/85Dn29+d42oE3F111Vk3smUsTKifzGkENlCQgKgZ18+2U7W3SyzunkeIQIZCRmWX4eoEAwpRCUtKQm4dAlQ8a8f2U7+g3xFXovoYVwnhUhOej2wdy9w4QKQlga4uAA1awLduwMaDaDTAQsWAHPn2rpSKucc3Bxku5aju6Ns1yJ6GEMKkRySk4HwcGDxYuD6demugGq1FFr0esDbG3j9deDePaBPH7aikM05eznD2dsZmYmWjSdxcHOAWw03maoiMsaQQmSpgweB3r2B1FSg4C4TogjkP9QEnpgIfPCBFF66dbNJmUQPU6lVaDm+JfZ9sM+kNVIeJqgFtBjbAhoHfpWQdfDXOSJL/PUX0Lmz1LWj1/8bUgojitLj2WeB//u/EiuRqCjNRzcHBPPPF/UiWrzaQr6CiP6DIYXIXHFxUtdNfr401qQ4CkLMkCHAiRNWK42oOCr4VkDwq8FmBRVBJaDhkIaoVKuS/IUR/YMhhchcixcDmZmmTyUuaFGZN886dRGZoMfCHgh4OgCCqvhJRVALqNqqKp799lkrVkbEkEJkngcPgOXLi9+C8l/5+cBPP0ljVYhsSG2nxtDtQ1H/hfoA8NgVaAWNFGRq96yNYX8Mg53WrkRqpPKLIYXIHD/9JA2UtYReD6xcKU89RBbQOGgw8IeBGBYxDHX61DG0qghq4d/QIgC1utfC0N+GYsjPQ2DvbG/Diqm84JBsInMcOQLY2QF5eeZfQxSl6xApgCAIqBlSEzVDaiLtZhqu7LyCrHtZgAhoK2lRq3stuPu727pMKmcYUojMkZpq+bL2oiitm0KkMK7VXKWZP0Q2xu4eInM4OMizIJuzs+XXICIqoxhSiMxRtarlLSkajXQdIiIqFEMKkTmGDjV/Zk+B/HzgpZfkqYeIqAxiSCEyR+3aQEiIdH8ecwgCULcu0KGDvHUREZUhDClE5nrjDctaU954QworRERUKIYUInP17g289prpQUOlkpbTHzvWOnUREZURDClE5hIEaWn8ESNMO6dHD2DDBvO7ioiIygmGFCJLaDTSqrFhYUC1atK2/4aPgueVKwMffgj8/DPg5FSydRIRlUKCKD7u3vLlQ1paGtzc3JCamgpXV1dbl0OllU4H7NoFLF0KnDkDpKdL66AEBkpdO/36AfZcSpyIyhZrfodyxVkiuajVwDPPSA8iIrIYu3uIiIhIkRhSiIiISJEYUoiIiEiRGFKIiIhIkThw1kpEUcT1vddxLeIaHiQ/gKAS4FTZCXWfq4sqLarYujwiIiLFY0iRWW5mLo6vPI7Diw4j+UoyVBoVULAgqQj8+dGf8G3ui1aTWqHR0EZQ23FBLyIiosJwnRTIN8c77VYavu/+Pe6cvyNtKOKTFVQCRL0I/y7+eHHLi3B0czT7NYmIiGzJmuukcEyKTDKTMrGy7UrcvXRXCiePiX6iXtp5488bWBOyBnlZeSVTJBERUSnCkCIDURSxccBGpN1Kg5hf/IYpUSci4VgCfh33qxWrIyIiKp0YUmRw6/AtxB2Ig6gzvedM1Is49f0ppN9Ot0JlREREpRdDigyiv46WBsha4OiKozJVQ0REVDYwpFgoOyUbZzacgT5fb/Y1RL2II0uOGMaqEBEREUOKxZKvJkOfZ35AKZCZlImctBwZKiIiIiobGFIslJueK9u1slOzZbsWERFRaceQYiE7ZzvZrmXvYi/btYiIiEo7hhQLuVV3+3dFWQvYu9jD0Z2LuhERERVgSLGQi7cLAp8JhKAxP6moNCo0e6UZVGr+OIiIiArwW1EGrSa0MmkRt//S5+sRPC5YxoqIiIhKP4YUGdTqXguValeCoDa9NUVQC6jZrSYq161shcqIiIhKL4YUGQgqAYN/Hgx7Z3uTgoqgEVChSgX0X9vfitURERGVTgwpMvEM8sSIPSPg6O5YrPEpglqAew13jNw3Ei7eLiVQIRERUenCkCIj3+a+ePX4q2gxtgU0Wo006+ehvCKopCeO7o5o+2ZbjDk8BhUDKtqmWCIiIoUTRFFU7Frsc+bMwebNm3HhwgVotVq0bdsW8+bNQ926dQ3HZGdnY9q0adiwYQNycnLQo0cPLFmyBN7e3sV+nbS0NLi5uSE1NRWurq6y1J6TloOTa08i5o8YZN7JhEqtgrOXM+o+Vxf1n68PjaNGltchIiKyJWt8hxZQdEjp2bMnBg8ejJYtWyI/Px/vvPMOzpw5g3PnzsHZ2RkAMG7cOPz6668IDw+Hm5sbJkyYAJVKhQMHDhT7daz5ARMREZVl5Tak/NedO3fg5eWFffv2oWPHjkhNTYWnpyfWr1+P559/HgBw4cIFBAUF4eDBg3jqqaeKdV2GFCIiIvNY8zu0VI1JSU1NBQBUqlQJAHD06FHk5eUhJCTEcEy9evVQvXp1HDx4sMjr5OTkIC0tzehBREREylJqQoper8fkyZPRrl07NGzYEACQkJAAe3t7uLu7Gx3r7e2NhISEIq81Z84cuLm5GR5+fn7WLJ2IiIjMUGpCyvjx43HmzBls2LDB4mvNnDkTqamphkdcXJwMFRIREZGcSsUUkwkTJmD79u34888/Ua1aNcN2Hx8f5ObmIiUlxag1JTExET4+PkVez8HBAQ4ODtYsmYiIiCyk6JYUURQxYcIEbNmyBbt370ZAQIDR/hYtWsDOzg6RkZGGbRcvXkRsbCzatGlT0uUSERGRjBTdkjJ+/HisX78e27ZtQ4UKFQzjTNzc3KDVauHm5oZXXnkFU6dORaVKleDq6oqJEyeiTZs2xZ7ZQ0RERMqk6CnIglD48vKrVq3CyJEjAfy7mNsPP/xgtJjb47p7/otTkImIiMzDdVKsjCFFHomJwE8/AbdvAzk5gLs70LIl0K0boFJ0xyIREZnLmt+hiu7uodLhwAEgLEwKKDodoPnnvypRBPLzgRo1gIkTgVGjgIq8VRERERUTf78ls+n1wDvvAO3bSwElP18KJnl50iM/Xzruxg1g+nSgQQPg7Fnb1kxERKUHQwqZRRSBKVOAOXOk5wWBpCh6PZCUBLRtC5w/b/36iIio9GNIIbN89x2waJFp5+h0QGYm0L279P9ERESPw5BCJtPrgY8+Mu9cnQ64eROQYeFgIiIq4xhSyGS//w7Expp/vkoFfPWV1GVERERUFIYUMtmSJf/O4DGHXg+cPg1ER8tXExERlT0MKWSy48efPFC2OE6ftvwaRERUdjGkkMnS0iy/hloNpKZafh0iIiq7GFLIZFqt5dfQ6QAnJ8uvQ0REZRdDCpmsRg2giNsqmaR6dcuvQUREZRdDCpls9GjLZ+Z4ekr39CEiIioKQwqZbOhQwNnZ/PPVauD11wE7O/lqIiKisoc3GCzvMjKkucD370sLmHh6Aq1aPTZBODsDr74KLFwoTSc2hSBILzNmjGVlExFR2ceQUl6dOwcsXQqsXAlkZRnv8/QExo0Dxo4FqlYt9PSPPwb++gs4dkwaBFtcogh8/32RlyUiIjJgd095k5cnNWM0aAAsW/ZoQAGAO3eATz6RRrZ+9lmhA1C0WmDHDqBlS6ll5EnUaun/v/oKGDTIwvdARETlAkNKeZKXB/TrJ90dEHj8imw6ndSXM3068PbbhR7i4QHs2QO89x5QubK07b+BpSCcdOkiZaIzZyx7C0REVH4Iosg7qKSlpcHNzQ2pqalwdXW1dTnW89prwPLl5k3NWbJE6gIqQl4esHUrsHYtEBcHZGcDFSsCbdtK41cCA6XjfvtNGu7CmT1ERGWDNb9DGVJQTkLK1atSUjD3x+3mBiQkAI6OFpeyZ4/UTeTiYvGliIjIxqz5HcrunvLim2+KN3ikKKmpwI8/ylJKly7Gg23z9fnYemEruq3thsrzK8PxY0e4z3VHoyWNsPDQQtx/cF+W1yUiotKFLSkoBy0p2dmAj49lN8tRqYDmzWW9dbEoilgSvQQf//UxEjISoBbU0In/phcB0rK29mp7DG8yHJ93/xwVHCrI9vpERGQ5tqSQZc6etfxufno9cOQIkJMjS0l6UY/Xfn0NE3ZMQEJGAgAYBRQAEP/5X44uByuPr0TblW2RmJEoy+sTEZHyMaSUB/dl7C5JSZHlMjMiZmD50eXFPl4n6nDh7gX0+L4HMnIzZKmBiIiUjSGlPNDIuGafDGvZH4g9gAUHF5h8Xr4+H2eSzuDjPz+2uAYiIlI+hpTywMtLnutoNNIsHwuFHQ6DRmVecNKJOiw7sgzZ+dkW10FERMrGkFIeBAUBdepIN84xl0YDDBjw7+psZkrMSMRP539Cvv4xC8k9QWpOKn48K89MIyIiUi6GlPJAEIBJkyy7Rn4+MH68xaVsPr8ZOr0JN/sphEpQYd3pdRbXQkREysaQUl4MG2b+QmxqNVCvHtChg8VlJGQkmN3VU0Av6nEr/ZbFtRARkbIxpJQXrq7At9+afp4gSF09q1db1l30jxydPFOYc/LluQ4RESkXQ0p5MnQosGiR9OfiBA5BkB6bNwOtWslSgrujO/Si3uLrVNRWlKEaIiJSMoaU8mbiRCl0VK8uPS9senLBtiZNgLFjgTt3ZHv5NtXaPLJom6nUghrt/drLVBERESkVQ0p51L8/cO0asHMn0KMH4ODw7z4XF+Cll4DDh4Hjx6W7H8fFAbfkGQPSsUZHBFYKNCx5bw6dqMO4lkXfkZmIiMoG3rsH5eDePcWRkyPdn6ewxdpEEdiyRQo3/3QTpacDmzZJN1fOyAAqVADq1gWefx5wcnr8S4UdDsOkHZMgwvT/9NSCGl0CuiBiWITJ5xIRkfys+R3KkAKGlGLR6YCMDJy/7YawMGDVKum+hQ/3FuXlSWHllVek2cq1az96GVEE0nPS0XhZI9xKv2XyeikalQZ7R+xFu+rtLHxDREQkB4YUK2NIKZ7Vq6UAIgjSsilF0WikRpkffpDWfytw+jTg7AzUrAlcvncZT333FNJy0ooVVAq6h9b0X4OXGr9k6VshInpUZiawYYN0M9WUFGnZhipVpEkHDRrYujrFYkixMoaUJ1u5UgooxVUweWjTJqBFC2D5cmDQIKBZs3+PuXb/Grqv7Y6r969CLaiLHFCrElSwU9nhh4E/oH9QfwveBRFRIa5fBxYuBL77Tuq/trOTWo9V/wzbzM8H2rcH3ngDGDhQluUYyhKGFCtjSHm8qCigbVtAb+LM4YIZzB07Aj/9BHh4PHpMri4Xm89vxuKoxfj75t/SeRAM41WqVqiKCa0mYFSzUfBylukeREREBfbuBfr2lfqvH9dErFZLwWXkSOm3LhlutlpWWPM7VMbb41JZ9dln5v3iIIrSeTVrFh5QAMBebY/BDQdjcMPBOJt0FqcSTyE1JxVOdk6o5loNnWp0glpl2f2CiIgKdeAA0L27FD6e9FuY7p+W3tWrpYkG33//b0sLWQ1bUsCWlMe5fRvw8zO9FeVhDg5AQgLg7i5bWURElklOBmrVAtLSzPsH7osvgClT5K+rFLLmdyhjID3WypWWd7/m5gJr18pTDxGRLMLDgdRU838D++yzx3cPkSwYUuixTp+Wum0sodEAZ8/KUw8RkcX0emDxYsv+cYuPB379Vb6aqFAMKfRYlvyiUUCnk2bzEREpwt690oweS6jVwNKlclRDj8GQQo/l7Gx5d49KJa22T0SkCBcvWv4Pm04HnDsnTz1UJIYUeqwaNaRfGCwhiv/ez5CIyObS0+WZmZORYfk16LEYUuixRo60fGyYXg8MHy5LOURElnNxsbwfu+A6ZFUMKfRYjRsDbdqY/0uHWg306gX4+8taFhGR+WrVsnxGgFoNBAbKUw8ViSGFnmjKFPN/6dDppJWkiYgUIyQEqFzZsmvodMCrr8pTDxWJIYWe6PnngXHjzBtn9s470oKORESKcPUqMHq0dONASwbPVq4M9OsnW1lUOC6LT08kCNKSAjqddMsKQXh8S6lKJbW8vPUW8PHHJVcnEVGRUlKAv/+W1lX46ivpXj0BAdL/m3NjssmTAXt7a1RKD2FLChWLWg0sWybdtqJ+fWmb5j8Rt+B506bS3Y/nz+fNQolIIRwcgGeeAYYMAVxdAS8vYMuWf++EWlwqFdC7N/D229arlQx47x7w3j2mEkXg0CHg22+BS5ekX0zc3YGgIGDsWKBFC1tXSERUTNu3Ay+8IE1jfNxUxoIm4v79gXXrAK225GpUOGt+hzKkgCGFiKhcO3sWWLAAWL/+36Ci10stLGq1tK1hQ2kWwKhRvPvxfzCkWBlDChER4d49qU87Ohq4fx9wcgJ8fYGXXgKeeor910Ww5ncoB84SEREBgIcHMHWqraugh7DNioiIiBSJIYWIiIgUiSGFiIiIFIkhhYiIiBSJIYWIiIgUiSGFiIiIFIkhhYiIiBSJIYWIiIgUiSGFiIiIFIkhhYiIiBSJIYWIiIgUiSGFiIiIFIkhhYiIiBSJIYWIiIgUiSGFiIiIFElj6wLIcmk303Bh2wVk3cmCPl8Px4qO8O/sjyotqti6NCIiIrMxpJRSoigiZncMosOicfHnixBFESqN1DAm6kSIehG+zX3RalIrNHyxITSO/FETEVHpIoiiKNq6CFtLS0uDm5sbUlNT4erqautynkiXp8Ovr/2K4yuPQ6VRQZ+vL/Q4QSVA1IvwbuKNl3a+BBcflxKulIiIyjprfodyTEopI+pF/N+Q/8PxVccBoMiAUnAsACSdTcK3T32LzDuZJVIjERGRHBhSSpm9s/fi/P+dB0xo/xLzRaTdSsMPz/4ANpwREVFpwZBSiuRm5OLggoNmnSvmi7h16BZu7Lshc1VERETWwZBSipxadwp5D/LMPl+lUeHw14dlrIiIiMh6GFJKkeiwaIvO1+frcWHLBWQkZMhUERERkfUwpJQSol5E0tkkk8aiFHodnYg75+7IUxQREZEVMaSUErkZuRYHlALZqdnyXIiIiMiKGFJKCY1WvsXY7JzsZLsWERGRtTCklBJqOzWcKjvJci3XaspfsI6IiIghpRRpOqopBLVg9vmCSoB3E2941veUsSoiIiLrKDMh5euvv4a/vz8cHR3RunVrHD5c9qbaBr8abFhF1hyiXkTrSa0hCOYHHSIiopJSJkLKxo0bMXXqVLz//vs4duwYmjRpgh49eiApKcnWpcmqYs2KCHwm0HAjQVMIKgGO7o5oOLihFSojIiKSX5kIKV988QXGjBmDl19+GfXr18eyZcvg5OSElStX2ro02T377bNw8XExrdtHkELKi1te5KBZIiIqNeSbMmIjubm5OHr0KGbOnGnYplKpEBISgoMHC19CPicnBzk5OYbnqampAKQ7OSqeE9D/l/7Y+NxGpN5MfWL3j6ASoNKo0H9Nf1RqXql0vEciIio1Cr5XrHFvuFIfUu7evQudTgdvb2+j7d7e3rhw4UKh58yZMwezZ89+ZLufn59VarQpPYBc4JPBn9i6EiIiKsPu3bsHNzc3Wa9Z6kOKOWbOnImpU6canqekpKBGjRqIjY2V/QOmwqWlpcHPzw9xcXFwdeWU6JLAz7zk8TMvefzMS15qaiqqV6+OSpUqyX7tUh9SKleuDLVajcTERKPtiYmJ8PHxKfQcBwcHODg4PLLdzc2N/1GXMFdXV37mJYyfecnjZ17y+JmXPJVK/mGupX7grL29PVq0aIHIyEjDNr1ej8jISLRp08aGlREREZElSn1LCgBMnToVI0aMQHBwMFq1aoWFCxciMzMTL7/8sq1LIyIiIjOViZDy4osv4s6dO5g1axYSEhLQtGlT7Ny585HBtEVxcHDA+++/X2gXEFkHP/OSx8+85PEzL3n8zEueNT9zQbTGnCEiIiIiC5X6MSlERERUNjGkEBERkSIxpBAREZEiMaQQERGRIpX7kPL111/D398fjo6OaN26NQ4fPmzrksqMOXPmoGXLlqhQoQK8vLzQr18/XLx40eiY7OxsjB8/Hh4eHnBxccHAgQMfWZiPzDd37lwIgoDJkycbtvEzl9+tW7fw0ksvwcPDA1qtFo0aNcKRI0cM+0VRxKxZs+Dr6wutVouQkBBcvnzZhhWXbjqdDu+99x4CAgKg1WpRq1YtfPTRR0b3juFnbpk///wTffv2RZUqVSAIArZu3Wq0vzifb3JyMkJDQ+Hq6gp3d3e88soryMjIMK0QsRzbsGGDaG9vL65cuVI8e/asOGbMGNHd3V1MTEy0dWllQo8ePcRVq1aJZ86cEU+cOCE+88wzYvXq1cWMjAzDMa+99pro5+cnRkZGikeOHBGfeuopsW3btjasuuw4fPiw6O/vLzZu3Fh84403DNv5mcsrOTlZrFGjhjhy5EgxKipKvHbtmrhr1y7xypUrhmPmzp0rurm5iVu3bhVPnjwpPvvss2JAQID44MEDG1Zeen3yySeih4eHuH37djEmJkb88ccfRRcXF/Grr74yHMPP3DK//fab+O6774qbN28WAYhbtmwx2l+cz7dnz55ikyZNxEOHDol//fWXWLt2bXHIkCEm1VGuQ0qrVq3E8ePHG57rdDqxSpUq4pw5c2xYVdmVlJQkAhD37dsniqIopqSkiHZ2duKPP/5oOOb8+fMiAPHgwYO2KrNMSE9PFwMDA8WIiAixU6dOhpDCz1x+M2bMENu3b1/kfr1eL/r4+IifffaZYVtKSoro4OAg/vDDDyVRYpnTu3dvcdSoUUbbBgwYIIaGhoqiyM9cbv8NKcX5fM+dOycCEKOjow3H7NixQxQEQbx161axX7vcdvfk5ubi6NGjCAkJMWxTqVQICQnBwYMHbVhZ2ZWamgoAhptQHT16FHl5eUY/g3r16qF69er8GVho/Pjx6N27t9FnC/Azt4aff/4ZwcHBeOGFF+Dl5YVmzZphxYoVhv0xMTFISEgw+szd3NzQunVrfuZmatu2LSIjI3Hp0iUAwMmTJ7F//3706tULAD9zayvO53vw4EG4u7sjODjYcExISAhUKhWioqKK/VplYsVZc9y9exc6ne6RVWm9vb1x4cIFG1VVdun1ekyePBnt2rVDw4YNAQAJCQmwt7eHu7u70bHe3t5ISEiwQZVlw4YNG3Ds2DFER0c/so+fufyuXbuGpUuXYurUqXjnnXcQHR2NSZMmwd7eHiNGjDB8roX9W8PP3Dxvv/020tLSUK9ePajVauh0OnzyyScIDQ0FAH7mVlaczzchIQFeXl5G+zUaDSpVqmTSz6DchhQqWePHj8eZM2ewf/9+W5dSpsXFxeGNN95AREQEHB0dbV1OuaDX6xEcHIxPP/0UANCsWTOcOXMGy5Ytw4gRI2xcXdm0adMmrFu3DuvXr0eDBg1w4sQJTJ48GVWqVOFnXsaU2+6eypUrQ61WPzKrITExET4+PjaqqmyaMGECtm/fjj179qBatWqG7T4+PsjNzUVKSorR8fwZmO/o0aNISkpC8+bNodFooNFosG/fPixatAgajQbe3t78zGXm6+uL+vXrG20LCgpCbGwsABg+V/5bI5+33noLb7/9NgYPHoxGjRph2LBhmDJlCubMmQOAn7m1Fefz9fHxQVJSktH+/Px8JCcnm/QzKLchxd7eHi1atEBkZKRhm16vR2RkJNq0aWPDysoOURQxYcIEbNmyBbt370ZAQIDR/hYtWsDOzs7oZ3Dx4kXExsbyZ2Cmp59+GqdPn8aJEycMj+DgYISGhhr+zM9cXu3atXtkav2lS5dQo0YNAEBAQAB8fHyMPvO0tDRERUXxMzdTVlYWVCrjry+1Wg29Xg+An7m1FefzbdOmDVJSUnD06FHDMbt374Zer0fr1q2L/2IWD/stxTZs2CA6ODiI4eHh4rlz58SxY8eK7u7uYkJCgq1LKxPGjRsnurm5iXv37hXj4+MNj6ysLMMxr732mli9enVx9+7d4pEjR8Q2bdqIbdq0sWHVZc/Ds3tEkZ+53A4fPixqNBrxk08+ES9fviyuW7dOdHJyEr///nvDMXPnzhXd3d3Fbdu2iadOnRKfe+45Toe1wIgRI8SqVasapiBv3rxZrFy5sjh9+nTDMfzMLZOeni4eP35cPH78uAhA/OKLL8Tjx4+LN27cEEWxeJ9vz549xWbNmolRUVHi/v37xcDAQE5BNtXixYvF6tWri/b29mKrVq3EQ4cO2bqkMgNAoY9Vq1YZjnnw4IH4+uuvixUrVhSdnJzE/v37i/Hx8bYrugz6b0jhZy6/X375RWzYsKHo4OAg1qtXT1y+fLnRfr1eL7733nuit7e36ODgID799NPixYsXbVRt6ZeWlia+8cYbYvXq1UVHR0exZs2a4rvvvivm5OQYjuFnbpk9e/YU+u/3iBEjRFEs3ud77949cciQIaKLi4vo6uoqvvzyy2J6erpJdQii+NASfUREREQKUW7HpBAREZGyMaQQERGRIjGkEBERkSIxpBAREZEiMaQQERGRIjGkEBERkSIxpBAREZEiMaQQERGRIjGkEFGpEx4eDnd39yceJwgCtm7davV6iMg6GFKIqEg6nQ5t27bFgAEDjLanpqbCz88P7777bpHndu7cGYIgQBAEODo6on79+liyZIksdb344ou4dOmS4fkHH3yApk2bPnJcfHw8evXqJctrElHJY0ghoiKp1WqEh4dj586dWLdunWH7xIkTUalSJbz//vuPPX/MmDGIj4/HuXPnMGjQIIwfPx4//PCDxXVptVp4eXk98TgfHx84ODhY/HpEZBsMKUT0WHXq1MHcuXMxceJExMfHY9u2bdiwYQPWrFkDe3v7x57r5OQEHx8f1KxZEx988AECAwPx888/AwBiY2Px3HPPwcXFBa6urhg0aBASExMN5548eRJdunRBhQoV4OrqihYtWuDIkSMAjLt7wsPDMXv2bJw8edLQchMeHg7g0e6e06dPo2vXrtBqtfDw8MDYsWORkZFh2D9y5Ej069cPCxYsgK+vLzw8PDB+/Hjk5eXJ8EkSkak0ti6AiJRv4sSJ2LJlC4YNG4bTp09j1qxZaNKkicnX0Wq1yM3NhV6vNwSUffv2IT8/H+PHj8eLL76IvXv3AgBCQ0PRrFkzLF26FGq1GidOnICdnd0j13zxxRdx5swZ7Ny5E3/88QcAwM3N7ZHjMjMz0aNHD7Rp0wbR0dFISkrC6NGjMWHCBEOoAYA9e/bA19cXe/bswZUrV/Diiy+iadOmGDNmjMnvl4gsw5BCRE8kCAKWLl2KoKAgNGrUCG+//bZJ5+t0Ovzwww84deoUxo4di8jISJw+fRoxMTHw8/MDAKxZswYNGjRAdHQ0WrZsidjYWLz11luoV68eACAwMLDQa2u1Wri4uECj0cDHx6fIGtavX4/s7GysWbMGzs7OAICwsDD07dsX8+bNg7e3NwCgYsWKCAsLg1qtRr169dC7d29ERkYypBDZALt7iKhYVq5cCScnJ8TExODmzZvFOmfJkiVwcXGBVqvFmDFjMGXKFIwbNw7nz5+Hn5+fIaAAQP369eHu7o7z588DAKZOnYrRo0cjJCQEc+fOxdWrVy2q//z582jSpIkhoABAu3btoNfrcfHiRcO2Bg0aQK1WG577+voiKSnJotcmIvMwpBDRE/3999/48ssvsX37drRq1QqvvPIKRFF84nmhoaE4ceIEYmJikJmZiS+++AIqVfH+2fnggw9w9uxZ9O7dG7t370b9+vWxZcsWS9/KE/23S0kQBOj1equ/LhE9iiGFiB4rKysLI0eOxLhx49ClSxd89913OHz4MJYtW/bEc93c3FC7dm1UrVrVKJwEBQUhLi4OcXFxhm3nzp1DSkoK6tevb9hWp04dTJkyBb///jsGDBiAVatWFfo69vb20Ol0j60lKCgIJ0+eRGZmpmHbgQMHoFKpULdu3Se+FyIqeQwpRPRYM2fOhCiKmDt3LgDA398fCxYswPTp03H9+nWzrhkSEoJGjRohNDQUx44dw+HDhzF8+HB06tQJwcHBePDgASZMmIC9e/fixo0bOHDgAKKjoxEUFFTo9fz9/RETE4MTJ07g7t27yMnJeeSY0NBQODo6YsSIEThz5gz27NmDiRMnYtiwYYbxKESkLAwpRFSkffv24euvv8aqVavg5ORk2P7qq6+ibdu2xe72+S9BELBt2zZUrFgRHTt2REhICGrWrImNGzcCkNZnuXfvHoYPH446depg0KBB6NWrF2bPnl3o9QYOHIiePXuiS5cu8PT0LHQtFicnJ+zatQvJyclo2bIlnn/+eTz99NMICwszuX4iKhmCaM6/MERERERWxpYUIiIiUiSGFCIiIlIkhhQiIiJSJIYUIiIiUiSGFCIiIlIkhhQiIiJSJIYUIiIiUiSGFCIiIlIkhhQiIiJSJIYUIiIiUiSGFCIiIlKk/wcgvvVncSBckgAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render_history(hist, skip_frames=50)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Test manual behavior for an agent\n",
+    "\n",
+    "Need to set all of its behaviors to manual."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ag_idx = 9\n",
+    "manual_behaviors = jnp.array([Behaviors.MANUAL.value, Behaviors.MANUAL.value,])\n",
+    "manual_color = jnp.array([0., 0., 0.])\n",
+    "manual_motors = jnp.array([1., 1.])\n",
+    "\n",
+    "behaviors = state.agents.behavior.at[ag_idx].set(manual_behaviors)\n",
+    "colors = state.agents.color.at[ag_idx].set(manual_color)\n",
+    "motors = state.agents.motor.at[ag_idx].set(manual_motors)\n",
+    "\n",
+    "agents = state.agents.replace(behavior=behaviors, color=colors, motor=motors)\n",
+    "state = state.replace(agents=agents)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hist = []\n",
+    "\n",
+    "for i in range(n_steps):\n",
+    "    state = env.step(state)\n",
+    "    hist.append(state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "render_history(hist, skip_frames=50)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/vivarium/experimental/notebooks/selective_sensors.ipynb b/vivarium/experimental/notebooks/selective_sensors.ipynb
deleted file mode 100644
index aee523f..0000000
--- a/vivarium/experimental/notebooks/selective_sensors.ipynb
+++ /dev/null
@@ -1,814 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Quick tutorial to explain how to create a environment with braitenberg vehicles equiped with selective sensors (still a draft so comments of the notebook won't be complete yet)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2024-07-09 15:48:58.727097: W external/xla/xla/service/gpu/nvptx_compiler.cc:760] The NVIDIA driver's CUDA version is 12.2 which is older than the ptxas CUDA version (12.5.40). Because the driver is older than the ptxas version, XLA is disabling parallel compilation, which may slow down compilation. You should update your NVIDIA driver or use the NVIDIA-provided CUDA forward compatibility packages.\n"
-     ]
-    }
-   ],
-   "source": [
-    "import logging as lg\n",
-    "\n",
-    "from enum import Enum\n",
-    "from functools import partial\n",
-    "from typing import Tuple\n",
-    "\n",
-    "import numpy as np\n",
-    "import jax.numpy as jnp\n",
-    "\n",
-    "from jax import vmap, jit\n",
-    "from jax import random, ops, lax\n",
-    "\n",
-    "from flax import struct\n",
-    "from jax_md.rigid_body import RigidBody\n",
-    "from jax_md import simulate \n",
-    "from jax_md import space, rigid_body, partition, quantity\n",
-    "\n",
-    "from vivarium.experimental.environments.utils import normal, distance \n",
-    "from vivarium.experimental.environments.base_env import BaseState, BaseEnv\n",
-    "from vivarium.experimental.environments.physics_engine import total_collision_energy, friction_force, dynamics_fn\n",
-    "from vivarium.experimental.environments.braitenberg.simple import relative_position, proximity_map, sensor_fn, sensor\n",
-    "from vivarium.experimental.environments.braitenberg.simple import Behaviors, behavior_to_params, linear_behavior\n",
-    "from vivarium.experimental.environments.braitenberg.simple import lr_2_fwd_rot, fwd_rot_2_lr, motor_command\n",
-    "from vivarium.experimental.environments.braitenberg.simple import braintenberg_force_fn"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Create the classes and helper functions"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Add entity sensed type as a field in entities + sensed in agents. The agents sense the \"sensed type\" of the entities. In our case, there will be preys, predators, ressources and poison."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "### Define the constants and the classes of the environment to store its state ###\n",
-    "SPACE_NDIMS = 2\n",
-    "\n",
-    "class EntityType(Enum):\n",
-    "    AGENT = 0\n",
-    "    OBJECT = 1\n",
-    "\n",
-    "class EntitySensedType(Enum):\n",
-    "    PREY = 0\n",
-    "    PRED = 1\n",
-    "    RESSOURCE = 2\n",
-    "    POISON = 3\n",
-    "\n",
-    "# Already incorporates position, momentum, force, mass and velocity\n",
-    "@struct.dataclass\n",
-    "class EntityState(simulate.NVEState):\n",
-    "    entity_type: jnp.array\n",
-    "    ent_sensed_type: jnp.array\n",
-    "    entity_idx: jnp.array\n",
-    "    diameter: jnp.array\n",
-    "    friction: jnp.array\n",
-    "    exists: jnp.array\n",
-    "    \n",
-    "@struct.dataclass\n",
-    "class ParticleState:\n",
-    "    ent_idx: jnp.array\n",
-    "    color: jnp.array\n",
-    "\n",
-    "@struct.dataclass\n",
-    "class AgentState(ParticleState):\n",
-    "    prox: jnp.array\n",
-    "    motor: jnp.array\n",
-    "    proximity_map_dist: jnp.array\n",
-    "    proximity_map_theta: jnp.array\n",
-    "    behavior: jnp.array\n",
-    "    params: jnp.array\n",
-    "    sensed: jnp.array\n",
-    "    wheel_diameter: jnp.array\n",
-    "    speed_mul: jnp.array\n",
-    "    max_speed: jnp.array\n",
-    "    theta_mul: jnp.array    \n",
-    "    proxs_dist_max: jnp.array\n",
-    "    proxs_cos_min: jnp.array\n",
-    "\n",
-    "@struct.dataclass\n",
-    "class ObjectState(ParticleState):\n",
-    "    pass\n",
-    "\n",
-    "@struct.dataclass\n",
-    "class State(BaseState):\n",
-    "    max_agents: jnp.int32\n",
-    "    max_objects: jnp.int32\n",
-    "    neighbor_radius: jnp.float32\n",
-    "    dt: jnp.float32  # Give a more explicit name\n",
-    "    collision_alpha: jnp.float32\n",
-    "    collision_eps: jnp.float32\n",
-    "    entities: EntityState\n",
-    "    agents: AgentState\n",
-    "    objects: ObjectState    "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Define get_relative_displacement"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# TODO : Refactor the code bc pretty ugly to have 4 arguments returned here\n",
-    "def get_relative_displacement(state, agents_neighs_idx, displacement_fn):\n",
-    "    body = state.entities.position\n",
-    "    senders, receivers = agents_neighs_idx\n",
-    "    Ra = body.center[senders]\n",
-    "    Rb = body.center[receivers]\n",
-    "    dR = - space.map_bond(displacement_fn)(Ra, Rb)  # Looks like it should be opposite, but don't understand why\n",
-    "\n",
-    "    dist, theta = proximity_map(dR, body.orientation[senders])\n",
-    "    proximity_map_dist = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))\n",
-    "    proximity_map_dist = proximity_map_dist.at[senders, receivers].set(dist)\n",
-    "    proximity_map_theta = jnp.zeros((state.agents.ent_idx.shape[0], state.entities.entity_idx.shape[0]))\n",
-    "    proximity_map_theta = proximity_map_theta.at[senders, receivers].set(theta)\n",
-    "    return dist, theta, proximity_map_dist, proximity_map_theta\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "to compute motors, only use linear behaviors (don't vmap it) because we vmap the functions to compute agents proxiemters and motors at a higher level \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def compute_motor(proxs, params, behaviors, motors):\n",
-    "    \"\"\"Compute new motor values. If behavior is manual, keep same motor values. Else, compute new values with proximeters and params.\n",
-    "\n",
-    "    :param proxs: proximeters of all agents\n",
-    "    :param params: parameters mapping proximeters to new motor values\n",
-    "    :param behaviors: array of behaviors\n",
-    "    :param motors: current motor values\n",
-    "    :return: new motor values\n",
-    "    \"\"\"\n",
-    "    manual = jnp.where(behaviors == Behaviors.MANUAL.value, 1, 0)\n",
-    "    manual_mask = manual\n",
-    "    linear_motor_values = linear_behavior(proxs, params)\n",
-    "    motor_values = linear_motor_values * (1 - manual_mask) + motors * manual_mask\n",
-    "    return motor_values"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Add Mask sensors and don't change functions\n",
-    "\n",
-    "- mask_sensors: mask sensors according to sensed entity type for an agent\n",
-    "- don't change: return agent raw_proxs (surely return either the masked or the same prox array according to a sensed e type)\n",
-    "\n",
-    "Then for each agent, we iterate on all of his behaviors. For each behavior, we iterate on each possible sensed entity type. If the entity is sensed, we keep the raw proximeters of the agent as they are currently. If it is not, we mask the proximeters of the specific (non sensed) entity type."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def mask_sensors(state, agent_raw_proxs, ent_type_id, ent_target_idx):\n",
-    "    mask = jnp.where(state.entities.ent_sensed_type[ent_target_idx] == ent_type_id, 0, 1)\n",
-    "    mask = jnp.expand_dims(mask, 1)\n",
-    "    mask = jnp.broadcast_to(mask, agent_raw_proxs.shape)\n",
-    "    return agent_raw_proxs * mask\n",
-    "\n",
-    "def dont_change(state, agent_raw_proxs, ent_type_id, ent_target_idx):\n",
-    "    return agent_raw_proxs"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Add compute_behavior_prox, compute_behavior_proxs_motors, compute_agent_proxs_motors\n",
-    "\n",
-    "- compute_behavior_prox: compute the proxs for one behavior (enumerate through all the sensed entities on this particular behavior)\n",
-    "- compute_behavior_proxs_motors: use fn above to compute the proxs and compute the motor values according to the behavior\n",
-    "- #vmap compute_all_behavior_proxs_motors:  computes this for all the behaviors of an agent\n",
-    "- compute_agent_proxs_motors: compute the proximeters and motor values of an agent for all its behaviors. Just return mean motor value\n",
-    "- #vmap compute_all_agents_proxs_motors: computes this for all agents (vmap over params, sensed and agent_raw_proxs) "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# TODO : Use a fori_loop on this later\n",
-    "def compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed_entities):\n",
-    "    for ent_type_id, sensed in enumerate(sensed_entities):\n",
-    "        # need the lax.cond because you don't want to change the proxs if you perceive the entity\n",
-    "        # but you want to mask the raw proxs if you don't detect it\n",
-    "        agent_raw_proxs = lax.cond(sensed, dont_change, mask_sensors, state, agent_raw_proxs, ent_type_id, ent_target_idx)\n",
-    "    proxs = jnp.max(agent_raw_proxs, axis=0)\n",
-    "    return proxs\n",
-    "\n",
-    "def compute_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_target_idx):\n",
-    "    behavior_prox = compute_behavior_prox(state, agent_raw_proxs, ent_target_idx, sensed)\n",
-    "    behavior_motors = compute_motor(behavior_prox, params, behavior, motor)\n",
-    "    return behavior_prox, behavior_motors\n",
-    "\n",
-    "# vmap on params, sensed and behavior (parallelize on all agents behaviors at once, but not motorrs because are the same)\n",
-    "compute_all_behavior_proxs_motors = vmap(compute_behavior_proxs_motors, in_axes=(None, 0, 0, 0, None, None, None))\n",
-    "\n",
-    "def compute_agent_proxs_motors(state, agent_idx, params, sensed, behavior, motor, raw_proxs, ag_idx_dense_senders, ag_idx_dense_receivers):\n",
-    "    behavior = jnp.expand_dims(behavior, axis=1)\n",
-    "    ent_ag_idx = ag_idx_dense_senders[agent_idx]\n",
-    "    ent_target_idx = ag_idx_dense_receivers[agent_idx]\n",
-    "    agent_raw_proxs = raw_proxs[ent_ag_idx]\n",
-    "\n",
-    "    # vmap on params, sensed, behaviors and motorss (vmap on all agents)\n",
-    "    agent_proxs, agent_motors = compute_all_behavior_proxs_motors(state, params, sensed, behavior, motor, agent_raw_proxs, ent_target_idx)\n",
-    "    mean_agent_motors = jnp.mean(agent_motors, axis=0)\n",
-    "\n",
-    "    return agent_proxs, mean_agent_motors\n",
-    "\n",
-    "compute_all_agents_proxs_motors = vmap(compute_agent_proxs_motors, in_axes=(None, 0, 0, 0, 0, 0, None, None, None))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Add classical braitenberg force fn"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Create the main environment class"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "#--- 4 Define the environment class with its different functions (step ...) ---#\n",
-    "class SelectiveSensorsEnv(BaseEnv):\n",
-    "    def __init__(self, state, seed=42):\n",
-    "        self.seed = seed\n",
-    "        self.init_key = random.PRNGKey(seed)\n",
-    "        self.displacement, self.shift = space.periodic(state.box_size)\n",
-    "        self.init_fn, self.apply_physics = dynamics_fn(self.displacement, self.shift, braintenberg_force_fn)\n",
-    "        self.neighbor_fn = partition.neighbor_list(\n",
-    "            self.displacement, \n",
-    "            state.box_size,\n",
-    "            r_cutoff=state.neighbor_radius,\n",
-    "            dr_threshold=10.,\n",
-    "            capacity_multiplier=1.5,\n",
-    "            format=partition.Sparse\n",
-    "        )\n",
-    "\n",
-    "        self.neighbors = self.allocate_neighbors(state)\n",
-    "        # self.neighbors, self.agents_neighs_idx = self.allocate_neighbors(state)\n",
-    "\n",
-    "    def distance(self, point1, point2):\n",
-    "            return distance(self.displacement, point1, point2)\n",
-    "    \n",
-    "    ### Add ag_idx_dense !!! \n",
-    "    @partial(jit, static_argnums=(0,))\n",
-    "    def _step(self, state: State, neighbors: jnp.array, agents_neighs_idx: jnp.array, ag_idx_dense: jnp.array) -> Tuple[State, jnp.array]:\n",
-    "        # Differences : compute raw proxs for all agents first \n",
-    "        dist, relative_theta, proximity_dist_map, proximity_dist_theta = get_relative_displacement(state, agents_neighs_idx, displacement_fn=self.displacement)\n",
-    "        senders, receivers = agents_neighs_idx\n",
-    "\n",
-    "        dist_max = state.agents.proxs_dist_max[senders]\n",
-    "        cos_min = state.agents.proxs_cos_min[senders]\n",
-    "        targer_exist_mask = state.entities.exists[agents_neighs_idx[1, :]]\n",
-    "        raw_proxs = sensor_fn(dist, relative_theta, dist_max, cos_min, targer_exist_mask)\n",
-    "\n",
-    "        # 2: Use dense idx for neighborhoods to vmap all of this\n",
-    "        # TODO : Could even just pass ag_idx_dense in the fn and do this inside\n",
-    "        ag_idx_dense_senders, ag_idx_dense_receivers = ag_idx_dense\n",
-    "\n",
-    "        agent_proxs, mean_agent_motors = compute_all_agents_proxs_motors(\n",
-    "            state,\n",
-    "            state.agents.ent_idx,\n",
-    "            state.agents.params,\n",
-    "            state.agents.sensed,\n",
-    "            state.agents.behavior,\n",
-    "            state.agents.motor,\n",
-    "            raw_proxs,\n",
-    "            ag_idx_dense_senders,\n",
-    "            ag_idx_dense_receivers,\n",
-    "        )\n",
-    "\n",
-    "        agents = state.agents.replace(\n",
-    "            prox=agent_proxs, \n",
-    "            proximity_map_dist=proximity_dist_map, \n",
-    "            proximity_map_theta=proximity_dist_theta,\n",
-    "            motor=mean_agent_motors\n",
-    "        )\n",
-    "\n",
-    "        # Last block unchanged\n",
-    "        state = state.replace(agents=agents)\n",
-    "        entities = self.apply_physics(state, neighbors)\n",
-    "        state = state.replace(time=state.time+1, entities=entities)\n",
-    "        neighbors = neighbors.update(state.entities.position.center)\n",
-    "\n",
-    "        return state, neighbors\n",
-    "    \n",
-    "    def step(self, state: State) -> State:\n",
-    "        if state.entities.momentum is None:\n",
-    "             state = self.init_fn(state, self.init_key)\n",
-    "             \n",
-    "        current_state = state\n",
-    "        state, neighbors = self._step(current_state, self.neighbors, self.agents_neighs_idx, self.agents_idx_dense)\n",
-    "\n",
-    "        if self.neighbors.did_buffer_overflow:\n",
-    "            # reallocate neighbors and run the simulation from current_state\n",
-    "            lg.warning(f'NEIGHBORS BUFFER OVERFLOW at step {state.time}: rebuilding neighbors')\n",
-    "            neighbors = self.allocate_neighbors(state)\n",
-    "            assert not neighbors.did_buffer_overflow\n",
-    "\n",
-    "        self.neighbors = neighbors\n",
-    "        return state\n",
-    "        \n",
-    "    def allocate_neighbors(self, state, position=None):\n",
-    "        position = state.entities.position.center if position is None else position\n",
-    "        neighbors = self.neighbor_fn.allocate(position)\n",
-    "\n",
-    "        # Also update the neighbor idx of agents (not the cleanest to attribute it to with self here)\n",
-    "        ag_idx = state.entities.entity_type[neighbors.idx[0]] == EntityType.AGENT.value\n",
-    "        self.agents_neighs_idx = neighbors.idx[:, ag_idx]\n",
-    "        agents_idx_dense_senders = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[0, :], idx)).flatten() for idx in jnp.arange(state.max_agents)])\n",
-    "        # agents_idx_dense_receivers = jnp.array([jnp.argwhere(jnp.equal(self.agents_neighs_idx[1, :], idx)).flatten() for idx in jnp.arange(self.max_agents)])\n",
-    "        agents_idx_dense_receivers = self.agents_neighs_idx[1, :][agents_idx_dense_senders]\n",
-    "        # self.agents_idx_dense = jnp.array([jnp.where(self.agents_neighs_idx[0, :] == idx).flatten() for idx in range(self.max_agents)])\n",
-    "        self.agents_idx_dense = agents_idx_dense_senders, agents_idx_dense_receivers\n",
-    "        return neighbors"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Create the state"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "seed = 0\n",
-    "max_agents = 10\n",
-    "max_objects = 10\n",
-    "n_dims = 2\n",
-    "box_size = 100\n",
-    "diameter = 5.0\n",
-    "friction = 0.1\n",
-    "mass_center = 1.0\n",
-    "mass_orientation = 0.125\n",
-    "neighbor_radius = 100.0\n",
-    "collision_alpha = 0.5\n",
-    "collision_eps = 0.1\n",
-    "dt = 0.1\n",
-    "wheel_diameter = 2.0\n",
-    "speed_mul = 1.0\n",
-    "max_speed = 10.0\n",
-    "theta_mul = 1.0\n",
-    "prox_dist_max = 40.0\n",
-    "prox_cos_min = 0.0\n",
-    "behavior = Behaviors.AGGRESSION.value\n",
-    "behaviors=Behaviors.AGGRESSION.value\n",
-    "existing_agents = None\n",
-    "existing_objects = None\n",
-    "\n",
-    "n_preys = 5\n",
-    "n_preds = 5\n",
-    "n_ress = 5\n",
-    "n_pois = 5\n",
-    "\n",
-    "key = random.PRNGKey(seed)\n",
-    "key, key_agents_pos, key_objects_pos, key_orientations = random.split(key, 4)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Entities"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "existing_agents = max_agents if not existing_agents else existing_agents\n",
-    "existing_objects = max_objects if not existing_objects else existing_objects\n",
-    "\n",
-    "n_entities = max_agents + max_objects # we store the entities data in jax arrays of length max_agents + max_objects \n",
-    "# Assign random positions to each entity in the environment\n",
-    "agents_positions = random.uniform(key_agents_pos, (max_agents, n_dims)) * box_size\n",
-    "objects_positions = random.uniform(key_objects_pos, (max_objects, n_dims)) * box_size\n",
-    "positions = jnp.concatenate((agents_positions, objects_positions))\n",
-    "# Assign random orientations between 0 and 2*pi to each entity\n",
-    "orientations = random.uniform(key_orientations, (n_entities,)) * 2 * jnp.pi\n",
-    "# Assign types to the entities\n",
-    "agents_entities = jnp.full(max_agents, EntityType.AGENT.value)\n",
-    "object_entities = jnp.full(max_objects, EntityType.OBJECT.value)\n",
-    "entity_types = jnp.concatenate((agents_entities, object_entities), dtype=int)\n",
-    "# Define arrays with existing entities\n",
-    "exists_agents = jnp.concatenate((jnp.ones((existing_agents)), jnp.zeros((max_agents - existing_agents))))\n",
-    "exists_objects = jnp.concatenate((jnp.ones((existing_objects)), jnp.zeros((max_objects - existing_objects))))\n",
-    "exists = jnp.concatenate((exists_agents, exists_objects), dtype=int)\n",
-    "\n",
-    "### TODO : Actually find a way to init this later\n",
-    "sensed_ent_types = jnp.concatenate([\n",
-    "    jnp.full(n_preys, EntitySensedType.PREY.value),\n",
-    "    jnp.full(n_preds, EntitySensedType.PRED.value),\n",
-    "    jnp.full(n_ress, EntitySensedType.RESSOURCE.value),\n",
-    "    jnp.full(n_pois, EntitySensedType.POISON.value),\n",
-    "])\n",
-    "\n",
-    "ent_sensed_types = jnp.zeros(n_entities)\n",
-    "\n",
-    "entities =  EntityState(\n",
-    "    position=RigidBody(center=positions, orientation=orientations),\n",
-    "    momentum=None,\n",
-    "    force=RigidBody(center=jnp.zeros((n_entities, 2)), orientation=jnp.zeros(n_entities)),\n",
-    "    mass=RigidBody(center=jnp.full((n_entities, 1), mass_center), orientation=jnp.full((n_entities), mass_orientation)),\n",
-    "    entity_type=entity_types,\n",
-    "    ent_sensed_type=sensed_ent_types,\n",
-    "    entity_idx = jnp.array(list(range(max_agents)) + list(range(max_objects))),\n",
-    "    diameter=jnp.full((n_entities), diameter),\n",
-    "    friction=jnp.full((n_entities), friction),\n",
-    "    exists=exists\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Agents"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(5, 2, 2, 3) (5, 2, 4)\n",
-      "(5, 2, 2, 3) (5, 2, 4)\n",
-      "(10, 2, 2, 3) (10, 2, 4) (10, 2)\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Prey behaviors\n",
-    "love = behavior_to_params(Behaviors.LOVE.value)\n",
-    "fear = behavior_to_params(Behaviors.FEAR.value)\n",
-    "sensed_love = jnp.array([1, 0, 1, 0])\n",
-    "sensed_fear = jnp.array([0, 1, 0, 1])\n",
-    "prey_params = jnp.array([love, fear])\n",
-    "prey_sensed = jnp.array([sensed_love, sensed_fear])\n",
-    "\n",
-    "# Do like if we had batches of params and sensed entities for all agents\n",
-    "prey_batch_params = jnp.tile(prey_params[None], (n_preys, 1, 1 ,1))\n",
-    "prey_batch_sensed = jnp.tile(prey_sensed[None], (n_preys, 1, 1))\n",
-    "print(prey_batch_params.shape, prey_batch_sensed.shape)\n",
-    "\n",
-    "prey_behaviors = jnp.array([Behaviors.LOVE.value, Behaviors.FEAR.value])\n",
-    "prey_batch_behaviors = jnp.tile(prey_behaviors[None], (n_preys, 1))\n",
-    "\n",
-    "# Pred behaviors\n",
-    "aggr = behavior_to_params(Behaviors.AGGRESSION.value)\n",
-    "fear = behavior_to_params(Behaviors.FEAR.value)\n",
-    "sensed_aggr = jnp.array([1, 0, 0, 0])\n",
-    "sensed_fear = jnp.array([0, 0, 0, 1])\n",
-    "pred_params = jnp.array([aggr, fear])\n",
-    "pred_sensed = jnp.array([sensed_aggr, sensed_fear])\n",
-    "\n",
-    "# Do like if we had batches of params and sensed entities for all agents\n",
-    "pred_batch_params = jnp.tile(pred_params[None], (n_preys, 1, 1 ,1))\n",
-    "pred_batch_sensed = jnp.tile(pred_sensed[None], (n_preys, 1, 1))\n",
-    "print(pred_batch_params.shape, pred_batch_sensed.shape)\n",
-    "\n",
-    "pred_behaviors = jnp.array([Behaviors.AGGRESSION.value, Behaviors.FEAR.value])\n",
-    "pred_batch_behaviors = jnp.tile(pred_behaviors[None], (n_preds, 1))\n",
-    "\n",
-    "\n",
-    "params = jnp.concatenate([prey_batch_params, pred_batch_params], axis=0)\n",
-    "sensed = jnp.concatenate([prey_batch_sensed, pred_batch_sensed], axis=0)\n",
-    "behaviors  = jnp.concatenate([prey_batch_behaviors, pred_batch_behaviors], axis=0)\n",
-    "print(params.shape, sensed.shape, behaviors.shape)\n",
-    "\n",
-    "\n",
-    "prey_color = jnp.array([0., 0., 1.])\n",
-    "pred_color = jnp.array([1., 0., 0.])\n",
-    "\n",
-    "prey_color=jnp.tile(prey_color, (n_preys, 1))\n",
-    "pred_color=jnp.tile(pred_color, (n_preds, 1))\n",
-    "\n",
-    "agent_colors = jnp.concatenate([\n",
-    "    prey_color,\n",
-    "    pred_color\n",
-    "])\n",
-    "\n",
-    "agents =  AgentState(\n",
-    "    # idx in the entities (ent_idx) state to map agents information in the different data structures\n",
-    "    ent_idx=jnp.arange(max_agents, dtype=int), \n",
-    "    prox=jnp.zeros((max_agents, 2)),\n",
-    "    motor=jnp.zeros((max_agents, 2)),\n",
-    "    behavior=behaviors,\n",
-    "    params=params,\n",
-    "    sensed=sensed,\n",
-    "    wheel_diameter=jnp.full((max_agents), wheel_diameter),\n",
-    "    speed_mul=jnp.full((max_agents), speed_mul),\n",
-    "    max_speed=jnp.full((max_agents), max_speed),\n",
-    "    theta_mul=jnp.full((max_agents), theta_mul),\n",
-    "    proxs_dist_max=jnp.full((max_agents), prox_dist_max),\n",
-    "    proxs_cos_min=jnp.full((max_agents), prox_cos_min),\n",
-    "    proximity_map_dist=jnp.zeros((max_agents, 1)),\n",
-    "    proximity_map_theta=jnp.zeros((max_agents, 1)),\n",
-    "    color=jnp.tile(agent_colors, (max_agents, 1))\n",
-    ")\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Objects"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "# Entities idx of objects\n",
-    "start_idx, stop_idx = max_agents, max_agents + max_objects \n",
-    "objects_ent_idx = jnp.arange(start_idx, stop_idx, dtype=int)\n",
-    "\n",
-    "res_color = jnp.array([0., 1., 0.])\n",
-    "pois_color = jnp.array([1., 0., 1.])\n",
-    "\n",
-    "res_color=jnp.tile(res_color, (n_preys, 1))\n",
-    "pois_color=jnp.tile(pois_color, (n_preds, 1))\n",
-    "\n",
-    "objects_colors = jnp.concatenate([\n",
-    "    res_color,\n",
-    "    pois_color\n",
-    "])\n",
-    "\n",
-    "objects =  ObjectState(\n",
-    "    ent_idx=objects_ent_idx,\n",
-    "    color=jnp.tile(objects_colors, (max_objects, 1))\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### State"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "state =  State(\n",
-    "    time=0,\n",
-    "    box_size=box_size,\n",
-    "    max_agents=max_agents,\n",
-    "    max_objects=max_objects,\n",
-    "    neighbor_radius=neighbor_radius,\n",
-    "    collision_alpha=collision_alpha,\n",
-    "    collision_eps=collision_eps,\n",
-    "    dt=dt,\n",
-    "    entities=entities,\n",
-    "    agents=agents,\n",
-    "    objects=objects\n",
-    ")   "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Test the simulation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from vivarium.experimental.environments.braitenberg.render import render, render_history"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 600x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "render(state)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "env = SelectiveSensorsEnv(state)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Autonomous behaviors"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n_steps = 10_000\n",
-    "hist = []\n",
-    "\n",
-    "for i in range(n_steps):\n",
-    "    state = env.step(state)\n",
-    "    hist.append(state)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 600x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "render_history(hist, skip_frames=50)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Test manual behavior for an agent\n",
-    "\n",
-    "Need to set all of its behaviors to manual."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ag_idx = 9\n",
-    "manual_behaviors = jnp.array([Behaviors.MANUAL.value, Behaviors.MANUAL.value,])\n",
-    "manual_color = jnp.array([0., 0., 0.])\n",
-    "manual_motors = jnp.array([1., 1.])\n",
-    "\n",
-    "behaviors = state.agents.behavior.at[ag_idx].set(manual_behaviors)\n",
-    "colors = state.agents.color.at[ag_idx].set(manual_color)\n",
-    "motors = state.agents.motor.at[ag_idx].set(manual_motors)\n",
-    "\n",
-    "agents = state.agents.replace(behavior=behaviors, color=colors, motor=motors)\n",
-    "state = state.replace(agents=agents)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n_steps = 5_000\n",
-    "hist = []\n",
-    "\n",
-    "for i in range(n_steps):\n",
-    "    state = env.step(state)\n",
-    "    hist.append(state)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 600x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "render_history(hist, skip_frames=50)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "venv",
-   "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.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

From ce92c29dbe45f5d73025043a66ae475aa3eb35c0 Mon Sep 17 00:00:00 2001
From: corentinlger <corentin.lger@gmail.com>
Date: Wed, 7 Aug 2024 16:36:19 +0200
Subject: [PATCH 6/7] Remove unused environments

---
 vivarium/experimental/environments/particle_lenia/simple.py | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 vivarium/experimental/environments/particle_lenia/simple.py

diff --git a/vivarium/experimental/environments/particle_lenia/simple.py b/vivarium/experimental/environments/particle_lenia/simple.py
deleted file mode 100644
index f87f5c1..0000000
--- a/vivarium/experimental/environments/particle_lenia/simple.py
+++ /dev/null
@@ -1 +0,0 @@
-# TODO
\ No newline at end of file

From aa8314aecabdeaef36152bb893d0bc9b78402743 Mon Sep 17 00:00:00 2001
From: corentinlger <corentin.lger@gmail.com>
Date: Wed, 7 Aug 2024 16:38:38 +0200
Subject: [PATCH 7/7] Rename selective sensing notebook

---
 ...elective_sensing.ipynb => braitenberg_selective_sensing.ipynb} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename vivarium/experimental/notebooks/{occlusion_choice_selective_sensing.ipynb => braitenberg_selective_sensing.ipynb} (100%)

diff --git a/vivarium/experimental/notebooks/occlusion_choice_selective_sensing.ipynb b/vivarium/experimental/notebooks/braitenberg_selective_sensing.ipynb
similarity index 100%
rename from vivarium/experimental/notebooks/occlusion_choice_selective_sensing.ipynb
rename to vivarium/experimental/notebooks/braitenberg_selective_sensing.ipynb