Example code#

from dateutil import parser
from datetime import timedelta

from neuroplatform import Database, Experiment

db = Database()
exp = Experiment("Your token here")
FS_NAME = (
    exp.exp_name
)  # FS ID for the MEA. This changes every time we change the organoids.

Spike events#

A spike event is logged whenever the voltage from an electrode crosses a threshold of six times the standard deviation of the noise.

You can query a list of spike events with the timestamp, the amplitude (maximum absolute voltage of the peak across 3ms around the spike) and the channel number using get_spike_event

To avoid returning large amounts of data, keep the time window small.
We recommed starting with 5 minutes, and increasing/decreasing the window as needed.

start = parser.parse("2024-04-05T00:00:00.000Z")
stop = start + timedelta(minutes=5)

spike_event_df = db.get_spike_event(start, stop, FS_NAME)

Spike count per minute#

You can get the spike count per minute for all electrodes for a given experiment name using get_spike_count to get a DataFrame with the spike count per minute for each electrode, with the timestamp.

spike_per_min_df = db.get_spike_count(start, stop, FS_NAME)

Raw spike events#

Every spike event is recorded for 3ms around the spike. You can get the raw signal for these 3ms of spike events using get_raw_spike_event to get a DataFrame with the timestamp, the electrode number, and the amplitude values for each event in a long format.

Since the sampling rate is 30kHz, each spike event will have 90 samples.

from tqdm import tqdm

df_spike_event = db.get_spike_event(start, start + timedelta(seconds=1), FS_NAME)

raws = []
for i, row in tqdm(df_spike_event.iterrows(), total=df_spike_event.shape[0]):
    t = row["Time"]
    t1 = t - timedelta(milliseconds=1)
    t2 = t + timedelta(milliseconds=2)
    raws.append(db.get_raw_spike(t1, t2, row["channel"]))

import numpy as np
from lets_plot import (
    ggplot,
    ggtitle,
    geom_line,
    aes,
    ggsize,
    gggrid,
)


def plot_raw_channel(channel: int):
    df_chan = df_spike_event[df_spike_event["channel"] == channel]
    # Start with an empty plot
    p = ggplot()
    p += ggtitle(f"Channel {channel}")

    for i, row in df_chan.iterrows():
        df_raw = raws[i]
        if df_raw.shape[0] == 90:
            df_raw["Time [ms]"] = np.linspace(-1, 2, 90)
            p += geom_line(aes(x="Time [ms]", y="Amplitude"), data=df_raw)

    return p


channels = df_spike_event["channel"].unique()
list_plot = []
for i, chan in enumerate(channels):
    list_plot.append(plot_raw_channel(chan))

nbCol = 3
nbRow = len(list_plot) // nbCol
if len(list_plot) % nbCol != 0:
    nbRow += 1
gggrid(list_plot, ncol=nbCol) + ggsize(800, 300 * nbRow)

Triggers#

You can obtain the triggers used for stimulation using get_triggers to return a DataFrame with the timestamp, the trigger number, the status (up/down, which corresponds to the times where the trigger was enabled/disabled respectively) and the tag if any.

triggers_df = db.get_all_triggers(start, stop)

Impedance#

When you have measured impedance using the Intan, you can get the recorded impedance values using get_impedance to return a DataFrame with the timestamp, the electrode number, and the impedance values.

df_impedance = db.get_impedance(start, stop)

Miscellanous measurements#

We also provide access to various environmental measurements within the incubator hosting the MEAs :

• CO2 levels

• O2 levels

• Temperature

• Humidity

• Pressure

• Pump flowrate

• Door opening/closing events

co2_df = db.co2(start, stop)
o2_df = db.o2(start, stop)
temp_df = db.temperature(start, stop)
pressure_df = db.pressure(start, stop)
humidity_df = db.humidity(start, stop)

port = 3  # port is the MEA number from 1 to 4
flow_df = db.flowrate(start, stop, port)

door_df = db.door(start, stop)