Systole

https://legrandnico.github.io/systole/
Admin
Systole is an open-source Python package providing tools to pre-process, visualize, and analyze...
Tokens:157,269
Snippets:1,079
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Setup: install and import libraries

Source: https://legrandnico.github.io/systole/notebooks/1-PhysiologicalSignals.html

Setup for the notebook: installs systole in Google Colab, imports plotting and Systole libraries, and configures Bokeh and seaborn.

```python
%%capture
import sys

if "google.colab" in sys.modules:
    !pip install systole

```

```python
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
from bokeh.io import output_notebook
from bokeh.plotting import show
from systole.detection import ecg_peaks
from systole.plots import plot_raw
from systole.utils import input_conversion

from systole import import_dataset1, import_ppg

output_notebook()

sns.set_context("talk")

```

--------------------------------

### Initialize recording with setup

Source: https://legrandnico.github.io/systole/generated/recording/systole.recording.Oximeter.html

Use the setup method to find the start byte and ensure data synchronization. Do not wait more than ~10s between setup and recording to avoid buffer overwriting.

```python
>>> oximeter.setup()
```

--------------------------------

### Import libraries and set author/licence

Source: https://legrandnico.github.io/systole/auto_examples/Artefacts/plot_RRCorrection.html

Imports required libraries and sets the author and licence for the example. This is the initial setup for the script.

```python
# Author: Nicolas Legrand <nicolas.legrand@cas.au.dk>
# Licence: GPL v3

```

```python
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns

from systole import import_dataset1
from systole.correction import correct_rr
from systole.detection import ecg_peaks
from systole.hrv import frequency_domain
from systole.plots import plot_frequency, plot_rr
from systole.utils import input_conversion

```

--------------------------------

### Initialize Oximeter and setup

Source: https://legrandnico.github.io/systole/_sources/auto_examples/Recording/plot_HeartBeatrpeggios.rst.txt

Creates an Oximeter instance with the serial connection, a sampling frequency of 75 Hz, and 4 additional channels, then calls setup(). The output shows 'Reset input buffer'.

```Python
oxi = Oximeter(serial=ser, sfreq=75, add_channels=4).setup()
```

```none
Reset input buffer
```

--------------------------------

### Install dev branch with pip

Source: https://legrandnico.github.io/systole/getting_started.html

Downloads and installs the dev branch to try the latest features that are under development and possibly unstable.

```bash
pip install “git+https://github.com/LegrandNico/systole.git@dev”
```

--------------------------------

### Example script header

Source: https://legrandnico.github.io/systole/auto_examples/Plots/plot_circular.html

Header comment for the example script, indicating the author and license.

```python
# Author: Nicolas Legrand <nicolas.legrand@cas.au.dk>
# Licence: GPL v3

```

--------------------------------

### Install stable version with pip

Source: https://legrandnico.github.io/systole/getting_started.html

Installs the last stable version of Systole using pip.

```bash
pip install systole
```

--------------------------------

### Setup Oximeter recording

Source: https://legrandnico.github.io/systole/_modules/systole/recording.html

Initialize the recording to synchronize data. Perform this shortly before recording to avoid buffer overwrites.

```python
oximeter.setup()
```

--------------------------------

### Configuring Serial Port Connection

Source: https://legrandnico.github.io/systole/_downloads/517fdd79621ce3738da52dd7295d8666/plot_RecordingPPG.ipynb

Setup the serial connection using a simulation or a physical USB device.

```python
ser = serialSim()  # Simulate a device

# Use a USB device
# import serial
# ser = serial.Serial("COM4")  # Use this line for USB recording
```

--------------------------------

### Import libraries and systole functions

Source: https://legrandnico.github.io/systole/_downloads/05f87e8486fb7fc51000715bce07f897/plot_RRCorrection.ipynb

Imports required libraries and systole functions for the example.

```python
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns

from systole import import_dataset1
from systole.correction import correct_rr
from systole.detection import ecg_peaks
from systole.hrv import frequency_domain
from systole.plots import plot_frequency, plot_rr
from systole.utils import input_conversion
```

--------------------------------

### BIDS folder structure example

Source: https://legrandnico.github.io/systole/notebooks/6-WorkingWithBIDSFolders.html

Visual representation of a valid BIDS directory structure for physiological recordings.

```text
└─ BIDS/
   ├─ sub-0001/
   │  └─ ses-session1/
   │     └─ beh/
   │        ├─ sub-0001_ses_session1_task-mytask_physio.tsv.gz
   │        └─ sub-0001_ses_session1_task-mytask_physio.json
   │
   ├─ sub-0002/
   ├─ sub-0003/
   └─ ... 
```

--------------------------------

### Example: Using Bokeh as plotting backend

Source: https://legrandnico.github.io/systole/_modules/systole/plots/plot_ectopic.html

Shows how to use the Bokeh backend by calling `output_notebook()` and passing `backend="bokeh"` to `plot_ectopic`, then displaying with `show`.

```python
from bokeh.io import output_notebook
from bokeh.plotting import show
from systole.detection import rr_artefacts
output_notebook()

# Use the rr_artefacts function to find ectopic beats
artefacts = rr_artefacts(rr)
show(
    plot_ectopic(artefacts=artefacts, backend="bokeh")
 )
```

--------------------------------

### Import PPG signal and ppg_peaks

Source: https://legrandnico.github.io/systole/generated/detection/systole.detection.ppg_peaks.html

Imports the necessary modules and loads a sample PPG signal for use in peak detection examples.

```python
>>> from systole import import_ppg
>>> from systole.detection import ppg_peaks
>>> ppg = import_ppg().ppg.to_numpy()  # Import PPG signal
```

--------------------------------

### Load ECG dataset with import_dataset1

Source: https://legrandnico.github.io/systole/notebooks/1-PhysiologicalSignals.html

Loads the example ECG dataset using Systole's import_dataset1, requesting only the ECG modality to save time.

```python
ecg_df = import_dataset1(modalities=["ECG"], disable=True)

```

--------------------------------

### Check system configuration with watermark

Source: https://legrandnico.github.io/systole/_sources/notebooks/6-WorkingWithBIDSFolders.ipynb.txt

Displays the current environment configuration, including Python version and installed package versions for systole and numba.

```python
%load_ext watermark
%watermark -n -u -v -iv -w -p systole,numba
```

--------------------------------

### Import libraries for heartbeat evoked arpeggios

Source: https://legrandnico.github.io/systole/auto_examples/Recording/plot_HeartBeatrpeggios.html

Imports required libraries and modules for the heartbeat evoked arpeggios example, including systole's serialSim, Oximeter, and plotting utilities.

```python
# Author: Nicolas Legrand <nicolas.legrand@cas.au.dk>
# Licence: GPL v3

import itertools
import time

import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
from systole import serialSim
from systole.plots import plot_circular, plot_events
from systole.recording import Oximeter
from systole.utils import norm_triggers, to_angles

```

--------------------------------

### Initialize Viewer for preprocessed folders

Source: https://legrandnico.github.io/systole/notebooks/6-WorkingWithBIDSFolders.html

Sets up the Viewer imports and interactive backend for navigating preprocessed BIDS derivatives.

```python
from IPython.display import display
from systole.interact import Viewer

%matplotlib ipympl
```

--------------------------------

### Install Systole in Google Colab

Source: https://legrandnico.github.io/systole/_sources/notebooks/6-WorkingWithBIDSFolders.ipynb.txt

Installs the systole package when running in a Google Colab environment. The code checks if 'google.colab' is in sys.modules and then uses pip to install systole.

```python
%%capture
import sys

if "google.colab" in sys.modules:
    !pip install systole
```

--------------------------------

### Using the Viewer to navigate preprocessed folder

Source: https://legrandnico.github.io/systole/_sources/notebooks/6-WorkingWithBIDSFolders.ipynb.txt

Setup for using the Viewer to navigate preprocessed BIDS folders. Imports required modules, creates a Viewer instance pointing to the preprocessed folder, and displays the interactive widgets. The Viewer wraps the Editor and allows inspection and editing of preprocessed ECG recordings.

```python
from IPython.display import display
from systole.interact import Viewer

%matplotlib ipympl

```

```python
view = Viewer(
    figsize=(15, 5),
    preprocessed_folder="/path/to/BIDS/folder/derivatives/systole/",
    pattern="task-my_task", # A string long enough to disambiguate in case of mmultiple recordings
    modality="beh",
    signal_type="ECG"
)

```

```python
display(view.io_box, view.editor.commands_box, view.output)

```

--------------------------------

### Configure and display the Editor

Source: https://legrandnico.github.io/systole/notebooks/6-WorkingWithBIDSFolders.html

Initializes the Editor instance with signal parameters and displays the command box for manual interaction.

```python
editor = Editor(
    signal=ecg,
    sfreq=1000,
    corrected_json="./corrected.json",
    figsize=(15, 5),
    signal_type="ECG"
)
display(editor.commands_box)
```

--------------------------------

### Install Systole stable and dev branches with pip

Source: https://legrandnico.github.io/systole/_sources/getting_started.rst.txt

Install the last stable version of Systole with pip, or install the dev branch to try the latest (possibly unstable) features. The dev branch is fetched directly from the GitHub repository.

```shell
pip install systole
```

```shell
pip install “git+https://github.com/LegrandNico/systole.git@dev”
```

--------------------------------

### Configure Viewer for preprocessed data

Source: https://legrandnico.github.io/systole/notebooks/6-WorkingWithBIDSFolders.html

Initializes the Viewer to navigate a specific preprocessed BIDS folder.

```python
view = Viewer(
    figsize=(15, 5),
    preprocessed_folder="/path/to/BIDS/folder/derivatives/systole/",
    pattern="task-my_task", # A string long enough to disambiguate in case of mmultiple recordings
    modality="beh",
    signal_type="ECG"
)
```

--------------------------------

### Output for DataFrame example

Source: https://legrandnico.github.io/systole/auto_examples/Plots/plot_circular.html

Output of the DataFrame example, showing two UserWarnings about set_ticklabels() and the resulting PolarAxes object.

```output
/home/runner/work/systole/systole/src/systole/plots/backends/matplotlib/plot_circular.py:132: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.
  ax.set_xticklabels(circle_label)
/home/runner/work/systole/systole/src/systole/plots/backends/matplotlib/plot_circular.py:132: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.
  ax.set_xticklabels(circle_label)

<PolarAxes: >

```

--------------------------------

### Initialize Viewer with BIDS folder

Source: https://legrandnico.github.io/systole/_sources/notebooks/6-WorkingWithBIDSFolders.ipynb.txt

Use the Viewer class with the bids_folder argument to inspect raw BIDS data directly. This approach allows for on-the-fly preprocessing without generating full subject or group reports.

```python
view = Viewer(
    figsize=(15, 5),
    bids_folder="/path/to/BIDS/folder/",
    pattern="task-my_task", # A string long enough to disambiguate in case of mmultiple recordings
    modality="beh",
    signal_type="ECG"
)
```

--------------------------------

### Output for numpy array example

Source: https://legrandnico.github.io/systole/auto_examples/Plots/plot_circular.html

Output of the numpy array example, showing a UserWarning about set_ticklabels() and the resulting PolarAxes object.

```output
/home/runner/work/systole/systole/src/systole/plots/backends/matplotlib/plot_circular.py:132: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.
  ax.set_xticklabels(circle_label)

<PolarAxes: >

```

--------------------------------

### Matplotlib example for plot_frequency

Source: https://legrandnico.github.io/systole/generated/plots/systole.plots.plot_frequency.html

Visualizes HRV frequency domain from RR time series using Matplotlib as plotting backend. The example imports RR data and calls plot_frequency with input_type='rr_ms'.

```python
from systole import import_rr
from systole.plots import plot_frequency
# Import PPG recording as numpy array
rr = import_rr().rr.to_numpy()
plot_frequency(rr, input_type="rr_ms")
```

```text
<Axes: title={'center': 'Power Spectral Density'}, xlabel='Frequency [Hz]', ylabel='PSD [$s^2$/Hz]'>
```

--------------------------------

### norm_bad_segments with doctest examples

Source: https://legrandnico.github.io/systole/_modules/systole/utils.html

Defines the norm_bad_segments function to normalize bad segments into merged tuple intervals. Includes two doctest examples: converting a boolean array and merging overlapping tuples.

```python
def norm_bad_segments(bad_segments) -> List[Tuple[int, int]]:
    """Normalize bad segments. Return a list of tuples and merge overlapping intervals.

    Parameters
    ----------
    bad_segments :
        The time stamps of the bad segments. Can be a boolean 1d numpy array where
        `True` is a bad segment (will be rejected), or a list of tuples such as
        (start_idx, end_idx) in signal samples or milliseconds when intervals are
        provided.

    Returns
    -------
    bad_segments_tuples :
        The merged bad segments as tuples such as (start_idx, end_idx) indicate when
        each bad segment starts and ends.

    Raises
    ------
    ValueError :
        If `bad_segments` is not a tuple or a np.ndarray.

    Examples
    --------
    Get a list of tuples such as `[(start_idx, end_idx)]` from a boolean vector that
    is of the same length that the associated signal and where `True` is a bad
    segment/sample.

    >>> import numpy as np
    >>> from systole.utils import norm_bad_segments
    >>> bool_bad_segments = np.zeros(100, dtype=bool)
    >>> bool_bad_segments[10:20] = True
    >>> bool_bad_segments[50:60] = True
    >>> new_segments = norm_bad_segments(bool_bad_segments)
    >>> new_segments
    `[(10, 20), (50, 60)]`

    From a list of tuples such as `[(start_idx, end_idx)]`, where some intervals are
    overlapping, get a clean version of these bad segments by merging the overlapping
    intervals.

    >>> bad_segments = [(100, 200), (150, 250)]
    >>> new_segments = norm_bad_segments(bad_segments)
    >>> assert new_segments
    `[(100, 250)]`

    """
    if isinstance(bad_segments, list):
        # Create boolean representation
        t_max = np.array(bad_segments).max()
        boolean_segments = np.zeros(t_max, dtype=int)

        for bads in bad_segments:
            boolean_segments[bads[0] : bads[1]] = 1

    elif isinstance(bad_segments, np.ndarray):
        boolean_segments = bad_segments.astype(int)

    else:
        raise ValueError(
            "bad_segments should be a list of tuples or a boolean 1d array."
            f" Got {type(bad_segments)}"
        )
```

--------------------------------

### Initialize Oximeter and Perform Online Peak Detection

Source: https://legrandnico.github.io/systole/_downloads/517fdd79621ce3738da52dd7295d8666/plot_RecordingPPG.ipynb

This snippet demonstrates how to set up an Oximeter instance and run a loop to detect heartbeats in real-time from the serial port for 10 seconds.

```python
# Create an Oxymeter instance and initialize recording
oxi = Oximeter(serial=ser, sfreq=75, add_channels=4).setup()

# Online peak detection - run for 10 seconds
tstart = time.time()
while time.time() - tstart < 10:
    while oxi.serial.inWaiting() >= 5:
        paquet = list(oxi.serial.read(5))
        oxi.add_paquet(paquet[2])  # Add new data point
        if oxi.peaks[-1] == 1:
            print("Heartbeat detected")
```

--------------------------------

### Example: Using get_valid_segments

Source: https://legrandnico.github.io/systole/generated/utils/systole.utils.get_valid_segments.html

Demonstrates how to use get_valid_segments with a random signal and a list of bad segments. The function returns a list of valid time series sorted by length. The example prints the lengths of the valid segments.

```python
>>> import numpy as np
>>> from systole.utils import get_valid_segments
>>> signal = np.random.normal(size=1000)
>>> bad_segments = [(500, 550), (700, 800)]
>>> valids = get_valid_segments(signal=signal, bad_segments=bad_segments)
>>> [len(sig) for sig in valids]
`[500, 200, 150]`
```

--------------------------------

### Import libraries and configure environment

Source: https://legrandnico.github.io/systole/notebooks/3-DetectingAndCorrectingArtefacts.html

Imports necessary libraries for signal processing, plotting, and data handling, and configures the notebook environment.

```python
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
from bokeh.io import output_notebook
from bokeh.plotting import show
from systole import import_dataset1
from systole.correction import correct_peaks, correct_rr
from systole.detection import ecg_peaks
from systole.plots import plot_evoked, plot_frequency, plot_raw, plot_rr, plot_subspaces
from systole.utils import input_conversion

output_notebook()

sns.set_context("talk")
```

--------------------------------

### Bokeh example for plot_frequency

Source: https://legrandnico.github.io/systole/generated/plots/systole.plots.plot_frequency.html

Visualizes HRV frequency domain from RR time series using Bokeh as plotting backend. The example imports RR data, sets up Bokeh notebook output, and calls plot_frequency with backend='bokeh'.

```python
from systole import import_rr
from systole.plots import plot_frequency
from bokeh.io import output_notebook
from bokeh.plotting import show
output_notebook()

show(
    plot_frequency(rr, input_type="rr_ms", backend="bokeh")
)
```

```text
BokehJS 3.7.2 successfully loaded.
```

--------------------------------

### to_epochs usage examples from docstring

Source: https://legrandnico.github.io/systole/_modules/systole/utils.html

These examples show how to use the to_epochs function with different inputs: using event indices, using event triggers, and using a rejection vector. They assume a dataset loaded via import_dataset1 with ECG and Stim modalities.

```python
>>> ecg_df = import_dataset1(modalities=['ECG', 'Stim'])

>>> triggers_idx = [
>>>     np.where(ecg_df.stim.to_numpy() == 2)[0],
>>>     np.where(ecg_df.stim.to_numpy() == 1)[0]
>>> ]
>>> signal = ecg_df.ecg.to_numpy()
```

```python
>>> epoch, rejected = to_epochs(signal=signal, triggers_idx=triggers_idx)
```

```python
>>> epoch, rejected = to_epochs(signal=signal, triggers=ecg_df.stim.to_numpy(),
>>>                             event_val=2, apply_baseline=(-1.0, 0.0))
```

```python
>>> reject = np.zeros(len(signal))
>>> reject[768285:] = 1  # Reject the second part of the recording
>>> epoch, rejected = to_epochs(
>>>     signal=signal, triggers=ecg_df.stim.to_numpy(), event_val=2,
>>>     apply_baseline=(-1.0, 0.0), reject=reject
>>>     )
```

--------------------------------

### Initialize Oximeter instance

Source: https://legrandnico.github.io/systole/_downloads/c526ecdb1c1d207cc7bfe76b0e1fd470/plot_HeartBeatrpeggios.ipynb

Creates and sets up an Oximeter instance with the specified serial connection and sampling frequency.

```python
oxi = Oximeter(serial=ser, sfreq=75, add_channels=4).setup()
```

--------------------------------

### Nonin3231USB

Source: https://legrandnico.github.io/systole/generated/recording/systole.recording.Nonin3231USB.html

Documentation for the Nonin3231USB class, including its constructor, methods, and usage example.

```APIDOC
## Nonin3231USB

### Description
Class for recording Nonin 3231 USB HR signal through a USB connection.

### Constructor
`Nonin3231USB(serial, add_channels: int | None = 1)`

### Parameters
- **serial** (pySerial object) - Required - The serial instance interfacing with the USB port.
- **add_channels** (int | None) - Optional - Number of additional channels to add. Default is 1.

### Methods

#### `__init__(serial, add_channels: int | None = 1)`
Initializes the recording instance.

#### `close()`
Closes serial connections.

#### `read(duration)`
Reads PPG signal for some amount of time.

#### `readInWaiting([bool])`
Reads in waiting Nonin data.

#### `reset(serial[, add_channels])`
Initializes/restarts the recording instance.

#### `setup()`
Resets the recording instance.

### Example
```python
import serial
ser = serial.Serial('COM4')
from ecg.recording import Nonin3231USB
exg = Nonin3231USB(serial).read(30)
```

### Warning
The signals received from the host are appended to a list. This process can require more time at each iteration as the signal length increases in memory. You should always make sure that this will not interfere with other tasks and regularly save intermediate recordings to save resources.
```

--------------------------------

### Run systole preprocessing via command line

Source: https://legrandnico.github.io/systole/_sources/notebooks/6-WorkingWithBIDSFolders.ipynb.txt

Executes the systole preprocessing pipeline on a specified BIDS folder for a given task and modality. This example runs 10 parallel jobs and disables HTML report generation.

```bash
systole --bids_folder="/path/to/BIDS/folder/" \
        --patterns="task-mytask" \
        --modality="beh" \
        --n_jobs=10 \
        --overwrite=True \
        --html_reports==False
```

--------------------------------

### Plot evoked heart rate with Bokeh backend

Source: https://legrandnico.github.io/systole/_modules/systole/plots/plot_evoked.html

This example shows how to use `plot_evoked` with the Bokeh backend. It sets up the notebook output, defines common plotting arguments, and creates three plots using the same three input types as the Matplotlib example. Finally, it displays the plots side by side using `show(row(...))`.

```python
from bokeh.io import output_notebook
from bokeh.plotting import show
from bokeh.layouts import row
output_notebook()

# We define a common set of plotting arguments here
plot_args = {
     "backend": "bokeh", "figsize": (400, 400),
     "palette": [sns.xkcd_rgb["denim blue"], sns.xkcd_rgb["pale red"]],
     "tmin": -1.0, "tmax": 10.0, "apply_baseline": (-1.0, 0.0), "decim": 100
 }

# Using the raw signal and events triggers
raw_plot = plot_evoked(
     signal=ecg_df.ecg.to_numpy(), triggers_idx=triggers_idx, modality="ecg",
     **plot_args
     )

# Using the detected peaks and events triggers
peaks_plot = plot_evoked(
    rr=peaks, triggers_idx=triggers_idx, input_type="peaks", **plot_args
    )

# Using the list of epochs arrays
epochs_plots = plot_evoked(epochs=hr_epochs, **plot_args)

# Create a Bokeh layout and plot the figures side by side
show(row(raw_plot, peaks_plot, epochs_plots))
```

--------------------------------

### Import Oximeter and serialSim

Source: https://legrandnico.github.io/systole/auto_examples/Recording/plot_RecordingPPG.html

Imports the Oximeter class and the serialSim simulation function used in the example.

```python
from systole.recording import Oximeter
from systole import serialSim

```

--------------------------------

### Initialize BrainVisionExG and read signal

Source: https://legrandnico.github.io/systole/generated/recording/systole.recording.BrainVisionExG.html

Create an instance of BrainVisionExG and use the read method to record signal data for a specified duration.

```python
>>> from ecg.recording import BrainVisionExG
>>> exg = BrainVisionExG(ip='xxx.xxx.xx', sfreq=1000).read(30)
```

--------------------------------

### Nonin3231USB.setup

Source: https://legrandnico.github.io/systole/_sources/generated/recording/systole.recording.Nonin3231USB.rst.txt

Sets up the Nonin 3231 USB device for communication.

```APIDOC
## Nonin3231USB.setup

### Description
Sets up the Nonin 3231 USB device for communication.

### Method
Method

### Signature
`setup(self)`

### Parameters
None

### Returns
None
```

--------------------------------

### Frequency Domain Table Output

Source: https://legrandnico.github.io/systole/notebooks/4-HeartRateVariability.html

Example output of the frequency domain table generated by the tabulate backend.

```text
=================  ============  =============  ===========  ==============
Frequency Band       Peaks (Hz)    Power (ms²)    Power (%)    Power (n.u.)
=================  ============  =============  ===========  ==============
VLF (0-0.04 Hz)          0.0078      1441.6998      56.7621
LF (0.04-0.15 Hz)        0.0938       522.1761      20.5589         47.5484
HF (0.15-0.4 Hz)         0.3555       576.0226      22.6790         52.4516
Total                                2539.8985
LF/HF                                   0.9065
=================  ============  =============  ===========  ==============
```

--------------------------------

### Visualize Poincare plot with Bokeh

Source: https://legrandnico.github.io/systole/generated/plots/systole.plots.plot_poincare.html

Example of generating a Poincare plot using the Bokeh backend for interactive visualization.

```python
from bokeh.io import output_notebook
from bokeh.plotting import show
output_notebook()

from systole import import_rr
from systole.plots import plot_poincare

show(
 plot_poincare(rr, input_type="rr_ms", backend="bokeh")
)
```

--------------------------------

### Author and Licence declaration

Source: https://legrandnico.github.io/systole/_sources/auto_examples/Artefacts/plot_ArtefactsDetection.rst.txt

Initial metadata for the script.

```Python

# Author: Nicolas Legrand <nicolas.legrand@cas.au.dk>
# Licence: GPL v3
```
Tokens:
Raw