cogpy.model.poisson_process

PointProcess:

Abstract base class for point processes.

PoissonProcess:

Implements a Poisson point process using exponential inter-spike intervals (ISIs).

PointBurst:

Implements a burst process based on a given point process and event duration distribution.

PoissonBurst:

Implements a Poisson burst process with exponentially distributed event durations.

ModeProcess:

Combines a mode function with a point process to generate a signal.

ModeMixer:

Mixes multiple ModeProcess signals and provides access to individual mode signals. Stores individual generated signals for each mode.

workflow:

  1. Define mode functions (e.g., Gaussian modes from a GaussianCover).

  2. Create PointProcess instances (e.g., PoissonProcess).

  3. Create ModeProcess instances by combining mode functions with point processes.

  4. Use ModeMixer to mix the signals from multiple ModeProcess instances.

example usage:

from src.model.poisson_process import PoissonProcess, ModeProcess, ModeMixer from src.model.gaussian_cover import GaussianCover import xarray as xr import numpy as np

# Define mode functions (e.g., Gaussian modes) gc = GaussianCover(shape=(16, 16, 70), sigma=[3, 3, 7]) modes = gc.modes # List of xarray.DataArray mode functions mode_processes = [] for mode in modes:

pp = PoissonProcess(rate=5) # 5 events per unit time mp = ModeProcess(mode_function=mode, process=pp) mode_processes.append(mp)

mixer = ModeMixer(mode_processes) mixed_signal = mixer.mix(duration=1000) unmixed_signals = mixer.get_unmixed_modes()

Functions

convolve_impulses_sparse(sig, kernel[, mode])

sample_exponential(mean)

Generate a sample from an exponential distribution given a mean.

Classes

ImpulseResponseMixer(point_process, ...)

ModeMixer(mode_processes)

ModeProcess(mode_function, process[, convolve])

PointBurst(point_process, duration_distribution)

PointProcess()

PoissonBurst(rate, duration_mean[, ...])

PoissonProcess(rate)