diff --git a/.codecov.yml b/.codecov.yml
new file mode 100644
index 0000000..bd646db
--- /dev/null
+++ b/.codecov.yml
@@ -0,0 +1,5 @@
+coverage:
+ status:
+ patch:
+ default:
+ enabled: false
diff --git a/.github/workflows/test-matrix.yml b/.github/workflows/test-matrix.yml
new file mode 100644
index 0000000..225b6b3
--- /dev/null
+++ b/.github/workflows/test-matrix.yml
@@ -0,0 +1,29 @@
+name: Platform compatibility test
+
+on:
+ workflow_dispatch:
+
+jobs:
+ test:
+ name: Test on ${{ matrix.os }}
+ runs-on: ${{ matrix.os }}
+ strategy:
+ matrix:
+ os: [ubuntu-latest, windows-latest, macos-latest]
+
+ steps:
+ - uses: actions/checkout@v3
+
+ - name: Set up Python
+ uses: actions/setup-python@v4
+ with:
+ python-version: "3.10"
+
+ - name: Install dependencies
+ run: |
+ python -m pip install --upgrade pip
+ pip install -e .
+ pip install .[test]
+
+ - name: Run tests
+ run: pytest
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..ca66e84
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,44 @@
+name: Run Finitewave tests
+
+on:
+ push:
+ branches:
+ - main
+ - develop
+ pull_request:
+ branches:
+ - main
+ - develop
+
+jobs:
+ test:
+ runs-on: ubuntu-latest
+
+ env:
+ NUMBA_DISABLE_JIT: "1"
+
+ steps:
+ - uses: actions/checkout@v3
+
+ - name: Set up Python
+ uses: actions/setup-python@v4
+ with:
+ python-version: "3.10"
+
+ - name: Install dependencies
+ run: |
+ python -m pip install --upgrade pip
+ pip install -e .
+ pip install pytest pytest-cov
+
+ - name: Run tests with coverage
+ run: |
+ pytest --cov=./finitewave --cov-report=term --cov-report=xml
+
+ - name: Upload coverage to Codecov
+ uses: codecov/codecov-action@v3
+ with:
+ files: ./coverage.xml
+ fail_ci_if_error: true
+ token: ${{ secrets.CODECOV_TOKEN }}
+ slug: finitewave/Finitewave
diff --git a/.gitignore b/.gitignore
index 6a7378a..9e0f4e8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,6 +23,7 @@ var/
.installed.cfg
*.egg
.DS_Store
+auto_examples/
# PyInstaller
# Usually these files are written by a python script from a template
@@ -49,6 +50,7 @@ coverage.xml
.pytest_cache/
# Jupyter Notebook
+playground.ipynb
.ipynb_checkpoints
# pyenv
@@ -107,11 +109,12 @@ docs/_build/
.coverage.*
# Images
-*.png
+# *.png
*.jpg
*.jpeg
# *.gif
-*.svg
+# *.svg
+*.zip
# ffmpeg output
*.mp4
diff --git a/README.md b/README.md
deleted file mode 100755
index 0e8ec14..0000000
--- a/README.md
+++ /dev/null
@@ -1,222 +0,0 @@
-# Finitewave
-
-**Finitewave** is a Python package for simulating cardiac electrophysiology using finite-difference methods. It provides tools for modeling and visualizing the propagation of electrical waves in cardiac tissue, making it ideal for researchers and engineers in computational biology, bioengineering, and related fields.
-
-
-
-
-
-
-### Why Finitewave?
-
-Because of its simplicity and availability. Finitewave is the most simple and user-friendly framework for cardiac simulation, supporting a rich set of tools that make it accessible to both beginners and advanced users alike.
-
-## Features
-
-- Simulate 2D and 3D cardiac tissue models, including the ability to handle complex geometries.
-- Simulate conditions such as fibrosis and infarction.
-- Built-in models, including the Aliev-Panfilov, TP06, Luo-Rudy91 models.
-- Trackers for measuring various aspects of the simulation (such as activation time or EGMs)
-- Visualization tools for analyzing wave propagation.
-- Customize simulation parameters to suit specific research needs.
-- High-performance computing with support for GPU acceleration (currently under development).
-
-## Installation
-
-To install Finitewave, navigate to the root directory of the project and run:
-
-```sh
-python -m build
-pip install dist/finitewave-.whl
-```
-
-This will install Finitewave as a Python package on your system.
-
-For development purposes, you can install the package in an editable mode, which allows changes to be immediately reflected without reinstallation:
-
-```sh
-pip install -e .
-```
-
-## Requirements
-
-| Dependency | Version\* | Link |
-| ---------- | --------- | --------------------------- |
-| numpy | 1.26.4 | https://numpy.org |
-| numba | 0.59.0 | https://numba.pydata.org |
-| scipy | 1.11.4 | https://scipy.org |
-| matplotlib | 3.8.3 | https://matplotlib.org |
-| tqdm | 4.65.0 | https://github.com/tqdm |
-| pyvista | 0.44.1 | https://pyvista.org |
-
-*Versions listed are the most recent tested versions.
-
-If you want to use the AnimationBuilder to create MP4 animations,
-ensure that ffmpeg is installed on your system.
-
-## Quick Start
-
-Here's a simple example to get you started:
-
-```python
-import finitewave as fw
-
-n = 100
-
-# Initialize a 100x100 mesh with all nodes set to 1 (1 = cardiomyocytes, healthy cardiac tissue)
-tissue = fw.CardiacTissue2D([n, n])
-tissue.mesh = np.ones([n, n])
-tissue.add_boundaries() # Add empty nodes (0) at the mesh edges
-
-# Use Aliev-Panfilov model to perform simulation
-aliev_panfilov = fw.AlievPanfilov2D()
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01 # time step
-aliev_panfilov.dr = 0.25 # space step
-aliev_panfilov.t_max = 5 # simulation time
-
-# Set up stimulation parameters (activation from a line of nodes in the mesh)
-stim_sequence = fw.StimSequence()
-# activation time, activation value (voltage model values), stimulation area geometry - line with length n and width 3 (0, n, 0, 3)
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, n, 0, 3))
-# Assign the tissue and stimulation parameters to the model
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-
-aliev_panfilov.run()
-
-# Display the potential map at the end of the simulation
-plt.imshow(aliev_panfilov.u)
-plt.show()
-```
-
-## Minimal script requirements
-
-To create a simulation script using Finitewave, ensure you include the following minimal set of components:
-
-CardiacTissue:
--> Set up the mesh, fibers array, stencil, and conductivity array.
-- `mesh`: Ensure that every mesh contains a border line of empty nodes (boundary). Use the add_boundaries() method to easily add these boundary nodes.
-- `stencil`: Choose between a 9-point stencil (anisotropic) or a 5-point stencil (orthotropic or isotropic). The stencil calculates weights for the divergence kernels. While the 9-point stencil is general-purpose, using the 5-point stencil is more performance-efficient in orthotropic and isotropic diffusion cases.
-- `conductivity`: This array of coefficients (default: 1) to simulate propagation speed. This is the simplest (but not the only) way to model fibrotic tissue.
-
-Model Setup:
-- Create and configure the model with a minimal set of parameters: **dt** (time step), **dr** (spatial step), and **t_max** (maximum simulation time).
-
-Stimulation Parameters:
-- Use `Stim` classes to define the stimulation area and add them to the StimSequence class object. For example (for 2D simulations):
-- - `StimVoltageCoord2D`: [stim_time, voltage, x0, x1, y0, y1]
-- - `StimCurrentCoord2D`: [stim_time, current, current_time, x0, x1, y0, y1]
-- Run the simulation using the `run()` method.
-
-## Quick Tutorial
-
-For detailed information and practical examples, please refer to the `examples/` folder.
-
-Currently, we explicitly use 2D and 3D versions of the Finitewave class objects. This means that most of the classes you encounter in the scripts will have either `2D` or `3D` appended to their names.
-
-### Cardiac Tissue
-
-The `CardiacTissue` class is used to represent myocardial tissue and its structural properties in simulations. It includes several key attributes that define the characteristics and behavior of the cardiac mesh used in finite-difference calculations.
-
-#### Mesh
-
-The `mesh` attribute is a finite-difference mesh consisting of nodes, which represent the myocardial structure. The distance between neighboring nodes is defined by the spatial step (**dr**) parameter of the model. The nodes in the mesh are used to represent different types of tissue and their properties:
-
-- `0`: Empty node, representing the absence of cardiac tissue.
-- `1`: Healthy cardiac tissue, which supports wave propagation.
-- `2`: Fibrotic or infarcted tissue, representing damaged or non-conductive areas.
-Nodes marked as `0` and `2` are treated similarly as isolated nodes with no flux through their boundaries. These different notations help distinguish between areas of healthy tissue, empty spaces, and regions of fibrosis or infarction.
-
-To satisfy boundary conditions, every Finitewave mesh must include boundary nodes (marked as `0`). This can be easily achieved using the `add_boundaries()` method, which automatically adds rows of empty nodes around the edges of the mesh.
-
-You can also utilize `0` nodes to define complex geometries and pathways, or to model organ-level structures. For example, to simulate the electrophysiological activity of the heart, you can create a 3D array where `1` represents cardiac tissue, and `0` represents everything outside of that geometry.
-
-#### Fibers
-
-Another important attribute, `fibers`, is used to define the anisotropic properties of cardiac tissue. This attribute is represented as a 3D array (for 2D tissue) or a 4D array (for 3D tissue), with each node containing a 2D or 3D vector that specifies the fiber orientation at that specific position. The anisotropic properties of cardiac tissue mean that the wave propagation speed varies depending on the fiber orientation. Typically, the wave speed is three times faster along the fibers compared to across the fibers, which can be set by adjusting the diffusion coefficients ratio (**D_al/D_ac**) to 9.
-
-#### Conductivity
-
-The conductivity attribute defines the local conductivity of the tissue and is represented as an array of coefficients ranging from **0.0** to **1.0** for each node in the mesh. It proportionally decreases the diffusion coefficient locally, thereby slowing down the wave propagation in specific areas defined by the user. This is useful for modeling heterogeneous tissue properties, such as regions of impaired conduction due to ischemia or fibrosis.
-
-### Built-in Models
-
-Finitewave currently includes three built-in models for 2D and 3D simulations. Each model represents the cardiac electrophysiological activity of a single cell, which can be combined using parabolic equations to form complex 2D or 3D cardiac tissue models.
-
-We use an explicit finite-difference scheme, which requires maintaining an appropriate **dt/dr** ratio. The recommended calculation parameters for time and space steps are **dt** = 0.01 and **dr** = 0.25. You can increase **dt** to 0.02 to speed up calculations, but always verify the stability of your numerical scheme, as instability will lead to incorrect simulation results.
-
-| Model | Description |
-| -------------- | ------------------------------------------------------------- |
-| Aliev-Panfilov | A phenomenological two-variable model for cardiac simulations |
-| Luo-Rudy 1991 | An ionic model for cardiac simulations |
-| TP06 | An ionic model for cardiac simulations |
-
-### Trackers
-
-Trackers are one of the key features of Finitewave. They allow you to measure a wide range of data during a simulation. Multiple trackers can be used simultaneously by adding them to the `TrackerSequence` class.
-
-Here is a list of the currently implemented trackers:
-
-| Tracker | Description |
-| --------------------- | ----------------------------------------------------------------------------- |
-| Activation Time | Measures the time of the first wave arrival at each mesh node. |
-| Animation | Creates model snapshots of selected variables, which can be used to build animations. |
-| ECG | Measures ECG at specific positions. |
-| Multi-Activation Time | Measures the time of multiple wave arrivals at each mesh node. |
-| Multi-Variable | Measures the dynamics of variables at specific nodes. |
-| Period | Measures the period of wave dynamics (e.g., spiral waves). |
-| Period Map | Measures period dynamics at mesh nodes and creates snapshots. |
-| Tips | Tracks spiral wave tip trajectories. |
-| Velocity | Measures the velocity of planar waves. |
-
-### Stimulations
-
-There are two basic options to stimulate electrophysiological activity in cardiac tissue using Finitewave.
-
-1. **Voltage Stimulation**: This method directly sets voltage values at the nodes within the stimulation area, triggering wave propagation from this region.
-2. **Current Stimulation**: In this method, you apply a current value and stimulation duration to accumulate potential, leading to wave propagation. Current stimulation offers more flexibility and is more physiologically accurate, as it simulates the activity of external electrodes.
-
-An important parameter is the **area of stimulation**. You can choose between a simple rectangular stimulation class (as shown in the Quick Start section) or a flexible matrix stimulation that allows you to define stimulation areas as a Boolean array, where `True` values indicate nodes to be stimulated.
-
-You can simulate a sequence of stimulations (e.g., a high-pacing protocol) by adding multiple stimulations to the `StimulationTracker` class.
-
-**Note**: A very small stimulation area may lead to unsuccessful stimulation due to a source-sink mismatch.
-
-
-## Package structure
-
-*/finitewave*
-
-Core package source code.
-
-*/examples*
-
-Scripts demonstrating various functionalities of the Finitewave package.
-
-*/tests*
-
-Unit tests to ensure the correctness and reliability of the package.
-
-## Running tests
-
-To run tests, you can use the following command, for example, to test the 2D Aliev-Panfilov model:
-
-```sh
-python -m unittest test_aliev_panfilov_2d.py
-```
-
-## Contribution
-
-Contributions are welcome!
-
-### How to Contribute
-- Fork the repository
-- Create a new branch (`git checkout -b feature-branch`)
-- Commit your changes (`git commit -m 'Add new feature'`)
-- Push to the branch (`git push origin feature-branch`)
-- Open a Pull Request
-
-## License
-
-This project is licensed under the MIT License. See the LICENSE file for details.
diff --git a/README.rst b/README.rst
new file mode 100644
index 0000000..2f750e0
--- /dev/null
+++ b/README.rst
@@ -0,0 +1,471 @@
+.. _finitewave:
+
+Finitewave
+===========
+
+.. image:: https://img.shields.io/github/license/finitewave/Finitewave
+ :target: https://github.com/finitewave/Finitewave/blob/main/LICENSE
+ :alt: License
+
+.. image:: https://github.com/finitewave/Finitewave/actions/workflows/test.yml/badge.svg?branch=develop
+ :target: https://github.com/finitewave/Finitewave/actions/workflows/test.yml
+ :alt: Test status
+
+.. image:: https://codecov.io/gh/finitewave/Finitewave/branch/develop/graph/badge.svg
+ :target: https://codecov.io/gh/finitewave/Finitewave
+ :alt: Code coverage
+
+Python package for simulating cardiac electrophysiology using
+finite-difference methods. It provides tools for modeling and visualizing the
+propagation of electrical waves in cardiac tissue, making it ideal for
+researchers and engineers in computational biology, bioengineering, and
+related fields.
+
+.. list-table::
+ :widths: auto
+ :align: center
+
+ * - .. image:: images/spiral_wave_fib.gif
+ :width: 200px
+ :alt: Image 1
+ - .. image:: images/spiral_wave_slab.gif
+ :width: 267px
+ :alt: Image 2
+ - .. image:: images/spiral_wave_lv.gif
+ :width: 220px
+ :alt: Image 3
+
+Installation
+============
+
+To install Finitewave, navigate to the root directory of the project and run:
+
+.. code-block:: bash
+
+ $ python -m build
+ $ pip install dist/finitewave-.whl
+
+
+This will install Finitewave as a Python package on your system.
+
+For development purposes, you can install the package in an editable mode,
+which allows changes to be immediately reflected without reinstallation:
+
+.. code-block:: bash
+
+ $ pip install -e .
+
+
+Requirements
+------------
+
+Finitewave requires the following dependencies:
+
++-----------------+---------+--------------------------------------------------+
+| Dependency | Version*| Link |
++=================+=========+==================================================+
+| ffmpeg-python | 0.2.0 | https://pypi.org/project/ffmpeg-python/ |
++-----------------+---------+--------------------------------------------------+
+| matplotlib | 3.9.2 | https://pypi.org/project/matplotlib/ |
++-----------------+---------+--------------------------------------------------+
+| natsort | 8.4.0 | https://pypi.org/project/natsort/ |
++-----------------+---------+--------------------------------------------------+
+| numba | 0.60.0 | https://pypi.org/project/numba/ |
++-----------------+---------+--------------------------------------------------+
+| numpy | 1.26.4 | https://pypi.org/project/numpy/ |
++-----------------+---------+--------------------------------------------------+
+| pandas | 2.2.3 | https://pypi.org/project/pandas/ |
++-----------------+---------+--------------------------------------------------+
+| pyvista | 0.44.1 | https://pypi.org/project/pyvista/ |
++-----------------+---------+--------------------------------------------------+
+| scikit-image | 0.24.0 | https://pypi.org/project/scikit-image/ |
++-----------------+---------+--------------------------------------------------+
+| scipy | 1.14.1 | https://pypi.org/project/scipy/ |
++-----------------+---------+--------------------------------------------------+
+| tqdm | 4.66.5 | https://pypi.org/project/tqdm/ |
++-----------------+---------+--------------------------------------------------+
+
+*minimal version
+
+Quick start
+===================
+
+This quick start guide will walk you through the basic steps of setting up a
+simple cardiac simulation using Finitewave. We will create a 2D mesh of
+cardiac tissue, define the tissue properties, set up a model, apply
+stimulation, and run the simulation.
+
+.. contents:: Table of Contents
+ :local:
+ :depth: 3
+
+Cardiac Tissue
+----------------
+
+The ``CardiacTissue`` class is used to represent myocardial tissue and its
+structural properties in simulations. It includes several key attributes that
+define the characteristics and behavior of the cardiac mesh used in
+finite-difference calculations.
+
+First, import the necessary libraries:
+
+.. code-block:: Python
+
+ import finitewave as fw
+ import numpy as np
+ import matplotlib.pyplot as plt
+
+
+Initialize a 100x100 mesh with all nodes set to 1 (healthy cardiac tissue).
+Add empty nodes (0) at the mesh edges to simulate boundaries.
+
+.. code-block:: Python
+
+ n = 100
+ tissue = fw.CardiacTissue2D([n, n])
+
+Mesh
+""""
+
+The ``mesh`` attribute is a mesh consisting of nodes, which
+represent the myocardial medium. The distance between neighboring nodes is
+defined by the spatial step (``dr``) parameter of the model. The nodes in the
+mesh are used to represent different types of tissue and their properties:
+
+* ``0``: Empty node, representing the absence of cardiac tissue.
+* ``1``: Healthy cardiac tissue, which supports wave propagation.
+* ``2``: Fibrotic or infarcted tissue, representing damaged or non-conductive areas.
+
+Nodes marked as ``0`` and ``2`` are treated similarly as isolated nodes with no
+flux through their boundaries. These different notations help distinguish
+between areas of healthy tissue, empty spaces, and regions of fibrosis or
+infarction.
+
+.. note::
+
+ To satisfy boundary conditions, every Finitewave mesh must include boundary
+ nodes (marked as ``0``). This can be easily achieved using the
+ ``add_boundaries()`` method, which automatically adds rows of empty nodes
+ around the edges of the mesh. You should apply this method if you modify the
+ ``mesh``, for example by adding fibrosis.
+
+You can also utilize ``0`` nodes to define complex geometries and pathways,
+or to model organ-level structures. For example, to simulate the
+electrophysiological activity of the heart, you can create a 3D array
+where ``1`` represents cardiac tissue, and ``0`` represents everything outside
+of that geometry.
+
+Conductivity
+""""""""""""
+
+The conductivity attribute defines the local conductivity of the tissue and is
+represented as an array of coefficients ranging from ``0.0`` to ``1.0`` for
+each node in the mesh. It proportionally decreases the diffusion coefficient
+locally, thereby slowing down the wave propagation in specific areas defined
+by the user. This is useful for modeling heterogeneous tissue properties,
+such as regions of impaired conduction due to ischemia or fibrosis.
+
+.. code-block:: Python
+
+ # Set conductivity to 0.5 in the middle of the mesh
+ tissue.conductivity = np.ones([n, n])
+ tissue.conductivity[n//4: 3 * n//4, n//4: 3 * n//4] = 0.5
+
+Fibers
+""""""
+
+Another important attribute, ``fibers``, is used to define the anisotropic
+properties of cardiac tissue. This attribute is represented as a 3D array
+(for 2D tissue) or a 4D array (for 3D tissue), with each node containing a 2D
+or 3D vector that specifies the fiber orientation at that specific position.
+The anisotropic properties of cardiac tissue mean that the wave propagation
+speed varies depending on the fiber orientation.
+
+.. code-block:: Python
+
+ # Fibers orientated along the x-axis
+ tissue.fibers = np.zeros([n, n, 2])
+ tissue.fibers[:, :, 0] = 1
+ tissue.fibers[:, :, 1] = 0
+
+Cardiac Models
+----------------
+
+Each model represents the cardiac electrophysiological activity of a single
+cell, which can be combined using parabolic equations to form complex 2D or 3D
+cardiac tissue models.
+
+.. code-block:: Python
+
+ # Set up Aliev-Panfilov model to perform simulations
+ aliev_panfilov = fw.AlievPanfilov2D()
+ aliev_panfilov.dt = 0.01 # time step
+ aliev_panfilov.dr = 0.25 # space step
+ aliev_panfilov.t_max = 10 # simulation time
+
+We use an explicit finite-difference scheme, which requires maintaining an
+appropriate ``dt/dr`` ratio. For phenomenological models, the recommended
+calculation parameters for time and space steps are ``dt = 0.01`` and
+``dr = 0.25``. You can increase ``dt`` to ``0.02`` to speed up calculations,
+but always verify the stability of your numerical scheme, as instability will
+lead to incorrect simulation results.
+
+Available models
+"""""""""""""""""""""""""""
+
+Currently, finitewave includes eight built-in models for 2D and 3D simulations,
+but you can easily add your own models by extending the base class and
+implementing the necessary methods.
+
++--------------------+---------------------------------------------------------------+
+| Model | Description |
++====================+===============================================================+
+| Aliev-Panfilov | A phenomenological two-variable model |
++--------------------+---------------------------------------------------------------+
+| Barkley | A simple reaction-diffusion model |
++--------------------+---------------------------------------------------------------+
+| Mitchell-Schaeffer | A phenomenological two-variable model |
++--------------------+---------------------------------------------------------------+
+| Fentom-Karma | A phenomenological three-variables model |
++--------------------+---------------------------------------------------------------+
+| Bueno-Orovio | A minimalistic ventricular model |
++--------------------+---------------------------------------------------------------+
+| Luo-Rudy 1991 | An ionic ventricular guinea pig model |
++--------------------+---------------------------------------------------------------+
+| TP06 | An ionic ventricular human model |
++--------------------+---------------------------------------------------------------+
+| Courtemanche | An ionic atrial human model |
++--------------------+---------------------------------------------------------------+
+
+Stimulations
+------------
+
+To simulate the electrical activity of the heart, you need to apply a stimulus
+to the tissue. This can be done by setting the voltage or current at specific
+nodes in the mesh.
+
+Voltage Stimulation
+"""""""""""""""""""
+
+``StimVoltage`` class allows directly sets voltage values at the nodes within
+the stimulation area, triggering wave propagation from this region.
+
+.. code-block:: Python
+
+ stim_voltage = fw.StimVoltageCoord2D(time=0,
+ volt_value=1,
+ x1=1, x2=n-1, y1=1, y2=3)
+
+Current Stimulation
+"""""""""""""""""""
+
+``StimCurrent`` class allows you to apply a current value and stimulation
+duration to accumulate potential, leading to wave propagation. Current
+stimulation offers more flexibility and is more physiologically accurate, as
+it simulates the activity of external electrodes.
+
+.. code-block:: Python
+
+ stim_current = fw.StimCurrentCoord2D(time=0,
+ curr_value=5,
+ curr_time=1,
+ x1=1, x2=n-1, y1=1, y2=3)
+
+Stimulation Matrix
+"""""""""""""""""""
+
+By default, the stimulation area is defined as a rectangle
+(``x1:x2, y1:y2, [z1:z2]``), but you can also define a custom Boolean array to
+specify the nodes to be stimulated. This allows you to create complex
+stimulation patterns.
+
+.. code-block:: Python
+
+ # Stimulate a 6x6 area in the middle of the mesh
+ stim_matrix = np.zeros([n, n], dtype=bool)
+ stim_matrix[n//2 - 3: n//2 + 3 , n//2 - 3: n//2 + 3] = True
+ stim_current_matrix = fw.StimCurrentMatrix2D(time=0,
+ curr_value=0.15,
+ curr_time=1,
+ matrix=stim_matrix))
+
+.. note::
+
+ A very small stimulation area may lead to unsuccessful stimulation
+ due to a source-sink mismatch.
+
+Stimulation Sequence
+"""""""""""""""""""""
+
+The ``CardiacModel`` class uses the ``StimSequence`` class to manage the
+stimulation sequence. This class allows you to add multiple stimulations to
+the model, which can be useful for simulating complex stimulation protocols
+(e.g., a high-pacing protocol).
+
+.. code-block:: Python
+
+ stim_sequence = fw.StimSequence()
+
+ for i in range(0, 100, 10):
+ stim_sequence.add_stim(fw.StimVoltageCoord2D(time=i,
+ volt_value=1,
+ x1=1, x2=n-1, y1=1, y2=3))
+
+Trackers
+--------
+
+Trackers are used to record the state of the model during the simulation. They
+can be used to monitor the wavefront propagation, visualize the activation
+times, or analyze the wavefront dynamics. Full details on how to use trackers
+can be found in the documentation and examples.
+
+.. code-block:: Python
+
+ # set up activation time tracker:
+ act_time_tracker = fw.ActivationTime2DTracker()
+ act_time_tracker.threshold = 0.5
+ act_time_tracker.step = 100 # calculate activation time every 100 steps
+
+
+Tracker Parameters
+""""""""""""""""""
+
+Trackers have several parameters that can be adjusted to customize their
+behavior:
+
+* ``start_time``: The time at which the tracker starts recording data.
+* ``end_time``: The time at which the tracker stops recording data.
+* ``step``: The number of steps between each data recording.
+
+.. note::
+
+ The ``step`` parameter is used to control the *frequency* of data
+ recording (should be ``int``). But the ``start_time`` and ``end_time``
+ parameters are used to specify the *time* interval during which the tracker
+ will record data.
+
+The ``output`` property of the tracker class returns the formatted data
+recorded during the simulation. This data can be used for further analysis
+or visualization.
+
+Each tracker has its own set of parameters that can be adjusted to customize
+its behavior. For example, the ``ActivationTime2DTracker`` class has a
+``threshold`` parameter that defines the activation threshold for the nodes.
+
+Multiple Trackers
+"""""""""""""""""
+
+The ``CardiacModel`` class uses the ``TrackerSequence`` class to manage the
+trackers. This class allows you to add multiple trackers to the model to
+monitor different aspects of the simulation. For example, you can track the
+activation time for all nodes, and the action potential for a specific node.
+
+.. code-block:: Python
+
+ # set up first activation time tracker:
+ act_time_tracker = fw.ActivationTime2DTracker()
+ act_time_tracker.threshold = 0.5
+ act_time_tracker.step = 100 # calculate activation time every 100 steps
+
+ # set up action potential tracker for a specific node:
+ action_pot_tracker = fw.ActionPotential2DTracker()
+ action_pot_tracker.cell_ind = [30, 30]
+
+ tracker_sequence = fw.TrackerSequence()
+ tracker_sequence.add_tracker(act_time_tracker)
+ tracker_sequence.add_tracker(action_pot_tracker)
+
+
+Building pipeline
+-----------------
+
+Now that we have all the necessary components, we can build the simulation
+pipeline by setting the tissue, model, stimulations, and trackers.
+
+.. code-block:: Python
+
+ aliev_panfilov.cardiac_tissue = tissue
+ aliev_panfilov.stim_sequence = stim_sequence
+ aliev_panfilov.tracker_sequence = tracker_sequence
+
+Finitewave contains other functionalities that can be used to customize the
+simulation pipeline, such as loading and saving model states or adding custom
+commands to the simulation loop. For more information, refer to the full
+documentation.
+
+
+Run the simulation
+""""""""""""""""""
+
+Finally, we can run the simulation by calling the ``run()`` method of the
+``AlievPanfilov2D`` model.
+
+.. code-block:: Python
+
+ aliev_panfilov.run()
+
+ plt.imshow(aliev_panfilov.u, cmap='coolwarm')
+ plt.show()
+
+
+Simplified pipeline
+-------------------
+
+Here is a simplified version of the simulation pipeline that combines all the
+steps described above:
+
+.. code:: Python
+
+ import numpy as np
+ import matplotlib.pyplot as plt
+ import finitewave as fw
+
+ # set up the tissue:
+ n = 100
+ tissue = fw.CardiacTissue2D([n, n])
+ # set up the stimulation:
+ stim_sequence = fw.StimSequence()
+ stim_sequence.add_stim(fw.StimVoltageCoord2D(time=0,
+ volt_value=1,
+ x1=1, x2=n-1, y1=1, y2=3))
+ # set up the tracker:
+ act_time_tracker = fw.ActivationTime2DTracker()
+ act_time_tracker.threshold = 0.5
+ act_time_tracker.step = 100
+
+ tracker_sequence = fw.TrackerSequence()
+ tracker_sequence.add_tracker(act_time_tracker)
+
+ # set up the model
+ aliev_panfilov = fw.AlievPanfilov2D()
+ aliev_panfilov.dt = 0.01
+ aliev_panfilov.dr = 0.25
+ aliev_panfilov.t_max = 10
+
+ # set up pipeline
+ aliev_panfilov.cardiac_tissue = tissue
+ aliev_panfilov.stim_sequence = stim_sequence
+ aliev_panfilov.tracker_sequence = tracker_sequence
+
+ # run model
+ aliev_panfilov.run()
+
+ # show output
+ fig, axs = plt.subplots(ncols=2)
+ axs[0].imshow(aliev_panfilov.u, cmap='coolwarm')
+ axs[0].set_title("u")
+
+ axs[1].imshow(act_time_tracker.output, cmap='viridis')
+ axs[1].set_title("Activation time")
+
+ fig.suptitle("Aliev-Panfilov 2D isotropic")
+ plt.tight_layout()
+ plt.show()
+
+.. The output should look like this:
+
+.. .. image-sg:: /usage/images/quick_start_001.png
+.. :alt: Aliev-Panfilov 2D model
+.. :srcset: /usage/images/quick_start_001.png
+.. :class: sphx-glr-single-img
+
diff --git a/Tutorials/Anisotropy2D.ipynb b/Tutorials/Anisotropy2D.ipynb
new file mode 100644
index 0000000..46008ce
--- /dev/null
+++ b/Tutorials/Anisotropy2D.ipynb
@@ -0,0 +1,477 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Anisotropy in 2D\n",
+ "\n",
+ "This tutorial demonstrates how fiber rotation affects the speed of the wave in\n",
+ "different directions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running AlievPanfilov2D: 100%|█████████▉| 2499/2500 [00:01<00:00, 2025.97it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 2499/2500 [00:01<00:00, 2001.84it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 2499/2500 [00:01<00:00, 2063.55it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 2499/2500 [00:01<00:00, 2068.86it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 2499/2500 [00:01<00:00, 2048.25it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 2499/2500 [00:01<00:00, 2106.63it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 2499/2500 [00:01<00:00, 2112.29it/s]\n"
+ ]
+ }
+ ],
+ "source": [
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import skimage as ski\n",
+ "import pandas as pd\n",
+ "\n",
+ "import finitewave as fw\n",
+ "\n",
+ "\n",
+ "# number of nodes on the side\n",
+ "n = 400\n",
+ "\n",
+ "alphas = np.radians(np.arange(0, 91, 15))\n",
+ "out = []\n",
+ "images = []\n",
+ "for alpha in alphas:\n",
+ " tissue = fw.CardiacTissue2D([n, n])\n",
+ " # add fibers orientation vectors\n",
+ " tissue.fibers = np.zeros([n, n, 2])\n",
+ " tissue.fibers[..., 0] = np.cos(alpha)\n",
+ " tissue.fibers[..., 1] = np.sin(alpha)\n",
+ "\n",
+ " # set up stimulation parameters:\n",
+ " stim_sequence = fw.StimSequence()\n",
+ " stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, n//2 - 5, n//2 + 5,\n",
+ " n//2 - 5, n//2 + 5))\n",
+ " \n",
+ " # create model object and set up parameters\n",
+ " model = fw.AlievPanfilov2D()\n",
+ " model.dt = 0.01\n",
+ " model.dr = 0.25\n",
+ " model.t_max = 25\n",
+ " model.cardiac_tissue = tissue\n",
+ " model.stim_sequence = stim_sequence\n",
+ "\n",
+ " model.run()\n",
+ " \n",
+ " # calculate properties of the wave\n",
+ " labeled = (model.u > 0.1).astype(int)\n",
+ " props = ski.measure.regionprops_table(labeled, properties=(\n",
+ " 'orientation', 'major_axis_length', 'minor_axis_length'))\n",
+ " props['orientation'] = np.degrees(props['orientation'])\n",
+ " props['axis_ratio'] = props['major_axis_length'] / props['minor_axis_length']\n",
+ " props['alpha'] = np.degrees(alpha)\n",
+ " props['density_calc'] = (np.sum(tissue.mesh[-1:1, -1:1] == 2) \n",
+ " / ((n - 2) * (n - 2)))\n",
+ " images.append(model.u.copy())\n",
+ "\n",
+ " out.append(pd.DataFrame(props))\n",
+ "\n",
+ "out = pd.concat(out)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Show the Wave Anisotropy and Properties\n",
+ "\n",
+ "This section demonstrates the anisotropy of the wave and its properties, including orientation, major and minor axis lengths, axis ratio, and density calculation. The wave propagation is simulated for different fiber orientations (alpha values) in a 2D cardiac tissue model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "cv_along = out['major_axis_length'] / 2 * model.dr / model.t_max\n",
+ "cv_across = out['minor_axis_length'] / 2 * model.dr / model.t_max\n",
+ "\n",
+ "fig, axs = plt.subplot_mosaic([[f'{i}' for i in range(7)],\n",
+ " ['axis_ratio'] * 3 + ['orientation']*4],\n",
+ " figsize=(14, 7))\n",
+ "\n",
+ "for i in range(len(alphas)):\n",
+ " ax = axs[f'{i}']\n",
+ " ax.imshow(images[i], cmap='jet', origin='lower')\n",
+ " ax.set_title(f'{np.degrees(alphas[i]):.0f}')\n",
+ "\n",
+ "ax = axs['axis_ratio']\n",
+ "ax.plot(out['alpha'], cv_along, 'o-', label='Along')\n",
+ "ax.plot(out['alpha'], cv_across, 'o-', label='Across')\n",
+ "ax.set_xlabel('alpha')\n",
+ "ax.set_ylabel('CV')\n",
+ "ax.set_xticks(np.degrees(alphas))\n",
+ "ax.grid(True)\n",
+ "ax.legend()\n",
+ "\n",
+ "ax = axs['orientation']\n",
+ "ax.plot(out['alpha'], out['orientation'], 'o-')\n",
+ "ax.set_xlabel('alpha')\n",
+ "ax.set_ylabel('orientation')\n",
+ "ax.set_xticks(np.degrees(alphas))\n",
+ "ax.set_yticks(np.degrees(alphas))\n",
+ "ax.grid(True)\n",
+ "\n",
+ "plt.tight_layout()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Effect of Fibrosis on Anisotropy\n",
+ "\n",
+ "This section explores the impact of fibrosis on the anisotropy of wave propagation in cardiac tissue. By introducing fibrosis into the tissue model, we can observe changes in wave speed and directionality. The simulations are performed for different fiber orientations (alpha values), and the resulting wave properties, such as orientation, axis lengths, and axis ratios, are analyzed to understand the effects of fibrosis on anisotropy."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running AlievPanfilov2D: 100%|█████████▉| 2999/3000 [00:00<00:00, 4383.59it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 2999/3000 [00:00<00:00, 4656.39it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 2999/3000 [00:00<00:00, 4415.98it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 2999/3000 [00:00<00:00, 4608.57it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 2999/3000 [00:00<00:00, 4650.29it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 2999/3000 [00:00<00:00, 4651.00it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 2999/3000 [00:00<00:00, 4654.99it/s]\n"
+ ]
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import skimage as ski\n",
+ "import pandas as pd\n",
+ "\n",
+ "import finitewave as fw\n",
+ "\n",
+ "# number of nodes on the side\n",
+ "n = 256\n",
+ "\n",
+ "alphas = np.radians(np.arange(0, 91, 15))\n",
+ "d = 0.2 # 20% of the tissue is fibrotic\n",
+ "out_fib = []\n",
+ "images_fib = []\n",
+ "for alpha in alphas:\n",
+ " tissue = fw.CardiacTissue2D([n, n])\n",
+ " tissue.add_pattern(fw.Diffuse2DPattern(d))\n",
+ " # add fibers orientation vectors\n",
+ " tissue.fibers = np.zeros([n, n, 2])\n",
+ " tissue.fibers[..., 0] = np.cos(alpha)\n",
+ " tissue.fibers[..., 1] = np.sin(alpha)\n",
+ "\n",
+ " # set up stimulation parameters:\n",
+ " stim_sequence = fw.StimSequence()\n",
+ " stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, n//2 - 5, n//2 + 5,\n",
+ " n//2 - 5, n//2 + 5))\n",
+ " \n",
+ " # create model object:\n",
+ " model = fw.AlievPanfilov2D()\n",
+ " # set up numerical parameters:\n",
+ " model.dt = 0.01\n",
+ " model.dr = 0.25\n",
+ " model.t_max = 30\n",
+ " model.cardiac_tissue = tissue\n",
+ " model.stim_sequence = stim_sequence\n",
+ "\n",
+ " model.run()\n",
+ "\n",
+ " labeled = (model.u > 0.5).astype(int)\n",
+ " props = ski.measure.regionprops_table(\n",
+ " labeled, properties=('orientation', 'major_axis_length',\n",
+ " 'minor_axis_length'))\n",
+ " props['orientation'] = np.degrees(props['orientation'])\n",
+ " props['axis_ratio'] = props['major_axis_length'] / props['minor_axis_length']\n",
+ " props['alpha'] = np.degrees(alpha)\n",
+ " props['density_calc'] = (np.sum(tissue.mesh[-1:1, -1:1] == 2) \n",
+ " / ((n - 2) * (n - 2)))\n",
+ " images_fib.append(model.u.copy())\n",
+ "\n",
+ " out_fib.append(pd.DataFrame(props))\n",
+ "\n",
+ "out_fib = pd.concat(out_fib)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "cv_along = out_fib['major_axis_length'] / 2 * model.dr / model.t_max\n",
+ "cv_across = out_fib['minor_axis_length'] / 2 * model.dr / model.t_max\n",
+ "\n",
+ "fig, axs = plt.subplot_mosaic([[f'{i}' for i in range(7)],\n",
+ " ['axis_ratio'] * 2 + ['orientation']*2 +\n",
+ " ['min_max'] * 3],\n",
+ " figsize=(14, 7))\n",
+ "\n",
+ "mins = []\n",
+ "maxs = []\n",
+ "for i in range(len(alphas)):\n",
+ " ax = axs[f'{i}']\n",
+ " ax.imshow(images_fib[i], cmap='jet', origin='lower')\n",
+ " ax.set_title(f'{np.degrees(alphas[i]):.0f}')\n",
+ "\n",
+ " mins.append(images_fib[i].min())\n",
+ " maxs.append(images_fib[i].max())\n",
+ " \n",
+ "\n",
+ "ax = axs['axis_ratio']\n",
+ "ax.plot(out_fib['alpha'], cv_along, 'o-', label='Along')\n",
+ "ax.plot(out_fib['alpha'], cv_across, 'o-', label='Across')\n",
+ "ax.set_xlabel('alpha')\n",
+ "ax.set_ylabel('CV')\n",
+ "ax.set_xticks(np.degrees(alphas))\n",
+ "ax.grid(True)\n",
+ "ax.legend()\n",
+ "\n",
+ "out_fib.loc[out_fib['orientation'] < 0, 'orientation'] += 180\n",
+ "\n",
+ "orientation = out_fib['orientation'].values\n",
+ "orientation[orientation > 90] = 180 - orientation[orientation > 90]\n",
+ "\n",
+ "ax = axs['orientation']\n",
+ "ax.plot(out_fib['alpha'], orientation, 'o-')\n",
+ "ax.set_xlabel('alpha')\n",
+ "ax.set_ylabel('orientation')\n",
+ "ax.set_xticks(np.degrees(alphas))\n",
+ "ax.set_yticks(np.degrees(alphas))\n",
+ "ax.grid(True)\n",
+ "\n",
+ "ax = axs['min_max']\n",
+ "ax.plot(np.degrees(alphas), mins, 'o-', label='min')\n",
+ "ax.plot(np.degrees(alphas), maxs, 'o-', label='max')\n",
+ "ax.set_xlabel('alpha')\n",
+ "ax.set_ylabel('min/max')\n",
+ "ax.set_xticks(np.degrees(alphas))\n",
+ "ax.grid(True)\n",
+ "\n",
+ "plt.tight_layout()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Using TP06 Model\n",
+ "\n",
+ "When using ionic model using smaller step (compared to the calculation without fibers) can be nessesary otherwise the calculation can be unstable."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running TP062D: 100%|█████████▉| 19999/20000 [01:24<00:00, 237.89it/s]\n",
+ "Running TP062D: 100%|█████████▉| 19999/20000 [01:18<00:00, 254.19it/s]\n",
+ "Running TP062D: 100%|█████████▉| 19999/20000 [01:19<00:00, 252.75it/s]\n",
+ "Running TP062D: 100%|█████████▉| 19999/20000 [01:17<00:00, 256.73it/s]\n",
+ "Running TP062D: 100%|█████████▉| 19999/20000 [01:21<00:00, 244.26it/s]\n",
+ "Running TP062D: 100%|█████████▉| 19999/20000 [01:21<00:00, 246.77it/s]\n",
+ "Running TP062D: 100%|█████████▉| 19999/20000 [01:22<00:00, 243.64it/s]\n"
+ ]
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import skimage as ski\n",
+ "import pandas as pd\n",
+ "\n",
+ "import finitewave as fw\n",
+ "\n",
+ "# number of nodes on the side\n",
+ "n = 256\n",
+ "dt = 0.001\n",
+ "dr = 0.1\n",
+ "t_max = 20\n",
+ "\n",
+ "alphas = np.radians(np.arange(0, 91, 15))\n",
+ "d = 0.2\n",
+ "out_lr_fib = []\n",
+ "images_lr_fib = []\n",
+ "for alpha in alphas:\n",
+ " tissue = fw.CardiacTissue2D([n, n])\n",
+ " tissue.add_pattern(fw.Diffuse2DPattern(d))\n",
+ " # add fibers orientation vectors\n",
+ " tissue.fibers = np.zeros([n, n, 2])\n",
+ " tissue.fibers[..., 0] = np.cos(alpha)\n",
+ " tissue.fibers[..., 1] = np.sin(alpha)\n",
+ "\n",
+ " # set up stimulation parameters:\n",
+ " stim = fw.StimCurrentArea2D(0, 200, 1)\n",
+ " stim.add_stim_point([n//2, n//2], tissue.mesh, 5)\n",
+ " stim_sequence = fw.StimSequence()\n",
+ " stim_sequence.add_stim(stim)\n",
+ "\n",
+ " # create model object:\n",
+ " model = fw.TP062D()\n",
+ " # set up numerical parameters:\n",
+ " model.dt = dt\n",
+ " model.dr = dr\n",
+ " model.t_max = t_max\n",
+ " model.cardiac_tissue = tissue\n",
+ " model.stim_sequence = stim_sequence\n",
+ "\n",
+ " model.run()\n",
+ "\n",
+ " labeled = (model.u > 0.).astype(int)\n",
+ " props = ski.measure.regionprops_table(\n",
+ " labeled, properties=('orientation', 'major_axis_length',\n",
+ " 'minor_axis_length'))\n",
+ " props['orientation'] = np.degrees(props['orientation'])\n",
+ " props['axis_ratio'] = props['major_axis_length'] / props['minor_axis_length']\n",
+ " props['alpha'] = np.degrees(alpha)\n",
+ " props['density_calc'] = (np.sum(tissue.mesh[-1:1, -1:1] == 2) \n",
+ " / ((n - 2) * (n - 2)))\n",
+ " images_lr_fib.append(model.u.copy())\n",
+ "\n",
+ " out_lr_fib.append(pd.DataFrame(props))\n",
+ "\n",
+ "out_lr_fib = pd.concat(out_lr_fib)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABW0AAAJjCAYAAAB3OjNNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydf5xPVf7Hnx9mmDHMtCPMd/yKmqIdkfyqph1LiKSMpUZjURSZImPN+pGfpWVTbIqiaM2ajRC1RGsyG0WsxpqiFPmZH5ltZBjNcL9/nLlcxzn33s/QNrvO6/GYx3w+955f93zOOe/3+/V+n3MDlmVZGBgYGBgYGBgYGBgYGBgYGBgYGBgYlAmU+7kbYGBgYGBgYGBgYGBgYGBgYGBgYGBgcB6GtDUwMDAwMDAwMDAwMDAwMDAwMDAwKEMwpK2BgYGBgYGBgYGBgYGBgYGBgYGBQRmCIW0NDAwMDAwMDAwMDAwMDAwMDAwMDMoQDGlrYGBgYGBgYGBgYGBgYGBgYGBgYFCGYEhbAwMDAwMDAwMDAwMDAwMDAwMDA4MyBEPaGhgYGBgYGBgYGBgYGBgYGBgYGBiUIRjS1sDAwMDAwMDAwMDAwMDAwMDAwMCgDMGQtgYGBgYGBgYGBgYGBgYGBgYGBgYGZQiGtDXgxIkTDBkyhNjYWMLCwmjSpAl//etff+5mGRj8R/DDDz8wfPhw2rdvT7Vq1QgEAowbN+6idH369CEQCFz016BBg/98ow0MfkLk5ORw9913U6dOHcLDw4mOjubWW28lIyPjorRbtmzhzjvvpHLlylx11VUkJSWxa9eun6HVBgb/WcyZM4dAIEDlypUvuG5khcGVhnXr1tGpUyd+8YtfEB4eTlxcHBMnTrwgjZEVBlcKdDLA/tuwYYNrOiMrDP4X8cknn9ChQweqVKlC5cqV+fWvf8369euVaY28uBghP3cDDH5+JCUlsWnTJv7whz9w/fXXs2DBApKTkzl79iw9e/b8uZtnYPCT4tixY7z66qs0btyY++67jzlz5mjThoeHk5WVddE1A4P/JXz//ffUrl2b5ORkatasSUFBAX/5y1/o1asX33zzDaNHjwZgx44dtG7dmiZNmrBw4UIKCwsZM2YMd9xxBzk5OVSrVu1nfhIDg58GBw4cYNiwYcTGxpKfn3/RfSMrDK4ULFiwgF69etGjRw/+/Oc/U7lyZb7++msOHjx4Lo2RFQZXEp566ikGDBhw0fV77rmHihUr0rx583PXjKwwuBKwadMmfvWrX9GiRQvmz5+PZVlMmTKFtm3b8sEHH3DrrbeeS2vkhRoBy7Ksn7sRBj8fVqxYwd13332OqLXRvn17PvvsM/bu3Uv58uV/xhYaGPy0sJfAQCDAd999R7Vq1Rg7duxF0bZ9+vThrbfe4sSJEz9DKw0Mfn60atWKgwcPsnfvXgB69OjBBx98wNdff01kZCQAe/bsIS4ujieffJLJkyf/nM01MPjJcM899xAIBIiOjr5ILhhZYXCl4MCBA9xwww389re/5eWXX9amM7LC4EpHdnY2rVu3ZvTo0eei0I2sMLhScNddd5GTk8OuXbuoVKkSIHa61q9fn+uvv/6CiFsjL9QwxyNc4Vi6dCmVK1eme/fuF1zv27cvBw8eZOPGjT9TywwM/jOwtyMZGBi44+qrryYkRGzQKS4u5t1336Vbt27nlCqAunXr8utf/5qlS5f+XM00MPhJkZGRQXZ2titJZWBwJWDOnDkUFBSQnp6uTWNkhYEBvPbaawQCAR566KGfuykGBv9xrF+/ntatW58jbAGqVKnCr371Kz766CO+/fZbwMgLNxjS9gpHbm4uDRs2PGeI27jpppvO3TcwMBA4deoUMTExlC9fnlq1apGamkpeXt7P3SwDg58EZ8+epbi4mKNHj/Lyyy+zatWqc8b5119/zalTp87JCiduuukmvvrqKwoLC//TTTYw+Elx5MgRhgwZwh/+8Adq1aqlTWdkhcGVgH/84x9ER0ezY8cOmjRpQkhICNWrV2fAgAEcP34cMLLCwCA/P5+33nqLtm3bUq9evQvuGVlhcCXgxx9/pGLFihddt69t27YNMPLCDeZM2yscx44do379+hddj46OPnffwMAAGjduTOPGjYmPjwfEVqcXXniBNWvWsGnTpoteRmNg8N+Oxx57jFdeeQWAChUq8Kc//YlHH30UOC8bbFnhRHR0NJZl8e9//5v/+7//+8812MDgJ8Zjjz3GDTfcwMCBA7VpjKwwuFJw4MABTp48Sffu3RkxYgTTpk1j06ZNjB07ltzcXD788EMjKwyueGRmZnLq1CkefvjhC64bWWFwpeDGG29kw4YNnD17lnLlRMxocXHxuR3dtpww8kIPQ9oauG4NN9vGDQwEnnzyyQu+t2vXjptvvpnf/OY3zJ49+6L7Bgb/7Rg5ciT9+vXjyJEjvPPOO6SmplJQUMCwYcPOpTHyw+BKweLFi3nnnXf49NNPXce2kRUGVwrOnj1LYWEhY8eO5fe//z0ArVu3pkKFCgwZMoQ1a9ac2w5rZIXBlYrXXnuNqlWr0rVr1wuuG1lhcKXg8ccf5+GHHyY1NZVRo0Zx9uxZxo8fz549ewDOEbk2jLy4GOZ4hCscVatWVUbT2lszVJ4OAwMDga5duxIREcGGDRt+7qYYGFx21KlTh2bNmtGpUydmzpzJI488wogRIzh69ChVq1YF1Lsx8vLyCAQCXHXVVf/hFhsY/DQ4ceIEgwYN4vHHHyc2Npbvv/+e77//nh9//BGA77//noKCAm1+IysM/hdhy4EOHTpccL1jx44AbNmyxcgKgysa//rXv9i8eTMpKSnK7eEyjKww+F/EQw89xB/+8Afmz59PrVq1qFOnDp9//vm5IJCaNWsCGHnhAkPaXuFo1KgR27dvp7i4+ILr9tki9pYNAwMDNSzLushDaGDwv4gWLVpQXFzMrl27uPbaawkPDz8nK5zYtm0b1113HWFhYT9DKw0MLj++++47Dh8+zNSpU/nFL35x7i8zM5OCggJ+8Ytf8OCDD7qWYWSFwf8aVOcOghjrIKKnjKwwuJLx2muvAdCvXz/feYysMPhfRHp6Ot999x3btm3jm2++4aOPPuLf//43ERER3HLLLQBGXrjArAhXOLp27cqJEydYvHjxBdffeOMNYmNjadmy5c/UMgODso+33nqLkydP0qpVq5+7KQYGPzk++OADypUrR/369QkJCeGee+5hyZIl/PDDD+fS7N27lw8++ICkpKSfsaUGBpcXMTExfPDBBxf9dejQgbCwMD744AOefvppbX4jKwz+F9GtWzcAVq5cecH1FStWANCqVSsjKwyuWJw+fZqMjAxatGjhOwjKyAqD/2VUrFiR+Ph46taty969e3nzzTfp378/4eHhAEZeuCBg2e5QgysW7du3Z/PmzUyePJnrrruOzMxMZs+eTUZGhmfkiIHB/wJWrlxJQUEBP/zwAw899BDdu3enR48eAHTq1ImjR4/Ss2dPHnjgAa677joCgQDZ2dlMmzaNa6+9lo0bNxIREfEzP4WBweXBI488QmRkJC1atKBGjRp89913LFq0iDfffJPf/e53TJkyBYAdO3bQvHlzmjZtyu9//3sKCwsZM2YMeXl55OTkUK1atZ/5SQwMflr06dOHt956ixMnTgCwZ88eIysMrih06dKF1atXM3r0aFq1asXmzZsZP348d955J++88w5gZIXBlYk333yTBx54gFdffZX+/ftfcM/ICoMrCbm5uSxevJhmzZpRsWJFtm7dyh/+8AeuueYaPvjggwteumfkhQaWwRWPH374wXriiSesmJgYq0KFCtZNN91kZWZm/tzNMjD4j6Fu3boWoPzbvXu3lZeXZ3Xt2tW65pprrPDwcKtChQpWXFycNXz4cOv777//uZtvYHBZ8frrr1t33HGHdfXVV1shISHWVVddZSUmJlrz58+/KO3mzZuttm3bWpUqVbIiIyOt++67z/rqq69+hlYbGPzn0bt3bysiIuLcdyMrDK40nDx50kpPT7dq165thYSEWHXq1LFGjBhhFRYWXpDOyAqDKw3t2rWzIiIirOPHj190z8gKgysJX3zxhfWrX/3Kio6OtipUqGBdd9111ujRo60TJ04o0xt5cTFMpK2BgYGBgYGBgYGBgYGBgYGBgYGBQRmCOdPWwMDAwMDAwMDAwMDAwMDAwMDAwKAMwZC2BgYGBgYGBgYGBgYGBgYGBgYGBgZlCIa0NTAwMDAwMDAwMDAwMDAwMDAwMDAoQzCkrYGBgYGBgYGBgYGBgYGBgYGBgYFBGYIhbQ0MDAwMDAwMDAwMDAwMDAwMDAwMyhAMaWtgYGBgYGBgYGBgYGBgYGBgYGBgUIYQ8nM3oCzi7NmzHDx4kCpVqhAIBH7u5hj8xLAsix9++IHY2FjKlTN+DB3MvLiyYOaFP5h5cWXBzAtvmDlxZcHMCX8w8+LKgpkX3jBz4sqCmRP+YObFlQW/88KQtgocPHiQ2rVr/9zNMPgPY9++fdSqVevnbkaZhZkXVybMvHCHmRdXJsy80MPMiSsTZk64w8yLKxNmXuhh5sSVCTMn3GHmxZUJr3lhSFsFqlSpUvLpSaAiopuKS645P8vf5XvBwE9eO41X2tK26adofzBtLW0dlyP9Hxy/u4EKF88LFfyOUTzS2EuTbq7prpVmDOvqcl5T1YOUJpiyi13u68rxml+lnUu6z2eAP5p54YHz/TOeC8fFpf62ftP6WWNtXGpbdPPbed0JP3PT7/O75b8cddn3woBCTfqQkntjzbxwwYVzIswjtWpMhTi+u/3mcPHapVur/ehtXrqeXKcKuufxs07r1gwvOedHRw1GNuvaZUMlv9LNnPDA+f55CjEvikq+h3Lx71LExQjVXFfdc363P6vy68p0Ky+YdqnS2gi2PDuv7hl0973y66DrN69nsNMHMLLCHef75ndcbFdcDp3/UuxaPyiNTuZM46VL+eEevOqRy3F+D7as0sgOZ55ijL3tDXd720uWX26uxG2M+7U/SjNH/KQN9p4fXcm2AUrb9mB1Lvu+97wwpK0C50PRK3J+spR3pCh/YYZz30ur1Nj35HJVKO9SlvO6syyncqjKgyafqly3a3JeO42uft1zu/WVXZab8qXrB2ceZ5ozAGYLggfU88KGs2/t30g3nlWKsO731M01ZzluaXR1q67J81hO6zY3woFTLvlV7fZqs5/67et+55qfsm2SRQgZMy/ccb5/QoDKJZ+dgroK58eGDsGIYlVar/wqUtUP0aorS6cMwfm5oEoTpilf136V8uN2X76ugq4NznZUdilXwMwLPc73TVjJnxvpYaOIC39fO43qmiw3dOXI951tkNMUSdflz+FcTKrp5FY4Fz+P/FlF/DjliVymauyrvqvkS4j0X1W+EzaJeAp9H18MMyfcceG8KM+FDg1Zl9HJcp1O68yj0o3KS/9VZco6slyXmx7jpj/p5qEuj1yXXKfKZiivue9shy2bVHaUzu6w0+rsFFVdoTjljJkXelxoV8gOPi+yCNR6gQy3+246ho5w8eOEC/F53yaJ4MIyVXm9ZIBcrjN/mHRN1oOcet2lkoFyOmddZk74wcX2trxGyuu513rsBS973U1u6NZAuFg2+anTT/tk+1r3nLKMldPJ7SqPGL92n4O3HJbb47xv/3fj4c7Da16YA0VcIS+IKuVVhi6NiihS3XOrQ3XPTzn2QA113PPj7fZ731mfqlyn4ub805XrVp+zTK/8queU2wTGd3G5oVLUnb+FLuIj2EgNp2CQf2td3apy5HTyPNKViyOt07h1jjF53jnv+63DmSbUZ3oQBop9v4iL54Kf5zfwDx35eUpz36ssNwVd/uz882qXDKcy7ccAcuZR1VOkSKOL7pA/y/+d9anaVSz994Jf405Xrt/+MbgQ8lqoW/vd9BJ7bVKtT87rqnpU+bwcv/I6e8pRjkq3kdupqsuLAPUiu3SyTC7PSx6GeKQBddSn3M+qfAb+4Pyd3X5v1XUbqt/Dvu5nrKjyuelnfuwGWf+R0+rmtSpvMLaKSs+Ry1Lpaao2qup23pPz69abnzLC838RbnqMDN0uDLks+Zr8XeXsdZatqkOOHHVrg65uuQwnYesW4acrT1WWqj7Vc4U7rukc5HIep64m97VObzK6U+mhWldV953Q2XNua9ulynUVxyLX4QU/afzyB3K/ubVLtY67wdlXl8qj+ZsbhrR1hb3weA1u+3sw5GawhKVKsQmmHD95VHXqoCvfjYCWDR5dHX6VTTe4GT5yOoPSQSbgvRZpLzLeL3mpy+82xlVjTreYO+87jRhQR33p6nSWoTPkdX0npy9S/KnqdX4+JV3zI+ScaY3BETzciE85ikKGrKy7bWfT1atT8r0ianWfS6tkBxu9qzMGvIwjN8PF73VjTPz0kNc53XropT94yXKv9VEuz5nPjVRWySUdwea2rtrpnG3VOeJ0/aEjiuX63EizYsV1HXS6nU4uGnhDpxc4P4dwcd+rxl6447NKZ1BBN4+c48WLGHAjNu02eREGqjGvqssN8tqimzO6tsifdeuI855bWwwuDTrC1I8eZKfTRYSWRqf1u7Z5EcJe7VHpfm5Q6Xpe5KkOzp1gbkSxrh1uum2wz2Wgh2p9dtMfVPlVNqe8Tsp8k9tar6tPJ9uCIU3l+27X/MgSL93MLa8qjRfvJcs5VRvta/7mhiFtfcGP4L4U70K4yz1dG3Tl+yVade3VDVYvZcRLwZPTevWXW91+FD5nOV5koUHpoFvsVKQomntu5bmRoHIaN2HiFDq68eBsq8pgse/L29z9OhhU7fQSnM7yw6U0Kujmid/0fvIY6OGXYHQjFP1uhfMT6SFHZQRDeuqgU8rdojOChUxAexkCurb5JXRlI9FvZLJB6SGv4ToyRCZ4dGSSF+HrZ61zkyUqstkvQSa3UV7bZYJIRxg5r8nHG3gZHl7Gjar/QxTpnfV5EVgGeth9rnMCh6LWNeTxH4o/At5rrHuRtaoy7PSqeed2HJCb7STXr9PH7LqCaauuflU7dMSyn7wGpYeXY1pGaZzjujJ1Okew9dr3/UbgutUTTBq3yODS6GXBONrt717BAWBsjEuBm00s6yhetq4NP7+H7UBU2fKglgNuskSGH11C5TBU6ZGq9jjzuZWv6ktVPp1c0hHVunY46zKRtpcJKi+2H8JThptB4TwL83IoIqqB5GfyOAecapDqlH2/Zasmmiq/TqnTkYH2Z3nSOutwgzHCSw83Y1YmaVWLofwZ6brfsezHYPGar16ksqpOL+HgZTi7GQTOPpUNM7ksnZGva5fqu04gG/jD5SD7vLaYBdsWt+hbVZl+ImRVW/Tctt4FEw17KddUbfJ7HILuu588BnrIR2Y4Eewa45coVK2zTiLGTUdwI4mceXTrphtU+orcrnAf5YDeeagyprzaqDPsnDLHLZ8zrYE/2H3n1P2d/3VjE+m6X91Dl06lwwRLQOoMWyeckbfO9G5GrZcdpNO/nISBbtyrjGbd2qCrA0Va1X2Dnw5uDnD5N/Czo8ZvNG8wO3ZkXcjNCe11PERpdQ+/xxr4jdZ13g+XrnnpXcaxcXlQmn70o7+o1i6nvuG1bjvLDLaNssPMLV0w1+X7wazPOt7LT/1ufIL9rM6jSbxhSFtPqJRj+btsGKjgxyiQFXlVfW5wI290g8lNUUFKo1PsSkNwOcv0Q7jZZQQzmd0IKoPLB+eY9UscejkHVL+VWz7nNZ2DQNVur3JUdfnJo0rnRnA786gEn6pf5X5SzWldW73mnlGsgsfl3HqnOyJAd+YrXKg8u21Fc4tEkRVuFYmrik5xO4dNRmkMkmCjZtyuOct0I8b9GGEG7nDrK7f1R6fs6r7Lv5NKf5GjRXRlqtZGWVkPQb22yuXI31UGgF0eiP7yqw+pIMsMHYHtTKMq241EVLXJODKChyzDZf1Y9V/O7/xvp1ONW139Mtz0CTddwUufOMXF41FXp46MVeXz6hc3fUy+piKvdUa6at6oyjfzwj8u9zFFpwheF3HqMipdy619umMd3NKpdCZdxKquXJXj2U1P9HvMlpdD2/5ucyTOZ3Krw9jhlw/OHZh+bF4bOhLR/u+ml7kRssE4+kpjZwcLXdl+26lzaur4DlV+1Xfnf6+XVF8IQ9oGDS/SUUemeCnH8mdVfV6Kc2m8CCpF0S2Nqm2qtrh9d+Z381z4IQHdlFLZsDJE1OWDlyKr+h6Kv22dOsPTS6jIC2kRFx894kakynW6CSddmX7yqAwzFVkr1+FmgKuMD9388SJrzTwpHfxES8jKtE4JL1akVaVz/p1ySesV+aojXVUEr1cdbtG6KoVerldlHARDlJZmG6UqssSQs5cHOqLSDc51yItcggsjFmWdqUiRxo1ocWunsyw/66S8U0ul/NuKu4podbbRD+kkX/cyGuTrOhLLzUFoEDxUeohOj3AzGuVjk1T2gp/5o4JbPrt8rzGpKlN+Jp0+6Iw692sH2Wmc+XR2mlyfrr2qcp3XZF3LzInSIRhdww/8EJZynU6HdzEX6x5+ImxVn3X6nhd56wfOdPLYkx3qXvltePWdn6AAHYx9UXqo9B55fbuc64/KcedWvp+63dZjP0670pDTfngj+Vnl6yo49TudLPSr8/qDIW1LjWCIDx1xIt/zyuPVHl1alYIdDAnrVo6f+t3qkidoMEqgavI7Ib+IyY+xZuAPwf5m9nfVtiVd+XI5qsXUy/jRbetwmxNuTha4UKEJRa3g+HFCOEllVX8GQ4qrDH6/ypGqT3XPZeAN+UxW+Z79X0XKytEaqshWOR34V/B1297clHA5v1dEqy5KRCa1wzXp3NqpS6P67rymI2i98hvi9tLhpejbaWyoZIfXWiiTNPKa5mctVBGdsp6ik2vOtM5rfuWdE6p1XqXr6IwoOU04F8s+nQ4nE1CqdjjrsPOYeRIc5P5zXpPh9nupdFwUn3Xl6tolX9MRuKWxI+y8bvp4KOfHlDzH/Dgq3OwRXXt0bdSVoSJs5ftmXgQHVRSq/Nn53Y0wldOrCNoQ9DqNqgwVdPNMt1vKT/myQ97vLiTVOHQLDNCRum7Rvm79rXs/j7ElLg+81ludTe62zsrQra8qOeVlf8v1BsO/6Nrqxj3Y+o5beTreyOv5VOu8k19w4wNV7bDh551W52FI26DgxZiXRkm6FPLQ7wRwDsbSTBa5HD+4HKSoX2+4W90qYst53ZC3pYebQqvqX50HTUdW+iEtVQtiCOrfXb7mZXSoFtNQLozYCgdqcN4wtv/cjF7nOiJHf8nEsVsfy+11ttFZpts6oarTGOKlg9f5sPI1OaJTpaT7ISaDJV+92ulWh1fErhecRLRuTKuewY9iozraQBXZUpoIEWN0lA52v3kpxF6Kthuh5bwvr2Fuee17KiXeD0nlRgb7JYrttPZ/N4LOLa+bwSDPNTejx60Og8sLnWwOlf5kh4EfA1xF8Mufg9XndeXrnAe6tjnzexEAqnZ6GcdeOo+qbTodSl5H5Ge2r8v1BWuzGFwMN6e0l/PajSh1O97JT+SrTFrKxzDIupKbziTvcHK2Q/6T08vlyM+EdM2Z30nIyum9HOZufXzKcU+VB4w8uZxwc7460+jsXdUa69ee95NWLl/HAbjpYH54BidUY9aPPibLOLlNqvb4Jb11+iSY4xF+UugGm/O/87NsiDhJG+e1YCEPmmDK8JP2cigcbmW4kd9+iWVnHao+VSm0qnqNclV6BOMEKM24k5Viv+UEQzaqyrWv2eXoBFZ14DqgKRdGzDrT6owSnREt33czauRrcp06ASlv2VWVAYaouhT4iUhVpZe35tn3ZMXeqzxV+ar88jU/0S1+8gUzB/2QpTrlzO2ohmC2F6qicJz/L5WsvlKhMtZU67oznR9l3ZnWTdHX5XH7buf30mF03/0Sxk44jw3S6Ziqa246qepzMEaXikhX9a8xwksHedy6ka5yPi9j3W3uyE5tJ2TCUx5nOp3b7xjwMy9Vxr6c/3KOOd0cCMbpolqDjG0RHEojV73yqEhKuFhHUekLOse5G2mpqkOnU6hIU12ksbM8lQ4YjK6jaluwUBHcqnpQpDHzonQIxpmrSuNnzfdb1qWmVck659ou26hu+f3ITT8cgix/3Pglt/aorqvsarkcf3PRkLaXDDdPhY5Bd5s8wdTpBS+SJ5j8XvlUip5uMQhGIXKW40b06gwxndLphDHCSw8/giDY8a4S8CrlXWeEehnuzsVbN3ZUgsTe0t0IaA0kwdVd4M6bgGipTtkw0i36zucIxmi3rwfbtzJBItdrFKrSQ0Wm+l1bVJEUcpSFnNatfj916e7ZyryfelVpddsQnZ9DOK+ceUWOqMpUpVHdC2Ztdz6Hrg/QXDNQw+5/1XqkUsxLS8royEidDhTMuukmx4JxJurKL0KMKV05fowMXXqnHPNDujmvyePc7bcxOlTw8PN7u33WkbehinvOvMXof0u5XLcxptMb3MgFPwav13PJZarSBGtf2P91tosbkaD7bJwZwUHnUFZBtZNGjkJ1kpzOa6pydccDONP6aZsuOlh2yqvaLtfhpacFc11OI+s5ct0yvPQxr/Xf6EyXDj9ri1+exq1sP+UEW344F8sjea11tkHFnankmVs7/ZLcXoSslwNVbo+qbW7PFgxpbkhbDzgXIp1AV5EuSPed10pDsrh9dlNO3BTC0pK3buX6Uar81KHqRxUZJ7dLJvK8jCk7nREowUGeFyi+q5R0+XdTGZBOA9bLGNWVr0rvhE2o2unll3mo2lsFaCj+wrrB/lawoSrdjmbQ/v1lJffCEeRtlZL/8jjULeZ+54nKE6hbf/yuC27pzLy4NPhRzOV7oDcGSqMYq7bTqSI+go3YVdUr12VfDwVqcuF8CC+5Fu74rosscdar+q4yxLyih1XX3KKY3chiAz1UEbQ25PM4nZ+DJV78OMjse26Ku073UNUnO/dUJI+OfPJS1HWyyAl5d4fcPvm7LGd1hppO51SReXDeAWNwaQjWcaHTf4M1THXGrWpeuhH9wRCzqvrsdG7Egpfd47duVX/IRLSczn7pjx8j28yH0sHPrhs7ncqp7CREdfd15XmRlqXVkeR6wx3fZT1FRUL7JZr9tMlNf/MiiVW6pK4e3Xcwc+NyIJj1D9w5qtI6mrzklLx2yvW4Od1UCMahrSrHr/NbbqfMKTn/y3X6bZ+c3r+ua0hbV8gGh5dB4Yexl9PplGIVvJQWXblu19zgVp/bAPXy1OvyymnclDdd2W5ebx2pZ4zw4OBmiMv9rzJmZagMBD9Gu30/nPPbS73qgos9Xc5jEFRjKRpoCLO6AB2hMyys2Z0XW/bjrUW9uIrvge1AXaAF0BKI48JtELKx7Kedcjvk7zrB5DZv/AgHO7+ZF8FBR5rK990iNPwozqqyvdqk2qYup/G65nbdvie3MRq4C+hW8tl2bNwkotTpiDpqRjZ0VGStrs/siHhVpLIqj+6z/GxeaQwuhpuDzw0y4amS38Eo0G6ElpzH6UDQ1at6a7Asw2xDRa5T3oUh55W/2+1WzVtd+0Klz26OQzciVyamVfXIBpmBPzj71MvgC0ZvUuV3wjkP3Mh7Vb0q/c6tHj9tkSG3SXY26KDqS93Y9bI3nM+l6i/5t1OVb+ZEcNARizo9R3ddR8CqonBtqI6C8RP16hUhq2qHfO6rSk+RI3NVdfoNCHCmdWub3D8qJ7ybruiX0DXzonTQ6T9+0sJ556qbLuXmeJPTq9Kq1kwv2aZylsnt8oLOgRhMXh1np2qfF1enSuPFZ/mDIW1dIS9CbkqBStEA/UBwK08FFduvKjdU8VlVr9uEgovfau+l9MhleZF5MtzapJrIKrLbbfC79asxwi8/VCSlvODpBEiw9dgvAlCdIa1rl1c6Z9qGENOOI49WgRCYt+h+5tCPWA7CS7CP2lD5fiAB4m+B+JbQpDVwE/poKK/5o2qLSgDIxriqLj/962cNMggOXlvI3AwLm3iUrwdDHqqUcHD/fVVbDN0idVVpQznf/o6woR78HuAeCOkv/j/QknK5BbC2KtCF80RZuKJslUHkFfVxStNuP0S3Wz7jyCgddHqEVx45vw2d0eD87qZHqOSPfd9pnOr0umLpu45kkvPZZK4KXkSVqj/8ksK6dqnqVslpZ512Wc7vRocKDnafylHKXrp5aXWmYOaeH13dC7I+7jbuZLvFTh/KeWe8l05j1+dlI6nap7KZ3EjtYGDkhX/onLBe1yG4rf2qe/LLxFS7fFTw2tFTWlyu9dRN51H1p0wWe5HVzt9GpZsZZ/flgxunYsONJHQ6kVVr36W0RW6DlwzxAz+y0C7fXrt1u350u57k9nmRrLJ8cdOP5LJV+pSzXH/zw5C2ngiG5PGTxg/hqytHN+Hc0vuBTAiHIqKhGhHcpC7N5NQNbrd+UV33qltH6hZhFKvLBd2C5PyuMw79lOs23m1jWGec6EhP+b6zLXWBBpDQGjKgWocT9C6aSe8OC1nV/D6Smq9k5treVOBHSAFm1KDWtp3M23Y//AHORxZ6OVl0Y11ngKiIWjf4IXHdiAmD0sMrMtXtnop41MEmPHWRvX5/S1Vkqi5yRVVuJOejaftBRg2s2gHCfp8Hb1WCvwOtKhGfuYklNZKYn/gbaFADuIbz50LLZeuiO7yiYv1EEOueS96y6DRoDIKDG5Eir9eqtUe+7+Wgxed9558zCkVVhl/SyXnNDbpn8Ho+lRyT5eMp9O2xn9OPk8/rmQ1KD7v/nFHKOieDTEj6JTHdnBZ+INsFqnKCIYNVhq79Xacv6tZbN3tJNyd1sO+poi3d4IfYNfLi8kJ2GOuODvDqd6+dTaX53fwSlCpnd2nrcSJcuqc7JsKrbD9Oal2ZfhxKwTqcDNzhh4zUpQvWuetmk7pBlc+rDJUTTb4vf1cdwwAXcgNeBLCqfrlONy7OJo9VkPM4g7r8rQOGtPWE18Bxgx8jxW85qsEhD0K/E835HPYCXcVxPwRxRmcX6bofJdCNYFO1x/lcpekX1Wc/E9zg8kOnvHqRrV6/u1xuMEaC16Kry1cSJUgCHT9cQlrbpyEOBvEyDC5JthcasY0P8joyZOaz9Bj0Bp+d+SW9ey6EyiDmULSmfGd7/Ahdt89e819Vp3zNr4Fj4I4QxZ+fow/cjA8/kbrFiN/NLTrESTxeqqGgaksN4DrxF5IC+8/w4oP9YCncHbUC640AaxJvg9GwbXcLvuEaruY7keX3CYjIdLssN8PGK2I5GEPDjtCX83gdo2DgD36iodx0GzfnbLA6g5t+5IysVeWRHWxy/c4ID5VOFqyTWa7fSeaqynKTu872FKNf/+W2qgwTY3BfPsh9rtNz3HQWP2StrJP7cSjI9bnpGTrjVjde5PGnI61VbfVLUKja5ewHuZ+dstOZVgU3o1+GCQi5PHDqUjbR4YeQdNN3SvvbqHQFL/LXziOfZ6tK41avThe0nfzOtKXVV9yc1H52OMlRywaXHzp7rki65kwTjBxXrbt2+aXRufysz37a4VWP87tK/3GTsap32/ipXy5TJ0vkfg/hwjlrIm0vA5yKvE7BVcFLGXFTUrwUF7fJ6OZ9VhGkoQhSqSXnXwpTBagB1yTAc6El13V1y+2VF41gJqQbiaaCyqBza5vBTwu3sew1bvwSvbr7OseFzjjQleUcu5Ewrypx1iHeoDfPrX4KkuHP9KJfpxehk0hZgyMEGsILB0dyD+8QebAI9sLK21tDv8iSskOkunQGjW5xd2uzE7o5pzJSwLs/DIKHvLXMbXuZTLq6kY1+okbtcnXfVVG4Xum82mM/x03APdAsAZokEF+0CeuFcFJrvgb58DSjObYC2jT6GOubAKTB4KWvEs4prPAAvZ+dWVKG00no7BOZPFWR4qWF08hQGSUyiWwM8eBgrzNOwhDUxKZK19HJBzf5r5MH8tomHwMl143mmkyy2c+m0/V07bM/q9ZkO3pe3iIup1cRUTriVdUOJxnstvYbeXH54cdp6/WbqH57L2Lfzch1a5MfvdtZp+q7n3pU+XXtcX6WdSdVnW7lqghy1Tol65y6NcqQV/7hdQyB3Ze2vA5GDqt0KD8ORV1ZMrwcx04uQXX0gq5+WWfzEwDgdd+vrhfsDie/fRiMnW9wcb/q1ptg+JDScC1+1k23z17f3RyDftqnImdVOqRO39IdWyXXJZfh1h5nHXIfOl9sCSbS9rJB9eOqBDrSfbfvqusqorc0Hg0V7O2qMstfHWgK61ojomp7lKRLZNLuJ5mU9iSC0FV5INzq9iJuS7Noe5HkKiJMRVKjSGcUq0uDm9GhIydVC7RuMUVxTTUf7Yg5ncEij4FwKY2zfYmM653Ol/2bEHP4ECwC5sGM3w1nTtbjMAdIhuvy9sN8KKhajpTWi+F2YC/cdXM2JIDY9m2Tt856nGNTt6iryGjdeqT67Cxf1bc6IW5/NuTU5YGfowVkRdrPtn05n6zUy4Smm9GiMoL8RH7UAPrB6NYwoBKV1x6lxafZ3MnfxZEh1YFcaLBjD1VrAN3hZDqwHY53CSWxwyfQD24mBzjMeSeHyjiRiVo/WxuD3YaoM+6CMZgMzsMZgeqEvO55QaWQ6/K6rZFyetVLtFQKt0qGudXrl+B0KuzOo3TCEXKjpuO6LbNU64NzjZdJXC9SUNcuN93NELWXDrf+l9OVpr9Vuoaqbt25+07oCEtVeaq8zvHqNn91487LyeGHkHC7Hux8cX5XPYNB8JC35tsIdou+Ko1fUlVVvx9y1+t4BredVPZ/v455FfyQviont1dQgUrP9OoDt7bo9AED/3DjiOR1UpXP+d0vz+TUSy7neufGHfmpQ173/ZDZtuNEZ1/7dep5wc0ud14Pjg8zpO0lQ0c+Of/7LUf+fikeKWcbruN8xKzzelMSraP8GB+A1FAYXQu4Bq6uxw18wYiD04BaXBjtoWq3mzfDSymTCVUdvDw0qjRe5RnhcXmgIhudkAW11+/ldyzI80zlKXMKJid5q0rvMIyvulG8YCwWzpypDA2AMfDJHxtBPyAR0qeNI7ANdravxdWFRwVJNRWYD6RB2H15iCMSbENbJaD8jkMvR4jzGVT5nJ91xLic15BTpYOs4PrZnhfMsQjO+26/kZcRoGoniv+qdlQBmgL3k2CtJ2fi9Vi3BNgTUYdb+Cdt+TtZTW5l16cxwpEBMBtYDZWqA1MhslMRJ9cDs+AFniSq0IKQ+6X2ylHq8rmDXkZHMWpjRZXe67qJtC0dgpHLboSJmxNWV5aKiPFab/2QlfI6rHO2qcqR9aLqCOdeHGJehQB3wtX3A+04r4NR8jmy5M8+fscu094p5ZQ3fmSpLCOC1YsuRU81cHc86PRoZxq/xKcu3SnHdzmtl2NXbquuzmJNOnkuuxneodL9cPR9ECyc80UuS6e76eBsq5EV/iE7Y3VEp5zHD/wcoxBMWjd9zq1NzjRuRKiXvuhGLDvvywSt3x1Wl+Ko1pHvdnlGXgQHeau9DXl90fEt8nd5HZfXcjeS0xkxrqvHLxFsl+PX/tU9S2l4BHscylyEW3tk+aUjz4Md38HpW4a09YQfb7jqh7f/q/L4OfBe5232MgbkNlWByt2AOx33QoBoqHwLa3M6EtoLRrw4hm4TM4A4eA+ScleyM7YW8C9RxgVt8jvJvDzXclud0HlB3KAz0nS/jw2jWF1eyEJBftmGyiBRLcB+jXNnHts4cP7J5KibARQCJMJamJPzOHnjwyAbnk8bCCOhAqfhdshY0I3JU8dBBFz/2T7+EpVCYTIEJliwE2gA9aK+gcqRCIP8HoRx7mVMOdsrzyF5/PopS0Uy6Iw3My8uP9zOBHOLFNVFm6rKdp7J6tcokMv1Op7BmSYcuBNaJxBj7aICp2lcZycnh0D0lEJAnPXcZtHH1Kt6CDYDmXA8CY5vBiaU/HWBSguBzfDN5oZsrXhTSVU2iWArivaz2ISU85oKbtEkOsMqGMPQODP8w9lXqrVMhh+F10ue29d0ZKSsK6kIGfk3V+leKiJXpfc4ZZH9oj77e3UI6Qa12gGtgZvgmv6wox7JR1+nh/UGNGgNNIKwgXBXR4QT/k5o1Q5B3IaWXLsHQlIQO6auQTjqQ7iwn5x9Iu80keVlaQhvg+CgIzBVv5nOJpA/y/qOH73JzfiV0+ruuc1pZ5tUpIAuv5sx7DySxMuA9yIzZCPeed9r26xOR3WSHAbe8ButqoMX0emnLlW0qBuhq7rn5SyXCVFdHq8ygiFx7TTyXzDw4/x21m/G/uWBvEvBhr2+yHqNm4z20q9kuWF/drMPVOum13rrvO7mALzUZ9HVqavPmU+n7+l4PT9t9iKEvWFIW1fotqBBMJ18cVr57b6qdKqBEQwR6sDvgZxKUGsUQpG/BmgBbwNrgB0wqe1Elh/rAk/XoMUt2dwY/09BUHETIrqjBkLJb0pwb1n18ux4GV7yf7+T2GsRcV4zwuXS4LUIOiF7t1RzSmeweCn1zjxuc8UmfUIdn6tA2CggHX5zC9aGAKyGb4mFCTC05kz2zK9GFX6ALGjEv8hMuxdGgfVlgKQjKwlbD9bkAFSH+5otYPvWpnAXEN8a3r7RUX+kpm/s9uuEhSqt6vnsayojRhbqcjrnPTMvSgc/SruXwqzbaqYq23kma7CGgHO7tRzdq2vjg/DVNUT//QDfLr+WNRvv4ejeytx/YiFLhnekK0upO+8oVITAfMicey8np0JkLwgJAVYA86GwD5AP9AI2wjSeRByRkMT53SG2w7Ah4sWANRBj1W3Losqw0kURq/LLZZljES4dl6IvOa/JMkInb1RkmHMtlA0h2UHoJGpkItOPUq7SP6ogxrEdTVsT5nTjn0U3wroiWAdwE5N2P4lVJcCCKQ+zsFpvCIEW1gmsTQGi3j4Ef72Ft62eWH8IQL9bgAHwXDsaWnuIL9pEuUMWxLRD6HnOaERne5yEkkz2qZ5HR9waErf0kPV9lS4sO16d8LIH3Maqm17sVoZubvodB34IaC/byC7HTd/3C9W6oetLHVS/nRcJbuAOFSEpy2w356zuml/C0ouclR3ZqjpUeXVlynqXrn7Z6e8V9St/dyNT3XYtud1X1Wdw+RCs3unlRPMD1XqrOkpKXi+DdZp5OfCCtf9VkHU73Xotww/p61aGXK+dRpff3+9cpkjbZ599lubNm1OlShWqV6/OfffdxxdffHFBGsuyGDduHLGxsYSHh9O6dWs+++yzC9KcPn2axx9/nKuvvpqIiAi6dOnC/v37S9EiVSfqvMVO6JQxuRzdNaeR4cdLrrsWCoRDShHWkgC9982Ea/ogjOIbWdy2E2QhHnMH/Pj7KM4ODNCCjXy+8xbqJh0l3tqEIGqbAjVhWBcuJG69Jo1OAXXL69a/Kq+M3/pV9ZR9lL154YTut/ISGKrFrIgLHQI6Y1L38hg5n9s4so1y+/6DVP7uKEyD4YvGizNr98KNVXdBZWAu1K1xlPo1D0E9eI7fkbxoGctWtadX11dhAzzffqCIKgyDZb2SGdF4jOCeHoCV97aGIf2BFpw/MkFe1EvjVXTmDXWU61d4us2nsquIld05EUx0q597XuSin0gS2wgIl67BxQqD27ELVYAn6G39BatCObaG1IJRwC6o1vYET/Ankqav5PbK62A7WH3h9U7JfE6JwyIaKvWDgrnlYAicrQE8D/c9swBWwVdcB/1qUPlERbivC1zXDXHmyIPQuR2h34VCs3ZcbCh5GSFeUSd+lCU/ZPbPj7I7L5zEqE6B18FtfZSdfionlPw9FH30nLOdzmvO+nVrqIoYtudcNFyTAle3dNw/RcLD73Nz3na2143jx/gAuda1jGg7jYKq5aAirDzamoe3zWBj/9YUJcDMigOwWgS4N3c1zAFrcwCrTzms0wE+330L2ya0YHyNsfAbgOOox7bzOeQ2B0uul31iquzOCRVUY001xlX5ZH3IzXHr53dT6SZuZKQfYl+eQ37apnPIyOuJfN2LkNWRDaUhXHVEs5EVpYOzP4MhGf0QpF5RoLqt/TqoonadTncdsexGOOvqt8uWSVi3COEQLn5mt3wy5Prkdsp1ljaSt2ygbM8LJ1RrqN3nfpxyqvVRfi+MioPS8VtudaqIUy/4cQb64RlUclElT/3Y4XadXk48Z726/vHzfBejTJG22dnZDBo0iA0bNvD+++9TXFxM+/btKSgoOJdmypQpPP/888yYMYNNmzYRExNDu3bt+OGHH86lGTJkCEuXLuWvf/0r69at48SJE3Tu3JkzZ878HI/lgNePpDI6LlUpDodZoZAPzzCaD3ffAuNCKXeogKTVK5n9txSIgK0H4iAHAqvgao7BQSAfvucqiI9ERNyGU/+Pn0Hl1qjJoWBJVD/el9IQu37gzF+2hUvZnReq38DN0QDq39j5+ZTmuhOy4qDzXLl58ZxOkWhirHx+yKiOlRsQJFOJnhLIBtoDc2DT4XjoLkq4mu+Y3v0RruMr5vd8BFJhaPpMKABi4eP5Tfg1H0Au3Doqi7t2ZGPVChD6XUugEWqFPlgyQ87r5g1VlS/XIQujshtZWHbnhB8l2JlOBb9b+uxrbnU5jQbn3JKNAFU9zuvRQH9CvzvOvCGPwWa4+gQwGJgOtIWqHINJMOrEJEiFQAg8dDCT7dzI3hN1IRPoAxVqnKVoPVTqAxyGRVf1hFhYdawD1WbvZWXEXYTOOU7KztkiWDClKm3eeZcfs6J4bVNP4ElExK1qfvg1GrwIXfm7k8w28yI4uBGgzmvydft7kfSnI21UyrSc3m2N9dK5VG3XPVs40Bqu6oNwdtxP6u4ppB6dArO6YR14hEnWBj7c3Z5AIXzFtcyJ6s0vc3dBIgSqnoWNcFfPbGYUPM7+ObAxH27gS1gNTIeTS2FjDkLmzCn5fxpG75taMoSLFX3iR6906xMVOVi2UTbnBLiPe9VYU8Htvts4diM4ZYJWR/za41wuV55nfsaK17iSy3NzzqjGuIos1q0XTgRjyMv5ijCyorTwOpLCbSeSikRU3Q+RPruVI8NNx/DjUA4WunbqEOwOIS+9VRc8IJO/zu9l22mhQ9meFzLkdcfud79rrvzd+VsGK+NV661MBF8qZ6O7plqndf3g5aArTRvdbGsdr1U6ni9gWZYVbPP+Uzh69CjVq1cnOzubX/3qV1iWRWxsLEOGDCE9PR0Q3owaNWowefJkHn30UfLz86lWrRrz58/n/vvFS00OHjxI7dq1WbFiBR06dPCs9/jx40RFRSHOFaj4Ez6hF3Rki874cF6zSdWmdLaO8s6KHmR3akHi3Z8w8m9P8Sb38/WOeCgE9gKV4VCbKHrzBqta3wf3wOtpyTzUI5NAmgXTYE3mbbTJ+JhrUrazJ/ABYiurW1tVpG6RS1rVs6oge9dlEg7FfVU99udC4Gny8/OJjHTbul428PPPi9FA+VK0XP6t/FwH/Zi4FOLeLrsB5HbDKgpQ1Br+lQ9brWQempDJoTFRxOzIZ2SDp6jNXgaOfQN2AWdg14IY6tc5xNN70xh9ZCpbqjekadZ2AKzuEIiCwHwLEuax2FpIUo+VHF1YmdE8zau1B8P+2cARTT/4abtqfOv61S2/W/kBYNx/xbz4ueYEOOfFM0CY447fKE436MoIpmyv7W1yWc7vdt7H6Wb9hbfm9YJmsCW+IU2zt3MgMZqa6XkUTCjH8or3kFxnGXQAlotcRw9XZhuNaFPjY1FUJyAbsr9sQWLuJ+Klfk2ALMj7Moxt3ERizie0brKSJXSlavNT3Lspk7dze8J6kTZwlQUNdouCyAuiD+ToF6++1d0vBtLNvHDB+TkxmfNHXPhZc5z/Q1Ab7/KaJ5ftV47o9Ai4WB55Eb42QoCmcPUt1D26gz3rG8AwePHjfqQefA1WwIF+0dTMzOPx5Mm82COdXgtfZf7dj0Ax7FxVi4+4jd6jFnJ8KkTugp6xr7Fg0cNs6N6YVglb2bKuITcWbCfsIMIREgW0BY7B8YRQonJ/FHOKxahljKq/nFDJYi8UA2lmTnjg/LwYx3lZodNZ/ej5XvCjQ8n3vZy8fsnmYHQbP/q/qp/s727z020Oh6N+Ia28Fqn+q/LInwMYWeGOC+2KynjrKcHIci+45VfVo8vvdc1vW910sUuBW5tkB4NKX7zU/nV+PwOM+q+YE1AW5oWTh1LxF8HajJeS1m0NdEJeV/3KFJVuh8c1t3a63ZfL9fPM9nj24i/89LfchjP44aHKVKStjPz8fACio6MB2L17N4cOHaJ9+/bn0lSsWJHExEQ++ugjAP75z39SVFR0QZrY2Fji4+PPpZFx+vRpjh8/fsGfgJeXSPZQeyHY9DrPhDxgVAOkGGEs1eVO/g4hkFj/E+gK9/NXvp4eD3OBfFjWpT1WE4jplc+qSffBdmAKPFQnE7rC9pbXEJO5izY3fwyxsIWbgUQufnuramI52yl7uZ335OdSlaNK5+a9UJXpvHapnp+fBz//vHBC5ekKJipBtwjrFm9n+UX4n09yGSFAb4jvhvVpAKZCaATcMhIe2pzJkjEdeY5hsAom9ZzIwElvwC2wbn5TKIT6Rw5BMoxOnQq9IIklsAsOtInmi2N1YRqcahLgRWsdSR1WQieoln6C3/AWPAAicjGEC/vtUsei3R/BCHNV39gou1EiMv5TcwK85IXfKAu3aBAngtka6ITz5WRe7VAp6yFAFaj1BPA4da0v6MAqm6/kCNVhDtRsnQfNIKL+WZJrLoMlCB9YV1FStSknaDP2Y0iGTQfieX72QI5+WZmr+Lfg8/oCZ2DPl9WInlpIYsYnsB3WTu1I3JmvaLEpmz+f6Q3zgCWQ1fJWEm94DzFOT+Euo/1EO6siWHRRJf99USNlQ1Z46QYy7DS6cetc5+TfRCZfVeWqrjmNV6d+oJJnoYq0JfOF/kQXx5B89HV25zXECgkw8OPnSc1+TUTIFkDNzXmwCF68OR22w/zVj0AOkAxxSfs5SCyHnokiMhbYDT9SgZbd17KUrljboWnOdsJmASug6HmE32I7EAu/LP9ZSZecRE14q3SeIulPBZ2MsL//98yNsiErnNDprMEStrq55Zx7KpJVNR500OnTXrqGH9LYOd9UzyKn0emHcPH8RJO+GHWf2P9lu0X3LDqbw+hQMtznhJ9jCNyOFdBBpWM5dR+dc9YLqohcL53NzzO6leW11gajE8kElH1NpwN51aOLWJa37f/3oGzMCydU/IVOt/FaK1Wy/FIJW7hY93CTETo9y0tXkfPo+CI3WWLfl/tH5iXsNKqdrM50qs8yVJyZf5RZ0tayLIYOHUpCQgLx8fEAHDp0CIAaNWpckLZGjRrn7h06dIgKFSrwi1/8QptGxrPPPktUVNS5v9q1a5fcsRcuP0oEUlpdejT33K6r7rmRpbYSXQMq12NItVcovB1oCyP7PUXjDjv51xCw5gBT4N7s1QT2InjYtgg+CYQBvh4atN7Dt5OuhWZAefiElsCNiBfFRCue10upUd3zk0dH9unK0C0E/70oW/MC3BVZG24kos6gUKV1m1Ne6eQ818CsWuTnVIDaQIQglfY8U42ZzXqT1Gslz/V9imWD28NI2DCyMX26vEzCwS3QBUiDvMlhMAYYAz1ZAFWh1tffcZoKUAfC5kBq0mv0WfUyLAIrHdotX1cSBVVL0S6/L/gL1qgCb3JcZTz9dxji/8k5AV7zwo+iL0cfBJNPB3nsqBRxt+18zigQgEio1Z+B+55nvtWdb+5uSP9WGdAW3vtbInfdnc3R+ZXhOWAeZB9owVMHRsBBaDv/HQqml4OpwHQ4Or4yedPCaP5KLkNHzaTa1BM0ztoJefD6o8nQBurWPMr+YUAagtzKg2Nza7Hx5tZELiwSTRsAbTI+FoQx27nwBWzys7gZUn4NPft38TpqoWyibMgKGSpCVV6bVDJFp1c5jU7VGue85jQcZZ1NVsa9ynI+R3XES/LuZ7V1B8cO1mLB0ocJzAcGi5dWPpo4DV6CHYPrUtCoHNRHyJ0ZQBPIPHAvTALGQF/mEjMnX0TRzoFX6c8UhjN5yDiKzyCOQXgH2g5+hwqTLUiEDt3fZllce+7hHfgGzs+PIsSLL6NL/sv96EX0yWlkg83+/t9BTpUdWWFD5fTW3b8U3VWV33muvozSkMPOeypdXP6vMpZl54FqvNrzONzx53SAu9Uv33PTl1R95mW7yff/O+RG2ZQVfo4f8NJpnGt+MGuUXyLW656fOtyOWvCTX9ceFUmt+uzVfj8ErltZTv3W69iLsoWyNy/8rssqe05Vll+ORaf7qNpQGn5LbosXFyDncdqxfjkf1Rqv4zP8yhNdPc7/bjyWN8osaZuamsq//vUvMjMzL7oXCAQu+G5Z1kXXZLilGTFiBPn5+ef+9u3bJ6XQkYryj6Ab2KGoJ1EwhKLXIHJes8uvCZ1hxNExhHUBtsGk3RMpXAI3bRdnDtIFmAeFcYhtrbFAKiIa/yVgMGxZ25CskbfaxxpyV49svrWugs0pCINFhpv3QwWdx8cNfhXYS5sgZQ1lY164CW7V4uslaLwW7CKEYi4r9HJaL3LYvh8O3MP+R6sS2aqIkYlPQQI0P5ILwCkqMXN+b2gL73AP78a34a7T7/EEL0IIFHUFqkJ0TiFZ1W+FNJg0ZCK0BGt/OUbzjHjXXyOgAB7gTdb9rSmBdKAO5D9QgfMv87ONDedWYBVB4ce4dsJNUKjS/vca4v/JOQF+5EVpDDW/UQs6qEhaVdSGz0iOq/swet9IXp6eRg5NhHOiH7AbGrENaz58wfUiUjYFbuALJg57FhrBmh73EDHhLBtSGkN56M+rrKID1IP0Z8bxRloPQValwEFieSx5Ki0PrKXWWth5uBYMgkPPRLGhX2MYDtQBEuFkL2ACXMX3Lv0gP6eXMSRHv+iicfwS62UHZUNWgLsir4NuDZcVbPm7TN44y5LPS7fHhpcuJddlr43VgSfg6W70tt7hY6s57WqsE2t/ZkmSvjAw4w1u4yO4XZxdG5F9FvoAL8HJu4EVcPeZFez6Mgb6QkzffOHYGwNH51ZmNM+Q2OoTaAmhFYFFQDSsGXsPuY9eCwdhGM/x6zMfcD9vit2UfFXyvNcAPYA4Tb95kejOPnDDfwc5VfZkBVwof1UkphvB7le/VpVvOzzkOktbj1t6L53MmU+2l+BcEAp3QtgTCOWqD2KyNUWM8ypcPP/d+lFltMt2mupZ5LY62ymnN/NChrtdIZOJXhGwTtnszC/LdZksVG3b19Uhw9bbnfWpduzIkElTP457HfGq2iElt8mrfBVx60YEq9rsBRVRfCnOp/8sys688LIFZXJWpRuBe98HQ6rq8rmRxF512Pmd/73gZfN7QRUYoPruJs/8ysbStvFClEnS9vHHH2f58uV88MEH1Kp1PiItJiYG4CJPxZEjR855PWJiYvjxxx/597//rU0jo2LFikRGRl7wdyFsb64X/HoE5GvO637hPJpARqi4f/UtLMy8h/H5E9m6Jg6S4FC9KMLWw7oGTdlzuBrcAoFxP3IsIhoGACMRRO5mROTtWPgnt/ARt0ESzP4yBQZATEI+D98yA6Ew2YaPrAS5TQjndT9bJ9wUSTdCKxiPSNlG2ZkXzgh0GX4Jezenhep3Up07JqfVOUqc98OBmrCuEp/SBGbD78/8QYz3u6HuwaMMnT6TgZvfgByYk/Q493y2htcrPkTT3dthA4R2gE3T4mEntLn+Y8hHODkygXx4Z14P8b0QWq5ay7V8TUL/LZAGi5p05l/lG0GTEqeK8vncBKQbVGuLl9GgErJ+8/78+E/PCfAjL/wowPJ9lQERDEnoNFr8/G66NKeAUHgaJjZ8FmLhuf5PsbVlnIiArQ41c/MIJEEON4sXICUiosvjEcRuLMx45mFaLd8KZ+Dt3T1JnrIMYqEGh+mduhA2g9UBPudGXjn8KLfxEZsS4wUhOw9i5uXzD+6A56EoHpgEpwqB8pDBg0BD1IaSyqhQbWF06wuvPjTzQob7nJAd1ToHtJvs8OO0hovPUXMaPLJMkA3ZYJzHNSGhG6yFIaOeZd6kx2jVeiu7DsfAMWBQSdVzgDXQe9JCaAadx2ZBJlixwHaoNBiYB5GJRdTvdUgcQbseSAJrM1Qbe4Jh/FHoYq0QR1o1QUTqRsNpKvJ6SjKf0oTIT4tovXgj5C4HDgBN4ekujLaehmYt0UcTO/vfyzkop7V/17Lv0Ch7ssLpsJYNRJW9IEM3R+Rygglw8NKpdW1xa5cqr11XOCICPKTkv30vBBEl4iBqv+pNR+srvj11FYutF0i1ZsGAGjCkZUm6+0Xac21w2m1Oh30IFx4f5JdIkOF0+OjsOjMvZLjbFX77S6XryPnd5L6sgwXzO9m/r5sT3G23T2mjeJ1t1ek5fstzEt1e9cnwE+nsVnewXMfPg7I1L9zsXKR7XvAbAORWlooQdpbvx+nu1+Hods1PPbqydG0Jd9zXcRJ+SGmdQ8+NDPZGmSJtLcsiNTWVJUuWkJWVRb169S64X69ePWJiYnj//ffPXfvxxx/Jzs7mtttuA+CWW24hNDT0gjTffvstubm559L4RxiiU0/hP6y/NIO5NHCLygMIgdHQPeNdQvOgcdZObhu+hpgV+TAdEhK2UIlTFDQqx9q6CdTMzYNt8Mb8HjxeezJbqjckq8+tsAH6H8xg9NSpvN8ygf7rM2AunMyBOdmPQ0w9Lj7b1glVpIp8v1hKq4JbX7p5dkrrWSo7KHvzwgkvQ1sn0IvQjwk/danGg7wQqsiAYqAjQ25/ls4TsihqDZFxRcJQjoY3YntAHmxo1hhOwOtLknntlz1JGrWSnfVqwRkoXCPIJqYD3RFOjl6IczcLoLA7IrBpCmzc3Zq4HvtFul3QPfddEl7ZAq1BGBpe/aeLBvESDs7n1ZXvp6/KJsr2nLARzLYzLwSjGOsiKtwiK+zv10CrgSx49D6sI4gxvgpuzN9J9sIWvB+fwOvxyfAcpNZ8TTj6JkDd1UfFcQi5wEhIHfAajEKQTP3gseFTGRY/kaE5MwUBdRoCTWDBwYc583xlXpgzkuYDcmnOJnFEwhgY3mMGmzbF0znqbY5vg9AQYDIM54+cV6yckeq6KFnn8+kgG0R+85UtlN15oVrDZBRp0srlqPKrZEMR54lKlbzx+m5fk+tqCPfdT86H13OqWYAXuowUx0pNhjOEiCjyMDieDsxHkKx7EWRuibworg+kI4IFi4GDQDLQHhZ92ZkZex8msBk2jY8XZG4JubuhU2MKksuJsmZB083beSgpk/T1LxJYbMFv3kdE2d4OOxJYOOoehoQ8izU4gIgMto9JkMksuQ+8HK5yX5VdR0bZnRMyWQsXj33n76Ej3HVy3Y9erNOZdOlt2Dq/qg4vnTscERnbGzoPhGsGIpxwTYGhCGf2/VC5Pwzpw2jrr3Q7lYH1XjlWHOxGzKh8kiat5PdMxuoTwCoKMNFaxK3WZoROVbOkvAchfiBioj0JlYcC93D+WLdoLiRxVc/jplOe0lx3ouzKj7I7L1RQRam6kbwqMla1RgVDEqva4SxHjoLV6WGl3bXjJ5+b7uf1/F5ksi7q2e03UJV/uTiQnwZle154rdNyutKm0Tlw/ZQrr4W6AEM/48CN9wmWv9HZ0LLDTfUCNV1ZXrJblU8n0/2hTGlagwYNYsGCBSxbtowqVaqc82RERUURHh5OIBBgyJAhTJo0ibi4OOLi4pg0aRKVKlWiZ8+e59I+/PDDpKWlUbVqVaKjoxk2bBiNGjXizjvvdKtegULOv7VPBR2b7xT8Xj+in3tungtV2uuAjhAGGSndSOm1GLLgo/ZtuXZuLv/o9CtqJuTxFt0YOOENWo78hCnxqQxfPoMaHObFfemwBKxeiDV3Crw+LZmHumSSufxekhcto1IErEtsyiPfTufVQH9gFnDc0QZn+5x94qUUqgwCVT6v+35gt8l9S8PPjbI3L8Db6La/qyKfitGPDd1vKS/Wqrp0ZTnThsMDVZk2fQQvdBoJzwP9YOvIOHK4md7zFnJgfDStUrfCRnioeSYchPcOJNI2PxvGQFgTaFlvI9nrWpC4+xOxQ287IuL2CJQvRrwcZjdiZ2o8ZLTvRkqHxdALRj76lDgCkYSShN8AP7g8r7yeyIaFH7JDlc7rNyy786JszonLIU69IkOc6YoV/1VpdNflcqtAg/ux5gbEFuz5iOjxkXAmBFLIYBHdeahtpnhjfXUEmZQJ1EMQUI3gaPXKVKt6QpBX6UAneJIXqHHmsKg6ESEu1sO7sW3ofCRLRPEehG+SGwoiuAOQAs3n5bJq/X2ivuFAZVi8NQVYWdLmcM0zqvrMfnbVPa/+9Sq3bKBszgsVdGuWX0VcR676NQR0ZIuqXXb6aKAjjI7knYltafzSTjFPuiPOmS2EuJz9YvxOgsgNwDSEA28I0As+G1yfXy7ZRehCoDq8EdeDfetqM3rCVKZ3eoSqnY6RMnYxdIei2tC8by7UgOzYFiTO/4Tvx1/FnIr9GJz/Knnbw6j65ikeWTIdArOBmzin/8W0ZMEN99G97bt8fgZO9QI2dINWnwOfoB7DfnVVJy5nIMJPg7I9J3S2giqd7pofXVilGznv6dqkalsoF+pwqnbIdVRBTIREaBCAATB58OP8Lm8G5RZZ8E07hj87nslZrXi6TRqf8yO/5gNu4Z80vXm7eJ/GLmA7fDajPv/mKhJ6bRHR5yEwOmcqc5v0BapCq/uhNUx+9nFuYhtz6Ecv5nPfnnfhmlCgJeKdAoeBLcB+Lt7ppHsOJ9z60EaZMrEvQNmdF14y14/8Vclu+ZpOF1DVr2uLV52qfF7l+2mL3wjh0ugqftrn1nf29f8evcmJsjcvnGuIzhZUrfm2Y1b1UjDn/2CgIlGd7VLpEMGcY+wlv7y4Ab/PdClyV3dfp0teXpQpiTJz5kwAWrdufcH1uXPn0qdPHwCGDx/OqVOneOyxx/j3v/9Ny5YtWb16NVWqVDmX/oUXXiAkJIQePXpw6tQp2rZty7x58yhfvnwpWhUMmQQXDp5w9D+cHyLTbaDqEAKV7yfuh63sfLwxKTsWE3jbwno1wIzkh+nJX6jZKg/6QhfegXwI2wnDt89gSnIqzfgnfArEQqAQWANkwT5qQ31Izlom1t5oGMt4lp++l7eKf0NeiLyw2O3XPa9qoqkMOBWBa+dxiz7A47qz7DNyJ5YplM15URpPkUw4qohH+7obSe/1WW6b8/OdvJrZi/4rMmAYhMYD8dA4dyeNk3ZStAmqFuSJ6KjBUFBHbEZoxDZCC0QJz9cbyNABM/l+1lUiyrYtwr+TA8yB0DmIl/jZw2obpExdLLbMzoOrU74TNsMGoHMX+G4eF79UyU0IuXn/VH3nRdKqyPSyPS/K5pwA/VZ9573SGATOMlSRoLJB4Gb4qOoIB2oII3g77Oxei7iN+wXpmgrHOkXzLnfzFr+h1fytzIh9mNQar4n7XeCzuPr8MncXdIFqrU6ITSpRsGNDXRpcv4e4FfshFaanPMLg3FdhOWyZ25DOA7KgE2Jb+EFgLILQ3YEgxNrCntnVqLv3KMTBu23aEHX6EPnC61HynF9pnlv3Wb6mMuJ0aZ3pyh7K7rzQyWk/0Td+5bwqrfOaTrnXRW848zWCpxO4d1QmT/AiN/CFOP9/OJAFZHPuaKmTeVBpFuIc6CzEnFoOxMEX3MC1absIawWLtnWmd/+FIl0TGNz6VXgGUW51OBIVzT/m3sENfEli608oyoNb+Cd3ZWVjZUP0wUKsxQFuuf9DeC6B3mkz6ccc7jiwnoU176H75nchFm5sA+PXDC/xwf3A+ejCHxzPacOtX3SGWShl+QUzZXdOeOn3unFZhFq3gYt/P3mt0ukVKuLW+d+N9JXLsG0f+43GKfA2PHLvdD6niDFM4BUeZXj6DO6ZvJDUR6fwGxZzI5/DMzD6malQFagnXt7KNIRTZDVQG/ozm48S2kKEuB74zBJO8BAI/e44P/4pitbjVzL84AzyYsNoyOfUPXiU5Lrzydz8EN1uyWAzzdjzfw3gUBXOH8vgZ8efs3+8+sQmt8smyu68kKMzvfQoHcmou6ZzZst1uBG+OvgllL3qVT2j87vXs7u1VacjOssOcfnspgeVhpguWyh786IYcOZxs43h/DpU7PjuZV/r5LoOOtkVLCegs9Pl76oyVTJKl1YFL+LWL+enK1tO68Zd+UfAsiyrVDn/h3H8+HGioqIQb3RwRtr6Gfwq+B1MugGsU5hV9UfCXUOxng3Absjqeittp37EqQEBwhJKkixBbAefAFu/jKPxvp28VzuRu4ZlwzphaMeeOUjkziKebDCJaX8ZweQHH2f4kBkQD8/3G8jQDjMFSZUGTw0fwdOB6yl5bbHLM10u+DXM/NZ/Bnia/Px8xfmUBjbOz4vRXChEwD1SSQU3It3tXmlglxcOdw7FaiEiSNc905SEzVvErb4II6AhbJjbmFZ3bxWRHW2hYGo5flUxmyd4kTOU56EhmQybNpHnXnkKJiAiCtcDCxFz617ELr/1iCishkBVKIyGkxFhRC8tFN1XFQLXnIJaXyIiB90MX93ir/oup9f1h5kXlwPn58VkvM9C9VJkw7lwHPg1WlCkU5Wr2rIWCrSABrdQbftejgypy4Fp0dR8KU+M39Mwo/bD3M+bVNtxAiLgeGwokTuLRNRsItAdhnWfyHONnhLjvTqwAnbuqkVcjf2iqjGIiPTlokwiIH3XOA5TnXlHHmND9caEc5LGfXcKB0cqWDshsARx9MIsYCNia3gi/F/c1xwK1EacS2I7Pbz64nIYE8VAupkXLrhwToSVXA1mnXIjrOzo6supe+nyVQGSaGz9i/dpRxJL+DCpPQWZ5YjochZCIPtvLUgc8gncDif7QqW1cLRZZb7mWlrdvZWdf6tFXPP90A92PlqLuBX7sXrB0mMdSZqwUsid1cAAKOoLoV2hw9y3WZV5n3gJXzrsWhdD/fRDYq7lAu3h2SZDGNF6miC1MoAHEDJnFpzcB5XiRZl0gsBsSzgJvwfWWcB7iAhDCJ5wVf1mxUCamRMeOD8vnuH8vAjGLvBKE+x4Dya9ityX52nJ0Qd3daTxyg1s7duKznMX8U5GD9gMx6eGUo/dHJtai0PDo6iRl8/h6ChicvJhJ3AaRqY8xaQjEwmveIzPon5J/dxDMAfendaGG/iSSpzkJQYxaflE2AcbBjWmK0s49Jf6WI0DsArhTB+CMN8mI16qHA/kwNEZlRnK82QM7A+zdiJI2+0lf7qI22Dg7JMzwCgzL1xwfk6MQ8wJFWnrh4QsDbxIT1kfc95HkTfYtng9l41L0VkuZ5supVwbxcA4Myc8oOeh4NLIUdV1t/so7qnkjc75q2qDG1nrN5/83akX+uWBLhc359U2P/Bnb5epM23LHnReavm7HJ3h5qGQ4Uyv85jrvA2qiRQiTkeIAlZBm30fY9UIEHYz0B5hDOcAhSWEbcOdcBDuGpAtlJpJ0KD5HiLji6AQHuNlrF8GGL57BpnT7uW9fokMbTtTeL5XweF0mLj+WYQ1Eal4dreJouoDL7gZc7r6vOo3CA5OD54N2esm/0Ze40L2qsmLnx+o5qHTI1gd7gOSxYuSAPKahUFPxCkFzUT0X6usrTActmxvCI0gYslZ/tnlDjqwioc6ZMJ2eC71KWEMAHu6VjsvU/tD+oFxsB6K5sKu5BgKGpajoHo5wgaUnIUbizC8V0DDmp9D2E1Sm3XP5Ownua+91gYvqPq47EYUlk2oFHjnC0905GuI4/Mp6Z5MzDqjRJwvx1SVrdr9oFKyq8O0W/h6+/9xpG1dKIaaGXnsHFRLnEs7FVInvcZc+gjCdQJEtioSDot4WLKwIxTAc3c/JV7q3QwRNVsd4jbvF0codEIcH5KOKHMJ0ATu5O904R2erD6JVpu30rjXThG5/jzQFgKxQF/YujyO38TO55qu28X8ibIf0yYKnFEifrf2eaUx4//yQrWmO+WEm9LvTCcTtrp1H5fruv9OXAekQEYlcqbeSrXpJ/hwY3vYDP8OOyvkyN8eJrHnJxyaFgWLoFIzoCdUW39CrPU5ENd2P9wCbzzag7ic/RT1hMB2SJq6UpyFngVbV8VBFIT+HTgIqybdJ15iVhXoDi/yBMsmtxfOjkVAFxjRcBoZa7sRCFhCn2sWJ6J650GlCGAk7O8LG6o3JnXUFOa9cz91P9wBMQHUa5If2XMpupvBxQjGse02tnW2gzw37P9u76GQ0zrLVekaoYhzYhOB3vBuR068XZ6cl27Fqh7gnWE9xFE79SBycBHH1tWC2vAKjwrCtkc+TIIt3RtCPEx6ZSKMgVMrqlI/9ZBwatSGzjuziMvez2FqcBvr6dnlNZYM6kirHlv5dtK10LqQTfHx7EqLgVREoG8TeDZuCLumxZDV71YOzYii2oATzE94hIkzh0FOHGTUKGm77RCS+1wH1T2534wM8Q+V7PYT4epX3usiQ90iRnUOLXmHjv3npoe51e+85/x+OfQZP6RwadLrIm69AhcMgoOqz2xi0o/89eMY18khnS1eGvvSrQ43qMjhcEU6p17ohyuT13rnPfmzFzenyutst/w7ybqofx3KkLau8FosVZ2tGoBuBJRuUpRWEW4IYfBZvfrCQO6OiAAsBBbB9H6PCI92WxjBH8S5/RGIszfnwaY28ezaFCMMgx4lRvd2GFZvIsljl3HX9Gy4GTasa0xBw3LU2ARbb4+Dq+oholKqqJt1Eby8Ms40urSlUXi98hn4h+xdUxnCbkLBKXjcfhPnHNHVpyrD+T0avnoQa28ANkBq+msk9NhC9PJC4YBAnJXW9JXtWE2AOdB00nZBUkVB0T+g6lX5gngaBDtn1BIGdDLUPXhUOEPWI85qyxnHniXVCF0KV585RsScs0RsOAu9EFsAI+CzkfUBcdYnTeD8USrOPnE+g/z/Ugxlv6T4f+f2prKDYi489kKn9OqMFfm7yonopnirtr7ZsPOFAjfBdTCXvmJMdwKaQVzf/WL8ZwLdYfiwGbw7vA1PzR4BC2DZgvbQEJKWrxQkbAriOJ3pQAd4dsMQChsiHBoTYMrIVNbVbgq3A0uBXGjXYR3HqEpt9okjEXrBjpS60ADx8qZ6YOVD4w47eWtAL75Z3RCmwKHqURw6ECscjRc8j+67rh90eez+M0bGpcHv9mz7mpcM8dKvdPX4MRjsdTccaASj2/FP60asCgHh1Mvj3BnNteoB2ZDa9jXIhpjsfIpWI7ifCGACPLQ7k7wDYcLJUAd691ootnCvQsiREEivNw76QCovUXQLgmzKR+QZA6wDJsELNUcK2ZEPhzZFwWk4nhtKlzPLGdL4WegFjW/eKeouIWwJgVq3Q6vWW3kxO53ewxby2elfio0yFxgsfkhvO60fh6GBN3RGtJvRJ+f1MihV3+08pxT3g9HJQYyhcOAueCAF1t5CqjWDtXe3JGLnWWgLz08eSMZz3aAVTB/8COkzxsEUIALGZk8hJj1f7MzoB02zt7OkSUf4GyJSdgf0mvGqkCdJCCdGCDRdvZ3OXbJ4khf4imtF/uVgfSTG9I9UFNdaib8R6dP4khtoM+FjYpbms2RWR6gOlTiJNT8ArSx4LgB/fwIYyIWEgDw//MDMiUuDX3JQl96+piJSZXK0NJBJ2GLcyVX5SAPVfT+6mhux6wU3YtpvHq/nU32XAxOMTRE8dI5VpzzWrVHBOKn9wI3AdWuP36AiXfucMq8ItfzS8RE66HZrySSxn7LstKrnDFfcsz/riGM9DGl7WSAPZJl4kdPooCK53Cajyqtbk/p//IxfvrSL5+sNFIpOHVi3tylLdnXkft4U5/AfgRXp3cTLVHvBhjaNIR9OUon6Kw5RWA9hXL8EJMDU7qOFgbwZ+BJaDdlKxOCzcARi+VZsu6Mhwr3tNcBVJJzb83oRTG6RB87yjSJ1eSGPP7+GshPB/C66iBI/hnxDUq6dI3bATYCjkyuL7aL7xN1NB+L55eZdHO8XSmCCuG5NBWsDMApCN0DobM69bCyu/36OHqgsotenIN4pNhVR/iio+9JRGAORiUXQBfISw0T0CJXYFB/PL4fsgu5wGx/BCRDnC3qtF273vSJCVHPE/q/7DQxhdflRmihPL2JWt71Pd82pPF8DreJYeXdrKvIj1IOCtuVgrxj/9IFDh6MIHLSgNtTjG27nI5gD96auhhWIaMDTUNgFmAtTDqRCRRixaBph+QiCdhUMz5lBQuYWWAXWSNjzZTW4HfrPy2Bo9kxBNE2HcE4ye0wK1ABrvWhl0UKYPusRiIeiHIipn8/XNetBznEuPg/auaXSy1jxiqj127cGaqj6T6W7qNZyXSSCl7xQ6V862WHfC+Gcgh3SHwYkYJUL0HTHdp7qPkK8ZK897FobI14w2QnYACc3wsl8sJIg9M8IB0VLWLeqKRyD6GGFooqdsGR+R6xEhDNiETBJ7Lw4nhTKR4dvI7QDHN1QWciS1bAhsTEH+kULGfM3iEsQxxnEpOZTdBoijxURuaqIF3JGQj84uRNB9K5AvBhwLJCMOIpnM7AQItLOljgJ8zj/2+iMLDcZE4xxZHAxvIxTOa3KIC4NoejWDhVJrDJCQxFR6ElANL2tbKykANbSAC/WTyex1yfijPL5MDRjJimbF1M0FAZnvSrOgr4dqAyPJ05m0+R4iIQ97auRkdiN8pwR0eeTgM0wu+ARiAUrCjHvViD0tsrQfHUuw6fPwBoMhEBhJ2g+NZfqHBZ6Wj3RBnrBXa2yxVEjxZCUtRK6wND+M2ENWH8sR/SQA+KUHRZzfoeMKhjAS8+SfxNDUgUPL5nrRiaqHK9eZft15Mrp/egGqp1SbtG3zrFHyedIxHlToYr0dhqdHuNGlsptkeEWSRusDuQnYthADdWOORluzjenLFcRkjKCdeK6tUcn57zWUTfo2uNWhkqHdNMjdXKvNNCN+yL8H/N1Hoa0DQp+BoufyA7dRPAin1QkrRNicDzPULgdhg6YSUFcOfJmhJGwfAtJB1cSUydfnN8ZjSCs6sCyT9vTqtdWKIAzlIfqENaB82et3Q7lZhRgtUUY6CGIiJL6sKtTDNU6nCDFmo2wNlo62lWaieUWNeCWVwc/XiiD4OFGAvrJ62cuyfDrnZMNkXC4rx3PM5Tblq/h/b0JVBt2QoztkiMOltKV2s2+5IXyT4qt3c1KtmYDRbuhqBVQHQpyyont28VQ7cgJrGaQMa2biEishxj6TRBpkhAG+mCouuc41IHD1KD59FxxRMl0+OWUXSJC8dxLO3TP5nx+r3kTzHh3m2NGybp0eBkRctoQl3Q6JTrccV2OvnAzOq6D0R1Z+XFr9lGbGhzGmg6rKnaATAjsFdn/TC+s7AAshVE8zV2p2eL4pTqIMZ4s0oV/9yMA6eNf5ECfaG7rvgYy4cC6aO7vN489TaqJautAYD7U3XFUGOgTEFHq/YBnoO6+o1TlGBRDIA0C3SEnKp7Bm1+F1nCqECiAVXRA7OxwHkHhfD5dtKxq+6GbYaPrRwN/kNcdp36gU+6LFH+qcnU6lKxHeDn4SiI3EvpwrCic1TPvgHqwsyFMTHqWYw2BWXCGEMiDd2e0gVYQGgLheyHQBJgEG0Y2hhBIaL2FR5tNgybw5PxJ0AWS2q4k0BCx9ucB9eAJ/kTkoCLOPF+ZwjVQbfkJsTsqDlplbKVm/zxOLkXIlwgE2VsMIeURsmU1PNZkKtnbWogjESbDzuG1xBEktUWbsQmvfgi9bTNcvL3Q7iObvFb1scp4NDpU6aAiYXXpvMpBKkNXnsoQ1aVxI+xrwldJTLMmkmrtoRKnxPmxccDtsGh+Z+G8vh3YC+nNxhGaCoyEhxIyBfE6Bp7gRVKZAXdD3VZHSclczL1TV4tzy2OBQvhTRCq7hscQ2Al0RXBXyRBIs3i+/UAAvouuTOa6ewnLARpCpYJC2A1FtyOO6hmM0Mc2wKbu8eLM22aiDU0+/ZiiyfCb8m9BxuGSh4gDbkIQ007y9nLYHAbucHO0+t22r5PlfghcuQ06QlgHL53ZqZuEIMZJOGKsdYWr0iF+KCIAqjXwJKwdiFC0Sl4Wy3UIe+EaoClQF3E8iZPUVek3ftrrpi/6jZb16iczN4JDMd7Bas41KpiAH7+kqs6+9MuHqcrW2bFu+p6KfFbVJ5fh5YT2A69+dV7zCjJQEef+bAxD2vqCczKoBoKXkqSLYgjGgyt7cW2W3lkPwHa20UgYyKvhq4rXirPVaiAM7c2QtetWGAt7FlSDVhDLQXHGZnloM+Rj8SKl6iWGyUJgKtxY43MCmxGyYgJCr+kO9Zsf4vBqmN/wEeEB7xeHevHwSxh5LQh2H6jIXbfoABXssoxBHjxkQ9itD51eY+d2ADcSVvXn1R7nZ6dgqAn9oNqwE3y0oy3tBqwTkVMLgQlQ9DlMmjKRz878krE7pvDewsRzL1IKDC4pZSHQHyKOnBWk7gogGb6KrkXK2MXCMN4MGc91E+flloeZ03qLY0cmgbW1AsczQ2laY7vIXxFB7la0u061JU8lgO3x6uxT1fiXiWu5DC8hbOZF8PBSeP1AZ2yEu9w/5bjnZpg45UV1aNaFzhMXcVd2Nv1XZ9C/Tga/i55I0qKVYlfFcmAeDJ8wQxyp0wfeHtWTwslAJ7D6wa7nYkSRI8F6owJshlPDAtRcnsdHo9pSNBFqJuXx5pE+xOYfFcZ9GlAAdzRYTUa9boKk2owwrKcCq6Db31awc1ot0Y4z0HxsLpnN7qVoE0Q2AYbDWCYgItTl55QNP1Wf+N1yKRtZqvIM3CHrSKdQ61IqEleGHyXZvubm5JLz1QRawyyITiikXYd1/KsvVLKioSFsKU5g1/wYKnAa2kDnUVkQC19/X5eTEeUESToPWjXfKo4YqQ2t+QAawAs7R8JeeHpNGgyCvGfCYDsUroGWZzZCAhyfDmGpiN3Zy4G9cHIAcBj6nXhNOEhAvHQsFTYfixcR7Jnw8vo0KnJaRNlOgLia+4UDMQqO70S826cq8AoEmp6FIRuBrxT9E4raQCxS3CuN09XgPGSjTienUVxXleGnLp1B71YHnHeKRcN16QyxdmG9Wo4n8l5lFJN4OSmNpw+kiWOmxsAdfMjjgyaLeQBMThonzjrvhziyYKq4HpexnwxSyGjQDWbBpuR4cUTOowhn+s0wfOoM6i8/xKKWnVmS3FE4O8LAig4wtPVM3hjcg0qnT5KcsYx1tzflUKcovo6oD8kQ+i0U9hP1PvXMCKhc8jj1EYEraZDT/1ZCB8IrK4aIs22b3ASdW0Of1ogIx3Dx3Of6QKdnuvW7gT94yWIbbvLXj2z3QmmjQmXnsWrHlG0D1QSGQ8pQGDcUdtxPe2sn+/9dlTXbbiPs+5Z8a3Xg7LFyWK8E4O2qMGMgfPMgE61N8Nf+vGi9T1OrCnTuBikpCAd2jZKynW1RRfnK+pHK2a9K50zrRrCr+saGlyPKwB9UXJQX1yHn1ckeP0SjrGPJOoFMzsr16+rU6XjBpJfboGqHn3Hoh3dw46z8yAA7jb81x5C2vqAjZ3WDVE7jZ3C4pZEJMnnC2X8hMK8boxOmUrfDUXgGGqfvJGHCFhENdTvnx0VFeIcuMAuaD8sVL7OtgYgCmQk0giqc4NDtUbAbMniQne1rCaWrE1AAU+qlsmVTQ1FeGlizAlSbXRKe5fv5dN4QP/3mdxK6GRhO8tsgeDgNOud3OQ0IY/2UJg1c+DvqIj7c2qBb1G/C2hrAGgkF9cqJaKMOQFu4tk8uAHuGVyNybxFPNpjEXRuzoT3MqP0wy8a0F4TtcmABkARP3j4JuoKVA3FD9nP/+HnsqF0XUqEip0nt+xr0hC+5gfHPDRdv8N4HX5W/TpBQnRAk2BrEVCkEtQKkenZ5vBZL93R970fAyenNvAgOXsaE17Yyt6iOU4p0skEgQ3c/HCqn0H7TMt6Z1EOcWdsXrt2by9RAO57tPkQkyy2p6iVEVHoOsAR+UXyMjDbdGBQ9lfo9Dol7u6HoeaBTyS4NZ5WJMKP6w4ScQZxVGAvcDh/ubk/KzsXMmPywcJJEAenQst9acu6+nrjl+8U22+XALkhutYzQXMS1PDi6vg7CsJafT2d0qSJynHlQfHcaL2Y+lA66yAo3uDm87etF0p99XUcsOg1HZ/4aMKAb/P0mvmsc4F/rgTyYZU1lIy0pegnaNV9H/Q6HqJt6VBytkw17nqlGg5f2EJF9FiLhvQaJouhBQBQkN1xGZrN7CSyxoAuMHjUVsiG6QyEcg7BZENmliOP9oHx+OeHMiwSS4fW5yVRKg37LXxRbxu2h9xIUJUDzRbkceCaawGqLd29vQ6vmW8ke1ILX5yeL40kawvtzE4hMA47B/gnw+UGoHPMd8C/UUbNuhpQqrS6NgTdkx6oTssNWR6LrSN5g26FDKBANrZ+Aq58AkmAGLKcLJEKgE8Q0zOfpJWmM3jhVOKB7Qcwr+VThBDSBgrRywmEQBa/3S4YmsKRlR8GDxsH3XEXK+sVkN2nBcu6B8lBQp5zYgbEBIVuOQ/dF74pjDzYAC+F4nVAy1najd9uFRCw6y4aUxiTs2MI2GvEFNzDj0YehItSL+Jrs5BaEcAYi4e/cKR6tPUIPGwNshiWdOrL9wWuY9+n9fPvOVfSeOxMR0dgHEfVov+xStvd00ef2XDKOb/8oRk26eslynVzWRZi66U0qHc3rN7Tv28c0yWVUQUTFtoarhsK7T9DDCvCNVQOrb4CBY5/HsgKsGnUfn3MjbcZ+zKndVYmZms/u6BhoD1bdABYBrM4VGD1lKta1AVLTX+ODM23o/c5MOs5fAk/3h5g+nHNAxqcDdyImW0vgwZJ2XMf5l4Y72+r8L/8WMoql/zrY/eGcC8aZETx0a72bDLH/B0NSqtLpbHGnDFMFAcn3deXoODQ/zkZVear8ftJ7wY2zkMtXcXR+8nrDkLaXBD/eCVU0g9sg9ZqEqvLtv3DxkokxCIJ2Hiya3JnXxyQLBSUEaAVtdn4M66ElG8WZt/OBIfDe2kSeWjtCRI0chsQ6nxBTMx9WQBV+IK7LfjLadxNGfiEM3z2Dq/g3NQbD5/2Bg/BHfofYsuEUWsEOTr+TVEVI6SJu3DxHBpcOWWENxvuk+y4bk8F6sUKBmrDjJm4buYZPoxsSUf8sDEMQppPh69XxRHJMvEwsAl7oP1KQR9UhNec12lVeDWlwfHqoiK59Bl7YNxJaQSATOAJvpvahwYo9vNuyDYN4iTvmrob2MJJJjB02hTvWrmbdoKZsoxF5a8JgH/TZ9TIzl/cW83IzCI+Jqv3yc8qHmstjXyUYVYLV62UbZm6UDl5Kv247WmmMOx15r1LEnehHyg+zWZV6H8cnwO5XgGXwdU48L1szGfHKNEgAaxaCMG2POG82ByiAU7urkjJkMS9vTuP9hQkwHFgHRcVwsnVJFQVAJwjtA6yGH6jC7ugY7p89TzhNTgOTYE9cNVKHvSbSdwBmwcblranBEeiPiKzKRpxReBrh7FgBVhq8fbvNDqve8Oy1ZdJpmLjlA7UhaeAPtsHmFgXihI6gkmV7aRRvjYOr8v38c+aNfNm2NlVjS1bGyXCMqtyTv5KiYnhvU6KIENwL1bqcgDown9+yZFBHiloC6+F3/BFrFYxs8pR4oVgaJM9ZxqvpvcSxBrcjosmnI3igOGA7hIdBxO6zbFjVmOO7gQ7w0NhMXh+fzHK68AR/gjMwftVwqA6h7aFT98XM4lGsbQE6r8hi2ab2JDb/hIcGZDI8awZURZBgtwN1oNZguDEFftheHRr0L2mM3O+yDPGCUy6beREcZFntFqygIm9VaXQOWi8HuDznbHLyQfimD9YfAyw8eg9h3wf4pEMjvh4bD5thy4aGFOSU40Y+Z0/LatAJsjbcStEDMGnnRKwoiJh/lszZ98J26JWfyfHkUO4883eOLw0VtgdQ2AQSp3/CxMxnGTnrKSLWn8VaXtKUqrAlpSFMhZvObIM+8F5aIt+Vr0pK7mJmrunN0ZTKtMrcypQGqbSbtI6kYStJ7fEaDIY/05tjVBXv8uglXkpGBIx85ikhS9oDg6ACp7khbw+9Gy4k5vp85g17jDRrHtWsvcBhLiZg7d9JJXuc/WwcfaWH2+6ZYMpwi9RVOcpVegKKdDLsKNpohA3cA65Oh7efIMGK5kPrMY79O5xv776KN6f24RhXQzy8XDNNyJYIaNdrneBT5wHHoX6NQ2KMluzum7mtN68PTxbypQtExhcxL/cxbuMjOo5awjvftoWQdtD5JqZue4x3rJFQuT/sb8UQaz48cD/QDeiNeKHNg5wndlV9ooJfwlaXzzj5Sgc3G03HgfjhPtzu6wKsVHlVep6X3ifLO+duBhXxqeoD3RE2cnu8+sGLXA1m3MpkuU4mOz+b4xEuA5zbkMGdHMRxTwcVgeimYPmZWM40xbB/J+Etj/HZmPocXxFK9wnv8lB6ptiSugKxVa4tsASa18w9n/VRuGtINhOznhWPvRSxjag7EA/1px6CXEjZt1ikrwqz66XQuOBfBH5tceNzYG2G3kcWIrx6Xgu6n4VAN4HcSD4/RLqfewb+4Fx0ZUNEt9h59btfQ101j5zfi4CaDLzhefoxh6a52wVh9Bw822AI3A1Mh71RddkaG0e/6i+KYdseQRDFQqUmiBeKxRWRNyYMlgCTIb3POEG2HkMY5H2hc80surKUD19pD7dDtZwT0BU+HNuehLu3cCOfE728EDJh3rzHGJj1BrfVWyO2jNsRIMrn0xkBXmuQmxEuz89gfyMDPXRRm7qjD9zyqKCLFHEaHTIhaX+uTn1rN/PnPQK5ELkCTlr12dGsLmTCb0/PF0lzILAIZrR8mGfnDxFHqh3jHNmaNy0M6kC7HuvgesiadSuVGkKl7gin3kE42RYenTYNhsOIHdOo/8ohvuEa3pjcgxntH4YcqJt1lMzn7uWz+fXFWYMAKxDOwvYIUbINiv4BRbsRDsljEEiCHJqUNEpFvvr5bm9XdIumDeZ3Mbh06NYdVXSGm5PbzuOmtBcBcXAXfMH1xKXu52QeRJeH453gzaw+hGZApZGIM5Y7QObyewm8cJb3FyQw+uapJPVcSWgSkAszSKXcwxaTpk6EvwFdoKBXOR6snMGxkZDV6VZxtFQyIrI8F47tLWnKSGg1YCuRmcAMyBsfRhNy+CO/o3luLsyBsXOm8P7IBGgGK3Z3Y2LfZ4WBPxXuXb+adze1EWdD14Pqw/fwYqN0MVwLECTxKITxPwREuLqz3/wYdjoDzsiK4OE1zlXj3U0vdrvut267jOvEuZrfRPN13TqwA7rf/S6nJlWl+dRcsse3oGgwNG29nYgVZ0kaslKca7se5tKX0NOQEdeNwHagqnjZ3s5ptciJiufz8jfyRfkb+Kj8bWTNvpX+zCZsI/Qc/Bq9kl9lUupEmAOBLogznPtA08ztEAaRS4o43iOUuzKzqf/KIVgDAxPeEHKgPgw484o4q3YzYninwp/5LUmLVlKFH0SUbjPITmnBM3kT2fNMNQo3w5LBHem8OYuALX+KgTXwXMOnRBBK5S4ID4vOKW7w00Onz4B7NK0t090IEd1RAao2yHWDGBd3AUPF34z+PGJ9zovWM1ifBVh7b0s+fKk9IZwhenohMc3zYR80zdouHOFrgHUIJwIIG30RMLekKe8AR+C9vyXyJTfwHVVhFmy5vSHLtreHg3ADXzCM5+jcNgvr4wAkiGNKOu/OwvpLgBdrpvLCvpFUnnOUcocKmG/9lkTra9hQC7gFccyULqI52MhjOZ1bxK6Bf+jIUDeiEkUaFdxkipfu5ad8Zxq5vXZZdiBRJMKJUIPzR9RcV/LXoOSvBuLMnQaI6PEqjvxu/JwMNw7Bec1L1/SjF12eQChD2rqiGP0P6de4kPOEKv7g/AIXzNkvznZElpSxkcKr1nGQWCK7F5ExphtbJjfkaL3KHGoQRdaXt4qzbTsAyxC7f+bDjrS6QoB8ijg3rSWCsI0uKTYHYURvLvkLgf5JGWREpEAGLEnrSKAOHK8aStj3P3Dhwu42GYKF7fEuzQTQ5TFRIqWDvKDLv6ku2toPqegUPnJ6v4gEbudGPuehOZkiWnAwkAkjcqYJA7YeVLv7BI1b72R21cdhBRzfHcqMeg9DAixZ11G8VKMiVMkvxFoEJEETPoU4eH1VMnSHrMO3wgZ4pf4QMh+9FzIQ5Y9BzKGp0Dwnl/e6JFKwpGTZPQzX8wVWXgCuDqCf+zriWkWWO697CXZn+fKLaQxKBy9jQoVgo211xosuasRWvKtAagpfr48XgXaFCEMWsZNCRHzDzkG1BKk0BlIPvsaICdPE+c+DEbZrNkTXKIT1sGFhY9gAbRZ9LPjTncAumJnWm/CKorwDidFkN2gBB2HdVa3pffdCevIXcfMw9DzwV/6Pg+yKjxHnPPdCyKHdCKIpDfHiJRCy6xiwED7g14jJqVp3/ETmFHN+S6Mu6tbIhssLrzVcp/zqIhBlJ6Efo6UI8VvHQUpHWizK5oG8ZbAIKkXDoeL6RHZBvOgrFt4bmUjzObm8caAHFfkR62w58RK8aYg5lAh3zF5N4tRP6L10piBIXwGSIWLWWfHiPKDN9I/FGbNxCOdHF4iOgtAliDz94P6u82AyRC8tpGmH7fTeuJAD8dHQHn7Tbz63nf6IDcMbi7PSo4CXoHA5sBw698oS+txO+CsPYB0U99mAiGqcC9ldWsCAf3GeIXD2jSqgQDZWdDqsMcovDV7zwk3PkvOG42+O6Qj7GjTetoHOdd8W5GgsTP/bIxRMKAdJkDjhE45FRYkzaksI0mpZJ6AYhvFHSIOUI4vZcHtjjnatzMSXnqUNWTTfl0ur5VtpPiqXuzpk0+bIx+RMvZXADxZ9mcvzDCVzxr2i3GJgJDzWfqoIHpkGB7pHc7B8LPwTWAO7BsfAM9Cu9TpIg8i2RYxvP1zsHJwG5MMf+D20gppT8sR5ufniHR43R3/MNW8cIbIwn6TpK9nQrLFwNq5GzM9M4DQ0QkT3XkgK6PrU1qOc88LIj0uDXzlup9Xd061Pql1QOp1KTh+COIrgTuZbz2KtDbDaugNrSYBXag4hteZrcDMk9voEjsFVfM+BwdFs2NRYjKnynDtbmeWIgJIsRFBVH869MHz2oykwCfryOj9QhS68A9thH7W5d9hqGAPdu7zLNewWYzwHrNwAzeflCjkzCnFvFfwwrzo7ajQg5frFrG3YkbdbdhC8F9URY1x+Tlsv8tJR/YxzMxcuP1T2nUqWeAXl6L6r7G9Zx1LVbUedR5b81eD8Wc7RnCdmawItEAbJnUAfSBgKbz1BjNWBulYnce/q+wn7vh281w02dIPOA0m1vibs+19T+UQbeO4JhNOkLucDMXScgxu8+D6Vre3kKYq48D0zcPF7fJxyN3gey5C2nvDyJugIXC8FTM5nn/Vpb7cJ5scMBaKh3xM0ta7BWngv7bLWwWRIyVpM01HbqVbnBDHX54sXjd2DEBj3AuvhjfY9mEtfDq2NYnZaijiDswYQD4VpCGP9IMKInoTYsjoZ6AP3ZqzGCg2QlLUSgMhORRR+FY3wivhpt+67KrLA/l/s+K4qIxiPiDE4goe9IOqIRfl3gosXK9Wi72aMhGryyJAU5rsq0YzN7OlXDWs9WPZ5snbk+U7I/lsLEaEBMBkipxWR2vo1GC8UI3oASyF0OgSmQlESJN+9DG6HhzZnkjGjGz9SgftqL4BkSD64DAohu1MLEeW0BkE0RcFdE7KJyDzLrj4xHEqOYt7qx0SaELntuueSn93td3DCLULEXne85o5BcHAzFLyMBdk4uFRiNxJIYt6L9wv9fBFina8Iv9y9i5q98qAXRNQ5S9y8/SJSqSLCKD+IIFKzSopbDsxGvOE+dyu0hXXdm4qXH3URTRy48Q0CK2BSyBBqLs/jGFUhEkIbADkQ3aUQRsIbyT2wPgrnW2KpP+UQd/RbDavh/urzzp3/vGRvR746VouiYrAKgZuB6ZD9u7uALaiNNj/RHcGS6gbBQxfRr1pngnGG69Yxnb4m32sK73XESg2wsX9rAnth0+F4WAG/nLoLukLREGAFfMfVWEnQ++aFJI1dycmb4blGTwkD+TTQEHGEQWWY1+Mx8cjLEVG1BRBZGapOBaoizphNLOmWVRAYCUvadGTDM40hC94c2wcmiJf8HV4Nx26HsJA8jk+FmQwkIuksrW7eKuZfG6AJ/BBRmS2TG8IkKBwApEGbrI8JLBe7n04egc821ef5yQNp3W4jQgA6t6rqCG43p6x87IWZI5eGYG0It/zOF/3pjHmds/w6CGtNJU7yTv8ecAJYBYN3vkrEgLNC7+8EMcPymZHysIjszgdmAVniHH/igF7wFr+h2qQT0Awq8CN8Cge6RAtSdjAUVYT0tHGcujNAu77rmEM/vqEet7VZI5oyFl7KSxPlj4GamXk0mLKH6c89AilQf8gh9iRWY8vahsKB8QyMTZ0inPMvIQKxQMzFbMRZ09lwknBG8QwLet/H7qr1YDm0GrZVyLyFwByY2aA39IEXeBK+cfaXrJ85iQy578HYFsFApeN4yXFVFKif6Fon/B5/YKcNRxCcoZDSh8bWSVLuXoyVBO1eWQc14P0DCfQ58DKLDnSGqvB/Y77m2vw91DyYR6uDW0VR+QhZ0A9ojXBQl0fMpYbi/m3b1tAvLwMqwqGp9Zkz73HKc4bqyXvE8YafivTTlz/CVXwPt4jdHdRH6G+zoN+2F1nLryEKnho0QkSmzwZ6CSLZyg5gzeoF+x/hvHPCjnCU+6M0R1bIAQTGtrh0OG1FlbNVp0ddSt87jy5w1m/PhxpAIoSNgmvSxd99Q2HeUKKLu8B7Q+Ht/tBgIPAkzHqChtYttLFO09vaTtj39Ui13uDhD2dQrdtevk26llkMAE7BuzAraiBfd/g/rMMBrLEBviWWU/uq8sPY6li9Aky0hsH+38A1QxEk13Vc+BLJS3l2Zz972djykTnO7zobHvzKCkPaekI3+FXwQ3jYP7pXZJtdr5fX3MY19J49k98yH6YA0+BoXGWxxWJ9SZIuQD2wJgHpYG0DBkDvXgv5gSqcpgL9kzLOvSiGvvB9RBSH6kUJ4TIB2m56h7zxYSLNPISSMxQhbEKAMWAVBzi/ncjPM4JeiVSl10XTIF3X3bfrMygdVBHoKuNOVnJVSq/zuowi6U82wuHiOSeNqSHQavdWtnMjgSYQCAGOA1Gwa1MMxEHi2E/gbxDoBc/2GcLRtMrcv3YenIHBua9CV8T4rgpP9RlBaDRCsdoNW5vFkZK1mLtqZvMSqex4pq4gxHZD4s5P2LQhXhgD0xHkbC5QTxg3MUfyhUNkFTBObrvjGS4a7zpD2k1Y6yD/PrJhbhA8/ESGqIwKHTHrNFz8CHY5fziM60Ou1YI7+Tsb4hqTPnIc7IbAb34k0MkSBFM0QtGfDkTA9L2PwCIo+itYDWHdgqZcvy5HnKeWgxjnUfDG+B4kdNkiSKxsRLTSHOAwVO0Ah+89H5lOPmQduFXMn2bwm9NvMaV7Ki8xCIAP+7eHyBIjvyHkjQzjILHETd9PpSgIpCN2gGxHbCm8YE0Ipo/sdG5yWBeBa+AfKmXZ7zql06fkyA8vJdr5vRi4hsonfom1IwDLYfbsFJgHX3CDeO9S2kp4CUKj4Y3ZPfhNwWICTYBEyBp/K+EV4eRuoDwcX4OIdKr/rtidlALPdxkIe+F4W6AOhK5DzJfakP1MC+EIyUcct5B2L0kHV9Kqw1aojZg/OyFQFWqMhKrzxZm3kX2g2o4TBFpYLPm0I5lN7oVUeGNyD67KP0HT9dshDcI2Qva2FuKMxKnwxbG6VBojtomnTX0Z/r4O4XV361dZzqj60RlcYHSpS4dK/3WbIypdyEvflfUp+7p9DudQyh1qy7hT6dzHUh6fPRkqI9bapTB97iMwAWY0exg6QWr/16A9vPG3HsKxtxe6t3pXOMOB53KfEkNtDny9Ip5lXdpTc1ieGJvZMCeqN5OnjyNsHxTMKseIjdMY0WoaTcgRRyMUl6z38xFbxhuJOkYXPA1/BY5BnbyjNB22XTjeC+DQjCimzE8VkYr9oOaOPJ4dNIQn/zaJ41VDYRQ0XrGTa/ma5I3LqNkjjylrUnn3uTZi9+HdwAAYmPoGnIGMZf1LdqMc5vyYV/Wpqv+D1cWudNg6kawbuUV3ys5pVZSsFwmru+bMZ0cJ3gU8DleVRPY1gZwdt3IyWwR0kC3+2jVax7z+j9HhzCoIgW/nXUtoNoKYHYBY/ychdJhCBEc6E3EMVT94NGUaWdNu5aOebfkhKhQGg3U8ANMhbul+/sGviHkpXzjTx8Dg1a8SnVkIuyHiyFmhfyUAG2DOsMepzT52dY9h4qRn2UwzjieEQjEk7vhEtGUJrK2ZCDwBDYaWNMSOhJRfWib3sXwN6Zpb5LKBN1TjV9ah3GSwm93slke222192d7VHV3y1wP6PAEzBtLYCsH6NIA1JMDi3Z3Yv7Qq1qcBjvWrRWqHKVhNA2K8XxXg5Uf78HnGLfRlHh1Yxan0qry4Pp056Y9zpENd6AV35WZjzW7P/pZV6T1pIfV7HmJrlzis+vDWgF6wE3Y+Vwtaweh5UzkbHs6Xu2uTZi2BYfdDrScgJB1xdnN13MlblS7jJMZ1wWW6/tRxGvL34OSEIW19QfamOq87IZOKbijWlCmXbRNkboRwFUC8IbXvmbli8R8F1V46Aadh9toUZu7tDSlAAQTmQEG/cuLcqBXwm/nzeXlqGm/TldlLUiAdoagMhhpV84lZng/AlpYNWXPwHqJ3FgqDvR9wBFo2WysI3BnCuC+MB665iQvPGFE9n7wwOKFbXPxMBDmtG1FoFKvSwctgtqGaC8EY7F75nL+jTD4WwQzoUO9t7tqcLUijMSVJ0qB+/0PCkTEHdmyvC9EwYuo0qi0/wZupfWAy7G+EUIz2AfMRL0hqgiBa50Dj6TuhEN47kEgFfqTB1D1C3zkCnBaebOog6lmC2LZXB05TUUSD9EMYKN/bzyx7M90UTr+Cwg1ua5VRsIKDrdSGOr6r0tjQnSHmvBdslK2sQIcAD2L9NsAvr99FzS55tLp5K5N3j6NgZDmO1Y0UEa19gVYIZX8QpKeMI5aD0AxCIyGQA99Qjy+nNsHahdg+2gZ21K5L79ULeX95AsMOTITxnN/J0R/YDDXSRFQUUUAvaNPzY6xGkFc7jMqHChm+cwbT89MoehR2zq7FprR4GvEvmATRvQpJzXpNzJXBiC3r6QjD/4SqT1V9qbpm/z/lktatjw1KBz/RfmjS6EhF5z1dXTZawLou/JBdncJ+kP7MOPp3yOD4LEjZvRh2wtqeHYWDbS40YzNzIh4Wc2MQfM21BLpAperAKxA5CzgOS3Z1FDuRpsC1fM349sOJbAvLUtpzNL4ygQSL4wmhPMcwyAdrBZAEyUuXiTNmBwEvwbF1iEjbY5D1zK3ckbyaSokQ+IXFow2mYTUPkDRnJclzlkEi9O65kNDrgXklR5VMhcRWwhDfsaQuDcbuoeXwtUwZMVa8pJbDXOiocNMr/eheNoysuDwIRn7Lc0lncKrKd16vAVf1p7c1hzOvVebJMy/wIAt4cVI6dIXrl+dAeRg87FUAvuEaQeSOhD0jq/EhdwiSNALhjItCOP7WgzUSMeSWwr07VnN8cqhwug2AgaPeEFGwg6FC4VnhtAiBl7PSeGNND3H282aR9tmFQyiIKwep8ENadaHHTYbD0VEcfa4yLQs+YVn79myjEcP7zzhHHPMMDMufRi/mE9mnSEQmNoGmL20Xc7wAhvefwT9pxoHx0bALmArWBHh2/BD4PfDdypKHcAYr+AnQMQgeOqIvhIt1ITf9yfnZmV9Og+a6/dk+T/NBGN2H+dazLLC6M/zf47HWBJiYNgwGQ6U4xEuFO5Vkmw9EQ+SsIlgHU/qkQhT0mfuycEBURTg06iACoFZAQYdyYgfgTnFcVRM+ZcaCh4m8vUjoP00Qc2QwNGi9h2WD2kME3L98Hh3avy10t3xoWXutCKZaARyELc81ZPCoV6m/8xB5I8MYc3oCkX2KSB8zjtoNvhTHMURA0pklWOsCWKsDtLB2wG/6ILasV0cdPKbbGeZ1z9jcwUO33rg57GTS1Xndi8ty5rMde3WBftB5KDyQDkMGQueBpFnzWDD3Pqz2AXHsWRqwHpKyV1Lz5jzhpBgELw5IF2t/P+D7mTy2ZzYcFrvBk3csE+vxJKBkhxBN4P34BN7o14OabfMoHAxbFjTkhoKdBPIRdvZc+IjbKPoUjvcKJXA71Ajbz5iwp7D+FeCbfdWxFgSYbw1BvBywBudtNJXsdHN8uvVZMAGCfvpeD0PaXhJUk8FL0XWeb+FVtu6/PODgVmsDs/Me54vyNwhBMBjh9dsuCKJTVIJsKEgrB9shotVZsUuuO7xVvxdMgcE7XuUrruNQ+yienzUQMiAQARyBd8e0Ed662BhYBHlfhonql8DGIa0hF/JahhHIgbBs+xnsyaF6Vuf2umAgG2pu+f1EjBiUDvJ4tCHPgVDpz80AL40C7CyziAsN0tbwe1j92b1CQeqLGPMjEcbFKgSRGykW/uwxLcTcSQcaQua2e6kVh3gp3y5RYmrr14TQaYQwTuKAzVCeM4xlPEX9YE/tasKDPkOQtrMXpnAoJYpDY6J4I7YHVIQ7T/9dKFYFCKWpENSKqLzVwstrernGtJkbwcO55VhnGHhFf+iiReS8zr9wTfoQ4HbaWP+AAtj0ZTwjlz8F0ZBdrwW/r/gs0T0LsWoEoCIsqt5ZbH99CdL5A91feZcdg+vCBmhS+2NBOL0jnH5UBSbAX+hJUUtR23PzniKr2a2MbzacY3Pg8BGEkyISNkxrDL0gY2Q38SKxuRA9oJBpdVNhAIQeh9DTEDdhP83H5vIhv4IBMH7+8PPR6LGIiMVMCDxkQe6buJOuzr4Il9LI80xlZLhFPhv4h8qhZuNiXebCfH5JEi+luRioCXclYEUEoD8MjpjG5Nxx4oV8GxCyoQaCgJoGSxI78supu0h95TXYDs/GDaH/2AxR1EJEdOHtQHtIunmlMKhHQlW+E2dhHoF7e62m2tgTWJ8G+HP533IbH8Fp+CoPsXupPDAVtnaJgzlQtQa8fziBQDNxDuGHK9rDYDgxrjyvDBki5M1uhNM8Da6a++25CN9WXbaKuZIqnqXB9XvgGHyyLFHY3sVw/mw5mbiV+1p2hKr6WM5n4B9eQQSyDiV/djimXeeE7je0r1cBWkMfuIEvIQ+ivjnNUJ4Xek8X2HymOelp47jmue1wBKZmj4Z8KKwOa7iTOdMf571+iYKonQLvr0rg8QaTYTP8I7oFB5ZHCwJ2OUTN+5E9idXE7r8ViHcExIr1f0NsY3auqwVx0Hv9QtgGRMHTt6cxYuM0ANIbjGPRrM5ijmZCzJF82pDFj2Gh3NtrNX/mt4JfTRZ5mQSh94oXDdIFRiY/RaCtRZNBH0MsFC0AysPYg1OomVQSBTxI9NCI1tPI3X4tDOmImOhy/zv/68hz4+ArHVQkq58dR7o0fvPa9YUC18CdQ2lq1WSB9SjWQwFSXllMzy/eZnKXcXAMRt89Veyei0dErB4WJRxqEoWVXlJkMgzPmAFzoB7fEHj2rAjgAHFs2nTxMSLprAjuWA6t+YDoSYWkzntNkLz5iPFsb5IohHs3r+ZA92g6sYJVo+6DGuIoqY1JrcVRVbOA+tC0x3bhHDkDv8grZGnFroyfP5zJd49j35Hryd7bgnVLmlKj/GEhXybALfyTWot2wn21ECG7XjuD3XQi+Z5xdAQHZ+CeX8JPTqv7rLrmlP3hCNK+K+UOdWWcJaJlrfoBTj0dwBod4LlWT5G8aBmMguFdZghH2zPwXmIijIGi/wM2wvGXQqEDwt6YMZAv69aH3VCUBHyJIGwHwfPbB/LWsc4wHf7EE8yhH5yBsHRoOm8730TUFbrTHHh/eQI/UoHPo+LYXL4ZFdblE7kCItsCBVC3x1FYBCkrFjPJyqCpdR2kpCMi5htw4fEJOJ5ZBy99SE6j6lv5mv3Zn6wwpK0ndBNF1/lOUlVWfN0EvttC5mbMCKLqFjYT6CfIp6erpwkyaBqQBqn7XmPosJmwGzZWbEnRUijaDScLEF6QyYjF+gRMXj6OmOb5pGW/zBubenB0b2V29Yuh88Esqk06wQ9UgUyIblsIU+Dp2DRBYjUQChyzgDConHtU0T/O55HJKB1Uhpvznnxd15fGsLi8kMlSHJ91ZKKczssD5axLLk8He1yFAzex+vY7sBYERBTIVLDGAM2g3/wXhTLUA57cPokvuIHEhp+IKKcjcDIdklcv4/BOxPEIjWDrhjjeW5soFKBoxJmCfYFXoF36Op5mFG9HdabuvqPiSJFUqJZwgkZs46qCfO7iPXoPWAj3irNDSYYtYxoK50ot1fN5CVe5j3SGgxec65XB5YHXVj2/xJ+KyJe37avW0pL5lXoLT/ICAM1vzmVSo4l8tqY+iV0+4cUe6exZUI3qM/ZAJ+i++d1zDouhPM+6R5vSoNEeeAlyXrqVnDm3iqNwdsF96xaQteZWJmY/y+iocbRbvg5egu+5ivSCKRSfKWnGDnhqzAjx4qYkOEW4OLLnDJArHIU719QSBFhbRHRIJmyjEUvGd+TJMy+Qsa0b99RbCNFQlAvWGkR0Iscd/eNFhp/i4t9EB3l7plvUiIE3ZDJKReB6rX0qcjCci8tQOQWLgJrQuRvWawGONwqFZHjlyBCsWOA56NXkVWF4D0cY0a9AUs5K3k1rA6vg9W3J/JoPhFEeBZnN7oWucEvchxyYG83+HNjfXNSYsG8LXfNWihfO7EBEhy+FNoHXGFFnGjwKcbXh+Hyw+gJroHHzndAJigqg3cZ1UA8mMUpEtE+CiF5nxTAMQ8yTGdChydt8P+//YDdUT9wjtrIDRfcgdko1gddnJDP13sccHEgCJcLmEmFkxaVBR4Dr7svX3WwCr7rs/NWBOGpZx1n4wj2MyJ0Ga2DgtS/wZq8+Yp2eD38sP4zJ/cfxPu0gE6YlPgrFcDIiTOwkWgGtC7KFo7oB3MjnvLgzHR6FxA6fULNH3vkltAmM5hnh4CiGUdFPccfc1bATWnXYStyQ/cKeOA00goy13XjizJ+gIkR0OcvkDuPo3v9dqAob0hqTXn0c21a3IHJuESQi5uhLCDskH2bW7s2WtQ35NWthOYzPn4iVGSAn51aYAKEvQb9ZL3IoNkoQY1OB4xA4AhRAOCdh2kmEkqbSYWXYwShmflw6nCSrV1TtpdZjO7/tszlDgJo0fX8d/8y4g+QJy4QN0RJSb5gixmcsQm/phCCcTiOcyjMhplU+geWc23FHeyANxu6bQtq1z4gxPh9oBO8tSRTHU1VEXI+FzmOz4CV4r08i49cOh7ZwoE30ueMOH90wjbxmYdTcnUfv6QvFGbiHEY71Poj3cMxGRKTHA01gSYOOrI9uSsqOxYydNIX3/pbI8aqhJLb9hITrt/D5zbfAfCh6DmY+M5T9W+NKjgZZidC1SmtDywS8scUvH5x8k3zdht+1SLYhbcL2QXigHkdrXM3I/CnCfxUCf49oI5LOAOaX6OVtEQ7tUXDXzdlQEUJLnMyRA4rO3bM6BXiGkdAJQtfCu13aCNsjA4bumEn31HdhEFzHVyyjCxvWNhaRtZOhwZA9AOxZWI12q9fRv38GN+XtpM3Bj/l35V/ALChcCG+s68HrC5M5nhnK9E6PMGLqNP659A6i5x2gt/UJYd//GkKegAFDS45QGIWIxi129IFKD9VB58hz9q9OFtuBBd4wpK0nvIgpGSoyy/lfR1bqfkyve2JyzfhiOOTB4JtfZfRLU0XEYA5C1xgMpMChaVG0yf2Y0OoiZ6UmcDwfYQAPBvqWGBGFYPUN0HvOQn7JZ+LlAtPFW5Qb794phFeCSDf6yFQxaTdC90bvnlN8KoT9iP48Xq8FRRdloOsHnSLl5oVywhjiwUEneHX9HSKl8TOuVQSvjsRULY49WG3dQbuD60TURVVgOHwVXQvKw0kqwQLYsaku9/E2k2uOE17uyRBoCD8UABFQIx4OjwKmwxlCuGtpNkWToWr9/ZzsiYgA7A5sh+iEQrpPfxcOQ8z0fJ6KH0HeujAOU4OwAZDT81Zx1EIfIB6Ojwql6Zztot6/grcjw428VkXV+CW7i3Bf0wyCgyx85UhYtyhb0BOGfuqyEQpcx+gXR9J5Y5ZQ3gcDY+CXO3ZRmAl5C8Oom3OU97mTA4OjWdKsoyCJ1oijEBL2bRGKVDI8OWgS5CPGfAi83aonv676Mbtbw9NXjeN4D3h+00CSslYSNgVqPAM1+sDJqTAx81nG9poCXaB/owzh6KgOzIGjDSpzXd5+EWneB5gPU75M5ZuDDelUsJLIvxWRsnExy/N6QDGELhBRuvwBxNlafvtDBT/n2crbMt1+P4OL4dxSDBf3nawvyQaISlbb14q5+DdUyY9w4HZ4AI7GVqZCYRHshRur/5NAGhABXVkq9KUOQHtYtqA9B5pE0zknCwrgoTqZtGq4FY5DUQYk11jG/pfgw8p3UHNSHrX+BrU+hbxOYRyoHc0fo1NpNWer0If2AqsgLqqk+VMQb7ufC4FY4Ajs3wzMgTMHgDVwbA7MWfo4gXFnYUGJQbQIMmp3E5EpZ2BV3/tY9GhnaAJHJ9cRcygNPoy6FXZC4VzolZ8JwGuJPeFtYC0IC7+K47dwI8jddC6ncWLmRPBQ6baXGnDgJettYzwRdqQw2VpMP+YIvWUXFGwox8uZaRTMKQfTYUbcw9zENqgOcTn7IRoGt36VA2OiiX6pkE4FK2EChE1AHJFWB2Lz8tgTV018z0es6znw7PAhWGsDzM99RETaFsOkhIl8OKE9VVoegV7CRmEv4q8lpLy0mMiRJc8fAVSF9NnjIE0EqEzuO04QZllAFNRmH8/XHiiG+GR48MwCmh7ZTsy+fMiH0FQE2ZYGjIRHR05jzo7H+RNPCFmXhnDcADwA1z71LcKIOo5en3JeL3ZJZ+AON70nRLqvOx4h2PpssrYh0A9GP0GM9Svo9wTzrBf558E7hI4fhdjhUAAv3pwu7Imq4juPQmbte8XxBINhWZf2jNzwlNBx5sPO4bXOOd8YA8/mP8X42OHCQZAPdy3KZsvchoLgXYMgbzOBJXBXVjZjd0+BCKj1xjEej5tMVu1buUa8He/c+2b2pFRj9poUPurZFq4HBsHRZpVFgMlqIAeSGq5kDXfyeoNkWAF33Z1N5JIiaAXvftlGHL/QCkLHwv+z9+9RUd/XHjf+GmECioEcqEC9EUjHSsRIEANWerBQUVEhYiTFwhETjKikEPHIEaPGe/GIgYq3iFELlQYiBlSMGKmcYIWIiBHFSgPBWxEKJxAxmAHn+WPP6GQywyXpeZ61fj/2Wizme535fr6fy97v/d57f7pqPMrhbdBwlif5S3X2fE/RXYbSG5Zzv5gWY+u0Kec3Rs7pja2uv63L3zwMzoaTrXkVzUMFtqkdKP8MpwN8IBcacSDLK1gc096gOAUvxx4m0Xc1W7LjaCvX3nMnbDkbx/V9TjJehsJxZz8OtCzh5cDDUAMzxxbBPdh3OJx1o1dINOxBSCCJs/wK7xcvU+M3XGx5PyBKW/QyGVgEy2w3s33oYqyCHkE1WIbCfJ9sXrubhbWrmtiY9yiOf4mK2a40RwznYNYSSm280fxegSZAgaZWwXzNbvCejjBwjUUkGWu37qS3OFffbO9+0PZHiykPR18ULWNed8PBZszAfPLdbj+/AJtAc1Py1RIIiYGr2X5gMeoDcMHdDcfCVunkbqDcB+oTcm3zPcRgaQWFP5Rc8RDFJh8aM52YllPM6SQfpiUUy/U+kLruDfJKA6BYPNWALG6xgD2YmemoVj21Q09sQn0gypRC21vGZm+P90v3ou+J6m4SMzUZdcdEMHXM2BgxdWwghDtLiGob4v3bBEs8kyX/2kg4XPc67IXRY+vxjfsMbEGTDg9CobkUHDzhziRbGAm2NoAfArCmwg6bxTQ3D2dQNtS4DxcDI1W+pz16ACyAnNiZbNi7hVNMZSh3ycmYKQZMBFxY6sb7Z8KwDlDLdclIvuke28bU85pyKBmbi5RG/gzbUyf9hnjfxZhSagjGGzNIerqHoZhKv6CTgeA2hS7MUU9FwCgLwB3anQdgeVeUno/dfTlGENd4npAJJ8WouBfH2fXTOT3Ch8jwXbAZKQ5zVOvMyILtpYtRlMNwG1COButKiOpKpy0QCIOOWKAOWtqRKA4V4mW3QQzjKiBaDG9FFmhCEOPCEl7lAygCy0pgMTR5DRZny16gXOuV/wmIy98YcKvfJsb6sCmwyvC4Pou3H6z98dIdGGvomDMM39edr18AS+cEN9SX9EFdAFf42XA++u1ULjIeywhgPZQwCcKgNGgcIfNOikHhjOTfHFaIXXsLH7v7Qgg8aEF0om3Q0qo9D8ll2LwGySHr7sRFPNnEKlYUp4EKKm64knUmmEy3OSgvwZ1aWwiEa3HQtgBhBAbC8EDI8wvgqFUwAHapMH72p1x8bgxES07pB+0QvvYIyhXImuMLcyOOgy9oqhRQA4uupOB37jzNgWAxEpQHIZ0onuca+6fOI853Cwy35gnz3JRh0ZORYfju+o3xHy+6PtwT6NcdUUF/DBjqSDrANhIfTQuavylYsTeNQApoibWEsWC15xG0gdW5R9TucyRm737yCZKpNgeeja8GdxhW1gI3wTIE2jyVsr60A55SkMlpcpPoXYlAGYxaUclb7SnwDyAJahMd4ShsLYmhZY0lG63epiLcFcf0VrkuFfZ5hrNxaTz7ksIF5A2UYpi/4K+4+51n2dbdEA/XzzpRctgDymBKegnLsnZzeqkPpyf5YB2kFtZhIgLKWiLRHN5Q4ubB9ofLIBJ+wTmiAnaILlYJZGgLEm68zeOYd6NtrL/PmB7WPy56Lz2F2JvSm3q7LuufrwMgHQAPXDXDSdb8F5pfKchhLpq7Cua1ZrNkaLLkHx8Kx738aPccAOaQe3g6NIP6AjASwpLzIB/UKviAV/mWpySnP+DdVSo50d1h34FwNtus4J/YyZhaIz/HI7Qa5ooNwl6EmVsDF/zcuOysgkrQHFCw42AC/uf+SiP2JPFfYtNngVNNE/Y0SmoPKygJ8+Dp9vui8/kiYFcXrK3ZyssclTFWiRC2IsGTi7TvGSB6WiB8iwVD7e4SpqmFmHCEWaLTtXTrhimA1pjeZUoX65eeRb/f90Riw+B4d+fo1gNdwblJyERpC0QSr6khzncLc6ce506uLW0xSlDB//BL8IZXuj4krDhPIrUjgDKYQQGbV21g5dgUrCPVLAlMpmnfYFZOTmH0sHqJsHOHWSPO4Gn7KR/dmifOEE/AHBZWZrK2cCu5Q6dDADgWtxISc5K8SwGoYm5DIWh8gIMwpbEEPOGOpy3v3k1kmetuLpxygxjIPDFHxlwBMEJylPsmf8ZFxuN++DxUwbixNQTGH0ExSMMvRxSyhvU4nb+O5JuaheRA7Gub90V+2L36QdtuRZ/VYcoz0RuQxZj0ZMAYvlB9w9+Q6RDEZP5C8aSXUBwAq+JH4AubJ2xgWfRuPrWZyC1GQARo8pGiSjWgDAZ1J9jZIeP1DOALPgsqKC55iVfyM8S73aKt5u2PGN3FEJv5HkEthbAZ0m+9Ce4QMfQ9WQRKYR1rgBe6aRv9du0tSNWbTt5b9oL++f2K1Q8XU8aDTgzb19S7NPQcGo47U8C8sf5jjzKlDcesVtgE6ofAVNiVE89rE7LE4E1GFKYWBERKBUUqfNOhvcU6GJbVInkO63mcu3b72cUsq9wNvnA60AdV423uHYWrzi4wCayiHkELzK07DqMhzCWPCROqeJ5rbDkRh/oSTIioEqbvelh9ZaWAAdfh+8x0w2fvDrg2xkgzFMN5oydGVf+4+GHSE6Dam2v7eo3hGPsZwVey2Lx5A0pbZB53BaLBSvUICqATM57iW97em8yUrSXicEuQ1AT4wpQFJRxMWAJmML84GyzAYSiUlo4jPnkX152dUFoDSXB9tBPWV9RYOwNRUG7lwatnDwLC+GheDw8yEeC2VK6hHdy5JGsK2uIDp8DpXBPclFyGhMHbbEQ18jbtuQPAEmauKsLn2GngDt9dFw3D8LpLh2CMqdNd6oq+sJ/7xbjoQFadwWcMaNXJN3rX6P66Aw2N3WMgMB1KfEipWURwaCED+QbWg//oY9jWdUC+hGWzDpnrtYQrdoPlDJiWWsyDeFkX7hUBEdpvC4LhvsA+sLsL3IXRe+uZElQiIeN3gXbwiKlmB7/jlfYj5DpPZ9j6FqiG5ZojWEchYyEH8k4E4M4lwmLyyEmcCblQsdOHCfcuyDqVAYNqQZMGVxNd2BgQz6HIUKZmfERE1HvCXp+E5MwF7F4UcLkpdjBXW8bj3XiZlznKCQLhdp3ee9B33hm2saGOZkzX7WcT/mvFGNBqKL3Rg43pRy9B+GLe1vyeTzMDoB32LQpnQlwVtgkdwhTMBJqh3m8IH/IKSxYlk5m6EPUkuUMp3sKGXY+kVrMA6xo1x/38YARcdXOR6fEeomdtBy7Bf7KNs1a+AiqtAZexDZAGb7WmYVvUQazre3iMrRYgKRZohYU+mbwdk8zCGZlin1RKIdiglkIqayYStWIHF9zcOMpsvForhBCrlSkxJUxJKJGNFAQsOIesg9WAOfhMreCKxViIgFuM4FU+YLX7ShI3rUYxSEPx4mnIOOmeMNP9++gHqv5vxFjqKUMxZObqn68GQuHPkbyuqeJa1niWRYsTwGdqBQBf21jyFu+isARGwswJRViFPQI38KIMrLTM7QQgBK7WunDMZjp/anmdbamrAdh4M541Zuu57KWiKHEiC29lsrZuKzsWJEhahbuABTRlDwYVDLX9grw7AeAMFeGu/I2fM25qDcyCorMTIRfOTvIinyCWsFMeyw5YBcF7C6md5Mj1EU6E8yf+ZqUiLylAyCJDERumGMy7ugSTOoDoY5nwNU9TZuEFqfBsQDV+C87zZaor/81/snjHdnjZGjGWepPW0Jjepb+vf8344dJXUqCx9VqX9sADeBPe/h3c/g2aG79CEzmATzU70NxRsM11NS/zEYSILfy52VjIhw01W6AArEeqYR7gqWWaV8LCgkzJRT4Vjmf48QXPMaT8vuCgGUAs7D4wH9sv73Bx6y9hPWStCGbUgUoZD/nATQgZeRKWQ6nvOCiA4JhCStPGwR74d9tCcRBqU6nlM4s2ByVYim1NukRo4IWcFwV/sH2Dy/EqFq7KpDJ1IkRC7pXpJJDEO1MT+LQsABf/Br50cUVzdgRHNG/AxilIPjhzvbbrDV5lTIw5OX7YOOgHbbuV7kJPewKruhPD6/sqBtf+zJodWQn4HvxMwqwLwd3tPKyAQ3tCeYqH/Jy/PTl/GQLQ2mq3vRCaejnUxcCDHPCd/Bk5LRFgC22x4PmwHNygadNg+ClwBfJtA2ATcBNqsofLQmYBdEmYkoTgGT63/jOYMgB625mNKVN9AbaMnd8vvRdTrJDuGAjd3asnVm53AK7+hDqceXZ/oiHMRooc6RQUK6R/tiMLxD1kiOfL/i3hcWzp3IBdKaJMFUNNDShXwYMZcHmPimVVu2EoPF99kT/yH1TYu2LfDGMSaiWkKQFq7gwXo2ae9rs6YUx5LSvjUlAeBc5BzMj9EAYbyreIl3E0PBkvxkCJvk7w3c1dht9huBDptvsNjh8nfQUBDQHH3oK/hve3hcwpfLRwHg2JNhALV8NdRHn3lWIVWbHBrOT3+N09D2fg6goXKIDM7Dkcjn5dDOByUCfC6oyV4g1fBeSCd9llNNsVlOMpBrYDjK6qJ889QPr/OfApquAt3qVV48KQqvvYTdWydNcj90oHZoHT2iZhZ0WAwhMxrKsRsDYnmdxt03kvIhbC4K8Wv0CTBJc3qSgpm8L386wZhuF11149GXrGQN1+sLbvogNndQ4p3TyjAw11opv/B2J6vTDl6NOf0/TXkWdhowpNlYLYgve4lwO+oz6DuXBm5yyZ9yOAPaBI1EiR1hwoCfeQ/ukGHIVBa8BuKlzVTOT0GR+GO0PdKgRIOgokQ9sqhIjULgAQNtAcBFTCX8v8sWyF0YqTQuy6BQUH54gRPVSuCQ4plHC/fBjLFTSV0Br9FO4OlyRHpwUQB988hDGVtbw9LJn5e7PJ4jf8gnOwCXbvmc/srqOQD1svxGCXDBaW91HEw8f2vhzmt9QoxgEf84ShbNiu3X02BHFNAbn90jvR11t028YYmzrpqZ2VfP/d6K63ln3hWsDpFGAOr3Z9wIUUN9GHooDVQB045TSx4lwaq9jErthIlMtlfxIJUtciEHY7zxcixwGYdfUMpMOYg7XCuvWHjiik0N566dOD+Vrm9nJYfmUDrAHlBDjkFypMwD0I0WstoILLJSphCabId69LW8FZJqPwB0Ig3ftNHvIUK31SUE4FlsH1KClSE5m2S+65CS67q8ACUle8AX7QkmSJYoAGVOB9/TKcg8UvHmJKVQkbQrawpn0DKasW8Y/dz8gP4Wd8txiQsXdjSvrXjP876UvqKGPnKsEcfsmn7AsLl9yzUaDJAirBdmSHROaBAE4/RbpDAgwrbBF9KAZh9MXCmMxaQnaeRBGF6DiLJH1g7LD3uMIL+O09L06LVLkHVdr7JkMXZnT4wj8cniPIrhB8YPzFawI+2QMFyPXroRJ3vqhx4ycPmyXPbRpgAZq5MKK1gdFB9XxZ58q3WBAcWsjHab7y+IuAo0ix8gTQeAJWkLbudY4xi6f5WiJG2l1pS1fSEmuJGV3snrIMPsrHuK7VXSSTKem3ufsm+uRBnRjbNrZP33lnjTBqfw1uC6F8OppaKzTHFWhODoR4UB8FnwkV+A89BnE87hOvhh0khbe4kOJGicqDljuWgiHNgqwDwQziG5bsSxZ9Zg0wHmYWFUk9jbuAFWz1i+EXK86wOPoQzQeGQwBE7ttF2NQ8/tbiDvnaGi85cOhmKBwA74jLMlaKwXvVZUiCPIIgDFoiLcEGFmceAqDhkg0EQsMFG3HAlwE2UBo2jtjr7zGuqAY8kaiSOAiZehLfg5+xtmgr5EBboRLa4aqvC3POFMBkwM0Ycaqv5EGdGCNe9l13Umg0Gk2fr/r/cWlra8PGxgb4L0Rb7kmMgbA9AbM9XdPTZ/3/02jtnIh1hpriyJfwLf4MxZca/OYf58zCWQJWqaQIkyIaUc6igDBojga7MMBF8g9+0wH3O4fwFc8w7m4NPIRmFdilQ8dcsNyKjP1UYBW0LLLENrVDwgW9kQF2Di7fUOGuOAUcNvi93T1bb9tJ/xg93L870V3fAWyktbUVa+vuwm3//1v+NeOit+cavk+QxesbE8fgST9IhOsKNP9USJXtEXA63ocpt0rEyRClvdVO0OQKwxZ7xIi3B6pAXQhnvvLllw8/xSr3ERyDa1nw/B2gGNSBkGETxmtZWfAior8kgaYAFOVIVdgWnoSDB0JeYgDBEwoFoPVBAKwAYCkohnwLz+YiVo2p9tE9o7F9powJw8XBsN1MzUFK+sdF7+TJuEjCtBLbyXeBwO72dXdtbxii9kzXDKLg+hweeELRfT9m2BXxx+ZQzOgi4q0P+fTd8fjsrRCFv1Gu0nRKaCvtSL8tB1whb1EAwUGF4AtN8YMZMvK+RA6FI1EbzXJ+3SpwzgPsYNakbI7tDOVeDHyu8eEKY1nmuhsOQo3XcFRVtylym4jfqPOyPkXKd+UGTOchTxEWmgfucCgxlAICWcRe/IadJ/XOG/wTOzYmb4bl+cDfTbwVw3Yy1m69EVPXxfePi27kyZhIpm/On+7WdAyO6W8bigq8pzPxfBF/XesvTjs7yLoUTFh6HrRDauwbBFKAKus2h8JCGcQD6niWRhzYNmy1FEvKBbqgYYQNjjtbeXXpQT7wjmRfaTgLozOp2QuqdfJ1VAJ1cDEHxh9AjPoMKSAzrK5FmiGAJwX3AuT89vwBvG2xkZS8lXwZbI+TfxOaSlCEIOvROQS8KtA+bY04ItXHQGmBAG5n5LtoRJbmMuAKvJx/mI8WzJNc7WM08M99fDctgjEHqG6/rp11667h+bqxodb+7x8TPcmTcfEOEqtvTLpb6zFyrCcZCPwOJ811cpjLs3zJEO/74sR7EdHdWyE17Q32sohrleMhHS6kuTGhsEr0lE4gEYqCJuL34nnaSwfwtcXTOK5qlTHiI9+0b184CxMyIR/qq4fgNKEJ7iN9sxIohvqMIXzDIEaX1Qtx5CCwFNRWoKxC+nslKMZr0HgrpD+vEjDtoQVYFiM6FdBRDpbtcs3Hs31JJ4oP8yPAGy7bq7jG83zFMywOOiR1PsKAdFCgwfVABddixsuNxiJ62U7kN90F1oPingamfY4kgzbFMuzOllMACf3joht5Mibe5smY6O163dd1XZevczoBmr9wavPL4A/Pe10kggwWsQfbxg7IgaalgxkSdJ87+bYMm9wCtUheWmu4GuTCQywYxAO6MGPMyFoZB5WwJSqOlcNSIAwyt80hvOgImrmgCEJs5FyZ862mPoK5ELV0B7cYwcd2L6OwQ+Z8N2SdKITifS/xPNcYsuq+zO+1yNoC4nwpgMlXTnI2ZDr4wtVYF8bE1dKWrMT6jJqPA3yZtrBYzk1FGIiZQLiMOfMuyUdKHbyVuJkPeYU8ghk/4hpOt65Tr/g5sIMnKXX6KobvqBN4p39M9CB9t7e7E2tkYpsE76i4/19mWFU+Is8rgGDXQnFYPEQcZJOAg1CR6IrHwmpK9nngE1ohQGggZG0K5kUqGT2snsQ7q/mvrt9jnaimY40WH0pHdJtNch8atdiTKzTcs8GxrJUGLxvsWltR/hqxIwrgwTkYNBvuZNgybGwLuMP1DCdGj6yX9SUJHrhC7v05hGcdEbthO5ABW0bEsdI7RWzuUzwxo/ORAq2lPHauZI2QFFTfYsH8rGxKw8bhffQyJbM98BlZgeJ1DbxzEbmZLjXO10j/149Q+jHOB2O6be/s7X6mba+kJzTcFEPQ2H26Yyh0BzoaKnL6xxt5wexzcAPfzZ/BWtBMUXCDn9Oyz1KYfEGg2ANEQ6nzOIiF2ihH7AKhJmM4+MGX7aA0F/bTuJwaWRjugt1BoBQs64ArUrWVIGAWfMq/Px7kGnNoOjCY92+EiYfGZHsYY3D8ELaGGuP5CXs7mHrrNemX3onSxGdT5+iLqfGiO6YzDE2dq5OBMFPBN8MVkoswHTSbkfDvPUj6jr2Il9sGFAWgCUSAp3KkoIUXtN2HaeeKsTr1iHvzgPsyXX8+DDQxoGyE1yZn0R4yQEDgaHgrYzOKCLjg7EaeZwANAcL0ZROQD8HehVy/4ARW8PEiX67fcRIjog24r0QWie7GQnfPbepYT4CJsXfWz5z6YWKKUWsIHuqf250SbG7kPGPn67MebIEQXuUDNJNg0FlJJ7CweQfuXCI8+QialQp8yirEI94oYC0BcKrZl465iNE8Ak6n+NC0aDDB6YXcO6YFbCPuP6mcXIYoTsWQmzgd52poCbIEZzh2LlTSKbhJnsFZHIN0eOAPqojb0Ap+VefBBkouaXOon4OQhJOEDct7bLjPL8pmAQcwowsCYC+L2HhiMyxvA20xju+2q36bGGtvY+d2t6+fKfXjpLftZ4zJYLimG9s21B+UwDDwnI5tyR3+6u0vxoYVYA9hCXnURw1hYGQzsenvodorgO389dnM9T7OirI0tp1bDRbQXI4Yt/dgBsehA95/+JqEbi/MhDBQrQDc4U6YLZhDWY42gKkZKAX1eMn/qfhWIzp5EhAAF+ugZi+UnhrH1xZP825cIieDJ+NU3CQ5bP0hat8O+e2zEOPDF7AGZTgUZUxE+e+Is0OXqzMHARUaoXjTS9TkD2cTb8MkYdp+1DQVUdae1msrY22t29a1qSmwqjehsv1iXIytsd2xedQGf4bXmFqzHeAnv8NPc5w9RDPhXBVDMu9zp9QWwqDp8GBWb1oJnRAb8x4nmSYOgECYUFlFbsB02oqVKN7UMC9oP37Lz1N7yRGrhEf4USTAbxcSmdEK8x4eFt3qoeQrb7lgyelqn8cgKJvFvhjx8JaAxTVwepOPFEDaCm9OShJ8whk0IQp4CKmeb4iu1gyWm5F1RztdO5r/gyz7YJbP3kAnZnxYFQEXgaMwbl4NYXV5LG48xNV8F2HflsOFA25kH5jFbhaLs6UMLi9SifrlDrgAq6DC3RWmof1CY04L3bYp+69fj+qbdBflYup8w3Xe2P10n23lz+dVLmq8JeXfGfD3Osa11PGsDE1hA2se+xmHhNyHaG0Oz2zEOZYIbIA/8Vs8aqoZvbWeMVtr5faboSHKhl/xF1gKD/ZA+OQjXPdz4lqzi6QxMAPCwCr+0eO1ID36TXK65qIoRfq+FXARPp7ry8f7fLnCWOxTvyZz0xzaMkBTiYw7a8S+sIOz5dPBEtSRMMa/FhLBOkhNbYAj0/yLZXyeg92z50uuXW0B8ms2KhSx8H5YGBTDS5Rx6+goPsEfLKFeUQC8y5P+b26krc0N/htKvw71r5MfOqeoEUOzAt7RMLihg0NeoZJOaQYy72Ug83QI0AoexdVwE+7zNMRDyyVL8jYFEBaUx2iHeuiEQTzAOlDNoaRQLAsQh0M2MtcvROZXe1CUgPqhMMo5BY7+rZTZeMAJ4BZsPRVDzX0V+EMIuY+JI6eYStrN18VRUQODwiG84IjY8DsR3SgRVvqkyDPYQ6rzG7AetgTGwVjYvW2+/KYViK6E1POYvzMbPGEpaXAFXrCsoOWmJd8sV6Cp9WS65mtsO3/FgIbZcHYxMth+xpMiZYa2uv5a3BfMsG84VD9o2ysxRMR7A07pjhkCtaaMEv1reqME6LMPfwZAhOd7dMTC6bM+cA4S2cTTrR3khk/n8ggVG+fGox4L93AAG3C53sCdfFtUNbdRdGh4PgmsbRCvxEF4/0AYz3j+QxaHKGRQb9aGFB0FpoIFD6nxHA4j4UPbmXzJs7xWk0U4f0KbqLMXbWSqLYw9t6H0dUHoV6T+NWKsHY0ZGt2d0927MDWRmRp7unOfhjQ15VYekAaDTsCB5jCWr9ggoRKjx8nknogoSBZadiEIeyMMNAvArhjqJw2BAvG1fX5MTnlBBYoYJIegJ1iVSo4rzCUvVEuKJV/xDM9Sh2NmK/suhXPd1wnmyv1H59fDMZi2qpjRWfUyfMsRj2SP7Wb47KYMO33p7OaYMUZud7+hX/ou+iFk3YXl9yTGlGX4rtOqE7BloqaU+Y3Z0k8zQb0T0ovexLnrSzgIy+03CMATK1cqIoDrcI3nsRyFeKkdYIpPCRcZD8XgEAVDMu+DuRRE+jwdPk+FizFwsQxCyk5CJ9j6dFA0dKKMHRftz9sKf2MU1MGgIGScRQPnoOWCJWf4tQBSBwweUQsej+Jv+L74GTTDtdTxsBzEkO4p/NGUmAK+e9pnDADulx8uPSm3xgASY/v19bOBwAsQA82bhsNBePZwNVuq48Ac2lLBKaGJb4rsHr/OX/MJ3IKNpfG0uw/47uvtALUKqSIOWHk/kus8ocTXQ3LgbodhCS0c3+SH1wlw9oVF8SlSrf6YOCo0/6mQ9DkHgRwY7ysmlIPiMo4FreAM08YWC5PqIVzIdiM9/01xZhQhYbXuCCPQHH75zHkxtlzgzmhbcAN1JmKMXwffuM9QzbjNmIW1cEtqEhxjFvJwLTxJLWUMuDW2rvbE9OwLm7pfel5fTRmEpu6j0w/0U4aJA++dpgTO3J0l6WyagVYY1tjCqDWVPN1+n0YcJMzbHBzam6AFagKHc8fdlku4Yx2rBm8Nh8+9Du7gUtVAS4qlFHoNQuZtT/nGUxZTaToxGDohbHMejTgwJbMEr6Cz0pdzoWKdK1b5j6AT6gOH8OuWEngo4O2O1ATxK4CsQ9bwkKeegAA5CBCQBURDU8dPCUvNY1vqap7n2pMl1gwYCm85b4ZKeJe3OJizBNphgk8Vc9cex/foZ2TFBoOZsK62zI6T5+mAq14ujD9yDfgDMl568970bb2ezu0X09Lb9bU36REGAh4wPAG2LYaYSNw+vYDHjGqOxYTyoAzOrJpFUexELmS7MZmzaBIQokW5/IWl5gmQqw3TZh9sXq7VoQ4As6Gi1hWspHBSOlFQCoOioebscEan1jNmai2cEaKULt/5PW8gAlL3vEG+WRCUwZ0rtmJnj4efK4pxUxQTE70fzSQF4UFHsB4q5KuG2TZs8YwT4KoaWjwtaThsw1kbH9gMz9pXwyJwOddA/ZkhkrM9GhZXHpKcoxlAMxIyXgivVWZBKoQtz4MCKUxWWTMKmI8gY14IzqBNs/K99F76kWDGpH99+P9O9J2v94A/wbOfE6lYhr3iS+Zt2y+v7grS51sR0HQh4A7TXIqhVezbXSwhN386HIBR9ypZwk4yT81hfmi2RAK5I3N1rfZ+a6A9fgBNQYNRRsGwuBbaNkNzMbiaV8i5HbDiaJr0xSyIIEPuVQl2NBNTvl+IIq2AJ2wPXAwpMOLUDYiA2gxHGZ+eoK6C2Oj34C5M5RSkwWLvQ1wequK4vR84w4tUsnbzVrHbbeBi0S8hFJZ1COPdcjKQAAXlc2iuGU7XwsFoKhXEaNLgw1fRevJ4YpN1pxv1Rcft3RjpB217LYaghqFCZcygMOUdN3YPY9v699H9Vxp8VgJt1D89msyxC7E8gyTgT5YJWjlBcneMm1fD23HJKFfAlMGFUAQVo10BuKxSoXFSQKmWdaUCfOG1oCy+WvBTyZM7GOgCtTfiHQkE/GFaYzEqn9uQC3NHHmfC5CrIl8FmuhPqeylMMQf0P+s/q2Fb93u0/98X/fdqalIy1ztueF5f3ldPwK7huUqGO32Jj38FFXNd0YTAawuz2Ba0GtzBe+RlYS/FIEZEJ8J2BaiD5qVSqbvGRyqyclG+5YU1MP4ENN0YTN16pMjGv0PdZLiwx417xZAe9CYWD79lyrASXmipYXX4ShamZ0oYYDvyvUcBP/luTQwQCZkr5sA26D78Tj/XoylDuzdAuu5c/eOmHEX9itYPk55Yn4YMEH3RN7oNQUljSrHuHF0fCeJ9XpP+2YnkdF4GivMarKPV0ArbYlYL6y8Esu4F81bKZmiGZVN3E3jnCG3lStpUSu6dg2nl2uourfJXc2A4g9LghbnwQhq4WsF4Lyjx8kARoWFRSQojFOdxCmqS67wkL/TMqUVgK4WUyETYXGYwqL2DtalbqbV3hEIgAsmXpZVZqmxcYhooujSRtkJk3RndXVsbiinDzhQIbnhP/fP6wdq+izGlVif6TFlTTmnDzxjs15/3zIGBMFnFZ/PHsnrNSmgW5X3liynQAebmiDPADQFIA+Aos2nZZ8mm1kT+0+K/WeKbDOlQ3+nK7jXz+cpmsPifzwGecK0KPo8GH9cKuAu5Z6eDPczcWgTxEHl2F3u3xlHqNg684LN2ZI2JgrTc12EuXCyW0TpQYyP3HQq4wvW5TtAKE1ZVQRe8mZIkqUq84UG0POKSlGSUS4FTULRoIsO8WyQ/qC2S7iQXmtOAGglXpwD864vZr3gNCfNW8l1nnuHa0Z2z1RjjuV//+nHSHchneMwYmKuvS+vSRznA4IUEa06wNmsrFUNdeftWsugg+VBkP5FfcZYPrELZ6xMH0dCQYsMxq5ks37QBMzoZ1tjCVE7RkGaDZskAicwIALLAdlQHH4yKlP5WCusOr+B6thOzWk8yxOe+/LS5sIztJIS/w6t8AO2QFxvA1zzN1rkxcA6crjehcBW7Y8rWEgiERZ4p4tzQOh1XuKTJvG8FV2+4CGDbKDlzz9r4SJRfBLgsbICtiK5VBKe3+fAcX0Az7Gt5U9bEocg04QwkQVh0HnjC3/g5K4tSwAoU/hrcfvUFvHLayHvobqwY00f7pffSl/W1NzqWLfCSpMm5VYTGUoHmEwVXhr2E+hy0pQtzjwL4hF8zobGK4HOFKM7o3Tadx/n98dH+TUVAT3cgFUpUHnisr+Zqhgtpvq+THvcmLfmW0AyqBbdhLPz01BeQBC5TG8AGfnmgkFJNAJhDOZ6Ebz5Cx2ywa2+Rfq8CZy8YXgsEQqnnOK7mu0j4uis4zmhlZWGK6FHJYJvQwTPtrUzJKoFm+HK9qzDgw8BpaxMcQ3S4IGmaqzddwEEKDlIiz8EphLB1E/zKzwOQrYlk8P1nwH0yAtzqCuEYe3eGwK0hsKuT/nHxrxNjmIix/bbI+3sVCIGPx8PbXlRrxnM45nX4B1yOVYEd5FZPl6iEWFidtBJOwfUAJ5z8mzhV/DIhBSdhJ9xIdse2roPwBUeozXZkyYFk0WU2QZrv67TXaKNQAfs7Tdgl3SYnZSZ7OmKw89YWcG2EmrThaHxhiV8ytENM9H7eHx0GdTBJcYTbExBn413ABdyp5Li7H7M4RttIcJnRQL3XECgGZSKwANRt8AXPoTkHHIRmfsLMkCKubnJh9LB62AO5vtMlZYIKOkbAc3yBOV3cuWBLbbYjZELe6ABYD2mxr+PJRXjlAVIAOVTaEVe+X1RXX/riuOvd/NcP2vZaDAFTQyW2J/asqXsabveE0hsCN9rf9QosvrJdEqAfBfZAmvvrkAQduYih2wxmr99nUBhQAx57qxmuKMev6y8C4MaCYjNc2wkaXXrGKGjLUPLAE6gG5SQgFer3DUGzBgnbC0MUujWgzpP0CfP4E+KVMyadRp5V//n0lVDDNjfW1sYMD1PSb2T8a8UYE8cUeNjdGOnuHqYAfmPiwHaWwQLwGFnN3WZb3t8Xxu78+eKNywVOQc6KmTwT9Q/Wea6gxM1DFptmaO105La/9Nz3VWGwD8avAPUy4BwMibmP82FtonQXvW+NAhrByvMRbIL/sX2JDXu3yJyuDTekHAkfcUfypWnxoA94FYnpMyzOo9/3Ow22u2u3npxBhgag4ZjoZ4j8ODHFOOgOdNVJTyHH+saJEcA3EgbyQPrzXETJ3wmaYQrxfhciuf38gSwIi8nj3ehEMXQb4Rm+wjpAzTfmaszNECN/PWLkNoKq7jYNkdrq4Ulw874TLIBvGIQmVsHegjhU94AZcNXPBUaCqhRJTRINigRI3fYGF+zdYBU8cgD1WnApbED9U/m9X+IMZgLeHjsXCirwyznPPzscqVC5Svjt41xT3YGypkRnXJi69ocyePvl+2JorHXnWDIEQIyt893t18rP4C5DpcrxUNg7NQ5GQMsZSwZa8Bi4wgyIhpjr+/kSZ77Zbse3PMWug/GwBsafuAbAkND7wnSNgbp0eYIXvBDGeAE8y5dsj18MXtBUPZiDo5ZwLwG8My8/rmh/eh7UDnUkqn0/LAe1ZhzfAI6FrVAODxYAaUjY4RUepwvZcTBBDJ9K6OwE7GHXwngBoOzhD7wpYbZ3kVQJqcAasItH0jiMymTshc/g2Q+AQ0ba3Nh2dyAifD80sH+9+GFirP0MdZ2ebAT9bf2xNQw2Qt4Xv6ElzBKPndVwCTF6T53Hb/l53uJd5p/Lln7sDY5lrbzcepxENjGNj6FGwkjf5S2YBKvPrBTn2lIkD+EiuJNvy+r4layN28opphJrkwx1oGkHJksBst/xB17mKCOu3CA4oZD1rJZCxc7QNHow+INiAaxbsYIm1WD2FsbJI+jA1XTt/2oYE1cr/b1VctleYSwdJRLlhz1cPqySteymgMAx5fvBEhRJUBLvQVTkDsEvrBDm5ItAI4QnH4G7oNiuAZ/tcHY7MhD1C/b1VgfVn5f614++i75uY25kHxiPgjE3sv9rKL3N+QV+7F46H7wh704AF78ah3UEUojSHrZcXQ/Aukkr4CF8fNOXtjolUTd3UJz7kjjtEhGA0xeZk1cBueCzoAKyYMyMWix4SGLKamzLOrh3EG4fhDZfJQ13hsoc7Q/1S4dgxz8JvlWIugrWsQYKJP2gZSVQDXnxAaK/tQI24F14mTFHa0V/swBNKeIw8QfioSHJBstWqA8bIiBUPJTOHseFm24yVr2A9VBzcziTa08yZm8tLAOn9CZYC4cOhEIndJySfLtYwriFNfyJeTxn9YU21fCXfFc/7emdmOr7/etF38RQl+0LkUnnvHgB3CbDdQeqNc+jeV6B5lsFo+fVPx42487VwF0pVHkweQkEwIblW8BcGyEageBLIHNwOzQ420AUuMQ1sKsqnrQVr4MNxATtx2rkIygEq4RHZA+bS53VcMZyhRWj0sRhHgU4g6roNkdtp7NreTzzSvZDC8xQZFFzF5zd4KImQFKLFMg1fjvPM7OgiF2Z8Vhri4j/W9dXFGVMFAJUMZibwX/xewZkaMAC/FzOQwKcIJCrd1youTlc1qBOoBwsk2HlqBQG8zXDFrTgUtwAORA8shDyIWbGfub7Z6O5YMVizWfc73BiQMNQsAzq4X0YO/bjdKd+0LZPYowN0psXZopJamzbcJ8hIGnsng7gCI3Yy+Y+xGOxdT/EIiGv3tB2UEnX9cFgBg2HbWQBynSmuWQ4HjHVPOtbDSMgTZOMIh1O5/pAElgHqhl0BskJ0gx5NwNwympCEQ0lUR4UL30J/KVy6zSbY3jnX2Yv0Yh1ZErxNHwmY6CRKe+FqXbqCfA2vL9O+hmFfZOeFFF9ZdUUoG5s29h7NzReTI0D3bYvT/EtDeE2aCph2LkWJvMXyb38EAgGMsCfT/jYYhpri7fis7OCQ2mhUAYuWxsYpLHE3Axey8qi7EWgAGqeQdhZBaAOhPn+2ZAMzttgQnkV9fuGwFCYd2U/WZHBNGPHm4uSoBmOJ/pR5DlRfl4dAjqZA0lQXPsSxxfP5XE1qMfPYqw9TI0FUwaeYfuauqancdYvvRNzvm88GANXuwN19e/VnRgySwYCtvAzJN2AJWxxj6Noz0Tu3LNlUWQKW8/EQCLkrQiQ1CB7EFZHFDK3H4DDd1+nuRgc1kFm5xtopgJWoN4LzAaNDTi6tsJsIEHCThctSmFKeQkEQGLgamFCrYExjbUwFCK83qPJebAAUb4ShTFhYRVtrTBoBSi3Ae2gjACOgkdVNRyEXSwVlqElnJ7rg0t+A8vYDn8/C49zphsadfqsWFNt2FtDujf36pfuxZzvz+VKgz990d8e2MNxJd83Gl+F4fAVz4iRUQnqMlD/D9hmdqCIhtJ748AVEuNXS/+KFgefOhXSy9+kNtIRJoHmDwpCFIeoy0GALWvYp1lNl8ZJCvAViZHrEVHNLMVuqIQhjfepqYGnrYBq2B01n6eBKYtkrJy18gU38J58GVsgKmAHaadeZ939d1CPgtp7jsKqTUAwo/XIOE0D6wBtVEYsaFKBOPgdO6j3HQIPoWGNDTmnZkI1tK8fIHpgAESRzpNIjd7on/pRMsaYPPrORd3+fnCqb2Kox+ikO1vB2D5j9oATRE/hcOzL7HpuAVd4gatLXdgXFA628Cv+Qsk2D55rref0JB8pEDYJTnv5oDwHtnEdnMMH4uG1/CyS/N+BINgQtIURrQ1sHRrD5TUqeBGGBbWwYcEWyIHftbzHruvxkAeKuYCXfNewiBZ+YtlAbeso2jYriSKdZn5CsedLDHG9D5GS/zPxma18gj9XA1wek0AUL38rn7uQcRCk/b8ZOArLDu7GMl2cjeoV0IgDV/e5yNgvANYi7MF2+GXeRfz5RBwb7UA5lC4aJ3rdVuAMxOzYioAcTjyZf3qjXxm+v35iSN9Ff73t1PuMkc+GYswJ+w1wG7CFmVCGF8RDcHEh3pMvy/yaDvjDijHr2G6/mLVjt0pI+PVi/svs96TvfBPfUZ8J8WI9MBXcs8+zaFMKLZcswQE0+UifKoeF5zLZvHwDW71iHveEv5j9is+GTYBAKF7xEt8qmvjIZx7cBeVhcKlreKL+F0DLFUt2sYS65Yi9YI4AvpvlO6gChTYyg7uAJzjeaoUacKprYqMqnlNWAbi3X+aPRKCxBOzB3e88quW3JR1QMmIL1UDa4deZn5MN6WA5Faz2PIJzcGefLQXNM6jcOxE2Au4+SKqEnyFjw5Tju38t+NeKfnuactoZrhu67U601Vjgn8A/YXSCME0xR+a+UlDXgXqGfB7m0kJtvCMvqw7L3NmJpCRbD3citUzrDqAdHCNaZQxFyvGYmv0wWfQtooEAOJ7ix4zBx7EugLWsgwCJvsMH6c8WELL2JMwSJxyVQslQAwTBeEWh9PW5cLXWhdqljuLMsEcIKO3wtL2aw8zjlfYjaKJAUQxfrHVDU6iAaG36knhYkZzGmBm1qJJvMyGzSpi2ngipqhOcqprAAtGpTkHOzZmiawWA+iIUeU5k11qpgrndYZm0Az9D6gSYIj4Z6ryGeIbuut7ZGP2gbZ/FFEOhOwZJdyw2Y4qAsQGor3B/H+x8e0sicbzLltg42nyUKBwfyYS+B8kR5QbWUWpZBOzAoaUVTSpoxivEmLaEL5NdoRN2LY+HBJhSVkJbMdwrhHb3AZKb0xOCswrFSz0bfNIrcOAeZMHbbKRo50zaZii5xvPdtIvhM3YHRumLMSNOXwzb2dQgMDT8+uWHiynAr7txYgxwVRvZb/g9hscM3505WA7iAQNxzGxF4Q2kwwEWcHjy6+JDUAEPwXZhB95ll2E5XF4qVYbxgqkrPsLWpwO7dMS7B7Ae2jVu8jkLzLsQpd9NPOLHPf1wcm1iXu5+DrW+Tlh+Hs/yJUEcg0L4in/DL+a8LDKz5X6cAJrBt+4zAc743MQzGWsPY04c/XN7YucYXmfKSdKvfPVN9JXY3izA3Z3Tm7bXfZ8OGHMAd5jXniVMIsAv7jwPeYq9xXH8rj0NRoI7lygKnCiGSD7QBhfi3bjjbiuMvi6gEPKZhSIJcuxnoowFQkERCCyAa9pw8b2ucVLMIAKIg0BOoI5EHIJTgbuQMfkNhrx4H8V/asANwucdgRKwTgSK4dWog7JGhfCkmrg9vO2QTL3bELYsiiPgzmmWBCVTPGEaeiod3zfq/i9ZssYA+H7pXoy9A/35yNhcpVvnjYGDhnqDLgJBCYQQrMlC46RgfnK29KMMUHqBMlGbXmAkeKdfhgWweeQGNGeAMHjQAkoLwBJcUhukP+4Bh1j5hoooVxR3NHRhxs9b6qm5MxxmwTUrV9IyXkeVBgyFkw7wd+Dv7aDZA4szD9EJNKfDjsoE/J8pBndYfnYD9h0DSM95k5ip+0mKeQflMslByBlQmks1ZUIQRtUC+T3hRUegHf7D9j28Rp/FL/M8a1nH6dk+mNHFrPbjDExsJt9iFneCbMlMm0PclL3AIIyn2DG21hoaiYb/lXr36nf2/TAx1f9NHTOls+obhNo1wHIOobsPSRGusYfwLfiMMTm1uHKNFl9LXuUDqnke5Z8lLQDtQDVMOVcCnZCVEsyQtffBCpYEJYM31LgPh5GgvA4rEtLEeZaL9MtCwBoUY0EzCXH0LQDWwLSRxTAWrNNAeQ7+ZvZzwlblETNjP76pn4ntcRMGHZDxF7YwjzEja+ESXA5XQYkSnKHtjJL6gCFk+s0BTzh+wY/MRXMgHU7H+jCecpQF8Mv2EsYsqIV8SVuSdyJAgN5JoGlS8G98BbFa8GGutj5HJnTUShHlHSEJKP8ZAkwx0d70sL873axfepaeHK3mfDeFlCnRRnO6LeSYZhaaBgUHly8RgOkYtJXCgypEByqFpOvvMIq/kXDlHQH7U2DX3XjeXJrEhRtuoq9nASOgMmIie6/H8S0WtCcOQJELzYGIfn8TsIDfcpjhYbKCBacWMmF5FTUO4JvwGQCfn9P+xIcI4GsFtEPNpuEcZAEvUYZzBmK/JwHlcOhCqIBMiUia5Qgk1doeOD3CB6xgtfNK3q5JJjihEMsy+P3DlShiITNsDmO5QtO2wSxir4BNVgiLcJU2Z2iL9vefA0pg2PUWvnKygTWgOapAc0AB1+0wzrjtSfr1ph8nfZlLDHWkb+SvAdgDilEaMjfNQfGtBsUMDc+WVqP8DSgPgGKqBkrBJbmBj8rmQTpo7IB2aKm1lCg+FUI8CkIiieyR12sPW1RxPGgF5SmEKX4MZpYVMcgNaIXs/fOhHVQ3QfFzDXTBNR+4vR5YBXkE0XbzyRNr4mH4NmjOhpoFMGZhLS5HGyQw9QpiZyRLBF96wptYvggKd2AN1K5zhHb4+JQvHqHVMBLq44fw6omDYtufQpwl9xAHRjEo3tRISpFhTRANc6OP09gCHAVlktQSaFujZJnFduJm70XyNujauKd3Yeq4MVvGtPSDtr0WU2BKb8Ck3t7TEIztjVcFcHRgQ/IWfBZUEEU61pfUtD5rwdSUj1BkaCS0qBio0yor7qCYBJ0u2v3t8MtthbAdyV07HvCE973CsM4GhzPw0OIpRhdpc3MORTwTDwF/hGLvCe+xEM0kBWVmXjTtHYmwoQzZHaYYNoZirLPrjDhT4J7hd+kGkimFV9fG/eDUv16MgbO6z8b6dU9sz+6cHbrPXlClkcIabkhYUKOwkTigPaUT2j0H8P6+MEiFiguujCuoIengO3AQTnm/TPuZATwbWc28gP14DYWS2R7Y8U/YCx97+dJiD7TAxvh4gq8XMrOwCLzh8KjXUT4PtMF8DjG5tQRuIgVgoiBrT7AoSsUIuyWUJ/kVH6cMMXwmY3OEOd+fb7obV8aMiN4A7f3yw8QUU0Qn3YXnG1Nue6PwDgRewnFGLX+wioERsNI/BfVBcLZrkHDSnUAOOI1qwi/nPBfc3GiLV4IFTEivYtiEFkgHh0ioOwdnvGdxeyvMvXtcqq+ukaJj+MIdjY8oZWEw/8VsaIfi7JfwmVyBsh1xkMwF9VbYejYGIuHRrxQ0uQ9GcwrU/0AMkC5hSS233yDGUj4QCLVujgA4RTQxm6Nw25Ldby6D8jq+ryAZhlIaa7feAK7dpa7Qf5/9Bsi/Rkw5kgzXeWPn6p+vBjwY0DCYj9bPg/WSokljD0W5E2XOvQuDbBGGhiUQCddvOqGwh18sOsOgpYhxrJuf94LGEzHqAQ//avg7JJW9g+ImqCpvUzYP7vJTYur2S8hsjdgv04fCC7FiSBAPXmHQ1OkkjMF6OL7Gj223VvPQ4inRp1zhdJoP6ljocIfjGX4oT8GgfKAWPrb3ld+WCXSCeipsZBVZ/AZGw8GsJUwJKmFI8X0si+GbBDvCCvIYtraFU0yVcQb0LVzV0JFquK50GtnXL70Xw/bt6Vyd9OSUdcWyoYUPUiMxG3QfVJAa+AY8BJ+iCmzPdeBdfplXuz4AX4Rw4QVUwpuTkiAHwvzzRCfxh10R8XhtOotD1z1y06ZLLk9X+DVnuJNmK9XogcDqIxAOilSt0289qCcDSdAeO4BRUZVQABMWVgm7vVzujytwCxQDNETe28WWfXFiWwSBc9eXaD5RwCo4YRaI0/UmKYw5CWaGFhEed4SKElfmPszBtrgDGsHyKFLAzAbmLCzg5bJT0lU9gWIwo4uI3PcYtlnyQK8evZLJN05i2Sg5EHkIz9rV8ST9jq59e6tDGR7rXyt6L73RiQz1ZMPj+rqAA3jCrx6epTkWXtmWIYcmwUBLGOQOxTdfgiTQ2EuKp6Tl75C1IhgK4fpQJ37/cCUTorWMvDMI6UkFHADHmFasEoQcZWuDAEEjoSMRhqW2cPqwj/zSVmCFVmvJAVUS3NP4iO6fhIDB2UA1qI7eJlSxmzWtW6QfJ4HmHLQnD2B+UbZcYwmaDiAZtkbFQILk+SQGNpzbwmWVStaVKLCqkRD157lGRvEbDBl7n1uMAB84fcMHHICD0DEb0b3OaJ8vBoiFzlYlBEBJmgdR7jvEpnrMstV/Jz3pYP029o+Tvq4Vhv+/BnZD5kWIgohffQhfAa9A/YTRqJMAZ7BJaxBHga4PdAhWhC3YlnVgm9whToZqZCzkIGPDRrZX+qeInpUEmW5zuFeMFDy+C7WzHYUkeBeuj3DiSHAgdMDziTA8F0mz4NPAQEv4mRU8pRmCohxohOpOD1RpELVvh9gWucBUaI5GGL1nZBsLiQQnClw2N8BSmBZTzPbsxWjS4NniRj4oi5T1rRDaTw2QfM9D5Vnj/7IR9gJr4P2SMLHTkd/PT0H5R8g3C+K9Q7Hw0eeIF+g6352XTGGF3a0XOru+Z+kHbXstvWWDGgOfenut/nZPLFHd/6cldKEFcg9MZ0jdfeo9h1Bm5sWp5S9zI2uETPRHgU0SokcnkArK8ZC1KBgWwqcLA2AZ0AmpYW/AUnhtc5aEJTmD7dEOMTqC5FtL9njQEmmJ4tEjig+/BPnwBT+Do1BAoHh1HntEjTH5fgxLoy/gnuE+YyyffsWq72KKgWPsHIwcM3U/Q+nuOsPv9OXIczN4lQ+Y575fFJcU+JRfSnjrOiAX8i1m8drULLCGsa3VXAh0g0lQcc8VLMFq6iMy+S2HD74OsfCsooKveRrugT2N2GVAcy28vTNZFrhWwF/2tTUDaVCEn4R7R8EHByNxdz8vRS9GIgviesSQSEKrCJlqM2NzxDcG2+Z6n3sDxhoDdw339Rvk/zoxxf7UsUYG0vc5yPD8gfCOgj8ynxUFabRNhQdloJwNijCgDhatSAFreP9GGOyBCWVVWAeooRU6woBsOJ7rB8Xg7AvEwvA8IAZqrgMFUoyPGonCyJsdAMVQf2kIdbfAd/JnXD3rAsFQNwPYA8pJUomYdPibrRNDVt3n63ZQdyI54dphb3IcS9gpnvNGiPTbxS1GcueeLcTA6IX12Lg3wCcAw5FQJMP27cngM3Vc/zzDd2NK+g2QvouhQ9rYdk9OWGMOVzW6CuFrHNYLMzURvBdc5s+2wQJK6aKNDsLlFSrcw8+j3gujV9XTUG3D+Tf9wB82RsZT4zwc9QHwOnEWRSlwAFSLgBjQFCio8YYE93fQ+MssPHNhkUQdNUNeYgDjT0DNneGoDyLrz1KgE/7A76ANlDkww66Ij0f4YtvYITr/KZjiWsI3DmC5QJvepBmaA0BTDNNGFaNpBdxha0AMSnsp4NTMT+Q7rOBBEWK8PESMqBigHPY8jNbmI9Rnp+u3m7H21R031NcwOK7//vp1qL6JKb3J1OeeDD4l4AVve7HP5g0YCUMd7qI+ALE171Eb7shqv5XcmWQLR+F/zZ7hzmhb5gYdl+lsDfwXSbyVsVkY6uXwfmIYip9oKDs6mac61IRUnhSGVQasnJrCsOIWqUZvCwWZcx6nMFB3giYDlJuAVWDl+4gbd90FFJoFmigpPFbi5iGsQWdImbOIaPayMjWF43v8WBKYzC2zEZLG5y6EueRBILwbkiipDKyAEeCxuZqb5iNRHNcQGbvrcQ5pwkETrmCXV6TUHkgHuiTHbkbxG0Jk+Qesad3CTpZCOXjfvQyboOZX44Ayvl9jwLDN9UXf1tG/pn+t6LsYOlh704b61wxEqlLYwlkJ92/pgg8XRIiunQZKN+Au+Pp/BvGg6IDQ+lyytgUTlpUH+TA6tR6rgkfiWEgA9U7tTykAxiJOhyAgHT5p9hFgJxosQ4BzYM89np8r+2iUXvGgEXCGS7gL4OUPzc1wehQCRjXDO5odKOOgaNNESACFL1hVP+J5v4tcvqAi71IAHzbPhFJYsTcNSmFI/n2JyLCBcTNqHuc4r3VzBGfwyK8Wp180eCyshnKYMq8ELODyHZX85ny4qnKBXHEMkgzWsWqwBJ/KCvavi4HyTJ6kptJvd1Mkhf7+/6+XnnQifd3IcN22Bndw/UsFmgAFmuUKbl+wQ+kNVEOCRZIAlXGIvbxZ/pquDIYO2BIfx/U0J7ndTWCPdj531+ZZbteCpg8h/NYRHLIRT3YYDOIbItzfA3cYnVVPSPFJmAt3NtkK89sbsIDKr9xQmsOQwU1QA5oEuM/TZC0NZgm7wBOabyIgre53hCBAbgwEPlMIOxH7Wlt3YCqn8LY9i+a6Anev84+BWaubj0Q1Wie32ua9Gs0pIB1em5FFW6Xkx718Q8XVIBfYCzEP0yDyNIL2GnMidbdmdLeO9zNt/w/FFPugu5fSE0iiL2p6z4r4RtixrfB3nqNtpBKngiamrC0BN1CNvA2RkJD9Dpog2Fa3muthThLS1AJh+XmSz9AL2CphHrHF79Hsi1SKLYBaZ0c+nu0LGZA6+w2oBJ/JFdj6d6D53wGM5XOIhqd4yJ11toznIjzT3W/vCVgy1lbdyY8FmPoXlh8n+saeKRb0DxVD49DYdwIMhI0KnuPvXGEsh2+9DgugRWUp4duRiNKyQOtcqAP1n+GWjSMTNlcRpdqBx95qrhVDTbFUm2QoEAnDA8QLX3YdPEZVw11o6YJ7MYjxUA7UgnWz9qfc0v7XsQlT4RD/AfHQ4m4JpbC8dgMEwtUrLpCpS1z1Q0FvU6EZhmK4gHfH4PlXvb9+Mc3g7OS7hqExloIxFomhKIHpnF/rzhSXEvGEA4NsgJswNe0j8IW9QXHQBa+VZQmQVQ0d+bA9cDGWt4BGmOlTJPP+NsRAdwWiQeUJTIKNgZI65543BLsWQh1cxBPnbVBSDGP8a+EEOF+Bz29B8ylhc7VVKhn9Yj0EgLUnDEoBdQ1itN8Cl5oGya0bAttZxtcMZlhmC4TBx/t82WjxNvwE8FEiod6m2suw3XoCanX/DRm0hgBuPyj140Q3vxkaE4bbxvQifUBEH+DVfXaAGCVrI7ZCMbhHnacjDf6dT7GnkVz76aLARwt7L5fZKK2AXLAe3IqmWcFzAVUktSegmnwbZRmU+UyGOPip5xds3BMv87wvlGuCSSp6h+IWmDxbW7A1DLgLwS6FYpwrbnO2VRvyVwSoYKddPDXF0BYDf2+B5xTFMk5XIM7wh2CdCySLgWE2/j52O6GlFdpuSiGljkmw4m4a1284wSb4K7+AeXA1yIVBvtomTkYAqTPQcsKSweld8PY9vh91pMR4dIcxoNAUg0T/3fXrUP8a6YvTVTcuzIHf4qExR/NLBb/mExpm2/AMX6FcDFiBS0QDb/Euw8pawAac7jbhTSmYS+g0rTAstIWND98WpmsBvDY1C421ApLAUhsGu/GszP9sQsDdGKQfNwO/QZzSgCIEPl7qK4Z0OzADKm66Qh3803YwCn/wKajgwlA3Po705Xmu4Z11mXWxKxjKP9hVE8+YhFoIg/ZJA0QXy4a2HKVESbXzOOrP0+wCZ/77F3yJM9f3Ocm56YALjOAWLSMs4SF07APHolYhsTwEdoMyGMb41PKLuWcoGjoRxR0NnK3hu8CU/jswZsPomIeGzih9h3q/9F50DlZT7M3ugEFb4NfwymIG359Ic91A1JES+Y8vvOmZBIB/yTHeqt0MDnA83w8yQfPbpwhLzSMqbAcfu/kKYJWIgLPrQflTOH3TB/UpaIviMeki98x0pgSVSH+MRRiINtqf4wwt9pY0uNmgBAalAfawYmeaAMhnwG4nTNkE5ELNQtjetYz6A0M4wAIBfGOhzRuuTR3PuKoagpMLhVnrgtjtIwFviPLcIeBXOVzOVbFlTRwjWhsoKp34ZLxkIY4NGyg6PBFaYdy8GhkvBTDGu5b3q8NQHkDaIBBy901HcVkD75xE4sn17Y3ezvv9OtSPl+7wE8Pjhuu4zkH7d6i8TbXCA+zgQTwMK26RAbIeVu5NgXhQX0IcE6VAFgwZdh9CYeXkFEavqoeR0JaghEmgsAKFJSiygCS4xQiaTgxm+YgNXJ3rQmn+ODTpcJh5ZCpseTapWvCnCMAGhk1teZKuIAwm3Kri2FfTpWhsKihiwFJRTFhlnhACVWBnJ7/Nbj2oryBrljdwBZSjEWd5M2AOmlb4KXcpS5hM5qI5VBZNhHtwfKmfrGFBiAPlIWhqQDGSx3U+nrYCpTmMK6qhEzPYB19/9TTiFOruXRjDK4wR2/SP9TNt/wWiY0KZAlNMMUO6A5eURvYZE1MvWP+49pyDgA2siEnDOlD9JNxiDZLs2RKS0t9BsQfaXGH02nqYDZmX5sgj2sHZhUAY2FVBlm8wdquQxcAGXIY18Axfsc55BZP5ixgp1UAM1HsOwfZuB3RCOlGsZZ2AuP/Uf35DVo1+u5h6Nv3r9dvCsG1NHe8L0Nu/mPRdTDGkDA287pwTpu5rTIyBivrfYYvPqtOMK67hFw//isYdqAbzri4cq1pFARsNil9oeHttMkSB0lnCMRgK6elviqcaUNlD8OZCiIbj9n4cOhWK94uX8doG6kYgDH5mK2sCXsiC9xCUIRJ2xSXEIBqBKEj7kEJoC7TFlQpg2+TVcAZh8HKH7xrQxtqwJwDXlGFtbJ/h4m7Kc9svfRNjoKHhMWOiD+IasnI7Mc1i0GdYf8MmVkEs5J6ajvVYaLozmKlnPqJQYUOC+zu05wyQ/GxByLowCR5YWbLs3G6IlrzlRIszo8MVAW8rEYXeHmiEt19MhgPgcAA0jUAIhDicBAfw8QKioM4BuAJjbcFOBWNerMXmy4diyNhow46qtGwXLyS0vBVoA2LhIAuYWVkkwIAVTNtbTMzy/VR+Okq7rtw20R7G2q4n6YnR0x2LpF96Fh1Yq5vfTDmvjelFum1DQET/2NPgE8SxHf7iPHOGyuSJAJxiKoeZR0jmSdS2wFywjlTjUt5Azp2ZsBMGxQPb4IsgN76+a09zCdyeikRC3IV/hD7HIB6QEPAO6u0Qtj4PymFyBlw7Cp/ZAV6gDoS2uzArMpuBwDAkty3tQCMozoEqAD5/CKpwUOVB06bBANyeJ9diCeTDNJ9iNjq8DVfAbhVY+8uxu1aO8FDL2nURJznjYUxErYShlw8QQ0jLsr3Bz7XjRZcvXb9tDdfTfvn/TnrzHoyt4d9o9z8L3g5MRWpNONa14hjSypV5Lwl7LwQwh8P8lkSv1VLhOxNqW0fBJPgJ/6R40kvkZk/HyvuRpEBQ8ZgFiz0CcibA2wuSZdsGGSO2wFI4FBsqTNtiJNXICpg2tZhZ7tlcvqJi66UYnqWOC7FuDBl1X+Z2e5iwtYpp+cU8x99pCLNhrc9WPLKqeUu1WQCwtWDl/0jOvwifmP2aTazCbMd9Xl1zECzgxgJ3/IrOc7ZuOl2Yye+KgtoRjjjoKjyFgWUEkqMxGjHS1yP3TYG/LvfH/8xfYaYGGS99GR+mnOaGYeT90jcxXHeNgbj67FoHYCH8fSyf5oxnudU2bF06UI7SnnIXlrIL1sOZqlm8eysRrGFmYxFjV3wGblAS60F68ZtM8y6WMbATNL7anxAKU3JKOGgTzqaOd3h2RDUkQ8j1k49zOLMeFt1IgREwLr0GKqUopmNoK7YgERT+CNj1rIbLpSoYD7sT50MBqK7Af5r9N04Hm8jwfkPGb4E2/38G4jycoY0eXAFp7q+L7rQA0rPelOe0gXGralhZnIKyGK7xPB1B2mtvIsDuaGGdcxc4A1dHuNBWroS5ENGaBVfg3wcXQzWEpJ7k9flpgAffdRT1JfWBbg3vl76Lfn83xDeMOfR0+/XPNQdeAp/pvK75CE2pAiLhXjtiv3oi+kcysAqGWP4DwqCtToliqUZyx8YDbqB4XkPLUktumY3gapSLAKZmiPNuK8Tc2s9ZJpN85G2CyMf73GVONPsR1ZXOYU0Ge4im/sAQ1FfgUFQonxdC3VTJTY47/HJEISHXT/LwJpAk+Wwn50Km+xyJyMtFipmNGC5PN4onmFcgMk7uIlkLEoWpblvWAUECHGMBxMHMF4sgB+oDh4A7EAuKamTcnwLaQWEH5uagDoFxdTUormh4NNoKWSP034uhzmqKBGXMTu8J6/uu9IO23Yo+E8oY+GRsnyFrxBiwa0whMAVGdifaa8wBdyTn1FBgLrRXDhCPshmUhHtQGjWOiLnvYV0OH6/zhWIIGXwEKqHWz5HJ9sikfgnCGvPkPmekqmt77QC8r1/mVT5gXHKNeF+sYMvsOH7ysFmUwjDYsTaBdJ83SeK/4CN4oszod0rd5+7APWNsD/3t7oBvU94mQ9G/rl+x6rv0VqE11t+7Awl7Ghemzh1GKrGwXtIbALAGnupQC6tQq7trfBQShj0brl5ygVjomCvh4VlXgnk+G9gDdaugpA4mKIqYfzQboqAh3gblUrmPIh7UGhUcA00uMtFbyrGP7X35IsJNxl86sBNiXPaDFfyu6w8SqtsJBMJC9iHmvWH79MWp0N14MbVP/1h3oHu/9F5MzSO9VWoNxdA46Y5xMozjf5oLzloQdR0M2XmfN/kDGZo0ZpGPVdIjJgRVQYaEp3IXjvCKGK+xYBX7CIaC0gosG+F93zD5yiiEFZIBBMDugPngDYr1wCJ4oGVxnC71gaGg0ThCFyhyIbF6NYqNGo48NwOAWe7ZvLYqi9MpPqJ8lSPjcz0C4DbC//BLiU4Ng6IrE6ETorbt4DXeh+v5CAvK0JAz1i76bWaO6TY0ZNkau1f/GvHDpbv53/C44VxkTFfS3/csgz9uEudXAqgnAf7Sf19rzCJ21HuoY0A5AdQ7QX0MsjyDpQBTCmLEBiOskgVyx+G+kOUXLDmbPWFZwW6S4t5BuQ3wAbP59+GAuNq8IoEWaHkGmh/CsfxQrM3g+TUw1gxx3J0BaoEaeBbYlxEONjDk6H0qglwZHg7W9sAlxAEfACuHpcjYKJWww93h83GJa2CLcxy7auIpXTeOr/g3+d0qyHWbzjaL5WK8JAPVsIqN8M49vr++6EtfnKrG3qHuf7/j+4dJb3VUYzaFOKshCH4DFjxEXQdFzhMl7dJQ7WkHAStY8PAAi9hDzNr9NK0YzFO3NdjF3WZaeTG+EZ/xHH+Xeb4YmZNTkTk6CnHerUFYtsk8roXRlD8YomD+sGxYA+p2xB5YJf+PJYTyQksNznzJ1zzNzy2rxBkIkA67V8yH7eDi3YDj+lZIgvqwIbwblCgVy5c++f6oRTv4Gz/nUteLNDn8hPGUSySIO2zxi6PE2YNyPCUkfDO4RDdwixHYruoQwOEulB4ex+e2KjHq65CxWQzq1ZDsvwRQIOuLMSDWlC6q/070//evGX0Xc7pfq/X/6z7/DH79O0iJ5LDmZTTvDqCZn7D2xa201SghALzuABHi6MqZNJMmt8FPnNchcCX0JSgDn+UVtPhaigNiBbBU9Bhd7tnrc51YuDeTrVfX8qWPqwBA8cBQyFw0h3u3JKLpzhpbeAifF8JTigZwheFR8GAttHY6QjR8FDyVcT41MBgWbz3ENRd44A17o+Okb8bC1RVaUKwSaJGxvW90OK/5Z0EMxMzYL6HdFtASZkmLp6UUO3ZGHIZjISZ6P3+1moh6G+JsSYftGYuxV3wtdgswZmQt1tFq0uJfR5kK1EjOX6ogN3Y6+6fE8CTPs86RbRiN1NN77bctfpgYm0dMtaUh1gJP3k0LlNxm/4sxKMw14A7OAbBkdjKEgSJdA2eh4awNVy3GwB7YabaUf/g+IylBzgBWMP+3uznIAsbE1IoeFScMdAJ5PF/P9T/OP+Y8w0ZWwUj4965PsS5XEzYhj2mVxTgtaEJ5HeaHZvPCKXjWFrwsS6AAPg0NgFIYaVXPy7MPY7cZ3pq9mfCDR7BN7ZCxsABUPreFBW+BEK42I8z0VMAGstYFi3OuExmjcVCwag7tngMo8fMQTKBTUk3hC6RDln2wOPKGwvLADdTcGM6gMFAeALwhe+osAbCZ3E37G+7vjmSlv9279aIftO1RugNqe/LG9hbYMgXu9vR71MBAqJJE/iHJJ/E6cBbKwOrcI2pHOEIU+CRX4L3qsuR3S4NpZcUcT/RDaQ7shGl8DG5QtxnJ9VHH4zCK/7nvi1XYI0pHj+M/+W9wgJygmZAES7t2YuX6SDw13nB9nRO0wyzyJbQWMJ5v05gCaspwMybGjDlTHgxTbdcvP1507+BHOBy+x0DvC6CrO8ccLKfgca5aQiSsJWSDLFhvtZqraS6PQ4iIRibwhZKflkqpAG45GWZY5tEcBuSA8w3wGQoO9nB8th9Xl7pQiTuaeMRgqYK9RMMZAXCLIifyoBiUuTDNv1gMbgtQZ4Ni4zfMqs3m+ikn9pgtAm9oKbFEsVBD1Z8m8H0DwbB/G07mP2Su6Jf/d8SYQouR7d6IMeaoKXZDMUTCuqAVMElSHlQsdWVmUBG/5hN+QjPH1/iBpYRZK1TASJjFMWFU3QQ8wcvvLE/faIQzEPFMlkRUaBknZXVwbSsszj8kiks1jFV9xqCzwE+loFiT72AcBzdwLwIoh83pG/hixk95hq9IOPsOaSyFuzClsIQm+8Hi2IhGxuYC+R0f1c1j46J42hMG8HP+BgWQXvAmFQoPpHJxbwwEU+/BVPsaXt8v/xrRtbH+umDMsDD8rBPD9cRwvbnHdqtlhO3MA+Bdmxga3G3IdZ7OcXs/GA3KT6DoxkSUs0C5SIoovR2SDHVQe8BRCq/mAo1gVwdEQlh6HjWr4F4CcBBKUjwkl2YidG0fzOki8DBDgN2p4BAFzp7ae+QDzfBZF3x+VFi0OYEzebn2MP/WMYBXLTO57KuCGtjFEgkVjBaD/l453FsLBMLk0pOQAYpT2oiMdvjdwz9ACHhHXyaKdCiFts0Qcvck7z58i0NnQ3kzIImENe9QpHBHEol2t8aCcd2pp7XDUFfrB6j6LqbIC4bn6IshYDsJouCbKAVrl29FqQK/xvOo7RFj1gq2jI4DFVhFPMJpeROB645wl58yfEwNzc3DedXzIHjDa7zP9XgnaAGNOcJ0TdX+zUUAn2pE/0mG66OdCCcTdRRS2CUBlO7ac/cA5dC+fgCKuzC3+DjfMAhrGymq9KyqGoJgcfEhAZ0eImCvFTi92ERm/hzmHd4vtTgqganwCh+ycn0K1vFqbBs7WPpwFx+7+0oBnFUprGUdkckfsJLfgyeU7hlHyM6T4iRPA3zBe9VlxvnXCLOqU34j7ZBuM5/4EbsQhFsHThm2vzFdV/+dGL7L3tp//SKiH9ViuN/w83dB3bdPJ/JNlIKwu3lQCMFxhVy+pMLaWS2OhhogXebR57nGkLL7qM9CQ7iNfGWA/BVtm8hFPCEPNAu0X3ELuYczjB5ZT9aiYDRPKQSgqgYaocLLla94hoEW0FYIw0a18CABnrXQpmaoBsKE2ehS1AAREDyqEDIgb7R4MZ6vhUE3ABUErjtCUdhExtTUyrrjCiSC38HzRLVkynhxR8CmOOAc2FZ18BXPsCUpjtooR2HEd0LRnon41Z1H+Q/tNUkQ1ZUO4dBWqJRnzADOQMzI/bATcjOmozj0CMVPNMxRZMAnHyBFBdpMvDtTUWCG5+iDt/3SOzFkdBpiUL2x8wYCk5mvOcbtS3ZobioEo7ECMzrJDZ+O5oYUfTSji9/yJ9gDK8em4BjSyqKlKUKsiIaDe5ewLHQ35AgLm1PwT+xkntbmb246M5g/EkHY3jwwA+t8NU1eg6UgeCrcO4ikLKwD2uHPzcFYu0PNWjid7QP5UKZw4qOIeSSuWC3pQKoAe1AfRchQS4ECbdqdkcAV6KhGxqo7BD08JnZNBHLcF8gCq82P8LlbQc0dYepihdw7Sps7vVzusS16NaqI21TscxU2eyCEXjwGbnXAWbrPed6TXmsovbfV+0HbbkU3wegbG/pgSncNbeyYqfONgTBKjCvZ+t+tDcTbA5qJCvbFh1MWOlkGTha4LGhgt+98MQraYVvjagA0KviQV1AuAy7BjTh38AXn2aDY/wiqhT24fc9i7GiGKPAuv8yxiFAqwl2ZW3wcGsHaVftbRsDHB3wZ7VAPjTCjq0AGFU/z3cm8L0aBsTYyZXTo37OvIHo/sPXDxHDhQO9zbyYpY6yd7hhV3d1HCT+DokkTRTnz1/7ZwM/5m+T+S4P6yCFiw8YAAfAlz1K7yRGPrGq2XojBOhasByO52bK0t7cAC75lzNFaXLmGIgnYDkTCi1ziTq0timANvyWTzk5kgfCRiq+MhDM2vmgWD+RYTiijc+pZMS8NzkmO3G9/ppDcobRherwbaxf9dusNU+eH9vF+8KpvYmmwbYwt0p0YC/8zlE6+b7goAScYDGtztqIphmU+u/Hwr2ZLfhxdmDE6op6Zk4ugBiyrkCT+dfBHIiAdmuPh3kLIZi5fN9pDIChnQUOiDVyBihJXhiEGSIc/cBQup6m4kv7SY6NmwuQqhqy/zyBnyQXFVKhbKIWV/M/8lUE8wKm4SYz6Shhy974YI5XAHmi6N1hS7+yEBwziA4tX+Ts/A19o99epKkq6D5fUtZExFogpENfQWOyOeds/Jn646M9junbsDThoCNjq/puD+RxJC3IG8iIDWLE+DcfUVkImn2Tm0SJ4KMxav7rzEi5XLEZKWwHgDXcZCkFQXz2E0hvjoBTqFgDpkKTZgcMi+RqfvRXsuxEua0cXTDkAdrqCX4tAnQN5FwLABooDXwJvSZHwgjNYZ4hDY69iHlY+jxhoCeNiasALvCijoxYp1OELgzsGYN8MuMPZBVrgOQRWNKbBGvirxS8gFWr3ODIk6z4EIkX99sJXqT+VkFdg65S1PDEsTL0D/W19HdfYeYbyY3S5fhEx1sa9ccjq60tlcBYs10P9tiEwF4rtX0IZjDDtzOBn/J2OKMT5tgLWsJ4XWmq4tXUUu+3nM5VTYAMXi3/J6PJ61MtAUQJkQYmzh1aXRwzXWAS8HQl7WcQp75dZbLOD+lNDANh3Nhx8IcprB5n75jA4sguaQRMCQy3rwQ3MOh/xZY3r4+Wy3neIsN5zgFCgEcInHOHwXikEq14HhMG0hGIS16wWAGwN/NEigj/zqjAm/eFM2Sw0DxV8UB5JWsrrmNFFy1LLx8Y+QbB1UwxEw8YD8RACOfkzUdRpWKI8CLcPIitcb/pzd7qp/pjqXy96L7p1txPTa7XS4ByANjb+22YGOmrYNzRc0hMEwTiXGgiBjW7xopcfgK/4N9ayjiKviShnSAqdiNL3AKhIcsWv6Dy/ePhXiSQaivT3DqAANFmAL4TV5Ekk0FZgA7APPG5VE7NzP80PwToZOAuD3MA6HV7IhrZ8+NxfONx1/lCntUE0nuCtKBR7oxkuDHUDVyjYOUce7SgSpXFXNksjx6HwBiJha0aMgFJR0HLPklFulbjcbWBlSAouLgIMMxX8Rp0XFuIJBNAylzRBmjoF1ifU4rRMRxiG6yHz3hyi2QMHFbBNjRRc+juylvTkCO/u3er/75feSyffx4D6Qkj7BokL2sGh/Yv5FUXkzJ4JnpCXG8A61jK75aToR6UwJPk+Z0OnU5LmIUOtFdaxFnLggrMbryzKkDk3GmHXhomTG3skQ4kNnGUyK+rSwBqahg6GZBiSfh/OyDTrcAMBgcMha3YwYQvywEVqZ3RhxvFcPzo1w3k/I4zNVRvYRCKK5HZ5UguE+V4H3INK3IWIVQmfWPmJA74ILlm4S1RIK+JozELs/3SgHVQxtyUthJatu/rMSjquQGnYON4ckSRrkTZH751IW9YdWKEl2H6G1hXTy3fQk50O8j57t1b0g7bdSk8TTHcDx5gHxBCo6olVaIxRqjtXrf19tmguKqAIFoZkipfgEuJRewiL6w6JYXwTdtvPR/1naLGHP1guoW0z0vGHIoazCjT/O0CSP5eAHc1MyK+ibaqSJs/BNGUMxmNkNcyD60udHocWcRCmRReL8WEB1p5qjr3uj1T6NvX8vQX3jE1WvfFu9Mv/nehPLsaYIUojn/XlxzISjNwzBvwiztOQbSOTcycQBPMbs1nYmMllNxXHCBLlRwWkgvszVbhUNtAWqmQqp3g56TDUA9uhbK3kBD1+048pNSXUhECDoonLSSrxSi+Ahesz2cMiNH4K7to9h7U7whq5B2tsV3K8xI9R/E0KklXBobmh4tXbA8MmtHDDxgUqz/Ik36P+nykAt7eAruE5xnJz93RNv/RNOjDOsDUEF7sLxTfFNjE8T/e/E7CH4c5M/99cWAWdXUg/Gwkr61KkOrYNsiYMhQtebuxeN58Iv/ew4FtqMoZjpzXMnVY1scQ5mXvDoC5TCrdcCwaPoGqGD5UedHUwUA3jHGrADipmu0o47AhYvmYDBMGgcsSBAgQpMtGsVbA2eSuZvnNEkQJ2D53P6siVKBo1ECggQODcIwAsYg8L7LLwHfkZz8T+g99Y/Blheuj3y+6MO3Mj5xke12fkGl5nijnSb3T8MDGcT3T5OPX392aO0jkp1MALvKFO5csyV6iB4GGFj1M1sQeoBU05hI3MkzDYSCBXlHDrCOAKdGGOYpgGp/wmvHde/o4/4KfcFeMkClgPCzdncjECMX6t4Ow5hM3YBspLEFxVSFsEDFZ8BgXwwlkpglE6dxxT0kvEkbEIlPsAf2jyHcxf+BUPrCx51fkgeScCuGIxVvKq7QHaYWZyEeo2oBOKR7zElM0lKP5XwzK2w1Bh59r5IjrcaAEh0spWwCdlfNew0LXrQL6//vYkxlighmBvPzjVNzGm+/eWMaWTr4FwASGT4nGKa4IA2MZyOAz7UsIpOePBXP/jWOYg8/FO8I67zH/bxoAXLF54iNcas8APOjyhxdMS5Z+BHGhPHUA1z0sl7ghgs5bJpHV4rOtaC0mQnikp0TL95rDQPxNC4Hmu4cA93shKhWj45qHkBiQULPdof0up/HdKaJLuc4DHQDPNCJCbhfyeDqBS1gWGAlGwOPMQ32Ih1yUihrs7ECdh4xMKtOF+XhAx9D0pAJWZxstzD/P2zmQWbUohdOwxOHgEOnfzZLyYGh/6DqPeGuL960XfxFh76e/7hu9M0gwDJsNXJ8EcFhZnsjcmTk4ZCeSIw0x3+jP8Lx+WR/Ahr9B+ZgCzu46SUfgGqLR5YpvBatUjNO1IigGtHE/xQ1EO6jTgHDRHguYmwt5LgAeuUpjY2RcYAbVDHakpA4pl/rd2hhdWwAtu4LwJnFVyf0UqODjDoUuhtL2o5PmH16AY6pcOYRAPmLUiG5Jg9YGV4AvP8QXbbyyGLHDmS5akJeOVeJZjBLGKzVAGTbmDZc1q53H+T7zktxAF2EN9xhBpo83AAsjKCIY2eD8yjPCII1jwUNjzLysR5rkhAcFwvjfUbbvr9/1Ovn+N6NvP+vOSqfnrG4j6gBpFB6GKP2C24z6f4M9f+QW/td3PT9d9ATOAOtidPR+fnArJ7XodHIe1wm/gIU/x4fIImWsPQIXKlRz7mVCApJ+qAUaDP59As6TsyCACzEE9F7CD4SXAKugIhH2x4czb+xHUwJbDcdAJ01KL+Yp/4xYjeM01C3Lh96xkpeb3FIe9JPZDLaIjFcBrLlmCe42FmfOKRGdrBp/8CpYHbpC8uxeAE3DazUdSAJkjgG0g7LsRzvG5fmzI2YJlHHgXXGZHUYI8YwT8gr8yfFMz7yiS4H4J3y/qqvvcHS7Vk87V+zHRD9r2Sn6IQtod2GLIaoDegSTGQC5rFiWmwCZ4PzeMqbUfkRi0+nE4BTna/0OFVaLuBLsEsNYxNHKAALk2M2kOTZ6DuVYJ6v+Aea3ZVAS5Yu2vpoBAxnBVvA8rYHRB/RNGoz9QCO9axdFQawNp2oJLUqpJK/rKpuEzGeuwhhPQ/5X0g1M/TExNRKaYO7p9Soz3BUOGT28YpDoxhzRYkpHMT1/8iu2li8ULeABq7R0fF/yKmbeffb7h4A+aalB6IVW7a9Q4W9bwUeU8lNrk5S6awQzxvs/MhCJqVY6o9kCeZjXj9tYIGHAFqIQNW7eQdy+AzlpgLrwadRDiYMOMLcwsK8K5pQFOwJZ1ccxPyBZFKBeOX/DD7fIXyBjpzWQ/UG+fvvR2stdnXPWzpP5vxBSz1pBlYApANDxmqCQbu/dAGD6HXbciKciZAyphyKqzEQeFL2wu2wAJ2hBvFUyYV8XiokNkLH+DWNf38O4q5XikH/+jmcnyTRvYNTYeB5X0mBp/eH4EMsc7S05OJcB6UN8ArMCjsBpGwO1MWKpYDY1wdbSLhMsCDmcRRaoSBvGAiDPv8f6KMBYfPcSGgi1oYhUwFN5en8z7vAYWkmfqT81zaLhpwwWLCfy16xdG2sxY+xu2uam2VBqc1x0rWgfs9gNTP04MQVljQC565xg6AOGJg2sg4MEtRlDvNYSSKx5iQNuDQv2NADlhWgfGKiQ8uhJogXEFNTzIAlzgxa5LaD5RwDm4HQPsBedAwAY2FGyBzaA4r+HqHRc00TD+BHSUA9Uw2RPwgbxtAbzvLPmfrQ/A+BRgNBI226LN0ayCQYlQEzVcsKECGFJ8n1nkcxFPPiiLZGp7Id47L/PU6FYpKhYABIFyKbQMtcR3uRTL0UxU8JH/PDQh4hxRvPeIjnDYHrRY0olEwneLj+m39zd678FwrUZv2/A6Y+9L/7x+cKpvYorA0NN6rOv/5sAsLL9q4WL886xqSX5MojhWEApxsLAmk0YcxLg9B9yF4+v8wBNWrE2DLije9xKUwltDN9NsZUsBM+CnwEiwOvWIMryETRUNZr+/j+VCHuf/sw5Ui/0QD7uq4gkvPiKGrj281bKbuwxl7844Sa8Ako6tFXGaZ2qLL7Ug4JJKit4wF2FDRSBM3KVQs2i4gE2u8G9dX0EV3PG0hQA4XPQ6lzNUtBcPoP3MAInIWAMJJ96BTrC928FlXxW/5hNKVePACjy5yMDwZt4bEQtV+YinXhfqagh+9EY365f/d0UH1rrCR5FkaFbC8uloKhSQiTCx65B+Fg4x6/dz56Ytb9YmCfu2Udh8VlGPsE5WS1qmeRBb/J5UkD8AihDgRVAvl7+ZqUWQAcrtQJUUHFZoq9XjCZ2d0htuF8O9YLBSNKC6A5wB75jL4AL4Q02V1MugAxSVGhlLI6EML/5g9jusKh/RkmTJNwzCu+AyxxaGwipYb7cFKuFD5kiouCvMTTjOrrJ4yson8zVP88rDD+EcvMtb4rgci4w3gAK4nu8kaajcYS3rZKy5y7EwlzzogNdSs1Cnwc2WUeIo+egi3TvHde+jL/N//7jpuxizow336c9fhtfotv+O0MThkaMVab9cwc+5wSAe8I+Rz8EZ2JoWw+KsQyyZm8x2+8UQC/V3hkAo+PhUgBt8fM8XVODRWM3couNczlXx5VfDMTcDRsI/GEqeZwC2YztYNmE3OMO3lgPEWVcFRIFlGCz0z6R60bNklsyR9J0jYHzsp4SHHsHv1nm2VseQuWYOIVUn2Zy+Ad+6z+AUHPf1E6fMKmQMNSIs8mbIdZ4O7vBxkC/bYlYzJrNW+r09TBlZIuNdl/s2Cxaey2RmY5GQFeM0RAbuYoTfDZ4uaUSRqMFecQ7ezgT+gCykd/h+agT9dcOU9ATs9m4M9YO2PYoSaczuWCCm2IQ9gbLdveTuGIr6UsZ7H8SCP/xn13+zhF0M4oF4IzqRQhhaduGGgi0MSkPSJVhpDZpYWOe+glH8jW95ikeK+zzvDNO+OoYyFTxiqsET5hdm07jKScJF6uRv341w8VaYAdEwlVM4Tm6lYpIrJ/eGIEwA3W827JD6z64/0Rh6j3orfWErGF7Tb4z/68UUoKszHE2do39ub9/lQHgGhnKXs5e8WHZut/T5BHDZ3AAJ4DO5AiJhYWUmJIEiH2pPOUIJPD/6ItZRerdzhiH+93m/NAyqtTmommFzyAY0icBO+NIOGQsZENRSiPIcpMa/wQfFkRJm5A5YgSId7O3rWVmewukkH16NPYjiFQ2zFB9rww7vGDyL4YKr2zbm3etujJhiiejfW/fZGEjSL30XnWLbG7aBIVBrDGQ0DNk3BugOgz3w267DMq+HIcDtUcAOSm56iHJiAT6pFaKoz4axfp+Rtu11cIULZp7MrCpirsNxti1fTe0VR8iG6kn5qQABAABJREFU50tAdRM4CFdjXagtccQhEIaZQUW4K8pjEt6nDgXSYfgs7S8M1/40Pxg+Wo5RCesyVvA1TxPICSkik4QoUNmIgWEFjgdbidy0Cw5I6Ph/sYUrjKXFfRjfLYRhrD17azh08oSx0x0j1/A99gNTP06M5QAzte6bUnB1x2zhWSVdmNGFGT51FRQffonj9n4cHDZfCslowaL6RUPAC07v8xEGepG2yMpsOGC2QGyYKBh+AGrPOlJ0YiLEwr0ZcO0cHF71Mt7tpfzRNpSawOF8YBUKVZB64Q2IgucVhbyWnyVMpq2AHcJO3Anjw+Dt5k1QADWJwxmVd4tZi7JFL7sFP+MLpuSXwBWwdIELS9349kMbFHaPeBAHV1UuUK6tfnxfnOl3htpCI3zdDgRA5XM/x9IF8glizlsFcP0IT5jMxgy43vRjY449YyC67r79OlTfxFj7mlrPjenKw7DtHMQ3BXZ4xFSjqEEM0XSgCK5nO4E5/LrrE3FWVPO4IExx+EtQCxf83PA9+hkRQe8RQQbDklsIn3cECuDQplAog/2KGJb7bYDx0PXhYAGp1gC7tY5BG0i49w61bo4U+U6EndDuOQBFtJA+EpeuluKW5qDMBlRwIcgNAmDJpoMMXNRMQ5oN7TYDOGo2W/SmgzwuAog5qLJuA5CbMp0TZoFgLU74NPvXIR/G5dRg1vkIq6mPiLVIJSpgB2serpcuGQLjUms4xiw2sQqNr7CAX7E5ArdBUlMZRo71ZHf0RTftlx8uho5WbTpAEqAqkiOaPWh+oiC85giaegUd9nB9n5MAQ+uRQmJZQITk6Yxm7+PifOtYC0XIGjGLx0VQcZMaFUSCJg2Ui0B5ChbFptCQYfO4iHFnq5LUE2+IYy0Knr4LA81guB84XIKNmiTqhw6hvXqAgEs2cp5qlrBxH7TA5oy3uDPCFhIhinQBrZIEdB29tZ7MwDlCuMoAhQswEhYXHeJd3iIzbQ6aBIRJC8SM3U++xSzUqyU0nVwEzCoEnEGTDqPL6qVNGuFg3RIIg5o9wwncd0R+pzO8FbuZp6ZpGGD3LURuBz7G+NxuKrqpO2d5v/xrxJRe1N1x/fWjBWiE30DMp1tR3b1NevqbQvRbByty0ngrbDO7iuNZVrYbfMGpqknmYxvYEhnHtBnF5J0JkMJdzhK9pCq/jcJdbv0MX/E0X5N7ZTqnL/igPgpWqY/EEXAC8gICaCuEtnPw85Z6ws8d4bXNWazOX0l5yy8l7ccaWOGTRnjcEYiG+qgh4rxzgJmbi2RMJQGbtLodQBWEnDsptZoWFItul4/kgM5EIrGygKXQcslSUjokQI39cCng56bmkGIgtxVnuT/4BPx6O3AScey18ESH7QmcNfXejOlQfZN+0LZb0U04OqDJFBtBHwwxfCFK+B4YYgw86U4x7k7uwEG4nubEcrNtBO8s5O3KZOiAHPeZopOkImEQurweFkAY2NyH7SMWs3bzVr5hEJP5C50aWx40wpkFs8AVPk7zhUWQGyDei9QRbzwOuVjokikhTuZAJHhUVoM7eJRVS36U77D7jHl9jBlo3SlMPQHcPbWXKYOj3xjvm+i3V08LiKH01hmhv98YAGmwvwMCKcDX/zNhg7sCVdCUOJj2mgEyIZ8DNsP7tWFwEFwONkAIXFs1XpgdOwEzWKRKIefMTF7bmiUskCjISZxJW4HW0TEXnM8CVvD+lTDqbB2hQFuALwEogppNw8VQyoVVbIJQmDKsBHvuCV2R25DWjDg2emoLHcu2uznFsH2MjTdT5xo7p98o+eHSm/mkO9aCqeOGAKN2eybcMhsh+aHCg6XyaeQGcg9Px2d9BUTBVvsYAZMKAHu4svMlYkbtBxtwcWjgqpuL3K4ZXAoaHqcYqR8xhFl+2YzxqcXlVgPEgl0GeBRU84vwM1yzdUEZKGGDTfmD5RctgDHltfLbBgM28CAf1pZvJZACwlLzGJdVw+VSlRhBYUA+UgTHFQ4WLoGxwoaJZi9zzhRAVRnfDY3UZ8j2ps1NHde/n6GBYYr13C99E0OASn8e627dNzU3mQOusBEWsReX6w1scY7DN/0zZg4rYv7CbDEOMkEZLik/2u0G8Bx/lzyd2zzEGL4rKaDU+xCwy1dy/fuNPQ9pkpf5+UlQyYuctJrG/M3ZqEJvM39YNoeyQ8XxYAOqFKALti9aDF5QEwG19xzBGgiHIrtfQRaodt7mxssKjh0MhS64EO7GhOgqKfwUAljAmMFVPIiHQUNhUCCMqaqFSlBPBeJBeRZJjTBWGynlq22SXCj+z2mQ8jmCPujarDdrsSndzNg7Mnxf/evEDxNThp8xXVa/rQcCL0HkHOpwhiK4kOYmgG0pXL3iAsUw2rseboL1TbXYmlbAeLBOULOe1WAFE4qq8Jp9ltkcxaOsmkPxobAIiBaHGVHAcRljjNT+hEA4HekDG+CbwUpaNlnyNU/ThTl+w85Te8IRq6mPJCf6OWEGEgNKW8RuiIYJDlVSh2OGghM2M3Fc34qV6yPml2dzJ9JW1qgIwAtynGeCD1TEu/Lrrk8IK8yj+MxLjM6sZyxXyE2ZTnvQAMnT3gnpq94kPfNNrLIeyZjuAtrhw+URrGMtipvwHH/n2MNZfJ/dZGw+MuX40DfAjf31y48T/egW/dB7c2FgV8J4ylFYakTnjgXLfBidWS+6ix9SVDsG8IW55OB2+QsqSlwhExyjWwWwAS7vUcmUGYPk+i+E4kkv8bdmJ2qTHLnjZcsv+Cs/vfrVE5Z5sprY6PdoWwVUS5oDOxXcOWPLdXcndqxNYLB5E1YJj6hY4cpzh6tkDDpAw1kbrDZpGMvnDHNtgXbwmFrNYL4GSzCnC85AeN0RAZsaASs4tC4UbkpOak/KGXBJI6zFi8AaGMQ3PDVNw3FmSN2NUri6yQXNAthkGy+M+xmAJUQ67+LqUBcGKm5TED2HhxZP8XGQL3/s+g+x6R8XsDQEYs0N/kP3Tu1+2/pfJ6bmF1P4R3driBo+FN1m+dANRES9x+RTJyUnrTO8uzlRTi+BWi9HsICr2S5wBTa3J3L1hAvBOYWEReSx3HkDMyOKpG+tgkMpoQyra8Fv+XlCKk8S8LdPZf4fCnjCwIxmguMKMTcH61j4le1Jrk5ygUDYcG6LfO9YaDhgI068RCAKnCKawBJe3XZQzunQHiuGKXdLYJnsPj3Jh/oTQ8g7EEDDBRtJs3MGSfUQBERCTdBwGnEgLeN1bp8DVf5tKuJdkX79JUKm+hIB0IyRDUyRD4wd0z+nu+t6Z2P0g7Y9Sm8Ape4AWX1wsrv7GFOMeyPWkN7B6KB65vEnCQOcAdSIQZKw6B0qDrhCKUQkvYe6DI6X+MEtsGyBZVW7IUM8JS7XGxgW04KmeQC7D8yHGph2tJg01eu4c4mcuTO5h4N4MfPhldoMGQzt8n3YIQySocBx3bP0RoHpyWAzpjQZ3rc3oK8+QNz3wdIvhmL4XrpbNHTSU9/uiwdL7z3GgcfyalFi/IBOWHQnhb8xCqsFj4Qd3gkN2Tb8gr/CCNgYGS+KvTtgBpH7dlHs+RLrWMtRZgvoGgPNN2GM4jjm5qCcixgWlkARvFaYxU8sGwT8OtcgoYSdoBp2WxgpC+ADXhWjqkQKkIlDowKhGPbmuQ2ZyYafDduorwZ1X+abfuleDOcSY0qubtsUK6EvTNJvIBzGLK+FvRDmn8fxKD/GU06Iw0k5pRNWFKZxJ9xWbhEHeMHzNy5K2oNTMKaoVlJ3JEGHNkfmM97/wCmiie2KUOrOwZsjkqgPGCJjqVqqeY+JrqU5G5SLYUjRfZyrkRQ5xZITkUnQvEfCBwmGdKLYGBsPx2BccY3khy4AomB0Yz1pXq/DHlDHQAGBfMUzsqZxjyf9uSfA21g7mmrTgSaOGUq/8fHjRKcndae06ouhU1f/fAfgeXx+e5qQuyfJGh3MyvwUyWu2D1bvWylAZzvy2uYKy2MF/w1u4BNTIftdIYkElEVAAVx2VpFwZgclVzyoOab9ukmQdPcdrBUVsq3tBvNnZOMzo4KLrgh7YzMsK9gN/qDyA5etDTybX01LoKWEFBZDw1KbJ48xFPKZJZ8LQeEJTIVBKhgUBqk33uDZ7Gouu6lgKVI0thIe+MAHayOhU+tA7BLWISrgQ9CFPn63bU2tw8baFoPtnnSu/rXjh0lPRp5hu+u2HeAnPhANfzKbB8CE61WAFCb6kFfkNHO47KsS/eYMTD31ESPib4C1sAyL9kyEYjjdNUVyfubAf7RkU+z7ElP/H/b+Pa6qavv/x59b2Yli4oFU8hrULig84p0S33iwNM1LWlp44K2Wpha9pfBI3lNTDx4xLUxNTXzD0aOkJnk3fMsJCy8ZpIZJgfcQgyMIioHu3x+DrcvVWmsvqPM59v3t1+PBY7PWmmuuueaalzFeY8wxgz7hOx7hAd8c4p95lbO0kjAIJbApro8sz54sYaW8elfwAPnYBp8j77wPfrMKKE2zypB6HU4V+Qo55o0Y50YBI2BN5lAWB73CPVyXtGOB3cimsfWqX7UQhszaKiEXgP+r+yeoB6HJB0mP6ELo6IOsZuSd1ZaOvHMvoApSDvUTmSwDOizJIT2oC0GjT1LiXgX8HVHKHSEn9L6Dke6m9+eAS7eoHRyErXL1yxWgECr2QcQ3PGAppLDjvbJKpzq2ODakDUxH5PcsufPzob2wf2uhw5QcyEDI/G1QcN6TevwsjxqC6LN5EJp4kO95EL/tBbSILeYRvsP+k+WWlx65UJooeZcORnSOGGgxuJgmbqdhl8QaL0qANm45/DA6kKJcKFoNPiNLsHey0G/CXkiFil6wYlcE4clboC7MWD5fYoC2B3s3xLC9GoYP2wCZ0HndMfyPnca+2cKebSEkjHlZvA6BHV/2wKtFhVTZePhv1vA/XnFMzY+ncjOyArEEPmj4Ko+1z6PlNil3FEvoY0ml2O0rhPE9rfgODiiJ9NrKQ3phEl3Qh3IM0RpjzMzB6rn7CFQlk2F5gHjLCJJ9R5Pe9mkso+xc6tQQ1oG9LRBevVp1FjzWLA/6wpXypjzWIk/0gAHwAKcYlrRKSNGxMDx9gxjdbJAR1IGYR96RV0gD8uHaWW/2LAqhfvU4v29uHx47kQdpYA+A77zawPbqOLpBcLypHxkjOsgc4QHrp4yAYNiS1kvK2RsSmr98y4v+qVkZPMUenrXuwrukRPYzGA+90z7B0swOs8AWeQ7/JaeJilrF+/a3sfzZTse23yKeXWbqUk8WMisPOfYWUMpgv8PwCP/85z/p378/zZs3x2Kx8Mknn9xx3W638/bbb9O8eXPq169Pjx49OH78+B1prl+/zuuvv859992Hh4cHAwYM4Ny5c79B6ZwpF0bCr9n81IKcmnzRCtFwDVq6syc1hDabL0nDngyvnonnU/qzjx48dON7mCvW8wuXm9BvqMTnYReyFKm4OnD0BiAYPHrf5F7KJPsUiIpaha93ASsZxRPsx9LEDm3h45GRnPBtA90QK2IRsB8utWoooVPusFDUxPqsR8jqnTOrCOp59tzdCvnd2y+MrE9a5GFtCXwtw4byWiM++XNvChZ4imIQA2yG5fOjCWl/RMIYVHt6+HQuwT/9NMTC1OB48ub4UDDEEyZA4oBXCU09iM+BErZf78v51V7QDc5V2bACDdJkGUaLAcVM7joNbFDcy51GPZH/u7mLUJSBkF+HgbrwBu/K8qspsPnGILhsRwTQYp13MlM/RuORFkGiNz4ZKSSuflFzqOtM7YXgIAn1vDi1QiVo5etAfXgRGXu7AUnQb91ewuO3yOWRyIYau2EOU2SJ0CBgGHy7v6MsLypElJB02Xn8TY94imLgcvj95CaDbR+ct3fg/d2xtHnmEt9MAVKgLUfJXdYS70gkjuYI4Kgo3ntjHqfC4yYUgncmvFSRBJNhUuIips6NlxAi7oAfTBs/SapgLrTiLJSDdRO8OWApVdSFd0Cb8FPXi7quta4pPXccyrqRt+3vC3dnn6gNIaJO5xjT6gP98awoYB5vkdu8JY9wkvQBXWAoXB0Ks4fOg+tgPYQYBMYCFfBxz0jZjTsf8gb4gC8cXdel+qXh0ca52A9YaM4FbOMl/EDufOBYdatIh682Ix60R4FC8K+oQ0qrflw8LOkoBBbDoYmBePMTB+nKzIyJcAGuWUqwdYXSSCt4QbTbPGgPO9eGMjNvIikr+mFPA0pg/MgPOZUVQLuQXBgJR6YHkDKkHw2WIXJbL2iWBkUbIKT9EUY1fR9OpXLn6iZl/RnVLej3Ly2vaL00dy/uvn6hN4/r6RKOXzf46SIEy34RK1ZE8Ib/XMoz6zBxZQIzOs+H8VCxC9odziV5jiyx/r+iP4nH7AH4442jfMujpM/swnt1/4ew5V+ybsFAtnmF0f7G1/RgH3Wp4lR0AG9OWUoQX8vckg6D03fQJKCM0gFW8cjzhYktEiAO+rENS46d/63731ABDwzK4Wvv9kKorUDmntYwIW42I46v5zCdeISTrJs8UELqJAlJm3D0Zc5/7QWjYNr0SczcMJEOKTkMDN4tpFwehBYepGKRLCv36H2TikB5548ywsXjaj4wBXrf2CWEcVsp60keFuMOnyGGQKMVlI7jX6O7uGQo8zBa6eL4vxIxTO0AlhJHrJCtkbBlTC/xCrQh434VlCZZhbTpBg+HZ4ENWXm3CwgBH78S/Meeluwjq4vgDqRUL8G+LueC07MlPmxTxCiQKRvrOf4ohPLIOjAZvEPg+cwkGI/EcQYokfPHqrrIHLFb8kqwvYx7exjdO5mUiH7iNdwNMrZ1YP3l5/isKIRNMX3kHXwhdtnbPB+eRPfA3XBACKqoWatgLAzcvptZTJdwhcCrofF8tbk77wfEstf3cayLoKgIUhb1o8F4sEy1Y5ltx/KwnXWWe6pfLAfpE1rziN4qJyOZSW04v/uNfHdXnwCpb2cGVKP5Ge7UM68huudp4FNgP4H5hwg/+hH27Raa7C7j0tGGvOiVyITmszk+2U/4HZC+1RZOnG8jhoJEiGq9irVRL4tBwx+J35xAtcc2PMtmCIM9q0PEMSRVVp1aMpF7RgArwT4S8r188C88DaOgPK8OeaN8eMwvj5CzR8T5uxucmNMGLsDAJbshCf7LazdRS1bxRHga5Xl1IEs2D+MwWM8inIAb7Nr8LB88NoKC1Z70SNqBpbEdy3k78yNnQNkBOOaIWesMWtycGag5Jy1nROe4q0jb8vJy2rVrR0JCgub1+fPns3DhQhISEjh06BA+Pj489dRTXLlye4lxdHQ0mzdv5h//+AcZGRmUlZXRr18/bty4UYsSaVWsHtnqzPJRW8JKeV49kFbeOudNkQhSuUAudOefvBs1mcziHjTKqYRwiApZxWUac36DBPE/PaqJdJjW0KThJTgGuREtwVc8ovAA5sCrCfH8VNSQXUue5V3e4MdnGkun3A/+rU/DCVgYNI7StlambZpEB45wO/6gsv6UAqiRYKpXf2bJP6WSZyb93Y27r18oofUt9YwP6knH6PuY/WayXPBjnhePowvc3kE8F4iAnl0/xfLnmzLhrEB+q4W0ON7Cp20JREBxqjtbBvSiZ9dPKfnYhxadi8ls2o6fqYdtLbzeNY6nIjMgAOYunw1Hwat3BVu3hcEy8DpbwZhli8SKbwP3aCAYhizfyhOhaTy69iuK97XAuaKgPK9FfDsjO7Sum7XG3v1ClQN3Z79w405iUA3lEn8HlGSh3n1654shE/qv3iBtfxhcHY0QSDHIqohqo8IHF2KgL5ye3gSGwLxu0eANpQOAeGgUDqF7DzKKlSRUTYQgsIUCKRCSeITXe8VBU/jjIag8AU91zsC2+Zys5NgN+WchfyiEuu0gbNiXeKcAHZFdiW+8JP3OFzEUlkNG1w5QDvdRBOUSs3Bgi92yBLE5MBT6jd0rnsGcqkGdGNWfkhRXeo6YyfvuJ3Tvzj7hzAjrzOCtHJfqAzmULPPhIX7AlnqOLIIIjTxIaV9oMApp8ytglO19Ud5vwMLp42R56CjYu+1xVjKaiubAdijvW4fskzb2XQ4hb7IPP/AQ5EKzTWKwcMTG3borjI4bgGioLAVK4Lt6jzBk7FaahSMrjtYhS8BDjjGIT3h6QjozZs0HT2gAUAyNNlSCDbzbQ+l46O2dzoz4+QzZvRVLJORt8IEhUNrWSnLGc1AFHfJzZPOYXlB0GEiB0r7g7Qelh62sskZxu48YjeFac67euK+WadX3KjfHvLvJqbuzX4Dzb1Wp+jsP7CDEfoRxS9bwSloS3/MQHgk3b3kPZkR0wD0daA0RsRspD6jDN95/ZGpIPKWpVv6n7mK6809C5x9k6vx4ssfYCE/cQiHNaDSqkif4gn5Ze4VIPQNehdWee325RTjl132ATSP63A69EA3fxnaEIHh98Ursg8Gbn/iY50lJ6idzURqwARbkT6Posfrcx0806VxGeNstQrL2BNrCYTrSIl/mtdlT5jFjxnyODAmA5pDRvAM7p4eyp2kIoz0+ZODu3TAE3BPBvTcMK18nevcgYBk0OloJi6F0mZXX+8bxyp+SICuR2/qJo56V9a1l1LaiLes6+55395xx9/YLNZT1aEUsZ22J/8tUaVelMHDKbvE0r4LI8R/Ca/CXun+TdhsPJ5cHwWHwCL0JMTAzbyLlOXU4vayJELKeQCYUnPRkzbahVL6GcJidYGHoOBgNfAXnl3lBEjRYAQ08oEEAEAoeZ25KqIJO8CofkD3AxlsV8XjHw/MbkmAMhKYehBEQO/NtcYiasgq6wt5djzNk5VaZrzwgZOURIkZv5KkTGQxO38Hp8004PacJcdvfpiFX2FPeS3SZw8gmS5sgu6+NR/lW9J+x8EFIDGsGDYXmEJb6pRjD3eBermAptcPz6yFzKWK5d2zG56jrmnjTOkvnmCf0HBLuLtz9fUJrvq4NiehYadaIYyM7M4blzG8Vxc5eoTQpLOMsrVhQOI3HNufdMl4cj/EDwD/xNNPGTJJ+s1v+lsYNF97/cHXWORDS+ggh84/AYInVfKRvgDx6DKTbushGr6vt4A+HvQJltWouLJ75Ch5BNymkGefzvCTPUCgY70nn8kNiNLdBUPMvhaDdDl9s74nHkJswXdr42+1iORQYSPqcLqTv6kLHQZ/zattE7rdcJt3SBCKS4ZP3IHkhsA9xpFLuHWM01teOcDXnMGUMi91ut9fqzn8zLBYLmzdv5tlnnwXEutG8eXOio6OJjY0FxJrRrFkz4uLiGDNmDCUlJTRp0oSkpCReeOEFAC5cuECrVq3Yvn07vXv3NvXs0tJSPD09gamI2c2ZNwImrmtdq+2HV+cxkR/srfFLKYDWQlKl7e0vY3EwoixPRl6lE+API6Z/wBym0mJlsVgPmwMDgUVgHwuWtrBm31CGD9ggwmAEMqG4I+RAOeKtmwHMQDwJ+8KR8AA6xn8LE5KRiUApBDl7T6XQpFVXZu7Xeo46X3VeFuBtSkpKaNSokZNn/Gdx9/SLujj39nT2HZTn0UiPKq1aqK5EJp0nIaMjX3V7lA49c8hOs9FuWK4M9J3gnbUxTLPMwp7mAYehYKInPvklsqPqa214sPFpPrncjzC3rXjHQXlUHZ6qt4cvevaUOLcTkVg4K5HY0PHIcqhjQDeYNmoSswvn8WrTeD5oESOeJYHI8pHFsCZM+tELqYlsWDwconMRT49ijfdRv7NR3dWkn2jVubNvcAN4x9UvnOB2v5iDDJBKgVdJFqqhvqZ17EzIdQP60Md+lO17n5NlgYFgTwFLGhIqZxfsDAwlgG9p43dJvDk2QcKul4kauUrG/0SEUF1W/QpVQCzM2xbNpLGLxAtlHVxNhAYRcDUZGsxB5pcLsHNQKE8vTudidLUHYC/wzoJ5gdFMilwkxfRGYiYeqI7nGXwMxsOr4fF8cCKGrf5h9IvaK0toe0t51mQOZYRlBKI91aROHNAKQfFrFQepnLu9X9wdfSIOaVA1lY304AW0hAk92PC3/gwZvBXL325i/3Md8UZ6EVgIp9c2oc3ZS9AJKq+DtRW8czSGqbHx0BuuDoAGE2HC9NnMazwN6z4oD6iDR/pNivqC926o7AjW68AZyOzUTnYBj0KI2VTI/Lodu+gt3o31gEXwbWeq69qPphTSJLqM44v8CFz1A2URdfEYfJPcbS2xHTsHc8G+CyzrEOKhG1SGwg+ebWQ1SCQyBI+ovl4I9ISCFZ749CzBngJ1UuzwNlCwFP1511HHaujNxc7kXa25ogqIuev7BNwt/eJt4F7FFWfzuKPOWwA94EQz6jQuZ02z4XTlAGdpRVjnL6EeZGR0IOTEESgDy/3X6NfiU57nY4b33iBye0+o+2oZN041lDE/BioTwLoQuX4/EAkpTfsx5JmtYgCv1iX2rnicb3mUxlzmKG2JO/G28GeFVG+sKjF2L9OYp6IzIBBKR1pplFEJsyA3rSW2wnMyLwFsg61Nw/jT9X38tV4sb12P4/N63fkn/8W9XGFS8iLxipxeXbZl1f8vB8KgMgisg7m19wD5QFcYNmAVa0+8LMMF0KPpDtItrZG186UG9WwWZmXYG8AUV78wwJ16RUOM5R/HZmQ9qFPQkBs/y1JuulUnPQYZr3WgHj/T+cIxuXYCaR8Z1Vm4IyHRKri918uy6jxmIXtizAQOwKaJfXiUb/FfeVrml0GwIieCYdfX4hF+E+Ig0vYhg9jM4NY72HSmD4MTd4juEQmTu05jbuFszjf1ooq6tOl5CWxQGQfWE4jIeALph9WGkSMxASQRybstJkMczI+I4g9cZnR+smzQNEvku4+9+jEka6uQzUWQ0akDIclHpD9fB2s9uFoO9etBVR5Yy8FivwYtzyKeyg4HAj15yZk86uxYD1W49G3nuN0v3kL6hRn5qabjmRX5bn9E+tW98IAvPAmMgpNdW9GYy3zMc4zLXyNyeTnYK8DiBsRB7oiW2Iaeg7GwNGw4B+jKQt7EK7+CDN8OhAQfkTYaDtkjbLTzywXgdF4T2kRfIm+RD34B1ftoFEN6WBdCCw9COGxNC6Pfib3SZIrg+dAkPk6OZE3EUNm74DAQBDNXT6Q+V1nJKHw5RU8+I7b9+9K3KvIRlrcYGfsd5LoeN1VTvkp5j7P7jDguczzUXeVpa4T8/HwKCgro1avXrXP16tUjNDSUL774AoCvvvqKysrKO9I0b96cwMDAW2m0cP36dUpLS+/4E9REudOy0qqvacGoI5o5J/CbW8CWIRLjI21GfzEklyONutrbZOfJ0Fu7FifOepUWc4vZOSoUCiG3U0uxmM8Fy2pghGystCc1RDZ1skHFMsAXLm1rKHlXwfnw6jiJvaF0qJUO+3Oqhbfzqnc0M5A48x7Ugl5nMXPegbvf+qeH/2y/UHuBOPvOlYpfs95Xam8f5XMdKISfoMPZHIiHoP0nhVNOBYpg6uF47As8KO9Wh4UTx/Ep/dniK31lNSOxboMhPbZS3x3YDg2a32QTg6WNfw25qS2F2BoFW8PCYEi1xTEAOAyz986DlfAn/o/0811IzntOvEaaSn6f0x0KYf3iEWLQoxm3tAnN93FWhzWdaIwss3plgLvdS8QI/5l+Ab8UXNWencpf+OXYo7UkUAsOb4gXWGWfwfZnnhOFozrUgcUD8V7qCxyGLhxgEW/ALnhhTCLkQ1T+KiFdc5CNZoKRPMKR9rsaGvMvWe60HTgGp8rh4nI4XhbI+fFeMs8EwtO90zk/3otmvnCxZ3URR8KkCYsgFrJX2+Q514FO8Oj1byV0gx98kBhDun8X2nJU5isPWHhxHEyHEaPXywuZgtqbVl3vzurUKM/fP/5zfcKMd5oZDxFHeKge2P6WzZDOW+EYfPlgewmB41DCL0Kb3Euy8dF0sC4CgmBqerzI7SXQIAFYAgsSp2HtJrl/XS8IEuHaDTE6ABQ1B3IheHA2xEJ+AFQuhqu50MySzYzW84UoHg+vdorn0erNbR4LyKPJw2XQFB4bmcfal5/FI/Imedt8sG0/x7DAVRAG164j/WA/sBysyeA/4LTsbH4DXj8fx+Q506Q/ZgDl4LO/BMv/2Kmzwy5e6LqErdJbRGt+VqZXes0afRfHPer7fr/4z/QLZT0aybbK7+eGEC1HwB9u+ngQGfkxD5Sc44nyL6E/PJuxlkKaCQm1Heyr6pNSPpTu/JPTu5qAJ1ya2ZAbVxsK+bkETiS14Z6n7eyZKctXLf3sFDd1p3/5VplPDlcX4TCEjfySqPxVROzeyKN8y3z/KHH2mI4QSgdko68eJRlsWtSHlFH9OFu3Fc+HJsmmfZvPMa9ptBg51sLipq/Q78BePBJvMjt3Hh6Lb/L0sHTmTpjNpKGLWBMxlFFJ73Pc5oflDz8Tu+xtjjQPkCXxWbDAM5qeaZ/KcXW8ThbC2u0vy/LcZfBA0xzSLYGIoVw5Ljnq1RnUXlfK+9T9C1Xa3+/88e/qF8ZzBZhdbXTzHQ96tNoB3aA02Apz4Y3X5rKR5+m85Jh4nG5HvLwvIAa3YDh0MlB0Xcf5HCAeSpdYRT65gDgibYf+JTs4xQMcGRXAYv9XIBFGr0zG4/BNKIfjNj8W8ibXuYedZ0IZPHcHlYOA5nC+qxd92Ua5Zx0+5nkSGcmJtDbQE6zR1SuNQMpyDOlr1+FT+vNu7mRp0xUwsXMCo+cnM8r3fS6FNmRv2uNc8PJiyIytEvoHKOjkScgzR0RnmQjWjvDExTQaxIMlE+65/DOW4XZoeZLbXoXqcAdaspGD1DXjiFATY/rvE/85GcqIwzCjO2qNYY70VcA3SKiET+HUHlgJoV130vz6BZpMKWPc2DVwHSoPAdOrCVuAvmA7e05iR6+E59nIH7iM95prlDevw480l/50TNK2G5krxugh0Gb0JUgBvxYFonMAbIDQ/INSpAvwZPleketWAsthAgsgF4YHbOD1FXESRmc7vG2LI9YymlxLS3ZbfIm1REDWHqhYIZlyFOGkzGz87YzH0NO1tcZ/rXvMyLr6+N2QtgUFBQA0a9bsjvPNmjW7da2goIB77rmHP/zhD7pptDBv3jw8PT1v/bVq1ar6inqQ0es4SuHX8VHMMO9mvRic5SOTzcDRu0X4X43EjypCiCN/+f2a9uTGtbwVi6R0FrJjZS48UHJOvHBjkN9yOIUvu+gtFsgZ1cu9l8mGM3sOhcAmuM49VByFFyISebfuG2LpPrEH7R33lO/n7JwRjIQitfKi/g6V/BYd527Bf6ZfOGBV/SrhjGRXfh/10ie9e/RQCj8h3uTTwdYtGwZDsb87Qbu+lAG/PXgcvsmbrZcyemgyA3N3QwLMLH9brs+Bf5SFQyewxMECJojlLxZsKedk2VPP6lg5vvDY4rzb8owXZE+2cZUG3KAuEc9sZNP4PkKCXYRIksRTpSl8tflReL4RxvGenSkJRl45VrTHH706NPqGv19jxn+uXxjVmVI41vJKMCv0On7rw0PNpE12hdJMxCg3C7LP2ESJtgGHwSukgr5sZ6/tcdbnjpDzKcA24Edkc40LULzJHVpB9kUbPAPjDqwBIHdOSwr2eWIFmk2XzW/c3YohBdbYhvLGrrksYwzpeV2oX088FUkA+gMV0C44V+ajWXLsMf2meKOvhJkjJhKaeJA2UZegL+y0hbKE16jbsQxWOjxCjOrIyJvZAQe5pBxrjJQIrTydhbC4u3F3yFAO6CkR6vFInaYFPAvtyYIyuJgLNrdsOIuQSzEwLW0SPWw7sEcCWXBkRADlK+vIEtc0OD+o2tCchKyamAxEQ0j+EegFLf3Bewlc8XSXmIRngQDIa+VDfbsn50rgWgX4jgeaQe4EYDGMZDX0hUcnQm61d9eeySGUL6tDeNQWGif9eCuEz9oA2TijwQpkmasb5G3zEflpLtI3MqETX/GW+2zOz/FiRPMPaLr2NJaQs/DsHoj4Ciocu3zDL+cTrflFT768ppFGLw+t+36ffQL+U/1CPSdrzdlq5bEKIR1zgQw4V8HQpDVYy8GjrIzk6c/xydxhPHnjMzgMO6eHwgVwHwp+uQVitFsNTQaU8YbvXJgDO2eG4p97mh++vJ+nxmaAG9jvteA1tgL3s0ASVM5EzqdB7Oq3hRCOg+GLN/AM26EvZKfaJKxNX5lrrENhcOQOLtOYx+bn8fHIyFseu5MGLxJy6Sy8wHrsNmQemg+0qo5DWgSbNvRh+JINPMx3PDY2D/uee4g78TYdZuWwNTAMesOkzYvoxFc8EZOGPQoxPs6B8p51sCy2Y/mbndOWs4jirg4vZyR36Y1P6nvV/cNInvp94d/VL5zLT0YkomNPgPpwDP7KW5ADjQ5XQha8u3cy7/pNFs/VICAY8vx9qNwC0yZOgsnQOfeYXFuMyCjTJctGfStF5o8BNkD5rjpY58LTPdPpMDaHF1gvbTgIyIKFu8bxPQ/R5OEywntvYUh5CuyGaw2t5E32ocXuYkJGH8Ej6SavlnzIjCXzuYfrrBgSAXPgEU4yM3UiD359TOQ2X8ib7MOM7fMhH3YuCuX4KD+2HOpFaYyVlYtf513eoAFX+YwneWFmIpGZH4IHjGUpLIIjYwIgHCzv2fmybRiWfXYsf7TDA6nw2XuIh22hqk61ZFEt5wM9/H7H/priP6tvO+DMCU0PenpgJbfHxmsIufkt6dOe5ul6Ozk/x0uMAxfAmgLzx0Td2hSMfMQ5Kgk4Cvd5l/FuyGTsGy3MqjedIRO2Sj/zAqbA66vj5DEecO+iQuGWJiPG9OlALGT4dhCDiw3cLyCrwN3AMsNO8NxsqIAjOQG8vzyWFtuLZe74/hwS63oDQj7vQMiwQrQ3mnTm/KR3rEyvx/GZJW/V583p278b0tYBi8Vyx7Hdbv/FOTWcpZk0aRIlJSW3/s6ePVt9xfGxnUHLe8HMfWbhjHBZT9DML5m5YiLJh56DAZC5rZ2QRgMAd1j49Tja8g0D2SLLmTZBfXeYxF8lpyfBngAfRYRLhzwMm3mWBSnTwBNObGsjin41nhqcAaHgt78A91mw/sIIfsKbURHvg89T3OmBYURgO+pLr4E7I7C0AqbrpVV7Ljjw+590/t/2CzX0vHvMkrnXNK6rB1U9Abt6oAuC8pV1OJ7qx8msIAoGebKL3uzlT+LJlAkp3frdDqjuKXGY3feDPR6Suz3HS+nreCcuhvOjvFjQdpp4Kd5AvEJsgBus5c9UdILysXWkf7kDS6BddC7DH95AWM8v4Qz8hb9J0aZAaO5BmA/2KOiQmFPtbau2omopbFpwZszR8qbSM2Lo9UvHeVe/0IL5fqFETetSnV4pRCsUm3PwFvPgOjSKB3LBPgDabc+Vsb8Kjif4QU84Syv+TDLMkPkhd2JLGAulRxFlpRN4zaqA1uBjyeVqDnzUNRx7HNgCzuHTvgTbawg5Ngi8e0Ny0nM8wne8mz+Z6Y3nEeh2kPru8GjYV2I8dEM2f/KD9MwulCfVkXIdrn6FMTDj2HzYDqUr5fzTx9JpwFVu+ljkhW4Zdhx/aiiX+Oldv6b43yyUef4WYRXuDtw9c4WR8KtFRFZ72mbBhjeG82zOWpr1Au80xDjdF3CD2Wfnse9CHyyhEsuy4/Fv8Yi6yZsjl8Iy6QfkVsdyLoGLIYgyXoIoH4nQeMSPrOXPNAqHzIntuLoY/FILiCMW3/HgnQJbF4VBFdgmwrqMgWxmEKUrrZACD3jC0vPDeWpJBh4jb3I6oQmXw++nXe9cWAKl1aFzWALkQtt9B/FLLZCl4L0R48bXMDx4A42aQovFxSRufpXCw22gcUtkp9f9aMd6VtZpTbxB1Gn08tQiG3//feP/fb9QyzhasrEWvIAQPmgxlvUnRoAbpDf7LyLWbQRf+FvdCRAMTw9OF511BRAPD/KDHLvDNGbBZqjLDRgJza4XSpvbAJua95HFQLOg1GbFmgh0guZeP/AG70rswuqNvR6bkcfxmX40o1BkpXBgDmTvskEujB6bzIqJEeStrt7wNQbwgE1f94EkeIatrPSKgFkwYcVscIdGqZWkrO7H4CU7IBT+myQheYPgtH8TWfIKLPUfDpnwGT35IrgnqV69IAju7/YDDT+7AVkLoew9xMvKUZ9qfcKM3OXsnFK+0iLbf9/4rftF7eQnkHp+CHiOaPsSFv3fGIJTstkzKoR7AwvBF+xDgGCo7AaVcYAn+B0rIM4zhtkp88Qj8DpwDOwrwXvzOSrrIcOXJ0L2bgIGgEfKTZ6IS2NN2lDIB5/UEpH5c4Ht8Ob2pRThLU5O0+HKrKYQLgTySR4hs1c7IaJag/VToBf4XShg9NBkKjyhyZQyevIZ31z/o6wUyYf7bhSJvJQOL17/B9/QluZcoFFmJaTC3OTZrOcF3mIeG/40nOZcgJXwybFhzLRNZAET6NF8B/QAjm2EfyyFioXIfKEMh6BefaSWm8w4H2jJRVpyqxmj+u8Ld49eoad7ozpvhph0kLcXgZ3wzgoyLKW0tGRj6S4GMEu6ndju72Ppa+fVvHi6dt0nzhjA60fjmFU0EV6DdakD2U5fJiyYzflBXmQebQf14P2VsaJrRMKV2KaQA+Wj6ohhcKUQto9wUhxKZsEJWxvIhMgFH2IvsMj8kgUdBuTABdjaN4ytncIgqiUS08GLO9ugFllrVBdmHQ310lbyy1VLWs8w81xt/G5IWx8fH4BfWCoKCwtvWT18fHz4+eef+de//qWbRgv16tWjUaNGd/wJ3NAnoIxIFa3Oo2XBNcPiqzucOm0lUEq2xZe3Le/wMc/BKAiekC0C2n5gkEwwhTTj28MdwQMsx+1Yw2AYf5dJbDX806sLI4vXQSlUbhbPka1DwiANviaIdybGiGv7YcQSshc+6hYuy06i4f0lsbL7d0G+k3fSuqalzGldM5uv+ryWMOW4/vudTP4z/cIIet9Eb0IxM4Aq+4LOMs53oOG+G+LJVAI+J0oIP7wFr7EVYqm7jgTpjwVegzVNh+JNEUwBSx5ERG2ET2Fq63i8y4thBJw7gYRZWAwXI+FqAESNXIV7OXgsuykx1BwrL5oiCndPoAR+GB3IuriBfOQfTnnrOlABlsOwZ0RIdXO7gvE4YHTezD1a/cnxv5ERRXnO1S+0ULt+4WxpmV56vWOARpAMnyweJuOyF7AYDhcFsrjvKxKHvBAeC8mDTfBSyjouFD8IFyG4Rzaf052Mvh1olA7Fu9wlpuZCIAua+UKDXvBS7DosCZCdY5P4a7lQtAsunoA124YSkb8RX0s2RTaweoHVDaz/Bc/yCXhCQTdPKpcANggdfRCPpJui5EQBE7i1bDFhw8vc64Eo5/WqPdo5yi+Jaj3vG6N6MlvHetfVz/199ov/XJ9QzrtaRiQzJIdDOSyGB2Dfu135pOcwiINNoX1kM4xEIAoqG8HS5sNhFPxf3T/x5WNBZK5ox0erw+EoBLfNJjnuOeq7w+Izr+BWl1sb5HVM+xzKYW+9MKLyV7Fm9VBacZYGEcA4ePfCZIoXuUMC9Fu5VwixCxCeuIW522fzz7rdoRP0u/wJ44atgTio3I4sWY9FyK7psuO4fR0cyQiAUHiDd6E1bDnaSwyE5YjyPgTeODMXukHBIE8sF+1wWeldq2fUNqpPpSzkTB7Vukfrub9fA99/dq7QImr1CHe4ZYCaCuP2r4HxcKJpG0JGHxFluC3MHj0Pvua299J1qIiXTY8uBTbk9IYmeOVXQA48NSwDqsBj5E3KPetAIQweuUOU4+Ywq+50LCF2aAo/5j+Iz4QSWX1xGDgBpdOtPHYiD5/kEjGI58GzoWvJoj0EQ/Ky5+jO5/jlF+CzpETa9ll4gFOQD5sYzOh1yRQHuRO/barMBzbozufyPivBZ1iJEMI3oM3yS2SvtdGv/V7GHV4DF+Cr5O6wGJpzActqOwWt/KDfPm6TEHqEqhFRbtS/1KSvVlqXbqHXL2onP4HU81HgHItGTyI6ezlPDEmj15DPKWu4jYTMl7E0hdy1LbGOhHuO2W9tSDc1OF7CIPSFQ4GBssT7KOyp+xTW3ohjRw5U9IXJu6bJ43bBFxN68kL5BlbsiiBvgA+MgozwDrISYha85LcOimBdt4Gcj/OieIw7r3aN5zseIXhotugPjn0wcpAxvQh2eYiBIWTwETzG3pS5KxTeq/s/7FwRCkGQW89GePAWOoccgylAOfSO+IRF+ydR8LoffA/zfWdgWWrH0tbO25bhrLM8TLqlBH56DyFqHftmOPNg1iJunUFLHjM6/v3OEQ78Z+cKZ5ySck5XQuuc+roS1xCnokKkDa2BsjmwMw6S34OMZAjeyFJLBw5a7Fhm/IzlSTsJlr/wtqUPllQ7w+I+4QXWs2D+NFrsLSa4d7bwTAOQME/piIftZLjhVpd7PrZjd4OQwiM0GVsGqdAq6CT+KadJGdCPpMOvMC80mnsalTBi1we8mhrPwzOz6D8zjf6+aZDwFeJh6zBOmIUWx6D8ddOoH2fQer4jDyWnqITR97kTvxvS1tfXFx8fH/bs2XPr3M8//0x6ejpPPPEEAB07dsRqtd6R5scff+TYsWO30tQMWp62ZoVc9ZJvI1LS/AfTxhXgXpLs4XTiKyiBxQteYeG2cdAfEmwvk93XRhBZbOokO75u+HN/cINxA9bIxFYEoX4H2eYVBqvBGgh+nQvot30vm+b0IbzHFqaOjCdlTr9blhUGwUtj1wmB+xqQC105gL6gokdoG0E94Dgj/pTHZjvb73cy+c/0C9C23qm9Rty4c0KpSX6Oc8r8HEK48hpy7pNv6dA7g+Ae2RSHusvpYqAcFrd6hYyZHfg7f4aekBnajk4c5kG+x54H9t6I0t8ICAb3YNgTE4Kb3ZOEMy/DeGiWCfXPVMfmDAb2Q0ZeB0iDE5lt5P7DkDm5HTSDpSuGEz5sCy/1WIdH4k0RCmfBgJItcHmjifpwvHdNxwa9vqCV7281/tx9+M/1CzXUy/HNKHFa3gpaaZrBCRg1/n3O+3txcRhcGtSQ/6MH3fmcec2jhcjNR/pCc7AsBnsW2I/CSw+vo4x7Wdp1OPeWVIj3YRkwFiqOIhuHJQJzod3yXIr7ulOUJjE/vTxhePoGyIVmC8A7E1gJjXzh6l6YGzkbBsNKRmF9Delb/ZHYVscQJeYM8A/4aF84rTjLlXLAEywX7Hxo8UUsjo53NYqd6fAgMapPM2O82vvETLrfD+6ePqElCxkRI3D7e9QHd4ggWbxUPWBw7A7oiCy1A7Z79mJcizXQCQZG7SY4P5vg5GxeGrlOvFiDISJ2IwA/4Y23N1ACKYv68dWF7jAZOqTncNzXj+G9N5DPA9hTIP8CsB28dldIVIIZUNreKv1kHdiDoV+PvVTuhg8Zzd61j0MnCaXQOeoYxV3dZcPWydBgA1g6QYexORQHuTOyeB3JQc8xsHA39k3QNu8g5ENuTEveHTYZEuH+NZehXwayfFFpvDQimFBdMyJ4K1Xp9Ppcpcbf75ec+s/3Cy3ZSX1NqUT2oc3sE0JwxkNjLksItCmInDEGiISCfZ5kBrVjlO/7uC+GTXP60ORCmYRJOAqHNgXCgups88Aj9Kb83w2G+a+Ci2I8O9mxFTPnTCTXtyWcRAxuNmAINLpYKcbqrtyKQ9iKswTxNeRBRI+N+Hc+LYRVT6j0RWKal+dAc2iz+xJ4wBXuxZ5tgf1QEOiJT2QJ+MLeRY+TvdYmIRPSgSJotzcXVsjmgOlJXSABRnV9ny73H4V/pMK5pchSWSX0ZEt1PavHJi1nD708lM+pqaJ/9+E/1y/05lfHiplNsHI9BCXzpeUGfPwecJHXLQthM9j8zsmKoxQLLIYTCW1k/wk3GNN0EZdpzJFWAWwJ7UWHdPHYc4QnyPJoR3u+ZmHmOBYnvSJLtGdBAN/iN7oAWkFIjyNsiRPjWl6eD4yF8NZbaBFdjNfmCj5YGcP4vR9CPmxtHgZBkPF1B9YMGMqW13qBBwyM3C1yUDkQC6XbrdAW/o8e5PMAdJKl5oQgfW0U7MwMZR0v4tMtDz4Gzh2AU4lw7j1gIbATkZm+53bMWqXMqSXfaHnCGnndmpFN9fD7nSMcuHv0bQf0YtEr71OeU8sKzrgVh9HLoXsXIxvMH0Xa2n5gPpTFyS/n4BR4RhdwgeayeikBkZE84P6mP2A5a+f4CD8sOXYsHeysrjuShi9e4jGvr7D0tGNpZcdyys65NTYaD/iR/y5Zg+W0ncmWP1F5399ZY6nPUksLci1H4e334JSj7TsMFM5Qk3Fb3WbNcH96pLmRs5SDL3GOu0r7KCsr4/vvv791nJ+fT1ZWFl5eXrRu3Zro6Gjmzp2LzWbDZrMxd+5cGjRowLBhwwDw9PTk5ZdfJiYmBm9vb7y8vJgwYQJt27blySef/I1Kqdc5tNKorR9aApmetbeGk3/jBkQs3ghZsGJ1BOMPf8ihToHgDq/HryQiZgVJPV/hu7SHwQ3ZdTId6VDrIH1ZF0I9DtIvYK8s2xsP9rFAMLIbZigQCtepJ0ucEiHd1oVHln2HT2EJKU378UXoEzLhcApja4feO+l5GBgNSFoElFmC0HHv3T2Z3J39Qu8bKb9JlcZ5LRgRtmaeLwLKz9SDIPBaUiFKRBKwH8Zv/pCdg0KZO3Y2hEBwq2wWho7jzfZLJQZaBbJj7AmJ2wbwVEoG6UO6MKZkFR8NCOf5Gx8zo+5M3l03mcpisMaLVXCTrQ+D2+6gx9EdrGA0j974FmwwqmQNjIDjvfx4LDhPylIFFW95IUq3mT5uxjqq1/a1/td75u9Twbg7+8VvAbWwrR6fHMaQUzB1KYendOLP/J19zftAfhkTPRIgvToURxyy0/YmON7Vj793+zNz02eL4S0Fnl6XDovTuXoMrlWBd3soGgH1x8JV4F9lXrQYXQzLwCu+gos3JOYnN8A+GCzB1cXrCZUdkZ28F8MLSYn0ZhdTt8eLYtIXyIGFi8bxxvSl7PfqQEjnI9AXXkpdJ97wqcgSxWVwWwBzjCM1HaMd9eeMKDeqZ8d19bW7d764+/qE2oPHSKEwGhMruRXP0F889KiLeK+ORYwLvYBcGOi3W4wV+4EsyPRtR/B0iXPOBeTaYLDuh9mp8yAQdg4JFe/uUpiZOZEZ+fN5bGUeFELIM0c4UhQgS/LKgUJI8ohg1NFkGnWqhNUwPyiK2PXvYx9vwRoDbTZf4r6+RTy7aS0pjYdBCSxnLKeGPMADQ04xKXoR9hKwDIBPGMRLseuImCPymyUejiZ1gTzZa+CNtXO5SgP4E4hspTenOlPWrGh7jjibi5Tzh9az7n7cff1C7R2lvqalZLsh1i84vcofS6Ad+3YLPkklbI0Lo1/wXukTX3FrtdH3/nVZmfo6KyZHEEQWLIZn4z7BkmOn14AtXGl+L1+49RTPwSlAOJSOtLJ25MtsTQqjO5/TJKSMGXPmyz4Zs+B0UBM28jxvRlbLT+OBdLBHwjavMBLSJvJ+fuytDfbK59TBI/Qm9u1gLYfYBW8zhmX4zSkg3bcLWQQxfvuH4u3uAT4HSqAYVmyLYPSwZJgIVMGKiRGM3p4sfR4I9siGXtAjcwfpfZ6GgvWIbGUk9+jVudE30Pt+jjHJcf/vq0/A3dgvQH9+dczVV7i9odD56nP3AkVY5tiZmDeTuKy3hUP6GvzzT0MaMB6Wt42W21ZDe78cqDZir/SKYPTgZILnZxO8LFvkkBLYkxfCX4klLaW/GCeygCIY2Hs3tIY0nsSvPFlklwHIfX1hU9c+dD/0Of3S98Iu2R/mKG2ZeX0GpZutzKk7hflrZmCPsEAW1L+/EjZA2qL+kA7Hff2oKqpLuym5cB0uRTTkWx4lgG8pKroPCiqROA3FmPcsVMpDNQn3ZLQ6zCjP32dIqbuzT2hBa47QG+f05m5nRKLec/XGx9OQuZAS9ydZ2vBNlq58k5ZzcmnFWb4uCaIi0guScwnkByQMQxHRTAAukUM+8C1MteJo0yUjHOOrgzB2kMhaxKgRtGRNo+tGcqjjV68OnHF8WtfBbF+x2O12u6mU/w+wb98+/vSnP/3i/PDhw0lMTMRutzNz5kyWL1/Ov/71L7p27cqSJUsIDAy8lbaiooK//OUvrF27lmvXrtGzZ08++OADg6DOv0RpaSmenp7AW0DD6rNGwqyZ81oCRG2gl/cU7LssosBsABbKMpGPeZ5JcxfJ+HkB6AWb+vZh8LAdcAYyMjoQknpEiNobcPUwNLABI6rTN4fz471oMUGWjJOCWP4mI+RtW+Ao9B7/CbstT3E74P9FJ++ATj0Y1Z1RGr3nmLnPArxNSUlJDZbq/L/D3dkv6lWf1VO8jb6xOp0Z4djonBXoBt+HYq9fBy6A3Q+e8drI9sjnRHlYBJwVi3fI4CPgDcUr3PFKr5AsdgOpYL8gh5bmsOao7LrsN7ZAjBbtgfFQeQCuFVmpX1bJt5422WQpGCwldnav7s5TLTJgMvR9bSOjWEl3PmcfPfgfFlNg+Sf6cQi13t2BmrR3vXZvpq6Vz7oBvOPqF05wu1/MQYIcK6EWaNWeD84UFKNjgEawcwT26xYhlJpXF2Ed4j2yG5F1RlXfvgyYBaMGvU9HDjMuZI30jRuws2soT+enQxIUzQLvwUi7b46QvOnIrvbjq4/3AhPh9JAmtFl3CSZAZTlY+8OWpF7cyxXC5n5JaaxVYrKtrL53KGIsTAFiYIt/LwYu3o3lATs0BnpkAAed1InZetTKQwln92l5p1QBsXdlv7j7+kQ8xpuROZsrlGPgvUAPrD814ufRnnAWir4G75UIebQM3tkQw9TIeFmSOgLRawNkzAawRiDLuNfBujMDCV+yhdIYaNQaSIJ3usYwpTie6/XggocPaTzJ6MJk8dDtBM+vSOJ13qe9u8RutkbAuoSBhEdv4eFFWZyMCpIQDcFgrYcYTdaB/TD8q8idPuzkwN4eEA6V16vLdD/ivZgJjISMsA6EpByBdChOcGcSf+XDkeMhMZXfbu4wa9zWu1+dRxUQc1f2Cbgb+4VjrjCrCzhI2ypgKCS3ZPefu3OFexk8ZYeM0euAidB3wEa2z5AwaVtbhdEvei94QOyct2lbHd81cubHJM54QVZLrITcpJbY9p+DEvEY/86rDf4DTlOZBG434F9e7nj1rABPOLIpgEfLc/jC43HChn4pRpBy2VPAI+cmbOdWSCpyYOmi4YxLWUPBEE98epcA8OqueD6YFcOe6SH0+svnnPxbK2zzz8m8cgGZs6qAeKhsBdYQxJM+Fvb6Pk5Y4ZewDNKnd6FHnwOwcz3iYWjkh+SsPZv5BmbGK+V5C3frXAF3R7+43SemIvq2GbkH7pz/rYgy+hDgC+cq4C13fki6H7/5BWydGEa/9nu5mgv/LAvl6QPpPNt1LX9jIrbEcxLWrKfcShbYq8AyBFKW9WPIgK0iW8Uj80om4Al7jobw1IUMuVYOPAMsgOPhflzhXoK3Z8NobhkjCEbClsTChG6zeffiG9x4qyHMgnWtBhK+ewt4yJ4EFg/AHbJP2qjHz/jnnqaV7STnLJXAEYSsVteDHvRIV+V5M/KUo55rsvxcC1W49G3n0Na3awO1/qc1ftWUY9FK78jT8b9jhZzjD26vilPu6eKAss2ZJZt/Sy7NbJ5m68YZd6H+vwIz+vZdRdreLfglaftrP6I6Leh/ODOEl1ae/fnR/l/4PCxCEV3h1aR4PkiPkU0FKmBeUDRFeDOBBfisLIF8SJ/Thf/yPiiTRCK3lAmrPzAdXu0bz5N8xhN8gc/mEhHIIpDNAMIQ4jYcXg+PI6H+RKiIw/wGbmYGD737atpZ9Z4Fd/skcrfA3CSiNXg7jtXXHcfqNm9mMFX3G3/o9xz2Ry1kx9loV5grl2KBTvDqa/EM4+907/4V4z5fyBu8y1Xq80h5Lu7PIAr+doSYSkM25YiAe3sW8qrHBxymIysYzQG68iRpPMUess4+zulWTWgz9xKMgPPNvWgRWXxrs43zNi9ajCyW+G/xYOn9E8JcaQk9v8aoU5MJtyaGprubtL1boE/amiVljYRqJ14RD7zJ+/mjWM8LfH6sF+TCukEDCR+6RXY5bo0sTV2HxDecCydOtuEobRnSYquQrB7V2deDS2ca0iS+jKJYyKnqQMixI5wP9KJF72J4DeYNiGYMy/DqUSGKyHTo2PVzvsrqLopLFBAAa9YOvUUIMB4YBqwFxkFpppVG3SpZkRlBTz7D70QBM/0n8nafOOkrP71nUBd69ah13YyXLc7r+Be4e0nbuwXOSVv1+O2AnnJhRdihJ/nUPpR+KXvFWDDgEhmpHQgZekSWwIbBmtChDM/aICHZPJDfamWc7cAsyPa30W5oLqWp0KgtMA3OD/Din3QnfMYWqICEuJeJmruKYZNX8d/8L2+ykKWMIzT1IBcHgltd8N4Op3s1oU2zSxy5GECHxBy2jgij34m9QgIEwuldTWjT9hLFR93x2l9Beac6eGTdlLkmA9FfchFDRrUHPH2B69Bx4uccGRQCn2gRts68R7RkSa35WV3nevcZzSnXuJtJ27sFt/vF24gRwtm8rT5XH/gf3C8Xc22ht5yywemIJrRZfgnCINb2NnEX3pb2flaucwYujWjIfcVlWM5Az6BPSWEIXhMqxKBXBPO6RTOKlSxnDFOj4+V8HvAwPOu/lunMpkNhjoS1qSZk14wayvD4DVAMBXM8uYfreO2ugHhYsSuC0YnJFI9wx+tCBVyHAl9PfFaW8OCoY/xwIFCmTDfoumkfBxb3kHkqHPFYTIK8NB/8eheIPFYBlMOlvg0ZyBa+3BUGT3+D7OxqhkhyJmNpjUlafaMmuLtJ27sBd5K2aqM3aM/TWr/1EU/0hwAvcHtUwn9UARO+heRHqfNkOTer6vJhi9G8yxssZRyf8CypDOCH4EBxepoFNJVwBE9vTod0CdMRlv4l/UM38OnuoTJ270dCPj2DyC1FCDE7ApGFtlc/ewnSnrdB5Y/V8lY9YBNU+oL1H8AuiN30NnET3pa8BwHFYAmwS5mqQFzdz2NeTtGqv98inTK9GaJXfd4CTHH1CSf49aStHkFYk/uU53CSh5YMoaXnm5nz3PjlmF6b8dcI/y/5JzP5mdO3fzcxbf9zMPNxzHivKdNWqo7N5KnOx6r6rWQXvSW21WogEn7mHs6HejHK/30WB73CpNxFLMiahk9hiSgUu6EuVeQX+VB8xl0siH0lt9OZTaAtfBAdQyvO0p4jZA5qx6EVgRLvOQ5ZTvUjsBfej46FZx3l0VMi1GU3a01xVjd6+evlrXx+Jb/HJRz/WTgsrlpQtm/HrzK9kYKpvk8rnePcL/NxTy4GoN3oXBGklsCI1R9gOWXng2MxhMQeIenz5/lgdAy2KedoNyuXqR6zRaG/jghLnSAh8GXhBzxhjcdw4ma8Tdqx/vilFxDecwtNYsvIav04JMFGnhdSbHv1Tsw2bi3DbZFeLBtEbYKgXl8CO9BXLtTvrle/DhjF+NQbO/TGEBd+G2h5cbrpXNfzGFWnUSolarSACIh6ZhWf7+0FA8A+CsL9tkA4zJw8Eaogb46PKBHrgKbgf+I0Q5oJYQviHUsATD4zjSYXytgS04tDVaGEJB6BydAiv1iMHzegL9t4ij3cv+8HLm1rCBfhq2HVhO0ZIBC6rt3Hg3zPpVDxImEwsA1YAhX7oFF6JTSH0VnJvMlCKJE4iOwshZ+Woj0e643RVTrXjeoNjfNm5gD193HBPLTGez0ohXtlumvAfvovToMD0GbuJfJSfQhJPgK5ULkYiIdOHOZ8kJd8qsHSJwDZFTwUSm1W2h3LpTypDpVVyNLw3dBiVjHhAVsojYN34mKIurCKgsmerF35Mk/Hp/Pt4o6MZzEFAzypXw+804AUaLP9EtSDto1zuBoF/QYLYXu1RDx82wy7BJvAa1YF9gHQoPlNifUWCuUpdcjd1xIS4MSgNhJ/OgkIgryJPmRdbA+ffMudnlWO+lTXoZZcqaxDrTp1nHcG9Zys/KvE1S9qA2d6g1LRdfwFwAMwynOlEEYdgeYwg5kixyQjS8NnwPm+XtiHIEu3vaDJ5jIscUAUpOX253P+C7xgqf9w2A6T0hfxHQ8zdW+8rNLIQmIRToQBfEo9rkMxpHfqIvE4s2D4CYlrXjkRfEJKOEsrkZ2CYXTPZFgJXj0qqPSASN8P8TlWwtZRYfywOVAW4xUDoRBLnDSh3kAunB/hBVHgd7iAQ7sCZWXfCVjYdxyPcZwvLcHwdCLwGTUjbLXOa30PMzqamWe6dItfjyq053m1rHQNGScPAp9B1UKIXgETlgKfQkQcN31SoOVZXglIIie7A6HxB3n37GR+GB3IG5lzKQ+vw0d54dAWepSnc2lQQwiDG9SFw/DphKHgC2vmDIUisM9FdOkcGDN+Ec93TZLVSQOQ+cYdKlPg0IJA5uVEY7UBS5ENJoPmstzzZSzYsXS0Mz9uBhabHcs7dixTdmOJ/wlGfQNVKxCF+zS1a09V3CbCjOQhZT2bzfe3SOPCr4fWHF7bMUwrrd7YqWdw14JabzdKq2w3ZghjPajLqC6vlgyllV5vntB6npnzWvVmToZykbamYUaw1fowZkhIdVp1w4E7GzuqtADFHKArx1P9ZHxvDc+ymRYri1n58OuMH/qhxPhJA5bB875JjDr0Pm7cwG9/AfWu/yyTTSewNoU2Uy5BPCQsepnOw47x44wH6VqcTSr9mbxgGsfz/MSjsBFCFLshq5M0y2x0XqvjqNPV16gPdM5p5V9bi5ML2lB7UqsHOfV3qVKlU39zJQGpR+Y6E6ivUJHoRVDcl2KlbgrHZ/qRmPgq9j9YpC3HvUxEW4kbSC4QApOZI8vxLiDW8jEQlbyKacsmwRTowf8xaub7ct2v+i8XWWbeF3qwTzy51oFPdAndp+8WAngzQljVA2Ihe1UwoqFovaOyzpSTmZqYVd5Xmx0y9epRb1JzoWZwRjaqPWuV59S/DgFb6zxI2+hAv9kpotAmIcQpiLLQCWZcmA9B4Ne6eqfb1kA9WOM/lFcvxvPp5T6cvOwnusAyGEAqbIeBnXfzdGy6ePz5Ie15GTAX/uidy5/Yx71coUl8GfaRMG9tNEQj4RIuwIETPQjJP0ISkcz3jZI8UoH9cNaj5a3yUQK92QVx8PIPf+dOjykzBKn6uvIeZ8pCTbxJlHm6lJCawVFfRkK/cozX835woANR4+cLWZULfrMKxKOpKVhbAZ3gscQ8WrQvZmbYRNglcZftPQFvqJwCjQZVkhLYj6n13sE7HTE2NIWU6f3ABo3CYQmvsqd5CD67Szg+yk8U8yzImvs4PiNLcHODlNB+WCbYOdQ3EBLB+ho0SEOW0AINmsPay0M5sbaajL0uS24tsUh/vQhf1HsCW/Q5Tg9qgn/b0zLPLAFWQgR/56bPDX5JTGkJ/Oq5tb7ivJ7SozUv6M0V6me7ZKhfDyNDhrI/OP53A4rhVCoJ4ROx/GDHkmvHMtDOGss47u/1A/mzgN2QuaIdXxPE9XrIvLAcCS/gh2OhAANjd0M9GLd4jRCtU6BT+RGYA8/GrGVTRB+RiYrhpR7reKxHHmyCL3iCpWOGsyWhF+TBR8vCsU4BBsFD138gvVMXSqdbZYXfIFi6bzjjPN8nafMrMB3ak4XlCzuWK3bqbyuCUDhAV8pH1WHmzIkkJzxHFXWZNmgSlut2HrnxHZWboOmY08Q0+YBLlu+QCekivxwn9AzUZggMtRxkVjnXknldxox/D/TmY6WsdA2JeVuJCOdKubsU+B5OVMIIaBtzkBGtPuDBFcd4d/NkPNJu8tKsdeAL7j2gyawyaA5P9ciAs5C7oCVLbcMZvm4DbII/F62SWLevwfIZ0XwcGcmRZQEyp6wEMuDC5SZ03nuMBlwVWc0PMuI6sKxkDK/7roSxB2BqKry1A8ZuhKeXIhs9rUQcPRzl16oDs3XmWJZuZuXRrzVOqx0V1Hm55o7fHkrZyWgcVEIrvdE9ZshctTyildbZ2KpH7NaEA1I+x4xcqfV89f9a+esR1+pnqJ+rVW/mdAsXaWsI5WBjZqBRfzA9olUJvQZu9Aytczks/fubfE17EZYuQL/We8UbdgXM3DBRvDuWQPL05/g4P5IRrCa4ZzYAdatuyjIMX6ArlM6ywgWIOrAKXgQayc7jsxfP4z5+4nseghio3ATYYMWCCBHw/i0DsoMk1OokSuh1atck8e+BlrVMqeyZqftKbiukZtLrff9SSITsJcHi+ZoL/6S7EKyRQAxEHV4lBNQIoCssDBuH1zMVsBL2zAwRPWAhEApPkgZDxDtq5ebX5RFnYMWK6na+GWgOU3kHYuB8mhfY4PMTvVhxPkJIqTjY1K2PLA8fdY7bmycYEd7KSUZNzGoZc9T51RZaebgUjprDDNFo5AGqhBEJfC/429h6fAh53Xw4sjqA3IstJczNWOAwFDT3FJ0lDekDu4B4GD5hA3+7/hcGF+7gKg2wjgYugjdFMAPwB++55yAQihe5y/1ecDUHLKGwIGAa33kHUTlbSjIpfpGEYugKC9PGQQzM843mzb1Lee36B2K48IQxJxfRmMuym3MOsBfG7V/Dnk0h8FAVsvy7JgTpr/X0cDzD1c7/fVDXrRaZYuSF4EgD4AWBLWWTowOI0bgv8CbiEVgFbIZpIybBEDFaV9gAX/i6KEBkG2Bv6uMMyd1KX7azsNs40Y2z4HseoiDVE1rDmZIHeepwBiTBY7F5sBmOrA4Q40MvaDAehozcyieP9KZz1DE4A5lz2sFqWOEfIc+aI0Y//2GnIQC2zOklsT5tcHUzVP43PDUhAwKgTfAleR9v2DozjEeTvuJLS3dgvUY9qhURZR05oNz1WU+RMqMQ6RlR1eVwGTNqBi1ZR0/Zc3yHKm65p/4jFV7cARPWQ9l7wDkG8QktPaFyLgTnZ9Ov7V7cQ+DSioYSOmQAsBrOZ3pxaFMg5+O8pN94IzrDCHBPhsy0dnxyYBiD9+8QOcYLJu+bxhv75kIwTOq9iJ+px8DU3RCAbHDmATwDHuNv8i7RfFf3EQiEyTHTSGQk/8ef2DkoFJpCN/bz8t8SsD9goeKvXuAuqwI9Ot1kRtZ8Ip7ZSJu5l6jHz3AOXqu7hHta2rlkuVS9EuOIoo70+kBtyFyt63rfQk8WU8PVL347KL1Bazr3OzxxryBKwXrI2sMxSz3WWJ4kz/Iolol2LM/Ysfxox3LWjmWZHcvL17CU23l231os/e083Ocsr65PpLIvMAvW5r5MQaAnlY8iK/X84EXWEZT6JelnumDZaOeB+wux5NuJfnw5lo/sWNr+RHfLYioab0R2vt+HCERHkLiDjg2XlAZ79bvohSLQqzMjqL1s9eQiNQGrRcjWV92rJtZdqDmc1ZtyfFJujOgMakOt+ryeru1sDHRG7takbOpzzsZvM9f0yGCj8VxNijvOaRm31e9qVf0py+Hsub+Ei7Q1hLPBTk+oVadx1rCMPryzD6poDKcgInoj9jj4KCxc+rpNUs14Zv6tvh/ReiP0hJBZsqyQetDa4zR7jz4uSvtuaDS5UsIlrERCIKTDOzNjoBzezFrKgOLdkAvWhbBiQASvvJGEZGZURlV5Dd9Jqy706kqZzkhA0/sWrsmkdlATtFqDmjqdGnpCt1E70cqrCrJywQ02xfSBujAuaw3pc7qQ0qofKYH9oDlUfA0VI+SOr2kv3uWr4SLNYCzM3DcRMiE0+aAQAiOROJ0e8jt6STJLzwwnecVzkArbW8iGHy3mFrP1tTBIh9EXkoWo2izLqiyf2RHBTG8icjbwK+vJLEHrzLBhpPA74FI4ag695XtG6cxcd1P91Yef4JXHFuMXUECHh3O4h+vSXt2gYJAnV6kvZOpmsDxuJ/uMjdNBTVi3YCAefW+S0PRlOnc+hj0NiALb7nMQCieS2tCq7lky4jpwmcaUjrWCJzTIhBOb2kAUWMaCNQK+L2oJxVCxCFgO3fkc4mBS8iIIhMv1GkMvwB2Wd46mSbMy/GNPk5vUUuaTptBr5OfIRGOkLKihrAtn9aqVTsvb2cw1F2oGx9JM0DbwOaDehV0t3LoBzcTgtg5Kl0FpJ7m6p1OIjLfboTIfZreed2vJuHtbwB067M2RMRwIy/qSys7wVFYGbw5bKvcuhvENF9GoYQlX46GyBVztIeQq14Fe0GF+jhRjOZAF5cvqMDB6N1cTgTQIbp9N6RIrV2kg8Q1ToXnjSzACclu1pC3fcHU+cBjeKZvGtQokZmgSHMoMBC/osWAH/eekkWNxRzYZqEJ/pZGe0qWGWkHRy8uZTKY1x7uM4rWDlnyvNnYr69vRL6oQUucUQvScQgieHSzt8yZWG1gPIQTtAGA6NDlQJl62rWFd5kDe5Q06P3OMFsOKwVfi4bIMSITKFyE4NZviru4Ud3OXvhEC08tnM41Z2IOAyTA+5cNbm4V1SMyBcmjqf5rIZR/yBF+IV2EONOMiB6b04IfegSxjDJZJP3P8+mOszH0djsGP8xpDJry7fPItoyIekD65C9NWLYAXc0m2dIWyRIQVU29g48x4oSWLqq8p71Wm05O51HmZkd9c+PfCITeY0eWuIGEUjiKerJ8Cy+D7FcBSWLYUli2ETjugZSb02McWy/3w5EbYuRRePMA9je1Y/O1Ywuzc/9RlZlyexr3bCrF8ayf3/nZktw2mh+UA7DwABckwKhEyV8DW9xBZJx2xqOutmFOvtFKe00urhoNANZNW65z6Xq1jR70rvZyVx0rvXUfampFULtREBnUYax2oqROUcp7Xk8XU46QW9HR+PTnCKA/1PGgEs8Y5LWJVqw9ozS1mDH1az1LzJWbltzvhIm1NoSaDjJH11+wzanp/JVAKU89RvMidOn+z8+b1hbIED2RpXi+k7wcrbnME/PeEwgttCDv7JZRVX7uOLAnsCsyBF1ITmRofz57JITAADni1k3SbYHRUssSF43t+uRTe0Rm0Oo0z7w8z7611Tk+Y0rKWuLxEao5q0uiO5fuV3J6Q9QZr5a/yPi2CVkt41lJmlGnPw0PwGU/CYqAYQqccZEj0VobEbiWvuQ/uaVDvOnACknq8wp6JIbIRBgegqNq4EQPkwLO2tbABKk7CiW5tRMbKkfhup3iA06OaiJdXIhyf7Ee/A3tlY40LUDkaOAOzmA7vfCVlc2qscKY4q+sSjENLGN1vpo+5jBm/PcySkurrjm/rIMGa0fJSLstHRkM8lJ6BNhMuQVMgAHyOleDXogAOQ/LE5/jguRG0u5BLm92XaE8WJFa3+UZgacstb0Mmgn/UaYrwJmTWEfyyCqjvXUnlciAO/PefBl84PscProNtinjkuqcCvtB59zHZ8CwGSIcWZ4t5JyaGnhGfisd5a6AYbHPPMadkMh/ZwmEr3Nkeazoe18fYo0TvvDPPFLVXidF9LmjDTF05yCgHtMax+kCA7FMzABqNgkbpwAR4am6GyDK5YJ2DeLPWg5EkQiBUzAT7EKicDW51gSlg7QiVPYAKWNE8AuZAg7UQWxZHg5PQoBU0GAsNYqqL5o0YQCYDE+U+j9SbfLQonNIyT/FUBP5c9++MP/Yh6TldoDdYXwNSwRZyDr+Ugltv04yLfFcRyM5NodAXGnMZCiHd0hOm7kN2uXGsMFKuRFFCq57MOBKYVRa0lDMXGfXbwsgTx3FdSwlXK+dWyIIxhxZR3roODIbzc7xYN2ggpED2IBu0lnA0C05MgxWAPywMHUebJZfgNeA1sM4FiuEyjfEKrpCQN57gngafMAhLGqJPeCPe5NuRFXyjIP+6L0m7X2Hi4gQei8+DXHiB9Zyf4wWe8EnPYdgP3oNH/k2m2SaxZ0wIm3lWdBAvsHxuF4PgM3Z63H8ARq1HCDXHEnGzZIRaNlTLkGoCwKweopQ/jZ6pl6cLvx305hUjD1S1MdbhzVqJtC9HKIXS6nPfIEs6DiDj8ffV1/YBcTA1Ec4lwmcbmWfpRFnDbfBxIhSsgGPvIcv29iGy/8Xq/K/wSyJWzxNVLSvqedgqvY+V72oUQk0rXyMyV+k5q3W/s/TK/F1zSO1hxmha03FHizPRG2vNfDszRKyW8UxPvtEjgPXyV/7qlUdrnq3SOe9Ir/de6mdphTU0Io1r9r1cpO2vgp6F1Yi0MsqrtmUAGaDX4G05BX+FksM+kAV5GT5CwC5GFOkXEQXHDRJsL8smMb2BE9C31UZReDrB64viqL+oSLxTBsD6lSMgQJacnz/jRVfvbFgGmUfbURFH9cbGpzTKpe4MSiFKbXlQQq+T6AlYWum0jrXIQBdqBofAoxYKtAh7h5eQ1mCthJZVT3lNbZnSyqeUwJ6H+OBEDDt7hVLerQ65c1pCLyifVQe/swWUPmPFMhfxIFkAT63MYNrkSdgOnBNCIBRoC3SCzcXDKI220s3jc/zjT4uiMxhapBQzdX88E/kbJ2LawGF4rHeeEGYrwd67mjyYAg/yPXeGRdBq7zWxJCrvAfkGNbnXjKLuQu3gTOhWntc6NiId1cRWfc71scEceKBvDo0CgPurvcjHIAa3jkA5RJzYyLgJa6AzUASneIAKL+jc8xjpaV3YtK8Pz3dNYs/EEDoGfQ4BcHb0w0yePk0IWKQ9b0rqI6EXdsNjbfNgCJAJlX0hO9wmYUMikVjOu4DNUNrcSivOkpbVH7pB9iEbFMH9k3+g4i0vXraMh58SuZOEMOM9q1RUatJmnYVfUC9DNErrgnM4vo+ecuEYu8wsAWxEm9dOQE9IT+hCXlcfWAQFkz1J79VF4sEWAglAJxgYvxuK4QcPPyzuYK0HF4q8RA7qVE3g9q4mTGOAcfB+Siwkg70QuAjnZ3oJWTsKMWwEyb0cgzFDFtGVA1ykKYTJq346diikQVu+gVSYNmeSyF9FsHDIOBrsA3LhKg1Ywqs8nZoOh+Gh4nNYutsRgioHbY8ZPUFfy4CpN48afQMjmUiLsFL+7zJk1BxqmVhP4TSSU63AQ+AzgtAfd/IG7+Ix6yavzoxnCa8RPnYLdIN2K3PhazhIV2nHuXBoeiBv7l/K8df8iA1/m7bhB6mYDgTCakaKHDQEiUFeCA/yg4zxZyAzrB0UworxEbLBZSo0KL8pRG45omMMAJ+RJXzM81JUN+g45HMW+7/CO2vmMpV3eJI0Jg+axoQhs+HFfViCy2HEUihYiOgTRsYC9TVHXZlJq3VNTZzr1b0ZMrcmRIML5qD0pjWaj82ECTBaTaMVKkDr/4vVf98jY7bjuBiR+a9p3Kd8vrJMyjTq81rvpFp1pUmS6r2r+llqmFlp5Ey2NZLZXKg51HO049fx/ZUwM3/o6YxmjU1aRGtNdVgjclivbGbLpZePlsFOqzxGxlNn9anef0BrbjA6NoaLtDUFR6WqG7QZsrC2zzMDdcepRCSyhWLgC4Jm1wtZM2YoJ/La8ETXNNn1NQVIg6iVqyQEwizIDrPxAuslwsF0eL99LDs9+8B1qJwDuaNasrNvKM/zMS1CirFEAjYITszmRY+1sleGqQavPKdFVpmx6jjr3Hpp1N/PJVT99lArH2rl08z9yv+NBlkU5+RZx7p3pqn/aepyg9X1RmIbcA6Lp50Z9WbCdmjkWwkX4aOEcNI7dWHnqFBmj50nxolMhLSNAVLAMhj+q+4/+WpGd1kSuw7Ku9WRkCOLYX30CPxDTouhIwjyfH1gN1jcEcXeA9LKn0Q6lYNcdaaAqa9rxShyNtkp89M6Nvs9XAJWzaAnqP4WhIYy70rgFOyEhOYvs5Onbxnb3KcANxBluxSZDjZBxoIOYqjoBE9npeO+HciH0JEHGTx4Bx+3iORJ7wy+Wt6d46/5QSrMnTEb2sPRywHkvtaSyzSWvlGvuhgVwFiwLpHDS3kNZWXGSngnKAb84b26/8PwyA0kBL0Mm6Bd71yIhUc4CcsuIl4spej3DTN1Z6QUqetPz4vWyPvZDInsgjGcjTnqOtVIHwyn8gNgIoTGH8QvqgDcwOdwCaGzDsIyyJ3ZUowGsYisUwT3cwG2wKiL79P4+mUA1sUNxDIdCIMhh7dS2RmZA6rg9MQmbC7qAzHQIrVYSCgbMqa3h8qHgW2wfHk0j43O44/eubK8vBxpzj1hIn+DevAjzeW+SHhzwFK4DkWbYFLUIhKXvwq58MCmHOo8Ywf/PdxJVIG5MdyMPKSXnxrOZC614dRx7OoTtYOeZ4/jfzOybRX8BOmPP03AkFOcn+PFB/kxfE53Wi07yaZBfUQEuQFPb04X44YbdL5wDIubnbf4K425zNG5XXCPAqLgv0m6vSleMbAdnig5KP1gPwSfzYZ4GD06mUuZDeFT+LvXcxTYPEW/eAYJyeAJ41d+KMa/XnBkSwjRB5bDCDjYPZSH/36Wea1mEW/piMT0fJ/bno7qOnImPznqS88grld/ynu12rkSepvDqslix3NdxozaQ+216SAzna2oMSJh1WmV+aufbeY56ry1jpV5GhmN1cSrGvVV6Rxpzc6teh7HRl6xenAzkU7vmstZ6tdBOTap25EZ7sWZAV0rH60yqAlJ5f96couRUdhZWiM9V89gp+bt1OSrnqylxzc4Mwqq8/o1HJY2XKStU6gbg7PKNSIutYjfXwO9BucGLYHp4NH7JsPbbsA/6jQ7bzwtFvAhkNfKhzdGzWXUrvc5HdGEdutyZVl5a0TpmQxnaQUpMNXzbT6jJ09HpdPuQi4MguOL/NgTGAJV0JajkGnn9uBhpHSozzvrNFrvrEfcmXmWlpXDhV8HZwOm3j2OX2ffQM8qpfyu1d6/mfAE+7lAc6ImrIIssMdZiCUO+xAgCHYmhXKde7hMY7pf/1yyKIe9Ix6Hi5Ae1kXIpw0IIdYRWAuEg8fRm+AO8zdEkbuopZC8s4BuUMR9EiZkE5AAka0+pKzhfdze/VXZ/oyMCMpzRkuczCgwyrRa9ewSoH5b6AmqeopBTZQ6pXBdCBxgLcPwP3xawnLMAHzBbkM8XhfBkV0BYJOlrWyA121x4AHDhqwSr8FQhGxaCpYAsDx5k3/RGAB7AhAGP/AgtmHneGnJOugGuXEtWXp0OMyFpUOGQzo04BpN4stgMUxeNI2pi+PhU5g6NB72Q1TWKkqnyPO8O50j/fWnkV2d1EvzzCzHM6pTB9T5atWhOq1ennqKlwu1h2M8MprPlSiG78GSZ+fBmGPExrwt4TbOwKZOfWS1UBLcyxXhfAqRkFDl4LW4gooAeJ338K93AlZC+OEtWPrdJNfWEuaD1QtZSZEMbTpf4jCdhPT1pnqDVSAU1lwcirUXVD4JBMHkFdOw9ARiwV6CEF2JMJMZ2LdX39cV2cyvIbASvDOBVNgyphcdYz7ntMUfMhORGIvK99dSXvTIWi3lRKse1fOnHjGoBXV5XHPHr4NagUTxv57Sqz5XCZyHqqWQWQT3QTCZ3Nu0kAc4RSxxDE7fIcaEKmRDMg/I6NaBympD9VbbED6lP6Mmv0/xaneYC/voIW05TdKzGJZ7viwGwdfgjVZzpW9Ux46mP0Skb6RxeYkUrR7sDA0VD/QBcCKwDU1jTkMyELwDOAAZByBiI5x7D/FUNKondX1p1YUWeaB3jzPZSfnrSO9wQlCf0/uODrnUBXPQM47Wtg6dzdXK626qY7PEpePXjBepMzkD7vSaVZZLfZ+eB7BROY28cNV1YURy6+Wldc3IGO6CeRjxIWaddozyqtT4M1smLZlErd86K6NRHmbKoTUGa43P6mfqcQtGz1LmY5Zg1tL3awcXaWsaRqy8M2uuWoCoqZBs5royz2swYh/z0qJ5fl+SKPRR0MhWKd6AAeC3roDDdGJlyuu02X8JlkPS9ldknL0AbIbG/IuHt2XxM/fwanoiexMeh2jADx4blsdTgzPgArxzfC6wAW2vSrODTW0bs5Iw1Ot0tbdquKAFN37Z9owmAi0rWk0GZuVEryQ81YN0KVSdY4vlYUY0WU/mgnZ0PbMPSqFJ+zIshUAzMUaMS17DwPzdbK43SBT+uhB27EtoDaFZB+Es2N3gJT5iz4AQJnSaTUFfT/CGYn93HuVbivCmciLMPDmRggGeNOcCS0cMl81yrkPy+Uhu9wt1vWjVk/LYqE70SHJ1Gq3/1dBT7l2oHdSCqlKg1yME1d47Wh4RjrSKNCFdieR/yezUTlZL7LPRdPxpLNsBL6AQHrn+HWyuNqzlwg3cOG7zY23nl2EUvD4iDhLg0oCGMArsf69DSPARWAYWD6A1DGm2VYiruZBts/HHkmxGlq+B6TBu5BpIgtGsgH8AQ2Fu/GyeGJ+GPQ/Ob/AiO89G76BPJAbpCCgOagEJ33A7bIj6HfWUGzMer2rlS6teMUjj+E5G38uliJuHnpKmJcRqGVcV49xPGTAV8pY/xvz1Myj1s4I7DB69A+Jgk60PPptLbsdUDgF2y63uB6BdQC6LGS9eh8+A/V91+F8iJe0uYDQwHpIPPcfMktnQCtkvpifS/uNgeO4GyAerLzAA5raeTeVu4BhYbFB5Ha4ugz80LMYyGJ7gCwmbEwM0knuKO7mz5sxQno3cxRFLI2ApwjQr68qMAqVH6qoJXD3iVk+RMCII4ZdymxWXMl5T6BlsHf8bkfNqOK7vh2XnOGepT9lDTUjKfYWo/auo6ASEQuU2wAtKl1mZwUw8qkog+gB8D1+uD2PVG1EAXApryOiVyTKHzEFWfPeEqB6rhMCdDe8ensyYbYsgBz6IjuGN6XNht4QiIRUWZo7j6bHp4AcZTTswhBQuWVrDx3HcjhW6H1la7tAbzMoiWm1bq58YOQw4q1M9fa4mzgYu1Ax6nqdmoWXwNZqr1bKGmbldKV/UxDNV69la59RtSlmma5iXP8yEOFBeU9eDGecDPTnVCGY8g10wD7X8pDdv/JbPMTqnPG+G6/p3tYX6JvOuyfON5hxnc5dDRtKSz2oGF2lrCMdgpEUwulGzDqJF8taU1de7rrYsVwFHWM8LfJwciT0E2WAsE/w2FzBvRDR4IwoMkNfNRwQ0d6AQ5n8dRfFad5Yzlkf5lncjJ/NcaDJjWSqbcGxHNuQAsqfbhMj9xUYByjKb7fDOSCgtsspIwHXh3wNnE68zq1N9VTo9TwhHP1OSnnqDZCVCAklMQPfviwnumc2BYT1E0YiHmf4TscdBZHmybJ5xHSLWbSRzUDuYj3gn5gJzgV3wf16Psz33Oe7hZxbMmIbPuhIYC/eWVLCdZwiOz8YaDd/yKD4zSmhxuJhXdyXyak68bOzxpDt3xnnWqh+t91DXgfoerfv08tdSLqz82onDBWdQC/bwS2FYKYxrndcTtt2AZuAmm+IdoCuWP9tJZCSpDOB8hBfEQmVX8Dh8EybC8JQNbAnvxQf5MTw2LE+8FFPg/R6xcBianCgTr9sUZKOZM0Aq7PV9XB65CVgB7cbmcu2EN+5zgSnIXDAW9s3oQ2mmlcxD7cANvhjbE4s73MPPtNudy66oZ7E0tGM5ZIdj3yIKuxJmlyI63l/5q6wXdd0p27eaPHf2THXeLvy2cEZMKclbN+AiZF6ExrDjhR78se43JIc9x/EVfuzcFMrgyB0ydjcCVsLMVhMl5E08EnczEh7lWwoOecJYONQpkNnx8yAD2QypufxGDNuINbj6vjQ4MiJA4nsGISRwHMz7Ohr6wtIzw7Ha5BwjwboIGjSHaxVg3wQvBayDoZDetwsfLQsnctCHDOd/GeG7HpLXI/1AayxXjvtG47QeeWRE+qoJWLOkcE1lNhf+PVD2D0fbuIZsePQZcBTKwFJoZ0u3XszymMaWmb245xM7lhl2PIN+Zq/lESrvW48wst/Ai1/BJ3CSR2gyoQzcYHHaK5zo24Z5OdHwGty7rRCKgFBY0SmC5SujZRPMeCvvzheF4DsewXLBzuslS8lc1o5pgZPobvmKY5YzSCdBUV4jhw5n7+3M6G/UrpX9TY/ANbrXSOZSOxS4UHPUxNtVCSNPUjP3qg25eueMvEvVqMnKK6O8nOVjxqCtl1dN3kcpg5nxhNa65tI5fh309Ecjo5WegVwrvbN53pmR12js05NVtMpiZhzVK2uVzjW95znLU3mfXnmV17TqpEojnRLmxioXaWsI5YCj7ig13QBIDaVCgsav3jk0rmvl7UZ2+2AsvnYsm4BSsIyxs2VQL/6b/yW7l40OuTmwBPz2F8AsqOwINIWJsxLIoj1/4y9MYAFrkoayrnEkqQwEd0he8RyvBsbDMgjaeBI+u4j2Mm4jwUo9CJi1ipghC814jrjw28IMeQi3By/leSOhW9nPjNI5rkkogopFXuANCWtf5vg2P1gGMwrnYymCjz2ek2V/fYHFEDwrG2bB8a/9oJ54B5442oZTPAAXIDTyoCjsyYAbvO85jg+CY+As0A3Wp4yg8k14ttNaZveewAfxMYwI/QBO7MFcvzB6L6OJQnlemY+Rkq51v57i4iKqag89wVvPm6Qmy/EArsE+aBlZRPT65fR7LoV3CyfTtTiblYyCtmCdAie6tZFl3vtlx/pM33ZsXRsmkQnSEK/EnvCRfzjZvjZKs6q//WHoGfQpXa8fADdID+wi3oY2xMD3Giz++hUJp9Mb8mb60CiwkuCobOkX7kAvaJp+BRaD5X67hA55NhVxX1T3C7NeG3rKgt4yPL3wIs7qW4twd6Hm0CLPUZ1Tj3HqscoxZ5wHjkAG9Dmwj7MXW3EfP3E/F3jixhcy9L+GbK4aA2NYLiESRol34fHJfvgfOI1P2xKOzAyg87FjzI+JglzY2jRM4tLWQ2I1J8GK1AjwhA7BOUL+noDs12yQA5O2L4ISGJe/hkOHAoXwDUQMH63AOx0sy4AU2JLRi7Z8w8v915LcfTRbLY/DqaXcNnSbMd7rjfNadeZMeTMixdSErrocyvyU1139o2bQI9ON4Pg2Wt/aISuVAlehLBdC4FnLLuZZ3uJZyy4YcQCWrYdjS4FPuU30HgE6YD1cSlMuUhpnxfIHO9H3L2c1I5nc5F0sPnbKtjah1fiT9Fiwg9H5ydATypvWoVFRJZsm9sHiZee5kdthKtyz0s7jlkO8Y/kTsBDxqFWX2cgwYUaG/y3kenX/M6PQa307PfLEJUPVHHrzbm3JWCWckaVaK3yMzpmF1uorvZU8evcpz9WG2DYyVhs9R/3n7D4X/j1Qzs9miFL1POFs3jf6lo40eh6szsbrmnAyzsqihLou1PKReo5x9nxnHJPWcxz3KfN1ZkjXS+McFrvdbq/Vnf8fRmlpKZ6ensBb3N51RQllxzFb8bW1vtb0GUo8DREdwQ12rO7Bv2hM+LotEu8tH7IX2fhjcS6WYCAJqIvIV2OAZMhb4YPf3AIYAMcD/XgsMk92UW4Gdf9Qxs2HPMSDl1Ru73isLIcWMftriG6t96xpPlr1eQN4h5KSEho1avQryvX/bfyyX2iRfc5I9UqNX7MwS0o2Appi/zoSS7YdHgB7a4vEc74Ol75uyHc8TMiwI7AI8ajyQIimVkhzSIOlq4czrsUaybIV4l2eBR9ND+fFhutosAgsi+1EHZ3P+7NioTdkdO3AS3xEbpN28NNCbvcJvb5QG+OFkVW1NvnppXf1CzO43S/mII1ICWdenWpoEbta8EICFALPdsUebYETYOl3jfAWa/m798tYpsOl8Q35gQcJDsiWYToVOIF42lYAE+D8Pi+ucC/1uUqbxEuyiZMnMARS5vRjyPyt8rjtSPzb60A9aLvrIEendKHrnH0cCO4BnvDErjS+ONZTPB7rVRexOdIPF+xB5gkj4romdWO2rmoCZZ5K5UrtoRvj6hcGuN0n4rjdJ8yO+3rjm+Pck/D0oxL+4BzYyyyQhXyeepCZ2Y7gw9myeWRfZEf7C8BIuftiITRLg9yecMUeQIcBObAYypvXoUH5Ta561KHh1hvYu1ikj6yszrsI6A3Jg54jInejxDKPQvpSCWTkdCBk/hHZeCwQyj3rMKPeTOL7TJX7tzo23jvPnd71NZWN1EqJHmFkJg8zzzMDV58wgzvniro6qWqrKzjurc8vNzCt4pcrlpTG2SdhwaPgg8hEh79FgtY2A87dzvu+ZvAQsmeG49ZzQEYlssrpPJLAEVhaS/7RKnNt5Z7awKjPOFPE1X3U2bEFiHX1CwPc7hNvo08e1naeNyNb6OWvJW848GvlDjXpqvw1KkdN5Em9fM2+r1G+yjLUtHxVwNuuPuEEzvVtM9C7x0xezuS12uZRk/v00v8W+i7IPKm1cri2HIVe+dTvo7zmgDl922UmMYQb2hWs9zGNGmhNGumvgVKwOALJ9YEAeiSk474S8ITnxyfxkXsk7SJyKe7kjlfzClZ0jWB0ZLLsOj4BKAK/gAJZDvgaPDYrT7ysIoFZcPOpulC2A7gKnNZ4B73OpHe+JmRuTTvYb1W3LtwJI0VTq87VbaCm38TMwA2iKJzG8oMddkL4uo+YTxQT3RMAaBJZRpOgIzAGipu684fYCiwBQBycD/diF715yWMd42as4dL5hjTpXSbZLgHGwkt+siETJ+CHo/dzhXuFECiHkO1HyH3mj8B73Kmw6PUBrfcwUqj1iF5nlla9+4zK5Zoeag+HIKtcYmdGUDarDJQiBOhDuCcWS3iPpmD/U30hmmxQGmWlyYEyirpeFuIpFvGsDYWCQE98TpTAWvgJb+6jiBaFxXAGsi/aaDc3F4Lg2ZKtQnz1rC7qUiARGAVHs7oAcGBdDzF69IL+fEqFL9TbBZY4wBsa9/0RxoH2ZjNmvV21PDyMFBIt8tUZnC0bdHkT1h5mZAC99ErUB65AFth2ZJO7pR0cgcoEuOxZbYwLOUJRJngvQdplMZBa3a5Tc6kcCPk9wWaDysY5YpDbBB7bb7I1LYx+J/Zif98C/jBvWTRj4pbhlVUhzdcTHiAfoqFyP1jbAssgN6glIblHyJzYjuB12cwMm8iC8gmUvdMEdn6LEFi5aLdndb04U3SM5g+zso7WXGNGEdJL40LNYTSXa8nGauh972sYr/DRwmmYUIx0FmWoM+VKJzf4qT78pCyP4znKzVaPGDxHC850AGfGbWdGcKP+oScDWVW/6nv0yq6+7pozzENLVtKTAWpDwupd03uW+n8tglVL/nC0p5qUQV0O5XFN5UM9OUb5HlpQnq+P8SolveNfQwa7YAwjmUBv7NSbI2qjryuhbB96xKdeHjXleIzyVb63Ub56c4NjflPXnxmOwmheMqrvX8dFucIjOIVWY1BO6Mr/nQnVWrA6ua5MV99kesfzi5EdiXPwcfuRE+PbgA0+3hxJo1Bo2+kg3qdLYRCM7pksGzKtRjxTghElfxbQFgqCPCWuG3BpREP4xB0xsX/P7QDp6udrHauFGzOdTi1AaV1T56dO66g3Z4KwC+ahN9Cp/9e7z2z+WvcY5VEJuMFfgXOyGczE/QmyIcw6ZAnrYjge6kcUS7BkIstb60GLvcV8xpPiaXgRwtjLPWtLeGPXXJJ3PSfetgFACWxZ0IuTPEIDx+S1CDb17YNsPqbeZEmrbSrrTV13ZohYrWOjOnFAT8FQ17dL0Pr10PI8UC41q8nyPTVE4Ki4z4vFc16R5d2tIP1MF0iEe5tWwgDwH3paVkgEIF7lN+BT+lNqs8INaNcilxYBxbzQNBFLvp12e3PFqzYVrLEI19SUW45huZtaChkWgxjykpE4uMDc8sm4PwyWIWAJsPP6oDhK3H2gLBlthaFK57y6ztRplAqNljLnrF7NLE3Ug6tf1AxmPSWUaR3jpXpMsgLXwB9OFgZhv2qh1cyT3LPSThKRhCw+AuPBewDQEVlBVAFEwzUaYK/2tm0AsBasNig/XIfFMa9gz4J++/dS7O8OVZC87DkmpS/iMo2hBN4Jj4GxYphjBVj/F/Hw9QRbwDkW2sbxLm/QPXw3c4qmUNawCbyTChzk9kokZ8qFuk7MynpmlAytPNX1bKZsyrnMcc7VJ2oOs4qd3v/qfqX0rlW2M61vpkQV0j6PIPJ8MSK/XOE2AXyt+rgQ8aa9qPh1kLxabUdLV9I6Vr6f+rxeGzciY7VkHD35X3nOjGymTOvSI357mA2PoLdkvyYkpxkiuIrbfUstX2jJM2p9WCs/Z8dKotWZTKhOo5ap9Lxf1RvgKqFH2Oo9X68sLvz7YFbfNsOrGI3dWlCuqnYQtnrp9cb92vAAWsc1IYH1OAW9OdIZz6A+dsb1Gf1vrt+4SNsaQ03OagkSzjqDEs4EdKW3r7NdVtWd2BGzaj8lPj5sZhC4wcxBE7m0q6HsKH7CKiRWOdAV0lO7sGbDUOwJiGdhFpTOsuKTVUJ53zpMODObq9QXguDW5KQWEmva0I3uMUOGaw1eWs/57awdLkDNBHVniqHWYG70vbTanKoNHc6FLJhxY6Yo780RcskdSIIr3EtvdnF/3x8gAQm1uQsac1k2p7kg2fzV+y3ePTuZiKyNUA7F29xZlzmQIUUpNKUQ2/5zDGu1Ckt/O89N2o70Oa1yGynWZg07ziY8PcOGekzSmiBcfeLXwR1tLwktT1A9D1JU540Uk0ogB56F8akfQgCkp3XhXq5w2r8JlqZAV4SwjUQ2F4sFS4ad0bOSadSrEvIQ4nUz9GYXOasfuOV5WBkHjAVLh59lCXgnIAp+5h7wQ3R1W/V5TxgR8wF7PcKwVwDHYEe3HiTYJiKsbqHG+9ZGwK/JPUZL9cx4mzhL64I5qOd4xxikNabpCb6OMcsN6IDnzgK4DnvCQ9hLGPZnLLy5fykEQcEQT2lu3lA/oQg2AxfgAU5h8YSWaVBgt0ns5RehQfObRPK/WDzham/wml8BVRARuxFmgN/uAlgHU3vHc/6kF2yHNc2HQkMoXuvOeV8vmAKvli9lw5rhZFgeoPK+HcBGhNTS23TJjNKinDPMzBE1mRf0nqV3zkVS/XZwZtR2JtvX1FirJ4cp89Frp2p5odIgrdlyaL2DM11Kq0705B1ndaR3rTYGE638aqaIu2AWakJSy+DrpvpV32907LhPbQw2S2KalU/Mtgsjz1h1OjPXtN5JLZOpz+lBS77SM8y78Oug1on1ZCSte4zSa8lgZg24jjTO9FozY626jGYNy7V5Z+WvXvnU4YWcwQxZW4l+3TrIb+dwkbaGMKpEowaqJ4wYQcn0KxuAkhRVPsdIwVF2wOrYUpf3MPn4u+AFb6fH0TT+Cl/wBHaLRQhbb2AYhI48yPCADVhCkRhu90Oj1ZXkBrVkVr3pxK+fygNvFMKxr7hdP84sH3rCvpkBQqtOlNe0rv8axcUFc9Cynjkj0dWCgBZJqzeIOmvn6j5SBXwDn0BRZEuJZxuDkLdVYB8sSvzw3Rv4cf+Dsmw8CxgCH0TF0Hf6RhgFx/p3JuYPH5DbqqV43zYDr2cqCN+7hcpjjeho+xZs0JwL0G8P/HUH+sYVIyue0TvrTYxmJm7lOWV69bIQrXtcCkfNUIG+EqD8dcDIG0KtlKg9Lxzpm8HTQHvxgN1HDzok59Cm2SUhVp9BNhyrQlZObILPYzrKrQOQmJwXgXR4aeQ6/C+cvrXCwnoW2A772oTIiot4IBUeS8+DIfDG13NhMeAL5Zl1SOzxKp3XHePqhTpszQijT5998P16bi+dVdeHkcKlV4c1UQpquqzQqAxaio0L5mA0xjj7VY9n9QE3Spb5YPlfO72mfU6H8iOwDvZ0C2FraBg+e0tksQPwLzdvuABbw8LwCS6RTcoyIej8N1getkMuWMaC19AKis5ARZk7lyY2lJVGbYF6ENvrbXYuC4Uq+NlSTEGCJ8NnbcBSz04US2jZvgjLATv1J9hhRCqwD2nz59FfNuisjrTmVz2YJfH0ZC0z861yXnbJUb8dzMi1RvKvEmqPJ7V8pAc9nUUtT2k9U+ucM7lGD1p6hNZYYNQ2Qd8gbVYvUd5j1lCh17dchFXtYIY81DN814Y01CN49YzmRmUy493rzGhvFs5CD2jVjVqW0VvB5CxPPTLY6By45o/fAlpjmXIltlp+MDP+Gxm7zBiMzZRTbxxW/2/mPmfP00uv5M/0ZCE9bksvPyPiWjmPmJk/jeEibWsEPfJFD0aNRiudVkPS+8hGjUSZzvGsHAiEV23xMAoSY17gRHmAEFWz5DKrkdiF1+H4UT/m5UVDNHABbLvPMX/JDHgRWFSEuCWWajxH/Z7Kd1Jbzp11YPW7aOXvuGZkOTEiA8GlhNcUbvyyjSq/sfK88psr46OpBzotC5gSWu1ES0G5M41nSAFMh+6huyVSyGGojAZLc1jLMN7pFUNeNx/xwm0KDITzCV5sn/AcKwZEwCI70f+ax2aelbigg6DVtpO8ETYXegDfVzKs6Srin5rK7WWwDu949QSkVT96ZVemN1LsjKB+lt430oNL4fjtoBVPzGyMNq20Vch39ILPwDLMzsOWs8xYMl+8xAPgajrSHMfCsOmreDgwC8IhJPkI86dHkTz+OfCF+TlRlI+oA+Vg+dQuqyh6StzbhMkv8wjfQW/Eo9AD2WTsArw7a7J4rtcDj7ibMBHYD1PrvUP/19Ngp8PT0JknhvrdnC15dAaz3iJ6ypjWMkwXagdH3anHfeWxkeygDgl1BTgP0ZUw9SK8A2UvNsFy0E6vA5/Tb/teALKb2+jt+wnfedggCD7gNSrS4NCCQCyVdsJbrIVAxLAxAlgE3oPBK76CJvllNF10mv4RG8AX4lLepi432JTWB98MGMgW7nmtBCJg3ZCXIMsOCbmwLBk4xS+9EB3voYYzskuPvNYzUBuRfc7uV881eumV84gSrj5Scyj7gt430atvRzo92UEt7zpT3LXSGbUhZTnVx+r7lfnq6Qp6ZTFDVmsRpUZGEL37fi3MEAYumINe+CO9tFrja01kBiMC2Ixx2UjmcEY8/5qx0xm5arRyyChklBmyXO+cmtRVrxpzoWZQb24Mv9R7K9F38NO7z5mObfaa3nUzY7Dy3prOcUZ5ahkuHb9mdGdnfERN9HjHM7VkYXUezuHqQU6hVjKMWHMjclCLYDR6nvoeLTJMK53yV/n/FWAOS++dAmV2/rt4A5YhcCKtDf6bTkMqlAZYabRM0v+DF6jHz7KT7GJgP0IGkIoo4qUaZVKXvzaDQG0tEc46oxFZ5SKnag49pUCvTyjTGCkQegq8kaCuR9hfo8T9PBYyuVkULDE9m4I1AKiCmPMLOdeiBS2Ci2Un8mKgFbQYWkzxBnf+wQu88uB7vJs6GVKQ+71lGfmSoteQvhDAusdfgsxkjfc3UhSMlKraKFjqZxopeuqyaJXVpXTUDuqldVWqYyOPUTTSKPNUnnOgFP5xDtm5ezQEwdbXwug3ci/H9wXSyfsYFi/wnv4TJ2cECSG7CybGJxAU8yWDUjYzcXuCeJHPgk/8e1N6w0qjo5X4rCshilVQDpX7ocWFYll9kQCXOjWkyYwyKnOBcWAdBOwFkmBR5CRI3sNtT8Oa1ptZzxg9RcrIW0Rdl2YUQjPnXNCHcszXIoD0DHLKa47NLqqAA9ze1K4+bAUoBbfnsLxoh4hS6NQIDsNuBsLHgC/UX2aHscCpjax76CWG25dCFrxji+EF1vPFhicYPmwDnIDC1DawGiYvm8ZZWpF8PhL6uYuRGxBhqApOeVWXRbl5k/IdKhVl13o/Z2SWui7MKjBq4kxNAqvTG805NZ2XXHAOLZlIjxxF57yzb6FuW1o6g7N89OQ3M+XR6+N6colZvUh5XJO60pI/9cqlzt/ZO+uVw6Vi1w5GMo8WlKSIWv6q6TPd0JdDlMZ3rTKqZQozK4NqKiPpHauhJR+ZXX1ktGLMWf1qEbjKZ1sMnuvCL1EB1FOdc8aTOBsXnckAWtyTG3fGstXKy0gv19I39cZjMzySM65NKw9nvIOeLGo0t6nnWa26hdtOa2b4MX24ZhSn0BKYjYRnowasRfYakSxGwpzWc0wI3mULgSf52KsfQxK34h91Ws6PgkZJlWQn2GgXksvsufOgCramhtGWozzwc6HEReQiQgCry2RGoHemdDhgREhrvJNTEtDZQHXDRJlcuBO1HUjV9+r1E6O81OXQGzQvIhtr3EudZ+zYR1ggClYMiuA7HoFB7hzY3JXBkTvY8lovBu7dDXOAKvDaXMHeb/oxaMYo2A91F5Rxs8CDz9t1ZFVkFCSv4Nay78zzwGmdsunVg5nJSp2HXl05S1/TCdaF2kFLKFYvhdP633HsuKcmQv15lOSopcKOPd0CvaDz3mPYAdLh/SWxVC4G62fAEri4ErKWPC7hQo4hcWzPwMB64pE+f3oUf/FOoOoG7LocRr+Ve+EEZC5oR3DbbJr0LYPeYE2FzK/bsZJRrLJFwTAgI5nbMWzNwIwioacI1YSE1VJyXATsvxeOb6InqGqNYUo4xiPld3JsjKS87wHYmg9bT8jhYRALQwA8bwXOw9MPAd8AViL+vIKH+IF7bYWUtW/Co19/y/CRGyR281hgEbzaN56l3d+E+4BP8oGdwL0ICVtc/fxT3OlZqzV+quMhmlGuHHkZyUFaz3IoVs5ILb3nGz3H2dziQs2hpV/82ryUMEME6+kgRnKzWo4w0kPMELJ6ZTZqe1r5OJOX1Hnp3a98J6M61JPnHNdc80vtYCQHmDFmO845W82kZSx2RmY6C+Gkfp6R3KcHI8O9s7R6cEb4minXrzWsg2u+qA30xjwz46ARHOOWkpBV5mtGd9Qqi96cYnZu0Jt7zMgczmQX9TX1c5zVnVFZasKB1a4fuMIjGELtzlzTj6OEnuUW1Tm1AFOp+FOTjXrl0BP+HGXIYejfPxUF5QBsyewlGzGNhAX8BctIO1snh8F+6Ld9L21CLmF7JBuJ1ebYUbYmAp76fYygvK++ifSOPJ0Jfur6/nUd5/+/oZ6I9axH6oFb3TYc99VHuz+oj7XalNGgeYVb37oxEAYFgzz5K28R32QqnIDPeBI8YGD+bnGeCoXTm5rw/KAkWIDsHB4AN5M94BgMZjMkf8PtOJ3nESLAURatdqj3bnpjhFmoFSWt8UFrktQiA5Rlclxz2fRqBiPC1ozAXVMFz0FelSJ9KF9WUuWDpYOd8m51sKyG02lNoB641QWShbD18gSSYG+3xwGoHIdEvEkHEuG/+JyqaltWvwF7GTXqfRgFwVnZ0vSTkZAiXeEqDVj1RhR8n6wgbI2W3tUE6vpxpog5U/aUS/ScLWV0Lev7baE3RumN947/1X9V3G77jjZxHmm8p4Bz1b/FSMiaI4gBb3/1PV1Jto5mmiWasoYekPUVw8vXsGd1CJZ/2LH81Y7lCztLLW9CxrfwyR6EsK2svr9QUYZS7pQx1PKachy2Yn6cVteZFgFbyS9lVGUIIvjl+K6+Xz0f6ClZyrRqMstl6Ks59L6nlvykJ9s6/lcfq/uL+l51ezIa2/S+uRp6co2WjKL+09Il9NqXkYxkNI4oYfQOWnqCIx/HEnx1GiPdzEXa/rbQM/DqEaZmVjSZmdvVMoeakFd64BrJJLVtD1pksZl3dJRNfaxHPtfHedgoJZGs9wwXfjsojd5GcMZpqGURJa6p0jigNbZpndO6T++a47rW2Kkuq/KZShnFaB6wcme4FGfzhTPOyghmeEB1XWjNy+bhIm2dwgwxok6vJ5goodfwjEhYZ2SjWtDR6khVQCm8BXs3Pc6hQ4EMPLxb4trGwUymw8fQb8peGSvygZWQu7wdNdsJ2U3jnBkoG/Q1xTktOFNItP53kbX/b6BHDGopII42pSUMa+Xr+DVSiJX3l0IGtLUd5P70y+T5PgY/LYUTpcTyVyhB9HA/CJr+Jf4lJ9h4/nkoq2TaxgVYut+EBcA/4FL/1ggJ4BCUSrnTiGHUn52RFM4mD2djg1ab18pTaxwxUgxdMAe1sGuGUNRawuaMJFReV46Rvmzo1p/iEe6Ud7TgkXkTgIN0hRKwzILiRe7k29th9Ye8bj6EzfgSUsE6AgiBCSNmw3UI7pGNNQysGUCkGC8S/F+Wx4YCHYFG0HfZRnou/gIW7UM6kcOYYaRQOYPWkjoljJQwvWdpKThade/sHhdqB63xRmtsdPxvRAhqjV8OAhXkWynHP+UYDZABVeuRcXwHUEzZX5vQq9XnsCgDnj4ACfuARIQI/l71HC2ohXPlOXVZ3VT3KRUhs+OuI62Wd4zyuc4UGy2lQgkjpUpvznPBHLT0BOV5tZKK4hju/Abwyz6kBa1vpRWDWd0W9OR5M0qr1rFW2zF6f/X9RqRBTcukhlZeSgLWiFQG/T7jQs1QE1JQSSSqDbN6JKWRLKAuhzOi0oysZ9ZYrC6bUbgGPWiVzZlHrsPbsqayTk3lNBdqBkc9as3PtRn3jOZsPX1Vj8cyIiG1xnh1O9eTUZyN+c7e1WFY0RqL9eZSo2N12fTGf6MyGsm7YFZPcplHDOEQ/q380n1cD2Y+ujqtI70eKWP2vJGQrnzmFTiXy5ssJCv/cSptYI0GyuG+G0U8tyMZLkBBc0/O0ooLNJd4nr/YBdzomWbqSg1H7DejOtRSiJzVj7NO6uoGvw5630FrQNcbjI0mEi0FRutZWnlagSoo+4pjlvuBbxFl/RpwEb+L+dzs4QFBiI7+OJAJEjfxGoztAW4WKMiArc0Qby1lP1C3c7OGGCOYqYea5uus/rTOu4Sufw+0luQ588o1uu4Q8HcwNPtTuK8C+776cAzOj/BiSLOtVF4H6yHYzjNEnNgIzeHBN35k3LsL6T1zF1e4lxnM5IfkQJiMrCxfDPSGMecX8U/+i42WCKJWrAJ/ODG9DX8mmSPdQyBjH7djjKrfxygMhNax+r3cVP87W7pYG5hdXuhC7eFMLnI2R5iBnpDuyMchwznG7FLkm1+Bd1K5k/gFbRnGrIylTOtot1okm/JYq+xGc6qRgqAl/6ifq06vlY9RWZR5ufpOzaH1DdTfzWje1vueyn6gHjP10ir/12qHzr6vUb7q8jrLRy+tln5gVgcy6g9mymhUT+r6UpPdLpiHs5VHWjKAw/hk5OWqJYeYkbf0ZI5rGmmdldWoD1XrKdTnl/OOs75nNtSBs9VfRmSu2kCoTG9EUCuf6/jfZdCoPX6tbmmUp97cozVemuGufs01rTRmZRazx3p5W1XX9epFL381tPJR16UViV3sHK4ZxRTUhJIeyaT1Ucw0TGV6rWeYIa2MnqludNeAHL4rCYEBYPVAwiNshvd6/Q8bx0VQmvASn9Kfr2nPAbpwe/Mxs0SbVjn0zjmgF/vNGVlldoD5NaSXC8b4LdqB2rKnN1jrtX2jwXY/t9u+49wpbvqcB7oAG2DEvYA3yli4/FRUfc8V4Ci3FX1lObSep/WeRsqEXh5GeWs9Q+t+B4zK4Thvpl+7oA2H0mCGXFQrBc4EczP5XoROQGN3Wl06CZ2gL9tZHhBN5WH41mbjz8UbIV6y8lpwnqTySEZ6rKbzyGNEHNtIaaaVRqsrwRPy0nzwSyxg+YFoPvx4PLARSys7z41KZuO4CNnUjB1Arkb5zCoGWoqU3juaWQJYmzQuwunfDyNC6Ncapo3GTyW0CB/H73mN/JwRWs7GY8d1LdJMS3HVMzQrYVaeMhrLteZKZd7q96vkl4SZElpEgwu1h9Z3q6mxwCgPLX0CVVpnCrJaVtMri145jeQSrbap3sxP6z51Hnr5GaXRq3NlvbkpzqnHHlTpXXNLzaFHriqvKc9rjT01MfBqyQVaRnW9stVUXjEigWszjtamjTkjmo2IVjOyltE3dOkWtYOzejPLNend44wnMZK99MqgTq9eGeSszHrymtF9RrKKMi8jPVjv2JmO7EwWc8bdOYeLtHUKZ4IOaDd65XFtn2VE3KrvUcJMJzhPhb8XjEO8aP8BpMLUwHim/WMBwUsz+ReNKbDcgKdt/P/Yu/PwJsq1DeB3mu7QFgp2YStlt5SlrAICKlJxA0WWI4LiDiiK6FGUg2wK4oI9LqD4IQhuIOhRBKF1AUEQpOyyyFIoS0uBlpbuaTLfHyEhmc5MJmnSSdr7d129msyWZyZ5Z9555p13zM0QxTte28IhVbAd/TjVVvaVKpByCSpHy+GBo2rkKrmwGa50Ymo7n9Ltoo5OJKTGS/3+rkjEcgzm39/Rq+PP4loFw3B13P6rn2Nb8RCf1Kspb5Z4xcPk9iVKv2Wp9VY6IXFErjyRa6ROLKQqyVKtOdRUhKWWdfW7q0gDLobjTEBPIBE4vzsKCRvTcej1LsAXAEYDtwg/4pfUu5H7dGNsW9gZ3bcfwK9LeuGW1G0I320wNzK/A3gRb2HVpjHYNLYHcEMBzA9zeg+rcT3MEx2C/UUMpVYtasZLjVPbysSyHdW0qBFvd6XvRurzyDVSiRepBI0jchf3pKaTO37YvhZX8KUSVHInK0qVdKVppU5GpJZjSzyNmmOso5MENQk7QLqvXB4vXGdbf1A6X5C72KH0fcktxx/S35lS/do2Bqnfn9J0jn4bjk6abZclvlAudw7k7IUKpfdy08j1/ygVv05mGpImPkY72ypUbryjBKV4mHg6V2KQ48oFZkd1KPEw27pNAK79ZtXUMy1sE7eW+Z3ppkFuPR2dp5M6aupMjvbFziQQ5eoTzuZVHO1/1VCaXiphW9WcnKNxarez0nFL3bGCZyAOOfNjF4+T+8LV/BAc/ZDV7vjkflgFQHYG0AHmB5J9BCASaH7/IWBUMQ7d3+Vqa+3VwHpLK1vbK8yAdMLVmcJYITOd1HvLstVUBG0rxOL5bVmm4dVw56nZ2as9oJSIhjmaz5LsV3uybolFXLZybcbZ7ugt/8XJI7mTbkC+nNuOc2Zf4MyJlTMXbpxJcvDwUHVqKvxKt6U5mlc8/BiASKCiANgTju/r3w9c/gnAapivzoXg1013oV7/LGAqMA4f4VLPBjjTvbX5GNDNgI3Cjei/aQdWLR2D7CURuOn67QDew7VK/ElcKw9SscideDnb95ntbY/ibhIsrx1tR6VhSicwStuYxwvnSR275ZJBchcEpRIp/lDeL4vnFy9fqr4g/mypfaxUAkjpwroUpTqcXB3SNhbbJLjcZyttc6ntqTSPVDyW6VkmXCOVCFf6Lh1d5BAvQ67uLDW/7bS2DwGWq5+Ify/i8wNH5JLQSjHKjZNKbovjt/1vO7+/zHDx59g2MlFzYQdguXCFuN7pqDupqi5f7nOkLvbavlfzOVLx2tZhnKkTOUryys3j7HZS2rZSw6UaXyld9FZ3Gzip4ShfJFW/UlqOo3HO5HfU1I3ULk/uWCU1Tk3dSS2lc3O5epQrDACMqqbkg8gUWa5SAfaVe4heu4vSFy/+fAMq/1ik4pE7iakAcBa6jiZgOaDbLODTV+7HqQ/bAfgZ+Po88L99MLc+3I9rHZQrFWzxe0cF2jbGEAfjxcOU1lW8XWzfi5drOfEjz3B0YqomOSlehlxLB6mKtHjZ4pMe2xNOZw4atsPlTm7U7MiVDkZyw23LfoDEeKV5bYc52n/xhKNqpCrM4laltq/F+yGlCrfUtID5N3G1VSzOAJdX41pL8j/Mw28qRn5wALCzAHtDbsAZ3TFg5xngHgB1A/A2XoDujADdZwJiW18GDr8H+zJi6RfU9uRDilSy2fZkRWo95JYh1+qmKvtu2xj8oS4mqe+JlEntp8WVeLkEk1RC1XZ5Ui1ALctQS81+W2oapQSx1LRSw5U+UyrxJl53qXnk3kttR/HxQ82Jn1QCnJxjkPizHWch95uR2wcp/Xal6r5SnxMA+32sVBm0LMMgmkfudyw+b5Krq0vFLbU8Z4fLbUfL8UwpgS21PKXvzHZ+HiucJ3cxVq4uJXXcFh/Pbd9XwP4zxMlY8XBxHOLPl/pMMTV3/8jVDZVikotNDallqbmzScy2FS5/79VHTf3BMs7R+aEzuSe544EStee5UrHZvpbL6yh9plzCWG08SscVV5Zn4VqilyXMIaVsulTmvqpfltKPSypx6+xybe0HWp2EbpwAbAQevfwl8NFRmE/4v4X551Fi8yfmqKJvO53S+hhQua8TR+vgylUTqSs/BvAWJmdJ7TbEBwi578dR5diZeaRaWblycJIrx1Kf68rvTep3pyY+uYON1HCliyZy5Ubu4OvsepKZmgq1VEsOpeUp3dYnN8yyv7ZckKiAOZEbAPO+3dLCPBwoLYC5D2cDcOYQgGj8GDYcKNwC84W0Q7BnWabU+qiJU+69v2iYbdlWWk5VLiyIW+3afpZc1wm8kOEc8T5aippEq3h/JrefF+8PbecT36HhqDKudBxTStyoPUGROgmBxHul46GjZK9U60dnj4O280ttV3GSj5wjV59Rmtb2wrXUdyv3fUt1UQIVnysVg+18SvUJ4Nq6Wc4pbOexDJOK01ESWpw4towPkZheaT2k1kc8XGqb2sYvtXyWC/ewPR4D6pK6colRZ+5cUhqmVJep6h05cvUqcWtduXqg0sV+qe2iNlEtlei2/UxxslzttibXKOWeHNUTLPOo2fc7ukCl9vghtc8WH0PkPkvqtdSFbTFXckXi+dUMdzY57Fo8TNqqovSly1UgIBqulprsve2PVC4hpObqSYH576N08/SHd8Fc+bC9bVwpCaZmp2Abu5oTHDWfJbd8y3Ti7WAZ7ky8pI5cBd72v9K8lu9LqssDpd+y1PfrzGeKh4lJJTqVliFFLmkqF5dSDI4+V0084n2Uo2Xx8OAcuZanSok/uVvuHN2iJrdMcUXcti+zCpj37f42rwuujj8P8+8jFyg8efU9YG6hK06oSsXjiKPErjhR6uzyLWy7VFCKQe7kRs1JBk88qkauwi6mdEFPbp+qlMhxlOyROpY42u+rqYSrrbuIp1c6CZMjnkacTFJzUdM2sefouKs2LpKn9Nu3vJZKjsqNF5Paf8t9j1LnGFK/Abk6mVw9xjJOat8pTthCYjpHnycep3RXoO384mU7+l07utAi3n48VlSNVLdIjqa1TK80nVTCUmq8s8uWG++oOwe5i8ZKy1FbNxEvS65lsdT8custTqA7kywm51i2s9TFZED6XNUdeRVXErpVndfZuoTU+sptF7VxOMrBuVLPkztu2Maq7nyb3SOoopRQcdRKRK4CLkfqxyc3XvzeUeVP/N5yUv8zgF2wJnEVEztKrUbk2FbanJnPdhpxRVUcmzgpKzWN3GfyYOIc8fZytLOS+u5s5zNA/oF0chVqC0sLDmfKl9TvSM1O3VGyU3wipZbSPsR2+zlTJm23mVTyQ02sLBfOcfXWNVe2s6OTGLmT1hJceyif7UPESq6+z4W5Na7tdLYcdSEgvg1RKikt1apWPMxRSxVxdzoWSg+2lGtZK759UileqfckT7ytpPZHcnUe8X5ZaT9vufDnLzGNmgtuSscANUlcuWOU7Xvxb1aq7uboWCa3D5f6PKX1kZsfUJ/wcrZBAtkTfwdyFxVsp4fNOINoOqljuqVuJTW97Wfa/pf6DUot21LmxGVa6rdlu05KF/pth6st+1LLUPu7VNofyH2Wo/MQZ2MgM0f1J6WEoG3SUOlit3i8XDJT3FVBBSon4eUu0LvS7YAz0yl1oyD32XJdQzj6DDWJZkfTicc7c25E9hfaxHUOqQtPSueH4gvUSsTHlRBI79fV5nDEy5Srv9iOU8ofiOO0fe/KvlfpmCf3WeLpndmulteW9+r2EUzaquKoAiXmKMGoNrkjV8GR+1ypz3OUBAbMP5YCmE/S5XauapPTUsQVOrXzOZpObgeklNiWes+TcOepScA7+s3IzSN3IiMeZoD0js7R70JcJpQSAc4kYuXKp6ODgdxBxvZEx1E5UYpTHIt4eUqJFaoaR/18yd2WprQ88byOli01v23Zsa3EG1C5XDk6yRF/pqOWG1KtWW1b20rFK37vrhPiCiifyLCFSNVIPXTEtuWIXIJH6jUgnTi1DBd34yROFAWIXksdn8THG6WLfI6SRZYkrWX+CtgfmxwlgOUSbUonE+L4bddVLmEHVF4f221lS+6YyDqUc5TqRnLfi3hepWW5etJq+1uBxH9xnUR8d5RcwlmpjCnFAchfoJObT2mYXN1IvN5KdSC1517kHFfvalGThLTlKDksdReTbRcYct0sQGaY0ufIxSaeRnwxXBybmovjUsPlhjm6I0kqLh4DPEtpf6l0jFCbd1Ha3wWgctdSUolY23jkcldKbI8trpyDqj1fD4D9cUXumCdehlTi2kKpeyO5hLrzmLRVpLQDltv4UgXIdpz4B+1oWkC6IuIKuYqUAeYWVko/KDUVR0eF3tFy1Cb9xBUs8eerSSja4km58xzthMTfnTPJfrlhStNK/cakfh9SSWFXLkQocXTgcHQCLl4P8cFFanni9ZcrD1LrJG6dyJMO18hVbB1VmKXmVWotYrscS6U5BPbLlkp2yvVnJherEqUkp5oktVSMUp8v916ppbFSXLbzqTnJcPXEjCqzHLOV9jeOLrA6mt4yTFw/kNpHysVoO15qOY5OBixsWzjKJbNCZIaLpxEv29E84s90tF2dSVBJbX+WCefYfieO6q6280gl48XUXHRV+r7lLgAoUTrRVXNeoBSHbR+4cp8rNd5R3Uvu89SeYIvreWq+G5InrtM4uijsapJQ7cVuuWSoo2UotQh2NJ1Sfcf2wrbSxXulupxcF1Ry5JZtO15cJ2Py1v3UXuQTD3N0Hu4ouSuVs7KdXq4+IxeX3Lxqz1XF00gt19H8lnEVoveOlgco34UkfkB6VY7D8pi0VU2pgiR+rZS4VTPeQilRpXRVuSrD1SZYxQVOLlZHJ0m21Jyw2Q63XbYByrdGOkqUkXpSB2Xx9y8+KZFjW2bELSrUnhw7mlYqPjHxbX628znzG5ZLFkhNZ7v8AIlhFuKH9Kk9wVb7HYhjsmDlq2qUWie4+3NsKyHiPtsA6RMRcRK3QjTMllyLV6VKvJppnSF1y6LUcCnikwvLf6l5lU48WCacY7u9pPZPUq38HdWdxPtppWOBUuJGvG90NJ+auoTSMqWmk/sM29cVouGuJlyVtpPSCZscZ44tVJnU70npgqtlvCv1LPHnStVrpJYjVZ+RWp7tf6XzE6k4bN+7+luyTS5YSK2XMwllpfFy01teW97zeKGebf1Drh6h9k4jNclDRy1O5S5Mq+1awNF8cnUPpfFyccnV/RzVucRdQjjaZuI6lFx8UsPdfZdUbSKX5JTibB5Kzbmz7X/xa9thSt0cqn0tVddRm4x19Nm2nLkop/Rerg4oNZ+jOqZjTNo6RamibZu4lKuIiMc7qhA7urqiNslp22xbqnIhLrhyy3U28almx+JKAZRKEgfgWvJCqWLpTIwkTXwS6ehkz9EVLwtLyyRxBVzpxFtctuSmd8T21g+lvgcdLd/Vq4NSJ2Ny8zk6EIvnlzsZc3RyxtZTznFUSVa6Dd92Gbb/xa/VUGpFK/58f9GfVCJTrksDpbg8cbJq+5ni15B47UxMcidFzpwoknMsx2zb966c0MnVV5xN0EjVKRzFI3XSI/XkernliH9PapO+SjEoradUbFLvpY55Sid5TE5VjVQdXOn3p3QRWun3b7tMufq81G9QTZ1HLnHpKE7g2u9Srq7l6FxC6bxL6jOVEuNy04undbSvYHLKeUqJWtsLy0rU3uEktSylbgmklqPmbiE5SvUWcZ1Lbetd29+nVF0vBPYPmhR/nqv1G7lkrtQ0POeuOtvjhdz5tpq6i3g6R/swtXUq23FSF/Us721jUPotq/0sKXJ1GTXLEW9XpYuC4vnU5Pucz1kwaVslUgkjy3A1ySS1hcrZCrxcxVpt8szCmcqM1LxqKpZKpLaX3PaU+iy5K/lVuWpD10gl3sXfu9TvQyphKPXaQk0iVOnqonicXPmQI67g2yaWpdZFapyjCyNSnyk3nTMHM6WTP9uYnN0mVJlSpddRqw6pZTn6LMt/cQVffJJjO1wqOamUTFZqOau0vlInHK6eEMjdpijXUlZuGVLELY2lxvO2P9dZLvCpSXo4IrXfk+o6wLJscYJG6TgidwFLaZ8tVfkPgHRrE0cnHHLrInVBT2p5jmKzvLa94OroxMX2c6Uu/DvarqSeMyfdjhKStu9t6yHO1v+VLmY4Suja/p6VPsPC9oK9VNmTuotOarni366jdXY0jS2lup84iUJVZ/nOXbkQK673ONOFgO3vVlwvkGvh6m6uJH4Bxw9iFfdBrfR5ju44crU+xOOF6+SOE44uWKk5Z3R0Hq60fCni45jcRS7buonUxT415//i93Ln5JblObpgKX6vVFdSu7+XS/paXqsrT0zaqqbmKq7c9ErDHBUO2/mc2dnZTivua8MVcicBzlZ6lN6LxzmzXKll21aw1Fz1IOc4OpG0TCP+fpR2XlLjpUglYJUq9QGiaZUuJogfZiMe7yhO8cFUXLF3dMBUik/NfFLbW1yepLaJ1PLIOVIPTbFtwSpOQKrpMkEpEazmQC/XKlVumUrv1SxDzbLF28LRZ8otQ671re20VW1FYlk2uUZqvyMeJ7cvldq/ySXxbacXJ42Ulu3ogq+jxLCzJ6FSiSXb446j5ao9figluizTyA0XH0NKIH2csCyD5cN5jpKycvVlNb8NpZNDpc8Uf75cuZCr49h+jlzZFH+muP4mXk/LhRC5urv4hFxqGttx4tdqT8jlkgnibWU7nOXCdZYkjly3SIDj7SvVqtTRfFK/XTnOdsOgtvsB8fKdTZCqrU86ahnrzO+XF7Y9w1ELVPFwqeOD2rqV0vRSw9XWfRwlQx3le6TGqzmft4xTOmaqTeDKHafUzCs3nS11ZY1J2ypxlLQBlJM0riR+bedXGidVGXK0PGcKsVyyzLYCo2bnIjXc0XZRsz62nD2pIsekdnRK5cFRJdnZ70hN8tTRfLbUnCTJ7ZTlTlqUksiOhinF42hetQdtuWFM3LrONuEvTiZKtThV6ptMjlRrWalElpr+2cQctSyxLFfqtkFXunawLN/2QWri+G1jsh2n9pbCCsgn09VQk8gmZY5OCKQSVVIXmoBrvwdx8kj8v0I0LED0Wi6pKV6u1HLkEkdKCR2peovafbxUXU5qe9nGIHex3oDKT0FWunAnV99ivco9LL9FC0cXEZSWo/ZkW2q8M9+v3LmF1MVi8XCpixaQ+K8Uq9QwqQSA0nmW2hN+NSfnllvPWXdyH9vjuVw3TVJspxEnfdWQa5WrNL1SnUeuzuLMBXu1d/vIXcxUajHrCrl6pyvfFykT/57l9qtqL0TZLscyTOn4LyYXgyv7PkcJVctylY5r4jqR5bUzpJYhHg7Ra2eOW1LHRdeOFUzaOqRU2ZCbzpZUwkeucu/oc8XLlSK1HDWFWW6ZSlcPpH6stgdJuUSXmoLhLEeVVaWENE/Cq07qJFDqRByovMOXm06OeF7b5SqVS2cvkqg5iRHv7JV27o6W4eizbMdJXZSRO3iq2a5S+yRynrh1p4W48i0mHq6mmwVxK1NXEsDi8Y6SxWq6RrCdXioG25avluElKpcn102C0jyW5YuXo+aEQirZzhMR9Ry19oTNeNtb8AHlkxOpxKPcdHLHFsv3qHQMUto3246z/X0HwL6PTrkLYeJkrhRx3Uh8jBO/Ftf15E4s5FouWuaRSqbZEn83rEM5x/a3ZoD0bc1SFxts57f9Lx4uXgZgf+FKqv5gO4/cOYPcb0J8wUA8Tk0dSKo8qKnjODp5FpdNuRN0taTKmOXWc/FwqhrbuoJU3clR4rOqd9hYliH+PPE4pYvJUsuRei/1GVL1D1fuynKmewg5UkljNZ/HFrjuJ5dLgYrhtqQuusnlTOQ+Q81+zlES2dHnKT2k3NGxxTK91PItdUg1eSLxZ6upv8lx/djApK1Dan4QFmoSolI/NvGXH6Lic5VOAsSVbrkfuFwsUnE7w/ZWOmevkFjeO0paWcglpcUnFaxAeY5l20odmKV+h+Lfu+38ai5G2B4sHO2k5U52xYlfNb9TtSfwShwlsW2XpSaJLD65lloXqe0vtRyqGnEFWy4ZqrZiLV62ZRqphKWj2+jkWsKKlyHXKtX2s+VuN5RLbsolsJ29VVCqJYfS9ErDnG1NQ66xTYwqsSQ+5JJJUicb4sSjVF3AUT3Edvlyxwi5pKXt8ArY74fFvy+pBLI4yeTo+CJVT5J6bTtM6oTEmYuEUklBS1Kaxwz3cnRCLZ5W/H06+g7F9XKpZTj725Cri8mdJMuRqsfYDneUmBXHJU6IS6230v5CLjbbYUr/qerkErXiaWAznbge5O7juqNEq9J4tbE4SgCL609KdwIpJbOlKG03pbqf3GfYJt3JNcGi92r3rY72kXLTiC+gOZvXkqozqNkvKp2Diy9qKiVL5c6xpZYvfvi5OA6lOqij+puaOq/zanTSdsGCBYiPj0dwcDC6du2KzZs3O7kEuR2eMz8Ky/RK04kr1+IdnNKXL5folYpRXLDEJzyA4x+gpcLuKDZnEs1y04vnESfa5D7X0Q5JLpaar+plQk4JpHesYnJlQWrHLF6W0g5UvHzxSYnU8hwtSzxe7uRX6XcttSypuORO2JQSrXLLl+PoQCf1unZwT7kQty5Q082AFFdaJsglVKWSxXKJWUslW1wO1cSitC5SLVRdrcw7aunrTKticSxSam+LEfcdKwy4dvuwmPjCmu1/OVLJFqmkqHhZcskguZMTqbqaq/UdV+o54uU7c2FQbj6li3riZchdvAEq37JZe7i3XFgEQPo36Gh+Nd+l0meKl6H0+5RLEstd6BAnYeVOhsWfo5ZcvUvpc6TKhlTMrsZhu6wA8HjhDEcJRkd3x4jrW3LHemficLQMtS1W1V6oVrtMuXqV7Xil7WU5HouTtI7uCJOK01GDAal5agf3n1cA0vts2zyQeH8kdS4pvhistGy1CVe582RH+1SpGNVMp3QOLJXbcpR8VnPsg8J0csditUlrdWps0nbFihWYNGkSpk6dit27d6Nv3764/fbbkZmZ6eSS5CrQzswvVeFWSsIoffniYZb/4gdFWMZJLVdNxV3pqoJUhV2pwukogaU0nVT8UhVCuXnUTFM7rgK6r0yoOfBKlRFnToLFHF3Jk/tcuZNdy+9V7kKHowsDUsOc2S+oObkSJzSk1tvRyZ6aRIQ4ntp1Eu6+cmGhtpWHXELQla4OpE4kbB/CIZ7fAOll2bZYsUyvJjnqzG15arsmkPpMNS1dlE661LawdaalSc3j3mOFZR+k5oGoSicMcvtsqXmkksG25JJQSscW8bEhBJX3wVIxSsXg6ERCar/u6MTCdjo188slqi3xi2/3Fif5nE0y+j73HysA++0qvrBgO40ctYnaqi5DqTzJLUfpBFfu9ycml4RwVI+xPfeSShxbpldajpr9gdw5FsDjhTPlwlE9Q822lKo3iZehpn4mV59QG4fUZ4jvFJKbT01iWk09RmldLXeGqLnIrxSLuM7qaFvVjvIAuPNYYXu3ktQ+03a/Jr77yNHFM7n9nNJ5urMXtBydS8sdW5w5Xqk9V5dKYDvKH0gNd4baedVd0NAJgiC4Hoz36tmzJ7p06YKFCxdah11//fW45557MHfuXMV5CwoKEBERAeA/MDdNV6ooK30hajLsclc95BKYajL+jj5PzbxSscutj7uGu4Mzy7ZMawTwGvLz8xEeHu6huLRXlTIBiMuFXmYqtb8bqZNvC/HBRel3BJnplH4HjsZJxeDsvK58rpptJDeNM/sFpQO07WfoAMxguXDgWrl4HZVvZbKthDubrBRP70w/ZM58ltS0aj9Lbt4KmXGO4pPaXkqf4Szx8iH6DLltbqsUwEs1uly4r0zMg/TtfUDlhApshjtLzb5Vbn8qt99We3yR259W5RgkXraaZSotX2r7OjpeOlOXqgDwfI0uE4A7y8UMVC4XFlWpH8t9jxaO6uNq6hzi5TpKjDpajtrPdbb8ScWpRE3szq6HDjX9WAG4+3xbqu7hSl2iKtTUOapSt1Pz+VC5fNu6CxSmqw5KMdjeXcXzCkeulYspAOrCfbkUpXqQO893HX2mo3kdHVOUYnR0bHJU91Mbo+10tlw5fqvLQ9XIturl5eVIT0/HlClT7IYnJydj69atlaYvKytDWVmZ9X1+fr5ljM1UUjtNo8Q429c60TRA5RND3dU/yzijzXAxo2h5tvOpPfE2ojKp6XQS04rfWz5Tbpm242w/Q7zdlE7U1SQuxMt25oBrtA6vodcvADhfJgBH5SLo6mupCoPc78b2O7Cdxh/mRIi/zTjb8VLzW4bbloNSm3GWciVVeZD7jYiXKbUu4uWK18l2XvFv1WgzzJbc71ap/InLl1zZlEpS2W5rcZy2+yPz9mS5sCdfLqRaUtj+JtUkQMXTyrUcUVqWbeXYdrmOKtLi90onKZb3pRLjlFqDOGopYju81GaY+Hds+xuWWp7488Sxy722/b7klluzjxfuLxMW4pYftr87pcS/eLzUCa1tpVzqO5f6vits5pWKQU3Zk1q+uEzZxmxhW6lXileunMv9ri0tm8WtqOT2G+JtYcvS0lZumZW/m5paJgB3lwtxHceWVF1ATRJHrj4uVW8Q/5er74jrLOJzBMv/UpvpxTFb5pOqo8iNk6q/ieuBtudKtttFPJ9UfU3uv9z5ir/Ea/F0kBhfs48VgDvPty2/w1KY9zdy36FYBdQnYdQmia6dF1b+HItSm/lsp3c2kSY1vfizxesvjtVyvq4m+aZ0EUdqOzqTzBPHaPsZljJtLmMsE/aUjxWW+q54P2a7v3FUX7cME9fZbc8hpY4LOlRevm0dXGqfKf588TTiecVsY5Pa54qPC1L7YYheKw2Ty+9JxSh3zLCMs53X0fdhO1zdsaJGJm0vXrwIo9GI6Ohou+HR0dHIzs6uNP3cuXMxc+ZMiSW95aEIyRtduXLl6pWtmsfZMgGwXJAZy4U9+XIx3QMRkreqqeXCvWViqgciJG9VU8sE4O5yMdsDEZK3Yrm4Rr5MvOGhCMkbsUzY4/k2AY7LRY1M2lrodPatVQVBqDQMAF5++WVMnjzZ+t5kMuHUqVPo3LkzTp8+XaOb8HurgoICNG3atFq2vyAIuHLlCho1auTRz/EGassEULlcXL58GXFxccjMzKyxB1tvx3LhGSwXvo3lwv1YJnwby4RnsFz4NpYLz+D5tu9imfAMHit8mzeWixqZtG3YsCH0en2lKxo5OTmVrnwAQFBQEIKCguyG+fmZn9EWHh7Og4iGqmv71/SdorNlApAuF4B5W7FMaIvlwj1YLmoWlouqY5moWVgm3IPlomZhuXAPnm/XHCwT7sFjRc3iTeXCz+NRaCAwMBBdu3ZFWlqa3fC0tDT07t1bo6iItMMyQVQZywWRPZYJospYLogqY7kgsscyQZ5SI1vaAsDkyZMxZswYdOvWDb169cKiRYuQmZmJcePGaR0akSZYJogqY7kgsscyQVQZywVRZSwXRPZYJsgTamzSduTIkbh06RJmzZqFrKwsJCYmYt26dYiLi1M1f1BQEKZPny7ZXJ08j9vf/VgmfB+/A/djufB9/A7ci2XC9/E7cD+WC9/H78D9WC58G7e/+7FM+D5v/A50giAIWgdBRERERERERERERGY1sk9bIiIiIiIiIiIiIl/FpC0RERERERERERGRF2HSloiIiIiIiIiIiMiLMGlLRERERERERERE5EWYtJWwYMECxMfHIzg4GF27dsXmzZu1DqlGmDt3Lrp3746wsDBERUXhnnvuwZEjR+ymEQQBM2bMQKNGjRASEoKbbroJf//9t900ZWVlmDhxIho2bIg6depg8ODBOHPmTHWuSq3EcuEZLBe+i2XCM1gmfBvLhWewXPgulgnPYbnwXSwXnsEy4dtYLjzD58uFQHa+/vprISAgQPjkk0+EgwcPCs8++6xQp04d4dSpU1qH5vNuu+02YcmSJcKBAweEPXv2CHfeeafQrFkzobCw0DrNG2+8IYSFhQmrV68W9u/fL4wcOVKIjY0VCgoKrNOMGzdOaNy4sZCWlibs2rVLuPnmm4VOnToJFRUVWqxWrcBy4TksF76JZcJzWCZ8F8uF57Bc+CaWCc9iufBNLBeewzLhu1guPMfXywWTtiI9evQQxo0bZzesXbt2wpQpUzSKqObKyckRAAibNm0SBEEQTCaTEBMTI7zxxhvWaUpLS4WIiAjho48+EgRBEC5fviwEBAQIX3/9tXWas2fPCn5+fsL69eurdwVqEZaL6sNy4RtYJqoPy4TvYLmoPiwXvoFlonqxXPgGlovqwzLhO1guqo+vlQt2j2CjvLwc6enpSE5OthuenJyMrVu3ahRVzZWfnw8AiIyMBABkZGQgOzvbbvsHBQWhf//+1u2fnp4Og8FgN02jRo2QmJjI78hDWC6qF8uF92OZqF4sE76B5aJ6sVx4P5aJ6sdy4f1YLqoXy4RvYLmoXr5WLpi0tXHx4kUYjUZER0fbDY+OjkZ2drZGUdVMgiBg8uTJuPHGG5GYmAgA1m2stP2zs7MRGBiI+vXry05D7sVyUX1YLnwDy0T1YZnwHSwX1YflwjewTFQvlgvfwHJRfVgmfAfLRfXxxXLh79Gl+yidTmf3XhCESsOoap5++mns27cPW7ZsqTTOle3P78jzWC48j+XCt7BMeB7LhO9hufA8lgvfwjJRPVgufAvLheexTPgelgvP88VywZa2Nho2bAi9Xl8pU56Tk1Mp606umzhxIn744Qf89ttvaNKkiXV4TEwMAChu/5iYGJSXlyMvL092GnIvlovqwXLhO1gmqgfLhG9huageLBe+g2Wi+rBc+A6Wi+rBMuFbWC6qh6+WCyZtbQQGBqJr165IS0uzG56WlobevXtrFFXNIQgCnn76aXz77bf49ddfER8fbzc+Pj4eMTExdtu/vLwcmzZtsm7/rl27IiAgwG6arKwsHDhwgN+Rh7BceBbLhe9hmfAslgnfxHLhWSwXvodlwvNYLnwPy4VnsUz4JpYLz/L5cuHRx5z5oK+//loICAgQFi9eLBw8eFCYNGmSUKdOHeHkyZNah+bzxo8fL0RERAgbN24UsrKyrH/FxcXWad544w0hIiJC+Pbbb4X9+/cL999/vxAbGysUFBRYpxk3bpzQpEkT4eeffxZ27dol3HLLLUKnTp2EiooKLVarVmC58ByWC9/EMuE5LBO+i+XCc1gufBPLhGexXPgmlgvPYZnwXSwXnuPr5YJJWwkffvihEBcXJwQGBgpdunQRNm3apHVINQIAyb8lS5ZYpzGZTML06dOFmJgYISgoSOjXr5+wf/9+u+WUlJQITz/9tBAZGSmEhIQId911l5CZmVnNa1P7sFx4BsuF72KZ8AyWCd/GcuEZLBe+i2XCc1gufBfLhWewTPg2lgvP8PVyobu6EkRERERERERERETkBdinLREREREREREREZEXYdKWiIiIiIiIiIiIyIswaUtERERERERERETkRZi0JSIiIiIiIiIiIvIiTNoSEREREREREREReREmbYmIiIiIiIiIiIi8CJO2RERERERERERERF6ESVsiIiIiIiIiIiIiL8KkLREREREREREREZEXYdKWiIiIiIiIiIiIyIswaUtERERERERERETkRZi0JSIiIiIiIiIiIvIiTNoSEREREREREREReREmbYmIiIiIiIiIiIi8CJO2RERERERERERERF6ESVsiIiIiIiIiIiIiL8KkLREREREREREREZEXYdKWiIiIiIiIiIiIyIswaUtERERERERERETkRZi0JSIiIiIiIiIiIvIiTNoSEREREREREREReREmbYmIiIiIiIiIiIi8CJO2RERERERERERERF6ESVsiIiIiIiIiIiIiL8KkLREREREREREREZEXYdKWiIiIiIiIiIiIyIswaUtERERERERERETkRZi0JSIiIiIiIiIiIvIiTNoSEREREREREREReREmbYmIiIiIiIiIiIi8CJO2RERERERERERERF6ESVsiIiIiIiIiIiIiL8KkLREREREREREREZEXYdKWiIiIiIiIiIiIyIswaUtERERERERERETkRZi0JSIiIiIiIiIiIvIiTNoSEREREREREREReREmbYmIiIiIiIiIiIi8CJO2RERERERERERERF6ESVsiIiIiIiIiIiIiL8KkLREREREREREREZEXYdKWiIiIiIiIiIiIyIswaUtERERERERERETkRZi0JSIiIiIiIiIiIvIiTNoSEREREREREREReREmbYmIiIiIiIiIiIi8CJO2RERERERERERERF6ESVsiIiIiIiIiIiIiL8KkLREREREREREREZEXYdKWiIiIiIiIiIiIyIswaUtERERERERERETkRZi0JSIiIiIiIiIiIvIiTNoSEREREREREREReREmbYmIiIiIiIiIiIi8CJO2RERERERERERERF6ESVsiIiIiIiIiIiIiL8KkLREREREREREREZEXYdKWiIiIiIiIiIiIyIswaUtERERERERERETkRfy1DsAbmUwmnDt3DmFhYdDpdFqHQ0RU7QRBwJUrV9CoUSP4+fH6nhweL4ioNuOxQh0eK4iIiMiW2joUk7YSzp07h6ZNm2odBhGR5k6fPo0mTZpoHYbX4vGCiIjHCkd4rCAiIiIpjupQTNpKCAsLA2DeeOHh4U7NazAYkJqaiuTkZAQEBHgiPI/z9XXw9fgBroO38PV1qEr8BQUFaNq0qXV/SNJcPV74+m8L4Dp4A1+PH+A6eAtX14HHCnWqcm7hSE34/WmF28513Hau4XZzHbed67jtXOPp7aa2DsWkrQTLbUvh4eEuJW1DQ0MRHh7uswXC19fB1+MHuA7ewtfXwR3x+/JtnFeuXMG0adPw3XffIScnB0lJSfjvf/+L7t27AzDfkjJz5kwsWrQIeXl56NmzJz788EO0b99e9We4erzw9d8WwHXwBr4eP8B18BZVXQdfPlZUh6qcWzhSE35/WuG2cx23nWu43VzHbec6bjvXVNd2c1SHYudTRERUIz322GNIS0vD8uXLsX//fiQnJ+PWW2/F2bNnAQBvvvkm5s+fjw8++AB//fUXYmJiMHDgQFy5ckXjyImIiIiIiKi2Y9KWiIhqnJKSEqxevRpvvvkm+vXrh1atWmHGjBmIj4/HwoULIQgCUlJSMHXqVAwdOhSJiYn47LPPUFxcjC+//FLr8ImIiIiIiKiWY/cIRERU41RUVMBoNCI4ONhueEhICLZs2YKMjAxkZ2cjOTnZOi4oKAj9+/fH1q1b8eSTT0out6ysDGVlZdb3BQUFAMy3zxgMBtXxWaZ1Zh5vw3XQnq/HD3AdvIWr6+DL60xERETk7Zi0JSKiGicsLAy9evXC7Nmzcf311yM6OhpfffUVtm/fjtatWyM7OxsAEB0dbTdfdHQ0Tp06JbvcuXPnYubMmZWGp6amIjQ01Ok409LSnJ7H23AdtOfr8QNcB2/h7DoUFxd7KBIiIiIiYtKWiIhqpOXLl+ORRx5B48aNodfr0aVLF4waNQq7du2yTiPu+F0QBMXO4F9++WVMnjzZ+t7y1M/k5GSnH0SWlpaGgQMH+uwDAbgO2vP1+AGug7dwdR0sdxsQERERkftpnrRdsGAB3nrrLWRlZaF9+/ZISUlB3759JafduHEjbr755krDDx06hHbt2lnfr169GtOmTcPx48fRsmVLvP7667j33ns9tg5EROR9WrZsiU2bNqGoqAgFBQWIjY3FyJEjER8fj5iYGABAdnY2YmNjrfPk5ORUan1rKygoCEFBQZWGBwQEuJSscXU+b8J10J6vxw9wHbyFs+vg6+tLRERE5M00fRDZihUrMGnSJEydOhW7d+9G3759cfvttyMzM1NxviNHjiArK8v617p1a+u4bdu2YeTIkRgzZgz27t2LMWPGYMSIEdi+fbunV4fILYwmAdszcpF+UYftGbkwmgStQyLyaXXq1EFsbCzy8vKwYcMGDBkyxJq4tb0VuLy8HJs2bULv3r01jJaIqHqx3kFERF7NZITu1BY0zt0G3aktgMmodURE1UbTlrbz58/Ho48+isceewwAkJKSgg0bNmDhwoWYO3eu7HxRUVGoV6+e5LiUlBQMHDgQL7/8MgDzraybNm1CSkoKvvrqK7evA5E7rT+QhZlrDiIrvxSAHsuO7kRsRDCm352AQYmxDucnoms2bNgAQRDQtm1bHDt2DP/+97/Rtm1bPPzww9DpdJg0aRLmzJmD1q1bo3Xr1pgzZw5CQ0MxatQorUMnIqoWrHcQEZFXO/gDsP4l+BecQzcAOLUQCG8EDJoHJAzWOjoij9OspW15eTnS09PtntwNAMnJydi6davivElJSYiNjcWAAQPw22+/2Y3btm1bpWXedtttDpdJpLX1B7Iw/vNdV0+crsnOL8X4z3dh/YEsjSIj8k35+fl46qmn0K5dOzz44IO48cYbkZqaar2d98UXX8SkSZMwYcIEdOvWDWfPnkVqairCwsI0jpyIyPNY7yAiIq928Adg5YNAwTn74QVZ5uEHf9AmLqJqpFlL24sXL8JoNEo+udvyVG+x2NhYLFq0CF27dkVZWRmWL1+OAQMGYOPGjejXrx8Ac/+EziwTAMrKylBWVmZ9b3mogsFggMFgcGq9LNM7O5838fV18MX4jSYBM374G1I3JAoAdABmrvkbN7VuAL2f/EOSvIkvfg9ivr4OVYnfV9fZ1ogRIzBixAjZ8TqdDjNmzMCMGTOqLygiIi9gNAmYueagg3rHQQxMiPGZegcREdUgJiOw/iVA6Ui1fgrQ7k7AT1/NwRFVH80fRObMk7vbtm2Ltm3bWt/36tULp0+fxttvv21N2jq7TACYO3cuZs6cWWl4amoqQkNDVa2HmG0/ib7KF9fBJADHC3QoMOhwdNXPaBkuwFvPNQQBKDUCRRXAoTwdsgvkDzYCgKz8MnywYj1aR/hWX3O++DsS8/V1cCX+4uJiD0RCRETeYEdGbqUWtrbM9Y5S7MjIRa+WDaovMCIiIgA4tbVyC1s7AlBw1jxdvPSD7IlqAs2Stg0bNoRer6/UAtbRk7vFbrjhBnz++efW9zExMU4v8+WXX8bkyZOt7wsKCtC0aVMkJycjPDxcdSyAuXVaWloaBg4c6LNP1PXVddjw93nMXXcY2QXXWk3HhAfhP3e0w23t1f+mXFVmMCK32IDconLkFRuQV3z1f1E5covLkVdkM+zqeIPRuQTs4qMBiGtQB40igtG4XjBi6wWjcUSI+X+9EDSsEwg/L8lS++rvyJavr0NV4rfccUBERDVPzhX5hK0r0xEREVWJsQK4+A+QvR/I3gcc+0XdfP8bDzTuAkS2BCJbAA2u/q8bDSg03CPyFZolbQMDA9G1a1ekpaXh3nvvtQ5PS0vDkCFDVC9n9+7diI299qCEXr16IS0tDc8995x1WGpqquLTwIOCghAUFFRpeEBAgMuJmqrM6y18aR3WH8jCxK/3Vrp54nxBGSZ+vRcLR3dx6oEaFUYTLpeYE66XisptEq/lyL2afLUOLypHXnE5istde4plSIAedQL1uFhU7nDaEoMJh7Ov4HD2FcnxgXo/awK3Ub0QNLb81Te/j40IRnCA528fMZoE7Lr6JOoGZ66gV6son7690pfKghRX4vfl9SUiImVB/uoeaxEVFuzhSLzL3Llz8corr+DZZ59FSkoKAPMdezNnzsSiRYuQl5eHnj174sMPP0T79u21DZaIyFeVXQHO/30tQZu9Hzh/EDCWOZ5XLP+0+U8soI45eRsZfy2RG9nCnNwNi2FCl3yGpt0jTJ48GWPGjEG3bt3Qq1cvLFq0CJmZmRg3bhwAcwvYs2fPYtmyZQCAlJQUNG/eHO3bt0d5eTk+//xzrF69GqtXr7Yu89lnn0W/fv0wb948DBkyBN9//z1+/vlnbNmyRZN1JM9T0y/b9B/+RuuoMOSXyidic4vKkHe1pWx+iWv9efr76RBZJxCRdQJRP/Tq/zoBiAwNRP2rw+3GhQYiJFAPo0nAjfN+RXZ+qeR66ABEhwdjycPdkZ1firOXS3D2cgnOXS7B2Tzz/+yCUpQbTTh1qRinLsnf2t6wbhAa1w9BY3Fyt775f0RIgGJ3Io7wSdRERETe65dD5zH1u/2K0+gAxEQEo0d8ZPUE5QX++usvLFq0CB07drQb/uabb2L+/PlYunQp2rRpg9deew0DBw7EkSNH+OBKIiIlggBcybJPzmbvB3JPSE8fGAbEJAIxHYDo9sCvrwFFFyHdr60OqBsF3JkCXD4J5B43L/fScXMS11AEnN9v/hMLCL2W0LUkci2tdOvGAH7qLmwSVQdNk7YjR47EpUuXMGvWLGRlZSExMRHr1q1DXFwcACArKwuZmZnW6cvLy/HCCy/g7NmzCAkJQfv27bF27Vrccccd1ml69+6Nr7/+Gv/5z38wbdo0tGzZEitWrEDPnj2rff2oeqjpl+18QRkGzN/k1HJ1OiAiJMCcaLUkXa3J1wBE1glCZJ0Am+RsIMKC/F1KeOr9dJh+dwLGf74LOtgflixLmzE4AdfHhuP6WOkuOwxGE84XlJqTuPnmZK45uVuKs3nFOHe5FCUGIy4WluFiYRn2SlyQBIA6gXpzIre+dGvd6LAg+OulD2SWJ1GLD6uWJ1E72+KZiIiI3KO4vAKvrT2EL7eb69aN6wXj7OVS2XrH9LsTfPouGWcUFhbigQcewCeffILXXnvNOlwQBKSkpGDq1KkYOnQoAOCzzz5DdHQ0vvzySzz55JNahUxE5F2MFcClY1eTszYJ2uJL0tOHNzYnZ23/6jW3T5iGRAIrHwTkjlR3vA1cfwcqqSgHLmfaJ3JzT5j/LmcChmLg/AHzn5h/iE0yt4V9K92wRkzoUrXT/EFkEyZMwIQJEyTHLV261O79iy++iBdffNHhMocNG4Zhw4a5IzzyAWr7WwvS6xAVESyRgLVv/WpJxEaEBMgmJz1hUGIsFo7uYtNK1SxGZSvVAL0fmtQPRZP60g/PEwQBecUGnLtcgjNXW+daW+te/X+xsBxF5UYczSnE0ZxCyeXo/XSICQ+2SeQGo3G9UHP/wf87wCdRExEReZk9py/juRV7kHGxCADweN94PJ/cFhuP5Lhc76hJnnrqKdx555249dZb7ZK2GRkZyM7ORnJysnVYUFAQ+vfvj61bt8ombcvKylBWdu02X0s/8QaDAQaDa3dzybEsz93LrQ247VzHbeeaGrPdyguhyzkIXfYB6M7vB84fgO7CIegqKp+XCzo90LANhOjEq38dIES3B0IlHnJpNJr/LFrfDt19S6BPfQW6K9ceSiaEN4Jx4OsQWt8OSG5LHRARZ/6Lv0X0GeVA/mnocjOgyzsB5GZAl3vC/PpyJnQVJUDOQfOfeF38g4H6zSHUbwEhMh6oHw8hsgWE+i2A8EaAzjsTujXmd1fNPL3d1C5X86QtUVWp7W9t6SM9vf4JyIMSYzEwIQbbjuUgdfN2JPft6bb+YHW6a103JDaOkJym1GCs1O3CGZvEbtblUlSYBGv3DDip/vP5JGoiIqLqVWE04cPfjuO9X4/CaBIQGxGMd4Z3Qu9WDQF4tt7hK77++mvs2rULf/31V6Vxlocbix9oHB0djVOnTskuc+7cuZg5c2al4ampqQgNlb64XlVpaWkeWW5twG3nOm471/jMdhMEBFdcRnhxJiJKTiGixPy/TlkOdBJNdSr8gpEf0hT5IXHID2mGgtBmKAhuApNfoHmCXAC5hcCh7U4E4Qe0nIMGhUcQbLiM0oB6uFS3LXDCDzixroor2MT8F9EXiAB0QgVCyy+hTtl51CnLRp2yHNQpO4+6ZdkILbsIv4pS4MJh6C4crrQkoy4ARUFRV/9iUBQUjaLAKBQGx6AkINIrEro+87vzMp7absXF8l1a2mLSlnye0WSCnw4wSTXxhO/1y6b306FnfCQuHRLQMz6yWk+cggP0aHldXbS8rq7keKNJwIUrZZJ96h7KKsA5hW4qLPgkaiIiIs87ebEIz63cg92ZlwEAgzs1wuwhiYgItX/QpJb1Dq2dPn0azz77LFJTUxEcLN8IQNz1lSAIit1hvfzyy5g8ebL1fUFBAZo2bYrk5GSEh0t3c+Uqg8GAtLQ0DBw4kA8RdRK3neu47Vzj1dvNZARyj0N3fj902fuhO3/A/Fd8UXJyISzWpuWsuRUt6jdHuM4P4QCaujk8g+E2Tbed0VQBo7WFbgZwtXWu7mqXC3qTAeGlZxFeerbSvII+8GoL3XgI9c1dL5hb67YwdxPh59kHhXv1786LeXq7We7CcYRJW/JZgiBg0e8nMG/9YcWELVC7+mXzJL2fDjERwYiJCEbXuPp247Ydv4T7P/nT4TI+++MkAvR+GHB9FIL8PXuAIiIiqm0EQcCKv05j1o8HUVxuRFiwP167JxFDOjfWOjSvk56ejpycHHTt2tU6zGg04vfff8cHH3yAI0eOADC3uI2NvdZdRE5OTqXWt7aCgoIQFBRUaXhAQIB7T/xMRuhObUfj3G0IPBcO/xb9PH7yX2Nw27mF23/TtYTm262s0Hz7v23fs+cPAhUllafV+QEN2wAxHe36n9XVaQgtzq6123YBQFQb85+YsQIoOGPfd67lL+8kdMZy4OI/0F38p/K8VxO61n5zbf8imgL6KqbsuK+rMk/95tQuk0lb8klXSg349zf7sP5v821rQ7s0Rv821+GNnw7X+n7ZtNIjPhKxEcHIzi+V7NfWYtfpy5jwxS5EhARgSOdGGNa1CTo0jnDpAW5ERER0zaXCMry0ej9+PnQeAHBDi0i8M6IzGtcL0Tgy7zRgwADs32//ZPGHH34Y7dq1w0svvYQWLVogJiYGaWlpSEpKAmB+MPKmTZswb948LUK+5uAPwPqX4F9wDt0A4NRCc5+Kg+YBCYO1jc3bcdtVjckI3aktaJy7DbpT4QCTQN5LEIDC81cTszYJ2kvHAakztoA6QEyi/cPBohKAAB5DFOn9zYnX+s0BDLAfZzIC+WeuPRQtN+Nacjcvw9zH7sV/zH9ifgFA/Tgg0uZhaA0sCd1mjhO63Ne5zov2c0zaks/55/wVjFuejhMXixCg12H63e3xQM9m0Ol0uKtjo1rdL5uW9H46TL87AeM/3yX7JOpX705AzpUyfLfrLLILSrFs2yks23YKraPqYljXJrg3qTGiwtX1UUxERETX/Hr4PF5ctR8XC8sQqPfDv29ri0dvjIcf60GywsLCkJiYaDesTp06aNCggXX4pEmTMGfOHLRu3RqtW7fGnDlzEBoailGjRmkRstnBH64+UV2UdCnIMg8fsYwn5HK47aqGSSDvZTKak4HZ++wTtEUXpKcPi7VPzsZ0BOrHA37a971ao/jpzYnX+nFAS9FD0UxGoOCsOYFbqZVuBmAsAy4dM/9VWq4/UC/uaiLXktRtCUTGA/WaAUd+4r7OVV62n2PSlnzKmr3n8NLqfSguNyI2IhgLHuiCpGbXbtOvzf2yeYNBibFYOLqLwydRv5DcFn8cu4hV6Wew4e9sHM0pxNyfDmPe+sPo1+Y6DOvaBLdeH43gAF61JyIiUlJcXoHX1x7CF9szAQBto8OQ8q/OuD7WvX2n1lYvvvgiSkpKMGHCBOTl5aFnz55ITU1FWFiYNgGZjMD6lyDZSs4ybM0zQFkBoNObb23W6a49BEfnJxqmk3lvM63sNLbv1Uxjea+zea9muTbTOopF6c4th9tOB6yfArS7ky1HpTDhXTXubLlXXmTuzsCue4O/HXRvYJOgje4A1L2uautDVeenNydY6zUDWtxkP85kupbQzT1xtaXu1Va6eRlARenVYceBY6IHZeksvyuF48SPk4CAUCAg2NyiV3/1r9LrQHOLXstrP73yftbXeeF+jklb8gkGowlz1h3Ckj9OAgD6tGqA9/6VhAZ1K/cXRtpS8yRqvZ8O/dpch35trkNBqQFr92VhVfoZpJ/Kw8YjF7DxyAWEB/vj7k7m7hM6N63H7hOIiIhE9p6+jOdW7MGJi0UAgMdujMcLt7XlRc8q2Lhxo917nU6HGTNmYMaMGZrEU8mprUDBOeVpSvKA75+qnni8kkxiVzCZW67JEsxJkjdbmm8Hl0se2y7fUaLZYcIbDpYlM63qxLgLcUiNFwRg+0IoXyx4FtAHAUF1AP8QwD/IvB39g6/+DzIPr40tOavScu+KVPcGxyDdvUEoEJ1o33o26nogMNQDK0Ue5ecH1Gtq/mvR336cyQRcybrW5cIlm64Xck9IJ+/Fii8BX9znYmw2yVx94NX3cq/lksEqk8R2rwPMLYydem2zfEvSWY6XXthj0pa8Xk5BKSZ8sQs7T+UBACbc1BLPJ7dlK1ov5kyL5/DgANzfoxnu79EMJy4U4ttdZ7F61xlk5Zfii+2Z+GJ7JlpeVwf3dW2CoUlNEBPB7hOIiKh2qzCasGDjcfz3l6MwmgTEhAfjnRGd0KdVQ61DI08rPK9uuuhEoG40AMGcrBRs/ouHyb7H1f9K0wiiZTparnDtvdJyq0QABKP0ebcapXnmP3JOSS7w1QjH0+kDzYlc/2BzKz/r6xDRcIXEb6X5bIeL5vMPNidstGoAorblnsloTrjZJmez9gFFOdLLrRtTuXuDyHi2Eq8N/PyAiMbmv/h+9uNMJmDnYmDdC46XE97EnNA3Gsx/JoO5j11jxbXXUvtj09VpDe5Zneqls0ng+tu/NhkcXBS9emHv1FYgvm+1RcykLXm17Scu4akvd+NiYRnCgvzxzohOSG4fo3VY5CEtrquLF25ri+cGtsG245ewetcZ/HQgC8cvFOHN9Ufw9oYjuLG1ufuE5AR2n0BERLXPqUtFeG7FHuzKvAwAuKtjLF6/pwMiQvkE91qhbrS66Qa9Ua0nlW5XKRnsKNErVE78iqc5vR1Y/Zjjz777PaBRZ5mktKOEtFI8cu/hYFlq1lXpPZyYVmbZF48CGRsdb7uIpuZkqaHU3NqvogwwlJiTIRbGcvNfWYHj5bmLzk9FslchYWw7XNUyrs4nmBx3Z/LdOOCP/wI5BwFDsVTwQMPW1xKzliRt3SgPbjDyWX5+wHXt1E1770eOjxMmk00y1wCYKlS8NogSwU68NpZffV/hnteVks7CtX2Qq9RePHUTJm3JKwmCgP/bnIE31h+G0SSgXUwYFo7uiviGdbQOjaqB3k+HG1s3xI2tG2LWkPZYtz8Lq9PPYsfJXPz+zwX8/s8FhAX7466O5u4TujRj9wlERFSzCYKAlTtPY+aagyguNyIs2B+zhyRiSOdGPAbWJnG9zbdVF2RBOhGkM4+P613dkbmX9RZ/AHDTRfrwxkDaq463XdJotlYUy9isLml7z0LpJJDJaO6DU5zMrSi9+r/MPNxQah5mHV7q4nxl9reICybAUGT+q05+AfYJaymGIuDsTvPrgFAgur1E9wY8ByYnuPM44ecH+AWZL074IpNRRcL4auvis+lXL7I4oPbiqZswaUtep7CsAi+u2ot1+7MBAPcmNcbr9yYiNJA/19ooLDgAI7s3w8juzXDyYhG+3XUGq3edxdnLJfhqRya+2pGJFg3N3Sfcm9QYjeqFaB0yERGRW10qLMPL3+5H6kFz646e8ZGYP7IzGvOYV/v46c39YK58EIAO9ifkV5Ocg95g0lEKt53rqpoE8tObE4/VmXwUhGvJW9tkr20SWC7ZK5Ukts7nIGEsGK/F4Chha9HjCfNfZAv+/qjquK+7xk9/dT1VdLHYuAuw9b9ed1GUWTDyKsdyruDJ5ek4fqEIAXodpt2VgDE3xLEFCQEAmjesg8nJbTHp1jb4M+MSVqWfwU/7s3HiYhHe2nAEb6cewY2tGuK+Lk1wW/sYhATWggMRERHVaL8dzsG/V+3DxcIyBOh1eCG5LR7r24J9+9dmCYPN/WCuf8m+/73wRuYT8Wp+srVP4bZzjS8mgXQ6c5cFAdX8PAxjxbVkbsbvwOpHHM9z/WBzFwhE7sJ9nfO8dD/HpC15jbX7svDiqr0oKjciJjwYC0Z3QZdm9bUOi7yQn58OvVs2RO+WDTFrSAV+2p+FVelnsD0jF5uPXsTmoxdRN8gfd3WMxX1dm6BbXH0m/omIyKeUlBsxZ90hLP/zFACgTXRdpIxMQkKjcI0jI6+QMBhodycqTvyOPZs3oHPf2+Dfop93Jc28Fbeda5gEUkfvD+jDgKAwoP09QNp/vK7lHtUS3Nc5zwv3c0zakuYMRhPm/XQY/7clAwDQq0UDvD8qCQ3r+mi/KVSt6gb5Y3i3phjerSlO5xZj9a4zWL3rDE7nluDrv07j679Oo3mDUNzXpQnu7dIYTeqHah0yERGRon1nLmPSij04ccHc/+IjfeLx4qC2fAAn2fPTQ4i7EWf/LkCnuBt5Iu4MbjvXMAnkHC9tuUe1CPd1zvOy/RyTtqSpnCulePqL3dhxMhcAMK5/S7yQ3Ab+ej+NIyNf1DQyFJNubYNnbmmNv07mYlX6Gazdn4WTl4rxTto/eCftH/Ru2QDDujbBoMQYxX6SjSYB2zNykX5RhwYZuejVKoq3ohIRkUdVGE34aNNxpPx8FBUmATHhwXh7eCfc2Lqh1qEREZkxCeQcL2y5R0QOeNF+jklb0sxfJ3Px1Be7kHOlDHWD/PH28E4YlBijdVhUA/j56dCzRQP0bNEAM4e0x/oD2ViVfgZbj1+y/k373wHc0SEWw7o2QY/4SLvuE9YfyMLMNQeRlV8KQI9lR3ciNiIY0+9OwKDEWO1WjIiIaqzMS8V4buUepJ/KAwDc2TEWr9+TiHqhgRpHRkREVeJlLfeIyHcwaUvVThAELPnjJOasO4QKk4A20XXx0eiuaHFdXa1DoxooNNAfQ7s0wdAuTXAmrxjf7TqLVbvO4NSlYnyTfgbfpJ9Bs8hQDO3SGPd1aYK/z+Vj/Oe7KvU6lZ1fivGf78LC0V2YuCUiIrcRBAHf7DyDmWv+RlG5EWFB/ph1T3vc07kx+2MnIqopvKjlHhH5DiZtqVoVlVXgpdX78OO+LADA4E6N8MZ9HRRvUydylyb1QzFxQGs8fUsr7DyVh1U7zd0nZOYWI+Xno0j5+SgC9TrJxwQIMPc8NXPNQQxMiGFXCUREVGW5ReV4+dt92PD3eQBAj/hIzB/Rif2vExERERGTtlR9jl8oxLjl6TiaUwh/Px2m3nk9xvZuzlYkVO10Oh26N49E9+aRmDG4PTb8be4+Ycuxiyg3SqVszQQAWfml2JGRi14tG1RfwEREVOP8diQHL67ahwtXyhCg1+H55LZ4vG8LXhQkIiIiIgBM2lI1+Wl/Fv69ah8KyyoQHR6ED0d1QbfmkVqHRYSQQD3uSWqMe5IaY+nWDMz44aDDeXKulFZDZEREVBOVlBsx96dDWLbtFACgdVRdpPyrM9o3itA4MiIiIiLyJkzakkdVGE14c8MRLPr9BACgZ3wk3h+VhKiwYI0jI6qsbXS4qun4+yUiIlfsP5OPSSt24/iFIgDAw32a46VB7RAcwL4NiYiIiMgek7bkMReulGHiV7vw54lcAMAT/Vrgxdvawl/vp3FkRNJ6xEciNiIY2fmlkv3a6gDERASjRzxbiRMRkXpGk4CPNh3Hu2n/oMIkIDo8CG8P74S+ra/TOjQiIiIi8lJM2pJHpJ/KxYQvduF8QRnqBOrx1vBOuKNDrNZhESnS++kw/e4EjP98F3RApcStAOCVO9qxv0EiIlLtdG4xnluxBztP5QEA7uwQi9fvTUS90ECNIyMiIiIib8Ymj+RWgiDgs60nMfLjP3G+oAytouri+6dvZMKWfMagxFgsHN0FMRH2XSBY0rTr9mejwmiq/sCIiMinCIKAb3aexqCU37HzVB7qBvlj/ohO+GBUEhO2REREROQQW9qS2xSXV+Dlb/fj+z3nAAB3dozFm/d1RJ0g/szItwxKjMXAhBhsO5aD1M3bkdy3JwT44dHPduKnA9l45bv9mHdfR+h0bHFLRESV5RaV45Vv92P939kAgB7NI/HOiE5oGhmqcWRERERE5CuYTSO3OHGhEOM/34Uj569A76fDK3dcj0f6NGdSi3yW3k+HnvGRuHRIQM/4SAQEBOC9+5Mw4Yt0rNx5BuHBAZh65/X8jRMR1WJGk4DtGblIv6hDg4xc9GoVhS3HLuKFb/biwpUyBOh1mDywLZ7o14Jd6xARERGRU5i0pSrb8Hc2Xli5F1fKKnBdWBA+HNWFD2qiGmlQYgzm3dcR/161D/+3JQP1QgPw9C2ttQ6LiIg0sP5AFmauOYis/FIAeiw7uhOhgXoUlxsBAK2i6iJlZGckNo7QNlAiIiIi8klM2pLLKowmvJ36Dz7adByA+da/D0YlISo82MGcRL5reLemKCitwOwfD+Lt1H8QHhKAB3s11zosIiKqRusPZGH857sqPbDSkrC9ue11WDi6K4ID9NUfHBERERHVCEzakksuFpbhma92Y+vxSwCAR2+Mx5Tb2yFAz2fbUc336I3xyC8x4L1fjuLV7/9GeHAA7klqrHVYRERUDYwmATPXHKyUsLV1OPsK60REREREVCVM2pLTdmXmYcLnu5BdUIrQQD3eHNYRd3VspHVYRNXquVtbo6DEgKVbT+L5b/YiLNgfA66P1josIiLysB0ZuVe7RJCXlV+KHRm56NWyQTVFRUREREQ1DZsAkGqCIGD5tpMY+fE2ZBeUouV1dfD9U32YsKVaSafT4dW7EjA0qTGMJgETvtiFP09c0josIiLysJwryglbZ6cjIiIiIpLCpC2pUlJuxPMr92La93/DYBRwR4cYfP/0jWgdHaZ1aESa8fPTYd6wjrj1+miUVZjw2Gc7sf9MvtZhERGRB+lUThcVxj7+iYiIiMh1TNqSHaNJwPaMXKRf1GF7Ri6MJgEnLxbh3gV/4NvdZ6H302HqHdfjw1FdUDeIvWsQBej98MGoJNzQIhKFZRV4aMkOHMsp1DosIiLygH1nLmPmmr8Vp9EBiI0IRo/4yOoJioiIiIhqJGbdyGr9gSzMXHPwaj9teiw7uhP1QwNQYjCi1GBCw7qB+GBUF9zQgv2zEdkKDtDj/x7qjlGf/Il9Z/IxZvF2fDOuF5rUD9U6NCIicpOfD57HxK92o8RgRJN6IThzuQQ6wO6BZJZWuNPvToDeT22bXCIiIiKiytjSlgCYE7bjP99V6cEaecUGlBpMaHFdHax9pi8TtkQy6gb5Y+nDPdAqqi6y8ksxZvEOXLhSpnVYtVbz5s2h0+kq/T311FMAgLFjx1Yad8MNN2gcNRF5q+XbTuKJ5TtRYjCif5vrsP65fvhodBfERNh3gRATEYyFo7tgUGKsRpESERERUU3BlrYEo0nAzDUH7VqKiJWUG9GwblC1xUTkiyLrBGL5oz0wbOE2ZFwswoOf7sDXT9yAiJAArUOrdf766y8YjUbr+wMHDmDgwIEYPny4ddigQYOwZMkS6/vAwMBqjZGIvJ/JJGDehsP4eNMJAMC/ujfF7HsSEaD3w6DEWAxMiMG2YzlI3bwdyX17olerKLawJSIiIiK30Lyl7YIFCxAfH4/g4GB07doVmzdvVjXfH3/8AX9/f3Tu3Nlu+NKlSyVbV5WW8gm+cnZk5FZqYSuWlV+KHRm51RQRke+KjQjBF4/1RMO6QTiUVYBHl/6FknKj4xnJra677jrExMRY/3788Ue0bNkS/fv3t04TFBRkN01kJPufJKJrSg1GPPP1bmvC9oXkNpg7tAMC9Neqz3o/HXrGR6JrQwE94yOZsCUiIiIit9G0pe2KFSswadIkLFiwAH369MHHH3+M22+/HQcPHkSzZs1k58vPz8eDDz6IAQMG4Pz585XGh4eH48iRI3bDgoP5BF8pRpOAzUcvqJo25woT30RqNG9YB8sf7YGRH2/DzlN5GPd5Oj55sBsC/TW/TlYrlZeX4/PPP8fkyZOh011LqGzcuBFRUVGoV68e+vfvj9dffx1RUVGKyyorK0NZ2bVuLwoKCgAABoMBBoNBdUyWaZ2Zx9twHbTn6/ED3rsOl4sNGP/lbuw8dRkBeh3m3tMeQzo3QkVFRaVpvXUdnOHqOvjyOhMRERF5O02TtvPnz8ejjz6Kxx57DACQkpKCDRs2YOHChZg7d67sfE8++SRGjRoFvV6P//3vf5XG63Q6xMTEeCrsGuF0bjG+ST+D1elncPZyiap5osKY+CZS6/rYcCx5uDtG/98ObPrnAp5buQfv/SuJrbA08L///Q+XL1/G2LFjrcNuv/12DB8+HHFxccjIyMC0adNwyy23ID09HUFB8l3BzJ07FzNnzqw0PDU1FaGhzj94Li0tzel5vA3XQXu+Hj/gXetwqRT46JAeOaU6hOgFPNLWiIBze7Du3B7F+bxpHVzl7DoUFxd7KBIiIiIi0ixpW15ejvT0dEyZMsVueHJyMrZu3So735IlS3D8+HF8/vnneO211ySnKSwsRFxcHIxGIzp37ozZs2cjKSlJdpnuajllmcf2vzcpKTci9eB5rNp1Fn9m5FmHhwXpYRSAYplbuHUAYiKCkNQkzCvXS8ybvwO1uA7eoarr0LFRGD68vxOe/GI31u7LQt1AP8wenGDX2tOTqhK/L39vYosXL8btt9+ORo0aWYeNHDnS+joxMRHdunVDXFwc1q5di6FDh8ou6+WXX8bkyZOt7wsKCtC0aVMkJycjPDxcdUwGgwFpaWkYOHAgAgJ8s89jroP2fD1+wPvWYd+ZfMz6fDculZYjNiIYi8d0QevouorzeNs6uMLVdbDUmYmIiIjI/TRL2l68eBFGoxHR0dF2w6Ojo5GdnS05z9GjRzFlyhRs3rwZ/v7Sobdr1w5Lly5Fhw4dUFBQgP/+97/o06cP9u7di9atW0vO4+6WU4D3tLYQBCCzCPgzxw+7LupQajQni3QQ0CZCwA1RAjpEVuBgng6f/mO5dds2oSRAAHB7dDE2rP+pusOvEm/5DqqC6+AdqroOo1vqsPQfP6zYeRYXz53G4DiTmyJTx5X4a0rrqVOnTuHnn3/Gt99+qzhdbGws4uLicPToUcXpgoKCJFviBgQEuJSscXU+b8J10J6vxw94xzr8fPA8Jn61GyUGIxKu3i0RHa7+LiNvWIeqcnYdfH19iYiIiLyZpt0jAKjU4kwQBMlWaEajEaNGjcLMmTPRpk0b2eXdcMMNuOGGG6zv+/Tpgy5duuD999/He++9JzmPu1pOAd7T2uJSUTl+2JuFVeln8U9OoXV4k3rBGNqlMYYmNULjeiHW4UMAdPn7PF5bdxjZBddaHcdGBGPq7e1wW3v75Lo385bvoCq4Dt7BXetwB4BWO89g6vcH8cs5PyS1b4sn+8W7L1AZVYm/prSeWrJkCaKionDnnXcqTnfp0iWcPn0asbGx1RQZEXmT5dtOYvoPf8MkAP3bXIcPH+iCukGaV5PJw+bOnYtvv/0Whw8fRkhICHr37o158+ahbdu21mkEQcDMmTOxaNEi5OXloWfPnvjwww/Rvn17DSMnIiKi2kCz2mjDhg2h1+srtarNycmp1PoWAK5cuYKdO3di9+7dePrppwEAJpMJgiDA398fqampuOWWWyrN5+fnh+7duyu2nnJ3y6mqzuuqCqMJm/65gG92nsHPh86jwiQAAIL8/XB7YgxGdGuKG1o0gJ9Mn5p3dW6C2zs2xrZjOUjdvB3JfXuiV6son+2Dsza2ePFGXAezB3rFo8hgwpx1h/F22lFE1g3GqJ7yD1x0J1fi9/XvDDAfI5YsWYKHHnrI7u6MwsJCzJgxA/fddx9iY2Nx8uRJvPLKK2jYsCHuvfdeDSMmoupmMgmYt/4wPv79BADgX92bYvY9iQjQ88GRtcGmTZvw1FNPoXv37qioqMDUqVORnJyMgwcPok6dOgCAN998E/Pnz8fSpUvRpk0bvPbaaxg4cCCOHDmCsLAwjdeAiIiIajLNkraBgYHo2rUr0tLS7E6S09LSMGTIkErTh4eHY//+/XbDFixYgF9//RWrVq1CfLx0qzVBELBnzx506NDBvSvgRY5fKMQ3O8/g211nkHPlWivZTk0iMLxbU9zdqREiQtQlYPR+OvSMj8SlQwJ6xkf6bMKWyBs90a8l8ksM+PC345j6v/0IC/bH3Z0aOZ6RXPLzzz8jMzMTjzzyiN1wvV6P/fv3Y9myZbh8+TJiY2Nx8803Y8WKFTwBJ6pFSg1GvPDNXvy4LwsA8EJyGzx1c6tq63ectLd+/Xq795a7M9LT09GvXz8IgoCUlBRMnTrV2t/5Z599hujoaHz55Zd48skntQibiIiIaglN7/uaPHkyxowZg27duqFXr15YtGgRMjMzMW7cOADmbgvOnj2LZcuWwc/PD4mJiXbzR0VFITg42G74zJkzccMNN6B169YoKCjAe++9hz179uDDDz+s1nXztKKyCqzdl4WVO09j56lrDxWLrBOIe5MaY3i3JmgX41zXDkTkeS8kt0V+iQGf/5mJ51bsQd1gf9zcNkrrsGqk5ORkCIJQaXhISAg2bNigQURE5C0uF5fj8WU78dfJPATodXhzWEfcm9RE67BIY/n5+QCAyMhIAEBGRgays7ORnJxsnSYoKAj9+/fH1q1bZZO27nzIsSM14cGvWuG2cx23nWu43VzHbec6bjvXeHq7qV2upknbkSNH4tKlS5g1axaysrKQmJiIdevWIS4uDgCQlZWFzMxMp5Z5+fJlPPHEE8jOzkZERASSkpLw+++/o0ePHp5YhWolCALST+Vh5c7T+HFfForLjQAAPx1wU9sojOjWBLe0i0agP2/pI/JWOp0OswYnoqCkAj/sPYfxn6dj+aM90b15pNahERHVCqdzi/HQkh04caEIYcH++Hh0V/Ru1VDrsEhjgiBg8uTJuPHGG60NQizduEk9OPnUqVOyy/LEQ44dqQkPftUKt53ruO1cw+3mOm4713HbucZT203tg781f8LChAkTMGHCBMlxS5cuVZx3xowZmDFjht2wd999F++++66bovMO5wtKsXrXGazaeQYnLhZZh8c3rIPh3Zrgvi5NnHq6MRFpy89Ph3dGdEJhWQV+PZyDR5b+ha+fuAHtG0VoHRoRUY229/RlPPrZX7hYWI5GEcFY+kgPtIlmtygEPP3009i3bx+2bNlSaZzaBydbuPMhx47UhAe/aoXbznXcdq7hdnMdt53ruO1c4+ntpvbB35onbUlaeYUJvx4+j5U7z2DjkRxcfaYYQgP1uLNDLEZ0b4pucfXZ7xqRjwrQ++HDUV3w0Kc7sONkLh5cvAPfjOuFFtfV1To0IqIaKe3geTzz1W6UGIxIiA3Hkoe786I3AQAmTpyIH374Ab///juaNLnWTUZMTAwAc4vb2NhY63C5BydbeOIhx47UhAe/aoXbznXcdq7hdnMdt53ruO1c46ntpnaZTNp6mSPZV7By52l8t/sscovKrcO7xdXHiG5NcUfHWNQN4tdGVBOEBOrxf2O7YdQnf+LA2QKMuZq4bVQvROvQiIhqlOXbTmL6D3/DJAD921yHDx/owvoUQRAETJw4Ed999x02btxY6cHG8fHxiImJQVpaGpKSkgAA5eXl2LRpE+bNm6dFyERERFSLsLbqBfJLDFiz9xy+2Xkae8/kW4dfFxaE+7o0wfBuTdCSre+IaqTw4AB89nAPDP94G05cKMLoxdvxzZO90KBu5RY6RETkHJNJwLz1h/Hx7ycAAP/q3hSz70lEgJ79/xPw1FNP4csvv8T333+PsLAwax+2ERERCAkJgU6nw6RJkzBnzhy0bt0arVu3xpw5cxAaGopRo0ZpHD0RERHVdEzaasRkEvDniUtYufM0fjqQjbIKEwDA30+HAddHYUS3pujf5jr486SCqMZrUDcIyx/tieELt+LEhSI8tGQHvnz8BoQH8/YVIiJXlRqMeP6bvVi7LwsA8EJyGzx1cyt2LUVWCxcuBADcdNNNdsOXLFmCsWPHAgBefPFFlJSUYMKECcjLy0PPnj2RmpqKsDD2hUxERESexaStGxlNArZn5CL9og4NMnLRq1UU9H72JwZnL5dg1c4z+Cb9NM7klViHt46qi5Hdm+KepMZoyBZ2RLVO43oh+Pyxnhj+0TYcOFuAxz7biWWP9EBwgF7r0IiIfM7l4nI8vmwn/jqZhwC9Dm8O64h7k5o4npFqFUEQHE6j0+kkH35MRERE5GlM2rrJ+gNZmLnmILLySwHosezoTsRGBGP63Qm4qW0UUg+exzc7T2PLsYuw1A/Dgvxxd+dGGNGtKTo1iWDLD6JarsV1dfHZIz1w/6I/sSMjFxO+2IWPx3TlbbxERE7IvFSMsUt34MSFIoQF++Pj0V3Ru1VDrcMiIiIiInIKk7ZusP5AFsZ/vgvia/VZ+aUY9/kuhAT4ocRgsg7v1aIBRnRvgkHtYxESyFZ0RHRNYuMILB7bHWMWb8evh3Pwwjd78e6IzvDz40UdIiJH9p6+jEc/+wsXC8vRKCIYSx/pgTbRvI2diIiIiHwPk7ZVZDQJmLnmYKWEra0Sgwkx4UEY0a0phnVtimYNQqstPiLyPT3iI/HR6K54fNlOfL/nHMKDAzBrSHu2xiciUpB28Dye+Wo3SgxGJMSGY8nD3REdHqx1WERERERELuE9t1W0IyP3apcIyt4Z0RmTk9syYUtEqtzcLgrzR3aGTgcs//MU3kn9R+uQiIi81rJtJ/Hk8p0oMRjRv811WDmuFxO2REREROTT2NK2inKuOE7YAsDFwjIPR0JENc3gTo1wpdSAqd8dwAe/HUNESAAe79dC67CIiLyGySRg3vrD+Pj3EwCAf3Vvitn3JLIvcCIiIiLyeUzaVlFUmLpWHGqnIyKy9UDPOOSXGPDm+iN4fd0hhIf4Y2T3ZlqHRUSkuVKDEc9/sxdr92UBAF5IboOnbm7FrmSIiIiIqEZgM4Qq6hEfidiIYMidHugAxEYEo0d8ZHWGRUQ1yISbWuHJ/uYWti9/ux/r9mdpHBERkbYuF5djzOLtWLsvCwF6Hd4d2QlP39KaCVsiIiIiqjGYtK0ivZ8O0+9OAIBKiVvL++l3J0DPJ78TURVMGdQO9/doCpMAPPv1bvz+zwWtQyIi0kTmpWIMXbgVf53MQ1iwPz57uAfuTWqidVhERERERG7FpK0bDEqMxcLRXRATYd8FQkxEMBaO7oJBibEaRUZENYVOp8Nr93TAnR1jYTAKeHJ5OtJP5WkdFhFRtdp7+jKGLvwDJy4UoVFEMFaP743erRpqHRYRERERkduxT1s3GZQYi4EJMdh2LAepm7cjuW9P9GoVxRa2ROQ2ej8d3h3RGYWlFdj0zwU8vGQHVjzZC9fHhmsdGhGRx6UdPI+JX+1CqcGEhNhwLHm4O6LD+cwAIiIiIqqZ2NLWjfR+OvSMj0TXhgJ6xkcyYUtEbhfo74eFo7ugW1x9FJRWYMziHTh5sUjrsIiIPGrZtpN4cvlOlBpM6N/mOqwc14sJWyIiIiKq0Zi0JSLyMaGB/lg8tjuujw3HxcIyjF68Hdn5pVqHRUTkdiaTgDnrDuHV7/+GSQD+1b0p/u+hbqgbxJvFiIiIiKhmY9KWiMgHRYQEYNkjPdC8QSjO5JVgzOLtyCsq1zosIiK3KTUYMfHr3Vj0+wkAwAvJbTB3aAcE6Fl9JSIiIqKaj7VeIiIfdV1YED5/rCdiwoNxNKcQY5fsQGFZhdZhERFVWV5ROcYs3o61+7IQoNfh3ZGd8PQtraHTsespIiIiIqodmLQlIvJhTeqH4vPHeiCyTiD2nsnH45/tRKnBqHVYREQuy7xUjPs+2oq/TuYhLNgfnz3cA/cmNdE6LCIiIiKiasWkLRGRj2sVFYbPHu6BukH+2HbiEiZ+tRtlBiO2Z+Qi/aIO2zNyYTQJWodJRGTHaBIq7af2nr6MoQv/wIkLRWgUEYzV43ujd6uGWodKRERERFTt+BQHIqIaoEOTCHzyYDc8tGQH0g6eR+dZqSgxmADosezoTsRGBGP63QkYlBirdahERFh/IAsz1xxEVn4pLPup+qEBKCyrgMEoICE2HEse7o7o8GCtQyUiIiIi0gRb2hIR1RC9WjbAo33iAeBqwvaa7PxSjP98F9YfyNIiNCIiq/UHsjD+811XE7bX5BUbrAnbleN6MWFLRERERLUak7ZERDWE0STgf3vOSo6zdI4wc81BdpVARJoxmgTMXHMQSnuhvOJyhAToqy0mIiIiIiJvxKQtEVENsSMjt1LLNVsCgKz8UuzIyK2+oIiIbDjaTwHcTxERERERAUzaEhHVGDlXlBMhzk5HRORu3E8REREREanDpC0RUQ0RFaau/0e10xERuRv3U0RERERE6jBpS0RUQ/SIj0RsRDB0MuN1AGIjgtEjPrI6wyIisuoRH4no8CDZ8dxPERERERGZMWlLRFRD6P10mH53AgBUStxa3k+/OwF6P7m0LhGRZ/npzElZKdxPERERERFdw6QtEVENMigxFgtHd0GMKCkSExGMhaO7YFBirEaREREBn209iT2n86H3AxrUDbQbx/0UEREREdE1/loHQERE7jUoMRYDE2Kw7VgOUjdvR3LfnujVKoot14hIU/vP5GPOusMAgKl3JOCh3s25nyIiIiIiksGkLRFRDaT306FnfCQuHRLQMz6SiRAi0lRBqQFPfbkL5UYTkhOi8XCf5tDpuJ8iIiIiIpLD7hGIiIiIyGMEQcDL3+5HZm4xGtcLwVvDOkGnY4KWiIiIiEgJk7ZERERE5DFfbM/E2n1Z8PfT4f1RSYgIDdA6JCIiIiIir8ekLRERERF5xN/n8jHrx4MAgBcHtUWXZvU1joiIiIiIyDdonrRdsGAB4uPjERwcjK5du2Lz5s2q5vvjjz/g7++Pzp07Vxq3evVqJCQkICgoCAkJCfjuu+/cHDURERERKSksq8DEL3ejvMKEW9pF4bEbW2gdEhERERGRz9A0abtixQpMmjQJU6dOxe7du9G3b1/cfvvtyMzMVJwvPz8fDz74IAYMGFBp3LZt2zBy5EiMGTMGe/fuxZgxYzBixAhs377dU6tBRERERDYEQcB/vtuPExeLEBsRjHeGd4IfHzRGRERERKSapknb+fPn49FHH8Vjjz2G66+/HikpKWjatCkWLlyoON+TTz6JUaNGoVevXpXGpaSkYODAgXj55ZfRrl07vPzyyxgwYABSUlI8tBZEROSNzp49i9GjR6NBgwYIDQ1F586dkZ6ebh0vCAJmzJiBRo0aISQkBDfddBP+/vtvDSMmqjlW7jyN/+05B72fDu/dn4T6dQK1DomIiIiIyKf4a/XB5eXlSE9Px5QpU+yGJycnY+vWrbLzLVmyBMePH8fnn3+O1157rdL4bdu24bnnnrMbdttttykmbcvKylBWVmZ9X1BQAAAwGAwwGAxqVsfKMr2z83kTX18HX48f4Dp4C19fh6rE76vrbJGXl4c+ffrg5ptvxk8//YSoqCgcP34c9erVs07z5ptvYv78+Vi6dCnatGmD1157DQMHDsSRI0cQFhamXfBEPu5I9hVM/8F8AWTywDbo3jxS44iIiIiIiHyPZknbixcvwmg0Ijo62m54dHQ0srOzJec5evQopkyZgs2bN8PfXzr07Oxsp5YJAHPnzsXMmTMrDU9NTUVoaKijVZGUlpbm0nzexNfXwdfjB7gO3sLX18GV+IuLiz0QSfWZN28emjZtiiVLlliHNW/e3PpaEASkpKRg6tSpGDp0KADgs88+Q3R0NL788ks8+eST1R0yUY1QXF6Bp77chVKDCf3aXIfx/VtqHRKRWyxYsABvvfUWsrKy0L59e6SkpKBv375ah0VEREQ1mGZJWwudzr5/M0EQKg0DAKPRiFGjRmHmzJlo06aNW5Zp8fLLL2Py5MnW9wUFBWjatCmSk5MRHh6uZjWsDAYD0tLSMHDgQAQEBDg1r7fw9XXw9fgBroO38PV1qEr8ljsOfNUPP/yA2267DcOHD8emTZvQuHFjTJgwAY8//jgAICMjA9nZ2UhOTrbOExQUhP79+2Pr1q2ySVt33Znh6624Aa6DN/DG+P/z3QEcyylEVFgQ3rw3AUZjBYxG+em9cR2cVZvXwZfX2RmW53AsWLAAffr0wccff4zbb78dBw8eRLNmzbQOj4iIiGoozZK2DRs2hF6vr9QCNicnp1JLWQC4cuUKdu7cid27d+Ppp58GAJhMJgiCAH9/f6SmpuKWW25BTEyM6mVaBAUFISgoqNLwgIAAlxM1VZnXW/j6Ovh6/ADXwVv4+jq4Er8vry8AnDhxAgsXLsTkyZPxyiuvYMeOHXjmmWcQFBSEBx980HqckLoz49SpU7LLdfedGb7eihvgOngDb4l/xwUdvj2mhw4CRjYtwvbff1E9r7esQ1XUxnXw9bsy1LJ9DgdgfobGhg0bsHDhQsydO1fj6IiIiKim0ixpGxgYiK5duyItLQ333nuvdXhaWhqGDBlSafrw8HDs37/fbtiCBQvw66+/YtWqVYiPjwcA9OrVC2lpaXb92qampqJ3794eWhMiIvI2JpMJ3bp1w5w5cwAASUlJ+Pvvv7Fw4UI8+OCD1um0ujPD11txA1wHb+BN8R/LKcSUj/4EYMLEW1ph4s3qukXwpnVwVW1eB1+/K0MNV57D4c7nZThSE1p6a4XbznXcdq7hdnMdt53ruO1c4+ntpna5mnaPMHnyZIwZMwbdunVDr169sGjRImRmZmLcuHEAzCfHZ8+exbJly+Dn54fExES7+aOiohAcHGw3/Nlnn0W/fv0wb948DBkyBN9//z1+/vlnbNmypVrXjYiItBMbG4uEhAS7Yddffz1Wr14NAIiJiQFg7gc9NjbWOk1135nh6624Aa6DN9A6/lKDEZNW7keJwYTeLRvg2VvbQu8nf/FDitbr4A61cR18fX3VcOU5HJ54XoYjNaGlt1a47VzHbecabjfXcdu5jtvONZ7abmrvVtI0aTty5EhcunQJs2bNQlZWFhITE7Fu3TrExcUBALKyspCZmenUMnv37o2vv/4a//nPfzBt2jS0bNkSK1asQM+ePT2xCkRE5IX69OmDI0eO2A37559/rMeX+Ph4xMTEIC0tDUlJSQDMrak2bdqEefPmVXu8RL5s5pq/ceT8FTSsG4SUf3V2OmFL5AucuTPDnc/LcKQmtPTWCred67jtXMPt5jpuO9dx27nG09tN7d1Kmj+IbMKECZgwYYLkuKVLlyrOO2PGDMyYMaPS8GHDhmHYsGFuiI6IiHzRc889h969e2POnDkYMWIEduzYgUWLFmHRokUAzCffkyZNwpw5c9C6dWu0bt0ac+bMQWhoKEaNGqVx9ES+4/s9Z/HVjtPQ6YCUkZ0RFRasdUhEbuXsczgAzzwvw5Ga0NJbK9x2ruO2cw23m+u47VzHbecaT203tcv0c/snExERaax79+747rvv8NVXXyExMRGzZ89GSkoKHnjgAes0L774IiZNmoQJEyagW7duOHv2LFJTUxEWFqZh5ES+48SFQrzyrfl5A0/f3Ao3tm6ocURE7mf7HA5baWlpfGYGEREReZTmLW2JiIg84a677sJdd90lO16n08nesUFEykoNRjz95W4UlRvRIz4Szw5orXVIRB7j6DkcRERERJ7ApC0REREROeX1tYdwMKsAkXUC8d6/kuCv581bVHM5eg4HERERkScwaUtEREREqq3bn4Xlf54CAMwf0QkxEezHlmo+pedwEBEREXkCm0UQERERkSqnLhXhpVX7AADjb2qJm9pGaRwREREREVHNxKQtERERETlUVmHux/ZKWQW6xtXH5IFttA6JiIiIiKjGYtKWiIiIiBx646fD2H82H/VCA/D+/UkIYD+2REREREQew7xbAfYAAIFXSURBVNo2ERERESna8Hc2lvxxEgDwzvBOaFQvRNuAiIiIiIhqOCZtiYiIiEjW6dxi/PubvQCAx/vGY8D10RpHRERERERU8zFpS0RERESSDEYTJn61GwWlFejUtB7+fVs7rUMiIiIiIqoVnE7anj59GmfOnLG+37FjByZNmoRFixa5NTAiIiIi0tZbG45gz+nLCA/2xwf3JyHQn9f7iYiIiIiqg9M171GjRuG3334DAGRnZ2PgwIHYsWMHXnnlFcyaNcvtARIRERFR9fv18Hks+v0EAOCt4Z3QNDJU44iIiIiIiGoPp5O2Bw4cQI8ePQAAK1euRGJiIrZu3Yovv/wSS5cudXd8RERERFTNzl0uweSV5n5sx/Zujtvax2gcERERERFR7eJ00tZgMCAoKAgA8PPPP2Pw4MEAgHbt2iErK8u90RERERFRtaowmvDMV7txudiADo0j8PId7MeWiIiIiKi6OZ20bd++PT766CNs3rwZaWlpGDRoEADg3LlzaNCggdsDJCKi2uP8+fMYM2YMGjVqBH9/f+j1ers/IvK8+Wn/YOepPIQF+eODUUkI8mfZIyIiIiKqbv7OzjBv3jzce++9eOutt/DQQw+hU6dOAIAffvjB2m0CERGRK8aOHYvMzExMmzYNsbGx0Ol0WodEVKts+ucCFmw8DgB4476OiGtQR+OIiIiIiIhqJ6eTtjfddBMuXryIgoIC1K9f3zr8iSeeQGgoH1BBRESu27JlCzZv3ozOnTtrHQpRrXO+oBSTV+wBAIy+oRnu7BirbUBERERERLWY00lbANDr9XYJWwBo3ry5O+IhIqJarGnTphAEQeswiGodo0nAs1/vxqWiclwfG47/3JmgdUhERERERLWa033aXrp0CU899RQSEhLQsGFDREZG2v0RERG5KiUlBVOmTMHJkye1DoWoVvnvL0fx54lc1AnU48NRSQgOYD+2RERERERacrql7ejRo3H8+HE8+uijiI6OZn+DRETkNiNHjkRxcTFatmyJ0NBQBAQE2I3Pzc3VKDKimuuPYxfx/q9HAQBzhnZAi+vqahwRERERERE5nbTdsmULtmzZYn0AGRERkbukpKRoHQJRrXLhShme/XoPBAH4V/emGNK5sdYhERERERERXEjatmvXDiUlJZ6IhYiIarmHHnpI6xCIag2jScBzK/bgYmEZ2kaHYfrd7bUOiYiIiIiIrnI6abtgwQJMmTIFr776KhITEyvduhoeHu624IiIqPYxGo343//+h0OHDkGn0yEhIQGDBw+GXs8+NoncacFvx7Dl2EWEBOjx4QNJCAlkGSNt/f3332jfXvriwfr16zFo0KBqjoiIiIhIO04nbevVq4f8/HzccsstdsMFQYBOp4PRaHRbcEREVLscO3YMd9xxB86ePYu2bdtCEAT8888/aNq0KdauXYuWLVtqHSJRjfDniUt49+d/AACz70lEq6gwjSMiArp164Y333wTEydOtA4rKyvD888/j8WLF/NuPyIiIqpVnE7aPvDAAwgMDMSXX37JB5EREZFbPfPMM2jZsiX+/PNPREZGAgAuXbqE0aNH45lnnsHatWs1jpDI910qLMOzX++GSQDu69IEw7o20TokIgDAF198gSeeeALr1q3DkiVLkJ2djVGjRgEA/vjjD42jIyIiIqpeTidtDxw4gN27d6Nt27aeiIeIajGj0QiDwaB1GFYGgwH+/v4oLS31ybsIlOIPCAjwyu4GNm3aZJewBYAGDRrgjTfeQJ8+fTSMjKhmMJkETF65F+cLytDyujqYfQ/7sSXvMXToUNxwww146KGHkJiYiKKiIjz88MN45513EBISonV4RERERNXK6aRtt27dcPr0aSZtichtBEFAdnY2Ll++rHUodgRBQExMDE6fPu2TdxU4ir9evXqIiYnxqnULCgrClStXKg0vLCxEYGCgBhER1Swf/34Cm/65gCB/P3z4QBeEBjpdFSTyKKPRiPLychiNRhiNRsTExCAoKEjrsIiIiIiqndM19YkTJ+LZZ5/Fv//9b3To0KHSg8g6duzotuCIqHawJGyjoqIQGhrqNUlEk8mEwsJC1K1bF35+flqH4zS5+AVBQHFxMXJycgAAsbGxWoVYyV133YUnnngCixcvRo8ePQAA27dvx7hx4zB48GCNoyPybTtP5uLt1CMAgJmD26NdDB8eS97l66+/xvjx49G3b1/8888/2LNnDx5++GFs2LABy5cvR4sWLbQOkYiIiKjaOJ20HTlyJADgkUcesQ7T6XR8EBkRucRoNFoTtg0aNNA6HDsmkwnl5eUIDg722aStXPyW20xzcnIQFRXlNV0lvPfee3jooYfQq1cv60XBiooKDB48GP/97381jo7Id+UVleOZr3bDaBIwpHMjjOzeVOuQiCp59NFH8fbbb2P8+PEAgIEDB2L//v148skn0blzZxQUFGgcIREREVH1cTppm5GR4Yk4iKiWsvRhGxoaqnEktY9lmxsMBq9J2tarVw/ff/89jh49isOHD0MQBCQkJKBVq1Zah0bkswRBwL9X7cW5/FLEN6yD1+/t4DV3NBDZ2rVrV6Uu2OrXr4+VK1di+fLlGkVFREREpA3VSdtXXnkF99xzj/V2VSIid2ICofp58zZv3bo1WrdurXUYRDXC4i0Z+PlQDgL9/fDBqCTUDWI/tuSdlJ6ZMWbMmGqMhIiIiEh7qmvtWVlZuOuuu6DX63H33XdjyJAhuPXWW/lgACIiqpLJkydj9uzZqFOnDiZPnqw47fz586spKqKaYXdmHt746TAAYNpdCWjfKELjiIiUnTlzBj/88AMyMzNRXl5uN47HACIiIqpNVCdtlyxZAkEQsGXLFqxZswbPP/88zp49i4EDB2Lw4MG466670LBhQ0/GSkQky2gSsCMjFzlXShEVFowe8ZHQ+2nXknTjxo24+eabkZeXh3r16mkWhy/YvXu3tZuM3bt3axwNUc2RX2zA01/uRoVJwJ0dYjG6ZzOtQyJS9Msvv2Dw4MGIj4/HkSNHkJiYiJMnT0IQBHTp0kXr8IiIiIiqlVP3x+l0OvTt2xd9+/bFm2++iUOHDmHNmjX45JNP8OSTT6Jnz54YPHgw7r//fjRu3NhTMRMR2Vl/IAsz1xxEVn6pdVhsRDCm352AQYmxHv3srVu3om/fvhg4cCDWr1/v0c+qqX777TfJ10TkOkEQ8OLqvTh7uQTNIkMx9z72Y0ve7+WXX8bzzz+PWbNmISwsDKtXr0ZUVBQeeOABDBo0SOvwiIiIiKpVlR6Hfv311+PFF1/EH3/8gdOnT+Ohhx7C5s2b8dVXX7krPiIiResPZGH857vsErYAkJ1fivGf78L6A1ke/fxPP/0UEydOxJYtW5CZmenRz6oNHnnkEVy5cqXS8KKiIjzyyCMaRETkmz7behIb/j6PAL0OH4xKQnhwgNYhETl06NAhPPTQQwAAf39/lJSUoG7dupg1axbmzZuncXRERERE1atKSVtbUVFRePTRR/H999/jhRdeUD3fggULEB8fj+DgYHTt2hWbN2+WnXbLli3o06cPGjRogJCQELRr1w7vvvuu3TRLly6FTqer9FdaWiqzVCLyJoIgoLi8QtXflVIDpv/wNwSp5Vz9P+OHg7hSalC1PEGQWpK8oqIirFy5EuPHj8ddd92FpUuXKk6/evVqtG/fHkFBQWjevDneeecdu/HNmzfHnDlz8MgjjyAsLAzNmjXDokWL7KbZunUrOnfujODgYHTr1g3/+9//oNPpsGfPHqdi91afffYZSkpKKg0vKSnBsmXLNIiIyPfsP5OPOevM/di+csf16NiknrYBEalUp04dlJWVAQAaNWqE48ePW8ddvHhRq7CIiIiINOH044NLS0vx/vvv47fffkNOTg5MJpPd+F27dqle1ooVKzBp0iQsWLAAffr0wccff4zbb78dBw8eRLNmlftdq1OnDp5++ml07NgRderUwZYtW/Dkk0+iTp06eOKJJ6zThYeH48iRI3bzBgcHO7mmRKSFEoMRCa9ucMuyBADZBaXoMCNV1fQHZ92G0ED1u8UVK1agbdu2aNu2LUaPHo2JEydi2rRpkrcgp6enY8SIEZgxYwZGjhyJrVu3YsKECWjQoAHGjh1rne6dd97B7Nmz8corr2DVqlUYP348+vXrh3bt2uHKlSu4++67cccdd+DLL7/EqVOnMGnSJNXxerOCggIIggBBEHDlyhW7fbbRaMS6desQFRWlYYREvqGg1ICnvtyFcqMJt7WPxtjezbUOiUi1G264AX/88QcSEhJw55134vnnn8f+/fvx7bff4oYbbtA6PCIiIqJq5XTS9pFHHkFaWhqGDRuGHj16VKl/tPnz5+PRRx/FY489BgBISUnBhg0bsHDhQsydO7fS9ElJSUhKSrK+b968Ob799lts3rzZLmmr0+kQExPjclxERGosXrwYo0ePBgAMGjQIhYWF+OWXX3DrrbdWmnb+/PkYMGAApk2bBgBo06YNDh48iLfeessuaXvHHXdgwoQJAICXXnoJ7777LjZu3Ih27drhiy++gE6nwyeffILg4GAkJCTg7NmzePzxxz2/sh5Wr149650Rbdq0qTRep9Nh5syZGkRG5DsEQcDL3+5HZm4xGtcLwZv3dWI/tuRT5s+fj8LCQgDAjBkzUFhYiBUrVqBVq1aV7q4jIiIiqumcTtquXbsW69atQ58+far0weXl5UhPT8eUKVPshicnJ2Pr1q2qlrF7925s3boVr732mt3wwsJCxMXFwWg0onPnzpg9e7ZdslesrKzMeisWYG7xBQAGg8H6RHO1LNM7O5838fV18PX4gdq1DgaDAYIgwGQywWQyIUivw4EZA1V9xo6MXDzyWbrD6T59qCt6xEc6nC5Ir7O7e8DSXYIlPltHjhzBjh07sGrVKphMJvj5+WHEiBFYvHgxbrnlFuv0lvU6dOgQBg8ebLecXr16ISUlBQaDAXq9HgDQoUMHu2liYmJw/vx5mEwmHD58GB07dkRgYKB1mm7dutl9ji2l+C3zCIJg9/kW1f3b++233yAIAm655RasXr0akZHXvq/AwEDExcWhUaNG1RoTka/5Ynsm1u7Lgr+fuR/biFD2Y0u+pUWLFtbXoaGhWLBggcc+6+TJk5g9ezZ+/fVXZGdno1GjRhg9ejSmTp2KwMBA63SZmZl46qmn8OuvvyIkJASjRo3C22+/bTcNERERkSc4nbRt3LgxwsLCqvzBFy9ehNFoRHR0tN3w6OhoZGdnK87bpEkTXLhwARUVFZgxY4a1pS4AtGvXDkuXLkWHDh1QUFCA//73v+jTpw/27t2L1q1bSy5v7ty5ki24UlNTERoa6sLaAWlpaS7N5018fR18PX6gdqyDv78/YmJiUFhYiPLycqeW3Sk6CNFhgci5Ui7Zr60OQFRYIDpFB6GitNjh8q7IdH0t9WCshQsXoqKiAk2bNrUOEwQBAQEByMzMRHFxsXVePz8/VFRUoLy83HpRCIB1moKCAuj1ephMJhiNRrtpTCYTSkpKUFBQgLKyskrjLbEVFRXZDXcUP2C+eFZSUoLff/8dFRUVduMssVWX/v37AwAyMjLQtGlT+Pm5rct1olrh73P5mPXjQQDAS4PaIalZfY0jIqqawsLCShccw8PD3bb8w4cPw2Qy4eOPP0arVq1w4MABPP744ygqKsLbb78NwNw9z5133onrrrsOW7ZswaVLl/DQQw9BEAS8//77bouFiIiISIrTSdt33nkHL730Ej766CPExcVVOQDxbXuCIDi8lW/z5s0oLCzEn3/+iSlTpqBVq1a4//77AZj7wrLt86pPnz7o0qUL3n//fbz33nuSy3v55ZcxefJk6/uCggI0bdoUycnJTlcODQYD0tLSMHDgQAQE+GYLF19fB1+PH6hd61BaWorTp0+jbt26LvU9Pf3u9njqy93QAXaJW53N+Pr1IpxeLgBr/6phYWF2+6WKigqsXLkSb7/9NgYOtG8VPHz4cKxZswbt27cHAISFhSE8PByJiYn466+/7PYpe/bsQZs2bVC/vjm54ufnh+DgYLtp9Ho9goKCEB4ejg4dOmDVqlUICgpCUFAQAPNJJ2Du81u8v5KL36K0tBQhISHo169fpW0vlwD2NMtxpbi4GJmZmZUS+R07dtQiLCKvYzQJ2J6Ri/SLOoQeuYA5Px1BeYUJA9pF4bG+8VqHR+SSjIwMPP3009i4caPdQ4Qt5wdGo9FtnzVo0CAMGjTI+r5FixY4cuQIFi5caE3apqam4uDBgzh9+rT1bo933nkHY8eOxeuvv+7WJDIRERGRmNNJ227duqG0tBQtWrRAaGhopWRMbm6uquU0bNgQer2+UqvanJycSq1vxeLjzScjHTp0wPnz5zFjxgxr0lbMz88P3bt3x9GjR2WXZ5sAsRUQEOBywqwq83oLX18HX48fqB3rYDQaodPp4Ofn51Lryjs6NsJCPx1mrjmIrPxrJ3gxEcGYfncCBiXGuhQ3AGsLH0t8FuvWrUNeXh4ee+wxRETYJ4SHDRuGTz/91Nr3nmW9XnjhBXTv3h2vv/46Ro4ciW3btuHDDz/EggUL7JYt/izbYaNHj8a0adMwbtw4TJkyBZmZmZg/fz4Ac3JXPJ9c/BZ+fn7Q6XSS35FWv7sLFy7g4Ycfxk8//SQ53tUT9rlz5+KVV17Bs88+i5SUFADA2LFj8dlnn9lN17NnT/z5558ufQZRdVl/IMtmn6fHsqO7AQD1QwPw9nD2Y0u+64EHHgAAfPrpp4iOjq7233J+fr5d9zzbtm1DYmKiXfc8t912G8rKypCeno6bb75Zcjnu7HrNkZrQpZZWuO1cx23nGm4313HbuY7bzjWe3m5ql+t00vb+++/H2bNnMWfOnCpVpgIDA9G1a1ekpaXh3nvvtQ5PS0vDkCFDVC9HEAS7SpHU+D179qBDhw4uxUlE3m9QYiwGJsRgR0Yucq6UIiosGD3iI6H388zJ3uLFi3HrrbdWStgCwH333Yc5c+Zg165ddsO7dOmClStX4tVXX8Xs2bMRGxuLWbNm2T2EzJHw8HCsWbMG48ePR+fOndGhQwe8+uqrGDVqlEutlL3RpEmTkJeXhz///BM333wzvvvuO5w/fx6vvfYa3nnnHZeW+ddff2HRokWSrXQHDRqEJUuWWN+zj0LydusPZGH857sku4TJKzZge8alKl2sItLSvn37kJ6ejrZt21b7Zx8/fhzvv/++3bEmOzu7UmOS+vXrIzAwULE7N090veZITehSSyvcdq7jtnMNt5vruO1cx23nGk9tN7XdETqdtN26dSu2bduGTp06OR2U2OTJkzFmzBh069YNvXr1wqJFi5CZmYlx48YBMHdbcPbsWSxbtgwA8OGHH6JZs2Zo164dAGDLli14++23MXHiROsyZ86ciRtuuAGtW7dGQUEB3nvvPezZswcffvhhleMlIu+l99OhV8sG1fJZa9askR3XpUsX6wPAbLtdAcwJ3fvuu0923pMnT1YatmfPHrv3vXv3xt69e63vv/jiCwQEBKBZs2YqIvd+v/76K77//nt0794dfn5+iIuLw8CBAxEeHo65c+fizjvvdGp5hYWFeOCBB/DJJ59UemglYL7TIiYmxl3hE3mU0SRg5pqDkglbwNwtzMw1BzEwIcZjF62IPKl79+44ffp0lZK2M2bMkEyY2vrrr7+sD/IEgHPnzmHQoEEYPny43bMygMpduQGOu3NzZ9drjtSELrW0wm3nOm4713C7uY7bznXcdq7x9HZT2x2h00nbdu3aoaSkxOmApIwcORKXLl3CrFmzkJWVhcTERKxbt87ap2FWVhYyMzOt05tMJrz88svIyMiAv78/WrZsiTfeeANPPvmkdZrLly/jiSeeQHZ2NiIiIpCUlITff/8dPXr0cEvMRERaWrZsGVq0aIHGjRtj7969eOmllzBixAiEhIRoHZpbFBUVISoqCgAQGRmJCxcuoE2bNujQoUOl1stqPPXUU7jzzjtx6623SiZtN27ciKioKNSrVw/9+/fH66+/bv18Ke665bUm3KbEdah+2zNy7bqBERMAZOWXYtuxHPSMj5Sdzpv42ncgpTavg7vX+f/+7/8wbtw4nD17FomJiZVOktT0a/7000/jX//6l+I0zZs3t74+d+4cbr75ZmsDElsxMTHYvn273bC8vDwYDAbF7tw80fWaIzWhSy2tcNu5jtvONdxuruO2cx23nWs8td3ULtPppO0bb7yB559/Hq+//jo6dOhQ6YOcvXo8YcIETJgwQXLc0qVL7d5PnDjRrlWtlHfffdfalyQRUU2TnZ2NV199FdnZ2YiNjcXw4cPx+uuvax2W27Rt2xZHjhxB8+bN0blzZ3z88cdo3rw5PvroI8TGOnfL99dff41du3bhr7/+khx/++23Y/jw4YiLi0NGRgamTZuGW265Benp6ZIn24D7b3mtCbcpcR2qT/pFHQC9w+lSN2/HpUNy7XG9k698B0pq4zqovbVPrQsXLuD48eN4+OGHrcN0Op1TDyJr2LAhGjZsqOrzzp49i5tvvhldu3bFkiVLKvX/3qtXL7z++uvIysqyHoNSU1MRFBSErl27OrFmRERERM5zOmlrecrqgAED7IZ74qmuRERk78UXX8SLL76odRgeM2nSJGRlZQEApk+fjttuuw1ffPEFAgMDK13IU3L69Gk8++yzSE1Nle3vd+TIkdbXiYmJ6NatG+Li4rB27VoMHTpUch533fJaE25T4jpUvwYZuVh2dKfD6ZL79vSplra+9B1Iqc3roPbWPrUeeeQRJCUl4auvvvL4g8jOnTuHm266Cc2aNcPbb7+NCxcuWMdZus1JTk5GQkICxowZg7feegu5ubl44YUX8Pjjj7u9mwMiIiIiMaeTtr/99psn4iAiIrI+ORwAkpKScPLkSRw+fBjNmjVT3XIKANLT05GTk2PXEspoNOL333/HBx98gLKyMuj19i0WY2NjERcXh6NHj8ou1923vNaE25S4DtWnV6soXBcWhAtXpB/AqgMQExGMXq2ifK5PW1/5DpTUxnVw9/qeOnUKP/zwA1q1auXW5UpJTU3FsWPHcOzYMTRp0sRunKVver1ej7Vr12LChAno06cPQkJCMGrUKLz99tsej4+IiIjI6aRt//79PREHERERZs2ahRdeeMHa1UBoaCi6dOmCkpISzJo1C6+++qqq5QwYMAD79++3G/bwww+jXbt2eOmllyolbAHg0qVLOH36tNPdMBBVF0EQEB7sL5m0taRop9+d4HMJWyKLW265BXv37q2WpO3YsWMxduxYh9M1a9YMP/74o8fjISIiIhJzOmkLAKWlpdi3bx9ycnJgMpnsxg0ePNgtgRERUe0zc+ZMjBs3rlL/sMXFxZg5c6bqpG1YWBgSExPthtWpUwcNGjRAYmIiCgsLMWPGDNx3332IjY3FyZMn8corr6Bhw4a499573bY+RO70/q/HcPxCEYL9/RAWHIALhdeStzERwZh+dwIGJfKiA/muu+++G8899xz2798v+ewMnmcQERFRbeJ00nb9+vV48MEHcfHixUrj2KctERFVhaV/dLG9e/ciMtJ9fXTq9Xrs378fy5Ytw+XLlxEbG4ubb74ZK1asQFhYmNs+h8hddmTk4v1fzV13zBvWEXd1bIRtx3KQunk7kvv29MkuEYjExo0bB8B814UYzzOIiIiotnE6afv0009j+PDhePXVVxEdHe2JmIiIqJapX78+dDoddDod2rRpY5e4NRqNKCwstJ7Mu2rjxo3W1yEhIdiwYUOVlkdUXS4Xl2PS17thEoBhXZtgSOfGAICe8ZG4dEhAz/hIJmypRhDfwUdERERUmzmdtM3JycHkyZOZsCUiIrdJSUmBIAh45JFHMHPmTERERFjHBQYGonnz5ujVq5eGERJpQxAETFm9H+fySxHfsA5mDm6vdUhEbjdq1Cjcc889uP3223m3AxEREdFVTidthw0bho0bN6Jly5aeiIeIyDUmI3BqK1B4HqgbDcT1BvwqP2yKvNNDDz0EAIiPj0fv3r19/gnsRO7y5Y5MrP87GwF6Hd6/Pwl1glx6HAGRV2vbti3mzZuHBx98EP369cOQIUMwePBgNG3aVOvQiIiIiDTjdM3/gw8+wPDhw7F582bJBwQ888wzbguOiEiVgz8A618CCs5dGxbeCBg0D0jw7ENLtm7dir59+2LgwIFYv369Rz+rNujfvz9MJhP++ecfyYdd9uvXT6PIiKrfP+evYNaagwCAlwa1Q2LjCAdzEPmm6dOnY/r06Thz5gx++OEHfP/993j++eeRkJCAwYMHY8iQIUhKStI6TCIiIqJq5XTS9ssvv8SGDRsQEhKCjRs32vU7qNPpmLQloup18Adg5YMABPvhBVnm4SOWeTRx++mnn2LixIn4v//7P2RmZqJZs2YuLae8vByBgYFujs73/Pnnnxg1ahROnToFQbD/TvkQGqpNSg1GTPxyN8oqTLip7XV4pE+81iEReVyTJk0wYcIETJgwAVeuXMFPP/2E77//HgMGDEBYWBjuvvtujB8/Hu3bs5sQIiIiqvn8nJ3hP//5D2bNmoX8/HycPHkSGRkZ1r8TJ054IkYiqk0EASgvUvdXWgD89CIqJWzNCzL/W/+SeTo1yxOkliOvqKgIK1euxPjx43HXXXdh6dKlduN/+OEHdOvWDcHBwWjYsCGGDh1qHde8eXO89tprGDt2LCIiIvD4448DAFavXo327dsjKCgIzZs3xzvvvGO3zAULFqB169YIDg5GdHQ0hg0bZh23atUqdOjQASEhIWjQoAGSk5NRVFTk1Dppbdy4cejWrRsOHDiA3Nxc5OXlWf9yc3O1Do+o2ry+9hCOnL+ChnWD8PbwTvDjg8aolgkLC8OIESPwxRdf4MKFC/j000+h1+uxbds2rUMjIiIiqhZOt7QtLy/HyJEj4efndL6XiMgxQzEwp5GbFiaYu0x4Q2WfeK+cAwLrqF76ihUr0LZtW7Rt2xajR4/GxIkTMW3aNOh0OqxduxZDhw7F1KlTsXz5cpSXl2Pt2rV287/11luYNm0a/vOf/wAA0tPTMWLECMyYMQMjR47E1q1bMWHCBDRo0ABjx47Fzp078cwzz2D58uXo3bs3cnNzsXnzZgBAVlYW7r//frz55pu49957ceXKFfz++++VWqt6u6NHj2LVqlVo1aqV1qEQaWbD39lY/ucpAMC7IzuhYd0gjSMi0pZer8eAAQMwYMAArUMhIiIiqjZOJ20feughrFixAq+88oon4iEi8hmLFy/G6NGjAQCDBg1CYWEhfvnlF9x66614/fXX8a9//QszZ860Tt+pUye7+W+55Ra88MIL1vcPPPAABgwYgGnTpgEA2rRpg4MHD+Ktt97C2LFjkZmZiTp16uCuu+5CWFgY4uLirH38ZWVloaKiAkOHDkVcXBwAoH379igoKPDoNnC3nj174tixY0zaUq117nIJXly1DwDwZP8W6Nv6Oo0jIqo+58+fxwsvvIBffvkFOTk5lS48soscIiIiqk2cTtoajUa8+eab2LBhAzp27FjpQWTz5893W3BEVAsFhJpbvKpxaivwxTDH0z2wCojrre6zVTpy5Ah27NiBb7/9FgDg7++PkSNH4tNPP8Wtt96KPXv2WLs8kNOtWze794cOHcKQIUPshvXp0wcpKSkwGo0YOHAg4uLi0KJFCwwaNAiDBg3Cvffei9DQUHTq1AkDBgxAhw4dcNtttyE5ORlDhw6FXq9XvU7eYOLEiXj++eeRnZ0t+bDLjh07ahQZkecZTQImrdiD/BIDOjWJwPMD22odElG1slygnDZtGmJjY+2enUFERERU2zidtN2/f7+1ZdeBAwfsxrFiRURVptOp76Kg5S1AeCPzQ8ck+7XVmce3vAXwc2/ycvHixaioqEDjxo2twwRBQEBAAPLy8hASEuJwGXXq2K+nIAiV9qO2rYzCwsKwa9cubNy4EampqXj11VcxY8YM/PXXX6hXrx7S0tKwdetWpKam4v3338fUqVORlpaGDh06VHFtq899990HAHjkkUesw3Q6nXXbsJUV1WQf/nYMOzJyUTfIH+/dn4RAf3ZFRbXLli1bsHnzZnTu3FnrUIiIiIg053TS9rfffvNEHEREzvPTA4PmASsfBKCDfeL2avJz0BtuT9hWVFRg2bJleOedd5CcnGw37r777sMXX3yBjh074pdffsHDDz+serkJCQnYsmWL3bCtW7eiTZs21haz/v7+uPXWW3Hrrbdi+vTpqFevHn799VcMHToUOp0Offr0QZ8+ffDqq68iLi4OP/74o08lbTMyMrQOgUgTO0/mIuXnfwAAs+9pj7gG6vvXJqopmjZt6nN9sRMRERF5itNJWyIir5IwGBixDFj/kvmhYxbhjcwJ24TBbv/IH3/8EXl5eXj00UcRERFhN27YsGFYvHgx3n33XQwYMAAtW7bEv/71L1RUVOCnn37Ciy++KLvc559/Ht27d8fs2bMxcuRIbNu2DR988AEWLFhg/dwTJ06gX79+qF+/PtatWweTyYS2bdti+/bt+OWXX5CcnIyoqChs374dFy5cQJs2bdy+/p5k6Y+XqDbJLzbg2a/3wCQAQ5Ma496kJlqHRKSJlJQUTJkyBR9//DGaN2+udThEREREmmLSloh8X8JgoN2d5j5uC88DdaPNfdi6uYWtxeLFi3HrrbdWStgC5pa2c+bMQXh4OL755hvMnj0bb7zxBsLDw9GvXz/F5Xbp0gUrV67Eq6++itmzZyM2NhazZs3C2LFjAQD16tXDt99+ixkzZqC0tBStW7fGV199hfbt2+PQoUP4/fffkZKSgoKCAsTFxeHtt9/GwIEDPbEJPGr58uX46KOPkJGRgW3btiEuLg4pKSmIj4+v1Ocvka8TBAFTvt2Hs5dL0LxBKGbdk6h1SESaGTlyJIqLi9GyZUuEhoZW6tc8NzdXo8iIiIiIqh+TtkRUM/jpgfi+1fJRa9askR3XpUsX662dXbp0wdChQyWnO3nypOTw++67z9qvq9iNN96IjRs3So67/vrrsX79erthJpMJBQUFsrF6o4ULF+LVV1/FpEmT8Prrr1v7sK1Xrx5SUlKYtKUa5+u/TuOnA9nw99PhvfuTUDeIVTOqvVJSUrQOgYiIiMhr8MyAiIi8xvvvv49PPvkE99xzD9544w3r8G7duuGFF17QMDIi9zt6/gpmrvkbAPDioLbo2KSetgERaeyhhx7SOgQiIiIir8GkLREReY2MjAwkJSVVGh4UFISioiINIiLyjFKDERO/2o1Sgwl9WzfEYze20DokIk0UFBQgPDzc+lqJZToiIiKi2sCtSdvff/8dnTp1kuznkYiIyJH4+Hjs2bOn0gPJfvrpJyQkJGgUFZH7zV13CIezr6Bh3UC8M6IT/Px0WodEpIn69esjKysLUVFRqFevHnS6ymVBEATodDprlzlEREREtYFbk7Y33XQT6tevj1deeQXPP/+8OxdNRES1wL///W889dRTKC0thSAI2LFjB7766ivMnTsX//d//6d1eERukXbwPD7bdgoA8PbwTogKC9Y4IiLt/Prrr4iMjAQA/PbbbxpHQ0REROQ93Jq0zcjIQEZGBjZs2ODOxRJRLWB5eBdVH2/c5g8//DAqKirw4v+3d9/hUVT7H8ffu5tkkwChGFNQCF2I9EQwFMFCABGwIKiX4qVcERvys4B6r+BVQSmiV+GKDREFVOy0xCtVUKmKgqCCBDEQKRogkGx25/fHJgshfUkyu8nn9Tz7bHbmzOz3nElyZr975sxDD5GRkcFtt93GRRddxPPPP88tt9xidngi5+3gX6d58P1vARjVtSHdL4kwOSIRc3Xr1i3Pz6dPn+a7774jLS0Nl8tlYmQiIiIi5ipx0jY7O5uAgKKLx8TEEBMTQ/fu3c83LhGpIgIDAwHIyMggJCTE5GiqloyMDODMMfAVo0aNYtSoURw+fBiXy0VEhJJaUjk4XQZjF23lzwwHrS6qyYM9m5sdkohPWb58OUOHDuXw4cP51ml6BBEREalqSpy0jY6OZtiwYYwYMYIWLVqUZ0wiUoXYbDZq1apFWloaAKGhoQXOZ2cGl8tFVlYWp0+fxmq1mh1OqRUWv2EYZGRkkJaWRq1atbDZbCZGWbjw8HCzQxApU7NX/cxXe44SGmTjhVvbERTgf/9XRMrT3Xffzc0338y//vUvIiMjzQ5HRERExFQlTtqOGzeOuXPn8txzz9GhQwdGjhzJoEGDqF69ennGJyJVQFRUFIAncesrDMPg1KlThISE+EwiuTSKi79WrVqetjdT+/bt+d///kft2rVp165dkW29ZcuWCoxMpOxs3neU5z7/CYB/929Jw/BqJkck4nvS0tIYN26cErYiIiIilCJpO2HCBCZMmMDatWt5/fXXGTt2LGPHjmXAgAGMHDmSzp07l2ecIlKJWSwWoqOjiYiIwOFwmB2Oh8PhYM2aNVxxxRU+N4VASRQVf2BgoM+MsO3fvz92ux2A66+/3txgRMrBX6cc3LtgG06XwfVt63Jj+4vMDknEJw0YMIBVq1bRuHFjs0MRERERMV2pb0TWtWtXunbtyosvvsjChQuZO3cuXbt2pWnTpowYMYKHHnqoPOIUkSrAZrP5TCIR3PFkZ2cTHBzsl0lbf4n/8ccfB8DpdNK9e3dat25N7dq1TY5KpGwYhsEjH2znwJ+nqF8nlH9f39IvR+6LVIQXX3yRm2++mbVr19KqVat8fde9995rUmQiIiIiFa/USdtc1apVY8SIEYwYMYIlS5YwdOhQJkyYoKStiIh4xWaz0bNnT3bu3KmkrVQa727az5LtqQRYLbxwaztqBPvuFygiZnvnnXdYsWIFISEhrFq1Ks8XHBaLRUlbERERqVK8TtpmZGSwaNEi3njjDb788ksaN27Mgw8+WJaxiYhIFdOqVSv27NlDw4YNzQ5F5Lz9nHaciZ/sAOCBnpfQtl4tcwMS8XGPPfYYTzzxBOPHj/fLG4CKiIiIlKVSnw2tXbuW4cOHExUVxd13303Dhg1ZuXIlu3fvZvz48eURo4iIVBFPPfUUDzzwAJ999hmpqamkp6fneYj4i9MOJ/cs2MYph5MuTcL5R9dGZock4vOysrIYNGiQErYiIiIilGKk7dNPP83cuXP55ZdfiI+PZ+rUqdx6662EhYWVZ3wiIlKF9OrVC4B+/frluSzWMAwsFgtOp9Os0ERKZcqyH9mZms4F1YKYMbANVqvmsRUpzrBhw1i0aBGPPPKI2aGIiIiImK7ESdvnnnuOwYMHM2LECFq2bFmeMYmISBW1cuVKs0MQOW+f7zjE3PW/AjDt5jZEhAWbG5CIn3A6nTz77LOsWLGC1q1b57sR2YwZM0yKTERERKTilThp+/vvv/v03cdFRMT/devWjT///JPXXnuNnTt3YrFYaNGiBSNGjKBmzZpmhydSrEPpp3nw/W8BGNGlIVc2jzA5IhH/sX37dtq1awfA999/n2fd2VdfiIiIiFQFJZ4wau3atcTGxhY4p+Bff/3FpZdeytq1a0sdwKxZs2jYsCHBwcHExcUVuY9169bRuXNnLrjgAkJCQmjevDnPPfdcvnKLFy8mNjYWu91ObGwsH374YanjEhGRirdp0yaaNGnCc889x9GjRzl8+DDPPfccjRs3ZsuWLWaHJ1Ikp8tg7MJtHMtwcGndMB7qdYnZIYn4lZUrVxb6+OKLL8wOT0RERKRClThpO3PmTEaNGlXgHLY1a9bkjjvuKPUlS4sWLWLs2LE8+uijbN26la5du9K7d29SUlIKLF+tWjXuvvtu1qxZw86dO3nsscd47LHHmDNnjqfMhg0bGDRoEEOGDOHbb79lyJAhDBw4kK+//rpUsYmISMW7//776du3L7/++isffPABH374IXv37uW6665j7NixZocnUqT/rv6FDXuOEBpk4z+3tsMeYDM7JBERERER8VMlTtp+++23nhvEFCQxMZHNmzeX6s1nzJjBiBEjGDlyJC1atGDmzJnUq1eP2bNnF1i+Xbt23HrrrVx66aU0aNCAwYMH07Nnzzyjc2fOnEmPHj2YMGECzZs3Z8KECVx99dXMnDmzVLGJiEjF27RpEw8//DABAWdm7wkICOChhx5i06ZNJkYmUrQtKceYkbwbgEn9LqXRhdVNjkhESiozM5O2bdtisVjYtm1bnnUpKSn07duXatWqER4ezr333ktWVpY5gYqIiEiVUuI5bQ8dOlTknLYBAQH88ccfJX7jrKwsNm/ezPjx4/MsT0xMZP369SXax9atW1m/fj1PPvmkZ9mGDRu4//7785Tr2bNnkUnbzMxMMjMzPa9zp4BwOBw4HI4SxZIrt3xpt/Ml/l4Hf48fVAdf4e91OJ/4zapzWFgYKSkpNG/ePM/y/fv3U6NGDVNiEilO+mkH9y7YitNl0K9NXQbEXWx2SCJSCg899BB169bl22+/zbPc6XTSp08fLrzwQtatW8eRI0cYNmwYhmHwn//8x6RoRUREpKoocdL2oosuYvv27TRp0qTA9d999x3R0dElfuPDhw/jdDqJjIzMszwyMpKDBw8Wue3FF1/MH3/8QXZ2NhMnTmTkyJGedQcPHiz1PidPnsykSZPyLU9KSiI0NLQk1cknOTnZq+18ib/Xwd/jB9XBV/h7HbyJPyMjoxwiKd6gQYMYMWIE06ZNo1OnTlgsFtatW8eDDz7IrbfeakpMIkUxDINHPtjOb8dOUa9OCE/e0FI3TBLxI8uWLSMpKYnFixezbNmyPOuSkpLYsWMH+/fvp27dugBMnz6d22+/naeeeqrAaeNEREREykqJk7bXXnst//rXv+jduzfBwcF51p06dYrHH3+c6667rtQBnPvBxjCMYj/srF27lhMnTvDVV18xfvx4mjRpkufDfGn3OWHCBMaNG+d5nZ6eTr169UhMTCz1yZjD4SA5OZkePXoUOTLZl/l7Hfw9flAdfIW/1+F84i/oppMVYdq0aVgsFoYOHUp2djYAgYGB3HnnnUyZMsWUmESK8t7m3/jsu1QCrBZeuKUdYcH+979CpKo6dOgQo0aN4qOPPipwoMaGDRto2bKlJ2EL7iv4MjMz2bx5M1deeWWB+y3Lq/iK4+9XBZlJbec9tZ131G7eU9t5T23nnfJut5Lut8RJ28cee4wPPviAZs2acffdd3PJJZdgsVjYuXMnL730Ek6nk0cffbTEAYaHh2Oz2fKNgE1LS8s3UvZcDRs2BKBVq1YcOnSIiRMnepK2UVFRpd6n3W7HbrfnWx4YGOh1ouZ8tvUV/l4Hf48fVAdf4e918CZ+s+obFBTE888/z+TJk/nll18wDIMmTZp4fdWDSHn65Y8TPP7xDwCMS2xGu/q1TY5IRErKMAxuv/12Ro8eTXx8PL/++mu+MgVdwVe7dm2CgoIq/Cq+4vj7VUFmUtt5T23nHbWb99R23lPbeae82q2kV7aWOGkbGRnJ+vXrufPOO5kwYQKGYQDuUa09e/Zk1qxZxSZbzxYUFERcXBzJycnccMMNnuXJycn079+/xPsxDCPPN9kJCQkkJyfnmdc2KSmJTp06lXifIiJirtDQUFq1amV2GCKFysx2cs87WznlcNK5yQWMvqKx2SGJCDBx4sQCE6Zn27hxI+vXryc9PZ0JEyYUWbagq/Uq8iq+4vj7VUFmUtt5T23nHbWb99R23lPbeae8262kV7aWOGkLEBMTw9KlSzl27Bg///wzhmHQtGlTatf2bmTJuHHjGDJkCPHx8SQkJDBnzhxSUlIYPXo04D7hOXDgAPPmzQPgpZdeon79+p4b1Kxbt45p06Zxzz33ePZ53333ccUVV/DMM8/Qv39/Pv74Yz7//HPWrVvnVYwiIiIi53pm2S52pKZTp1oQMwa2xWrVPLYivuDuu+/mlltuKbJMgwYNePLJJ/nqq6/yXW0XHx/P3/72N958802ioqL4+uuv86w/duwYDoejwq/iK46/XxVkJrWd99R23lG7eU9t5z21nXfKq91Kus9SJW1z1a5dm8suu8ybTfMYNGgQR44c4YknniA1NZWWLVuydOlSYmJiAEhNTSUlJcVT3uVyMWHCBPbu3UtAQACNGzdmypQp3HHHHZ4ynTp1YuHChTz22GP885//pHHjxixatIiOHTued7wiFcLlxLJvHRcd3YBlXxg0ugKsNrOjEhGRHF/8eIjXv9wLwLSbWxMZFlzMFiJSUcLDwwkPDy+23AsvvMCTTz7pef3777/Ts2fPPJ8bEhISeOqpp0hNTfXccDkpKQm73U5cXFz5VEBEREQkh1dJ27I0ZswYxowZU+C6uXPn5nl9zz335BlVW5gBAwYwYMCAsghPpGLt+ASWP0xA+u/EA+ybDWF1odczENvP7OhERKq8tPTTPPDedwD8vXMDrmpe8qmhRMR31K9fP8/r6tWrA9C4cWMuvvhiABITE4mNjWXIkCFMnTqVo0eP8sADDzBq1Kgyn+ZARERE5FxWswMQkRw7PoF3h0L673mXp6e6l+/4xJy4RPzQ7Nmzad26NWFhYYSFhZGQkMCyZcs86w3DYOLEidStW5eQkBC6d+/ODz/8YGLE4g9cLoP7393G0ZNZxEaHMb53c7NDEpFyZLPZWLJkCcHBwXTu3JmBAwdy/fXXM23aNLNDExERkSrA9JG2IgK4nLD8YcAoYKUBWGD5eGjeR1MliJTAxRdfzJQpU2jSpAkAb775Jv3792fr1q1ceumlPPvss8yYMYO5c+fSrFkznnzySXr06MGuXbuoUaOGydGLr3p5zR6+/PkIIYE2Xri1HfYA/T8WqSwaNGjgudHy2erXr89nn31mQkQiIiJS1WmkrYgv2Lc+/wjbPAxIP+AuJyLF6tu3L9deey3NmjWjWbNmPPXUU1SvXp2vvvoKwzCYOXMmjz76KDfeeCMtW7bkzTffJCMjg3feecfs0MVHbU05xvSkXQBM7BdLk4jqJkckIiIiIiKVmUbaiviCw7tLWO4naNi1fGMRqWScTifvvfceJ0+eJCEhgb1793Lw4EESExM9Zex2O926dWP9+vV5bm55rszMTDIzMz2v09PTAXA4HDgcjhLHlFu2NNv4mqpUh+OnHdyzYCvZLoNrW0ZyQ5son6h3VToGvqwq18Gf6ywiIiLi65S0FTHL6XT4cQlsfxd+WVmybZbcD9++A017QrOeENUKLJbyjVPET23fvp2EhAROnz5N9erV+fDDD4mNjWX9eveI9cjIvDeQioyMZN++fUXuc/LkyUyaNCnf8qSkJEJDQ0sdY3Jycqm38TWVvQ6GAfN+svLbMSt17AZdQw6wbNmBCoyueJX9GPiLqliHjIyMcopERERERJS0FalI2Znw8+ew/T3YtQyyT59ZZw0EVxEjVnLX/7bR/Vj5JNSoC80S3UncRt0gqFr510HET1xyySVs27aNP//8k8WLFzNs2DBWr17tWW855wsPwzDyLTvXhAkTGDdunOd1eno69erVIzExsVR3Enc4HCQnJ9OjRw8CAwNLvJ0vqSp1+GDrAbZ89QM2q4XZQzvQvn6tig2yCFXlGPi6qlyH3KsNRERERKTsKWkrUt5cLtj3pTtRu+NjOP3nmXUXNIXWA6HVADj4Pbw7NGfF2TfCyEkiDXgdLo6Hn5JgdxLsWQnHf4fNc90Pm909dUKzXtA0EWrHVEj1RHxVUFCQ50Zk8fHxbNy4keeff56HH34YgIMHDxIdHe0pn5aWlm/07bnsdjt2uz3f8sDAQK+SNd5u50sqcx32/HGCSZ/9CMD91zSlY+MLKzq0EqnMx8CfVMU6+Ht9RURERHyZkrYi5cEw4OB299QH2xe7k6u5akRDy5vcydqo1memN6jTCAbOg+UP570pWVhd6DUFYvu5X8fd7n44TsO+dbB7BexeDn+muEfx/vy5u9yFLdxTKDTrCRd3AJv+3KVqMwyDzMxMGjZsSFRUFMnJybRr1w6ArKwsVq9ezTPPPGNylOIrMrOd3LNgKxlZTi5vVIc7uzcxOyQREREREalClMURKUtH98L2992jag/vOrM8uCbE9odWN0NMZ7DaCt4+th8070P2njVsW7uCtl17EtDoioLLBwZDk2vcj97Pwh+73Mnbn5Ig5Sv4Y6f78eVMCK4FTXu4p1FocjWE1imP2ov4jEceeYTevXtTr149jh8/zsKFC1m1ahXLly/HYrEwduxYnn76aZo2bUrTpk15+umnCQ0N5bbbbjM7dPERU5fv4off06kVGsjMQe2wWTV/uIiIiIiIVBwlbUXO14k/4IcP3aNqf9t4ZrnNDpf0glYD3QnTgPyXVBfIasOI6cKBH9JpE9Ol8ATv2SwWiGjufnQZC6eOwc//c4/C/TnZ/Xr7e+6HxQr1OrpH4DbtCREtdDMzqXQOHTrEkCFDSE1NpWbNmrRu3Zrly5fTo0cPAB566CFOnTrFmDFjOHbsGB07diQpKYkaNWqYHLn4gpW70nh13V4Apg5oQ1TNYJMjEhERERGRqkZJWxFvZB6HH5e4k6C/rATD6V5usULDbu6pD5pfB8ElvzFRmQqp7Z4nt9UAcDndyeTdy91z4ab9ACkb3I/PJ0LN+u6bmTXrBQ26ukfwivi51157rcj1FouFiRMnMnHixIoJSPxG2vHTPPDutwAMS4ihR2zR8xyLiIiIiIiUByVtRUoqOwt++R989y7sWgbZp86suyjOPfXBpTdCDR/7gG+1Qf3L3Y9rJsKf++GnFe5RuHvXwF8psPFV9yMw1J10zp0LN6yu2dGLiFQYl8vg/979liMns2geVYMJ17YwOyQREREREamilLQVKYrL5R6Ruv1d+OEjOP3nmXUXNHFPfdBqAFzQ2KwIS69WPbhspPuRleFO3OYmcdMPwO5l7gdAVCv3FArNesFF7Us2VYOIiJ96Ze0e1v50mOBAK/+5tR3BgfqfJyIiIiIi5lDSVuRchgGHvs+ZA3YxpP92Zl31qDPTDkS39f+5YINC3fPuXtIrp94/5EyjsMI9pcLB7e7H2mkQegE0TXSPwG18lfvmaoVxObHsW8dFRzdg2RcGhd1MTUTER3y7/0+mrnDfQPLxvpfSNFLzG4uIiIiIiHmUtBXJdexX2P6+O1n7x49nlttrQmw/9/QHDUp4YzB/ZLFAVEv344oH4ORh+PnznJuZ/Q8yjsC3C9wPawDUT8iZRqGXe9RxbgJ7xyew/GEC0n8nHmDfbPc0C72ecbejiIiPOZGZzb0Lt5LtMri2VRS3XFbP7JBERERERKSKU9JWqraTh+GHD92J2v1fn1lus7sTkq0HQpMeVfPmXNXCoc0t7ofT4W6f3JuZHd4Fv651P5Ieg9oN3cnb4DBY/Sxg5N1Xeiq8OxQGzlPiVkR8gtNl8PXeo2w+bOHdBdvYdySDi2qFMPmG1lj8/SoKERERERHxe0raSuVSksvyM0/ArqXuG4r98gUYTvdyixUaXuEeUduib9GX/1c1tkD3KOMGXSDxSTi6F35Kcidxf10Hx/bC17OL2IEBWGD5eGjep/KOVhYRv7D8+1QmfbqD1L9OAzbgKAC3dqhHzdBAU2MTEREREREBJW2lMinqsvxmvdwJ2u3vuRO2jowz29Vt576hWMsboUaUWdH7lzoNoeMd7kfmCdizCjbPhZ+Ti9jIcN/obN96aNi1ggIVEclr+fep3Dl/y7nXAwAwPWk3TSKq06tldIXHJSIiIiIicjYlbaVy2PGJ+/L7fJfl/w7vDoGg6pB14szyOo3dI2pb3QzhTSo01ErHXh1aXAfZp4tJ2uY4caj8YxIRKYDTZTDp0x0FJmxzTfp0Bz1io7BZNUWCiIiIiIiYR0lb8X8uJyx/mHwJ27NlnYBqEdBqgDtRW7fdmRtnSdmoHlm25UREytg3e4/mTIlQMANI/es03+w9SkLjCyouMBERERERkXMoaSv+b99694ja4tz0KjTqVv7xVFUxndzTUaSnUmgCvUa0u5yIiAnSjheesPWmnIiIiIiISHmxmh2AyHkr6eX2J/8o3ziqOqvNPX8wAIWMYrYEwKk/KyoiEZE8LqgWVKJyETWCyzkSERERERGRoilpK/4vpHbJyumy/PIX2w8GzoOwc27iUz0SgmtB+n54qz9kHDUlPBGpuhxOF+98nVJkGQsQXTOYDg3rVExQIiIiIiIihVDSVvzbX7/B/54oppAFwi7SZfkVJbYfjP2e7MEfsSnmTrIHfwTjdsKIZPe8wge3w1s3aMStiFQYh9PFfQu3svT7g9hyznzOvR4g9/XjfWN1EzIRERERETGdkrbiv35dBy93g9RtEFQ9Z2EhH8N7TXFfvi8Vw2rDiOnCgToJGDFd3G1/YTMY9gmEhruP2fyb4HS62ZGKSCXnSdhuP0igzcKcIfH8d3B7omrmnQIhqmYwswe3p1fL6EL2JCIiIiIiUnF0IzLxP4YB37wCKyaAKxuiWsGgtyH1W1j+cN6bkoXVdSdsY/uZF6+cEdEChn4Mb14HBzbB2wNg8GKw1zA7MhGphBxOF/cu2Mqy7w8SZLMye3B7rm7hniqnR2wUG35OI2nt1yR27UhCkwiNsBUREREREZ+hpK34F8dpWDIOtr3tft3qZuj7AgSFQu0YaN6H7D1r2LZ2BW279iSg0RUaYetrolrCkI9gXj/Y/zW8Mwj+9h4EVTM7MhGpRM5N2P53SHuuan5mbnOb1ULHhnU4stOgY8M6StiKiIiIiIhP0fQI4j/++g3e6OVO2FqskPgU3PiKO2Gbq6DL8sX31G0LQz4Eexjs+xIW3AJZGWZHJSKVhMPp4p53Ck/YioiIiIiI+DolbcU//PolzOkOv2+FkDruhF+nu8GikVF+66I4GPwBBNWAvWtg4W3ukdQiIuchN2G7/Ad3wvblIXFK2IqIiIiIiN9R0lZ8m2HA13Pcl9Kf/MM9f+0/VkGj7mZHJmWh3mUw+H0IrAZ7VsKiwZCdaXZUIuKnsrJd3P3OljwJ2yubR5gdloiIiIiISKkpaSu+y3EaPr4blj3ovuFYywEwPMk9d61UHvUvh7+9CwEh8HMyvDsMsrPMjkpE/ExWtot7FmxhxQ+H3AnboUrYioiIiIiI/1LSVnzTXwfgjd6wbX7O/LVPwk2v5p2/ViqPBl3gtkUQEAy7l8H7fwenw+yoRMRP5I6wXfHDIYICchK2lyhhKyIiIiIi/ktJW/E9+9bDnG7w+xYIqe2e97TTPZq/trJr1A1ueQdsdvjxM1g8EpzZZkclIj4uN2GbtMOdsJ0zRAlbERERERHxf0raiu8wDPjmFXizr3v+2sic+WsbX2l2ZFJRmlwNg+aDLQh2fAQfjQaX0+yoRMRHZWW7uOuchG13JWxFRERERKQSUNJWfEPu/LVLH8iZv/YmGLECajcwOzKpaM0SYeA8sAbA9vfg47uUuBWRfHITtsk5CdtXhsYrYSsiIiIiIpWG6UnbWbNm0bBhQ4KDg4mLi2Pt2rWFlv3ggw/o0aMHF154IWFhYSQkJLBixYo8ZebOnYvFYsn3OH36dHlXRbz11wGYe+2Z+Wt7/Btueg2CqpkdmZjlkt4w4A2w2ODbBfDpveBymR2ViPiIrGwXY97Om7Dt1uxCs8MSEREREREpM6YmbRctWsTYsWN59NFH2bp1K127dqV3796kpKQUWH7NmjX06NGDpUuXsnnzZq688kr69u3L1q1b85QLCwsjNTU1zyM4OLgiqiSltW+De/7aA5tz5q9dDJ3v1fy1ArH93Defs1hh63xYMs49hYaIVGm5CdvPd7oTtq8qYSsi52HJkiV07NiRkJAQwsPDufHGG/OsT0lJoW/fvlSrVo3w8HDuvfdesrKyTIpWREREqpIAM998xowZjBgxgpEjRwIwc+ZMVqxYwezZs5k8eXK+8jNnzszz+umnn+bjjz/m008/pV27dp7lFouFqKioco1dzpNhwMZXYfl493QIkS3dc5nWaWh2ZOJLWt7o/v344B+w+Q33lAnXTlVSX6SKysx2ctfbW/h8Zxr2nBG2VyhhKyJeWrx4MaNGjeLpp5/mqquuwjAMtm/f7lnvdDrp06cPF154IevWrePIkSMMGzYMwzD4z3/+Y2LkIiIiUhWYlrTNyspi8+bNjB8/Ps/yxMRE1q9fX6J9uFwujh8/Tp06dfIsP3HiBDExMTidTtq2bcu///3vPEndc2VmZpKZmel5nZ6eDoDD4cDhcJS0Sp5tzn72R+Veh+zT2JY/jPXbtwFwxV6Ps8/z7ukQyuA9dQx8Q5nVocUNWPpmYvv0HiwbX8FpseK65skKSdz6+3E4n/j9tc5SeZ2bsH11WDxdmyphKyLeyc7O5r777mPq1KmMGDHCs/ySSy7x/JyUlMSOHTvYv38/devWBWD69OncfvvtPPXUU4SFhVV43CIiIlJ1mJa0PXz4ME6nk8jIyDzLIyMjOXjwYIn2MX36dE6ePMnAgQM9y5o3b87cuXNp1aoV6enpPP/883Tu3Jlvv/2Wpk2bFrifyZMnM2nSpHzLk5KSCA0NLUWtzkhOTvZqO19SHnUIzjpKh70vUDtjDwYWdtQdyM9B18Lnq8v8vXQMfEPZ1CGM+vWH0y7lNWzfvMyeX/ezo+6gChtx6+/HwZv4MzIyyiESEe9kZjsZM38L//tRCVsRKRtbtmzhwIEDWK1W2rVrx8GDB2nbti3Tpk3j0ksvBWDDhg20bNnSk7AF6NmzJ5mZmZ6p2gpSlgNCiuPvXzCbSW3nPbWdd9Ru3lPbeU9t553ybreS7tfU6RHAPZXB2QzDyLesIAsWLGDixIl8/PHHREScuVv05ZdfzuWXX+553blzZ9q3b89//vMfXnjhhQL3NWHCBMaNG+d5nZ6eTr169UhMTCz1N+gOh4Pk5GR69OhBYGBgqbb1FeVVB8v+r7AtfgBLRhpGcC2cN7xKs0bdaVZm7+CmY+Abyr4O1+Lc3Bzb8gdpmraURk0uwdX9kXJN3Pr7cTif+HM/YIqYLTPbyZ3zt/BFTsL2tWGX0aVpuNlhiYif27NnDwATJ05kxowZNGjQgOnTp9OtWzd2795NnTp1OHjwYL4BJrVr1yYoKKjIQSblMSCkOP7+BbOZ1HbeU9t5R+3mPbWd99R23imvdivpICnTkrbh4eHYbLZ8JzxpaWn5To7OtWjRIkaMGMF7773HNddcU2RZq9XKZZddxk8//VRoGbvdjt1uz7c8MDDQ60TN+WzrK8qsDoYBm16DZQ+75yeNuBTLLW8TUM7z1+oY+IYyrcPl/wALsOxBbOufwxZohysnlM2+i+Dvx8Gb+P25vlJ5KGErIqU1ceLEAhOmZ9u4cSMulwuARx99lJtuugmAN954g4svvpj33nuPO+64A8g/wASKH2RSlgNCiuPvXzCbSW3nPbWdd9Ru3lPbeU9t553ybreSDpIyLWkbFBREXFwcycnJ3HDDDZ7lycnJ9O/fv9DtFixYwPDhw1mwYAF9+vQp9n0Mw2Dbtm20atWqTOKWUsrOhCX/B1vfcr++9Abo/5J7/loRb3T8B7gcsOIRWD0FbAFwxYNmRyUiZezchO3rt19G5yZK2IpI0e6++25uueWWIss0aNCA48ePAxAbG+tZbrfbadSoESkpKQBERUXx9ddf59n22LFjOByOIgeZlMeAkOL4+xfMZlLbeU9t5x21m/fUdt5T23mnvNqtpPs0dXqEcePGMWTIEOLj40lISGDOnDmkpKQwevRowP0t9YEDB5g3bx7gTtgOHTqU559/nssvv9wzSjckJISaNWsCMGnSJC6//HKaNm1Keno6L7zwAtu2beOll14yp5JVWfrvsGgIHNgEFitc/Th0vq/C5iGVSizhLnA64PPH4YsnwRoIXcaaHZWIlJHMbCej39rMyl1/EBzoHmGrhK2IlER4eDjh4cX/v4iLi8Nut7Nr1y66dOkCuEfV/Prrr8TExACQkJDAU089RWpqKtHR0YB7igO73U5cXFz5VUJEREQEk5O2gwYN4siRIzzxxBOkpqbSsmVLli5d6jlRSk1N9XzTDfDyyy+TnZ3NXXfdxV133eVZPmzYMObOnQvAn3/+yT/+8Q8OHjxIzZo1adeuHWvWrKFDhw4VWrcqL+UreHconDgEwbVgwOvQ5Gqzo5LKpMtY94jbL550J29tge5kroj4tdMOJ3fOP5OwfX3YZXRSwlZEylhYWBijR4/m8ccfp169esTExDB16lQAbr75ZgASExOJjY1lyJAhTJ06laNHj/LAAw8watSoMp/mQERERORcpt+IbMyYMYwZM6bAdbmJ2FyrVq0qdn/PPfcczz33XBlEJl4xDNj0es78tQ6IuBRumQ91GpkdmVRGVzwIzmz3NAkrHgFrAHS8w+yoRMRLpx1ORs/fzColbEWkAkydOpWAgACGDBnCqVOn6NixI1988QW1a9cGwGazsWTJEsaMGUPnzp0JCQnhtttuY9q0aSZHLiIiIlWB6UlbqUSyM2HpA7DFPZ0FsdfD9bM0f62Ur+7j3V8QrJ0Oyx5yJ24vG2F2VCJSSkrYikhFCwwMZNq0aUUmYevXr89nn31WgVGJiIiIuClpK2UjPRXeHQK/bQQscM3j0Hms5q+V8mexwFX/dM9xu/4FWDLOnbiNG2Z2ZCJSQqcdTu54azOrd+ckbG+/jE6NlbAVEREREZGqS0lbOX8pX7sTticOQXDNnPlrrzE7KqlKLBbo8YQ7cfv1bPj0Pvcct21vMzsyESnGuQnbN27vQELjC8wOS0RERERExFRK2sr52fQ6LH0oZ/7aWLjlbc1fK+awWKDXZHBlw8ZX4KMx7hG3rQeaHZmIFOK0w8k/3trMmt1/EBJo4/XbL1PCVkREREREBLCaHYD4qexM+ORe+Ox+d8I2tj+MSFbCVsxlsUDvZyHudsCAD++A7xebHZWYZM2aNfTt25e6detisVj46KOP8qy//fbbsVgseR6XX365OcFWQecmbN/4uxK2IiIiIiIiuZS0ldJLT4W518GWNwELXP043Pwm2KubHZkIWK3Q5zloNxgMFyweBTs+NjsqMcHJkydp06YNL774YqFlevXqRWpqquexdOnSCoyw6jrtcDJq3qY8CdvLGylhKyIiIiIikkvTI0jpnDt/7U2vQ1PNXys+xmqFvi+AMxu+WwjvD4eB86B5H7MjkwrUu3dvevfuXWQZu91OVFRUBUUkcCZhu/anw0rYioiIiIiIFEJJWym5TW/A0gfd0yFc2MI9f+0Fjc2OSqRgVhtcP8s9x+3378O7w9y/s816mh2Z+JBVq1YRERFBrVq16NatG0899RQRERGFls/MzCQzM9PzOj09HQCHw4HD4Sjx++aWLc02vsabOpx2OBn99ja+/OUIoUE2XhnSjrh6Yaa1g78fB3+PH1QHX+FtHfy5ziIiIiK+TklbKV52Jix7CDbPdb+O7Q/9Z2k6BPF9Vhvc8LI7cbvjI1g0GG5dAE00OlzcI3FvvvlmYmJi2Lt3L//85z+56qqr2Lx5M3a7vcBtJk+ezKRJk/ItT0pKIjQ0tNQxJCcnl3obX1PSOmQ54dVdVnb9ZSXIajCiaSaHd3zF0h3lHGAJ+Ptx8Pf4QXXwFaWtQ0ZGRjlFIiIiIiJK2kpeLieWfeu46OgGLPvC4MJm8N7t8Ns3uOev/Sd0Gee+4ZOIP7AFwE2vuhO3P34GC/8Gty2CRt3NjkxMNmjQIM/PLVu2JD4+npiYGJYsWcKNN95Y4DYTJkxg3Lhxntfp6enUq1ePxMREwsLCSvzeDoeD5ORkevToQWBgoPeVMFFp6nDa4eSOt7ey66+jhAbZeHVIey5rULuCIi2cvx8Hf48fVAdf4W0dcq82EBEREZGyp6StnLHjE1j+MAHpvxMPsG82WKzumzkF14SbXoOmPcyOUqT0bIEw4A14dyjsXgbv3AKD34cGXcyOTHxIdHQ0MTEx/PTTT4WWsdvtBY7CDQwM9CpZ4+12vqS4OpzKcnLnO1tY/4s7YTv37x3o0LBOBUZYPH8/Dv4eP6gOvqK0dfD3+oqIiIj4MqvZAYiP2PGJO6GV/nve5YbL/XzlY0rYin8LCIKBb0KTHpB9Ct4eCPs2mB2V+JAjR46wf/9+oqOjzQ6l0jiV5b7p2LqfDxMaZOPN4b6XsBUREREREfFFStoKuJyw/GHAKKSABb6c6S4n4s8C7DBoPjS6Ehwn4e0BsH+j2VFJOTlx4gTbtm1j27ZtAOzdu5dt27aRkpLCiRMneOCBB9iwYQO//vorq1atom/fvoSHh3PDDTeYG3glcSrLych5G1n382Gq5SRsL2ughK2IiIiIiEhJKGkrsG99/hG2eRiQfsBdTsTfBQbDLe9Ag66QdQLm3wgHNpsdlZSDTZs20a5dO9q1awfAuHHjaNeuHf/617+w2Wxs376d/v3706xZM4YNG0azZs3YsGEDNWrUMDly/3cqy8mINzfy5c9HlLAVERERERHxgua0FThxqGzLifi6oFD3zcjmD4CU9fDWDTD0E6jb1uzIpAx1794dwyjsCgJYsWJFBUZTdeQmbNf/ciZhG6+ErYiIiIiISKlopG1Vl3USti0oWdnqkeUbi0hFCqoGf3sX6nWE03/BW9fDwe1mRyXi15SwFRERERERKRtK2lZlB7+HOd3hl8+LKWiBsIsgplNFRCVScew14G/vw0VxcOoYzOsPh3aYHZWIX8rIymb4XHfCtro9gHkjlLAVERERERHxlpK2VZFhwMbX4JWr4PBuqBEN3R8BLDmPs+W87jUFrLYKDlSkAgSHweAPILotZByBef3gj13gcmLZt46Ljm7Asm+dbsQnchany+DrvUfZfNjC13uPcvy0gxFzN7Fhjzth++bwy4iLUcJWRERERETEW5rTtqo59Sd8cg/s/MT9umkiXD8bqoVDRAtY/nDem5KF1XUnbGP7mRKuSIUIqQVDPnQnbA9uh9d6QICdgBNpxAPsm53zt/CM/hakylv+fSqTPt1B6l+nARvzftpEkM1CltPISdh2IC6mttlhioiIiIiI+DUlbauS/Rvh/eHwVwpYA+GaiXD5GLDmDLiO7QfN+5C9Zw3b1q6gbdeeBDS6QiNspWoIrQNDPoaXu0H6/vzr01Ph3aEwcJ4St1JlLf8+lTvnb+Hc27tlOd1L7uzeWAlbERERERGRMqDpEaoClwvWPQev93QnbGs3gBEroNPdZxK2uaw2jJguHKiTgBHTRQlbqVpCaoHLUcjKnDTV8vGaKkGqJKfLYNKnO/IlbM82/6t9OF1FlRAREREREZGSUNK2sjuRBm/fBJ9PBMMJLW+CO9a6b7wkInntWw8nDhZRwID0A+5yIlXMN3uP5kyJULjUv07zzd6jFRSRiIiIiIhI5aXpESqzX1bCB/+Ak2kQEALXPgvthoDl3JuNiQgAJw6VbTmRSiTteNEJ29KWExERERERkcIpaVsZOR2w8mn3lAgYEBELA96AiOZmRybi26pHlm05kUqkVmhgicpF1Agu50hEREREREQqP02PUNn8mQJz+8C6GYABcX+HUV8oYStSEjGdIKwuUMxo9IPbwdC8nVJ17Dp4nKc+21lkGQsQXTOYDg3rVExQIiIiIiIilZiStpXJzk/hv11g/9dgD4Ob50LfmRAYYnZkIv7BaoNez+S8ODdxe9brFRNgwa1w8khFRSZiCsMwmPvlXvq+uI7daSeoEey+QKewv47H+8Zis2oKHhERERERkfOlpG1l4DgNSx6ARYPh9F/um4yNXguX3mB2ZCL+J7YfDJwHYdF5l4fVdS/v/SzYgmD3MvhvZ9i71pw4RcrZH8czGT53IxM/3UFWtosrL7mQlQ9057+D2xNVM+8UCFE1g5k9uD29WkYXsjcREREREREpDc1p6+8O/wTv/R0ObXe/7nQvXPVPCAgyNy4RfxbbD5r3IXvPGratXUHbrj0JaHSFeyQuQP0EeH84HPkJ3uwLVzwI3R4Gm/6lSuWw8sc0Hnz/Ww6fyMIeYOXRPi0YcnkMFouFXi2j6REbxYaf00ha+zWJXTuS0CRCI2xFRERERETKkDIM/mzbO+4Rto6TEBoON7wMTa8xOyqRysFqw4jpwoEf0mkT0+VMwhYgujXcsRqWPQRb58OaZ2HvGrjpVahVz7yYRc7TaYeTKct+ZO76XwFoHlWDF25tR7PIGnnK2awWOjasw5GdBh0b1lHCVkREREREpIwpaeuPMo+7k7XfLXS/bngF3DAn/+XcIlJ+gqpB/5eg0ZXw6VjY/5V7uoR+L7pH6or4mR8PpnPfgm3sOnQcgL93bsDDvZoTHGgrZksREREREREpa0ra+pvUb93TIRz9BSxWuPIR6DIu7yhAEak4rQbARe3h/RHw+xZ4dwjEj4CeT+kmgOIXDMNg7vpfmbzsR7KyXYRXtzPt5tZ0vyTC7NBERERERESqLCVt/YVhwNcvQ/I/wZkFYRfBTa9BTILZkYlInUYwfAWsfBK+fB42vQYpG2DA6xDRwuzoRAr1x/FMHnz/W1bt+gOAq5pH8OyA1oRXt5scmYiIiIiISNWmpK0/yDgKH98Nu5a4X1/SB/q/CKF1zI1LRM4ICIIeT0DDbvDhHZC2A+ZcCb0mQ9ztYNGcn+JbvvjxEA++9x1HTua/2ZiIiIiIiIiYS0lbX7dvAyweCem/gS0IEp+EDv9QAkjEVzW5Gu5c707c/vIFfDYW9qyCvs9DSC2TgxNx32xs8tKdvLlhH1D4zcZERERERETEPEra+iqXE9bOgFVPg+GCOo3dl1rXbWt2ZCJSnOoR8LfFsOE/8L8nYMdHcGALDHgN6nUwOzqpwn48mM69C7ay+9AJAIZ3bshDvS7RzcZERERERER8jNXsAGbNmkXDhg0JDg4mLi6OtWvXFlr2gw8+oEePHlx44YWEhYWRkJDAihUr8pVbvHgxsbGx2O12YmNj+fDDD8uzCmXv+EF463r3/JiGC1oPgjtWK2Er4k+sVuh8HwxPgtoN4K8UeL0XrJnm/lJGpAIZhsHr6/bS78Uv2X3oBOHV7cz9+2X8q2+sErYiUmXt3r2b/v37Ex4eTlhYGJ07d2blypV5yqSkpNC3b1+qVatGeHg49957L1lZWSZFLCIiIlWJqUnbRYsWMXbsWB599FG2bt1K165d6d27NykpKQWWX7NmDT169GDp0qVs3ryZK6+8kr59+7J161ZPmQ0bNjBo0CCGDBnCt99+y5AhQxg4cCBff/11RVXr/Pz0OczuDHvXQGAoXD8bbpwDdl22KuKXLo6DO9ZAywFgOOGLf8NbN0B6qtmRSRWRdvw0t7+xkSc+20FWtourm0ewYmxXul8SYXZoIiKm6tOnD9nZ2XzxxRds3ryZtm3bct1113Hw4EEAnE4nffr04eTJk6xbt46FCxeyePFi/u///s/kyEVERKQqMDVpO2PGDEaMGMHIkSNp0aIFM2fOpF69esyePbvA8jNnzuShhx7isssuo2nTpjz99NM0bdqUTz/9NE+ZHj16MGHCBJo3b86ECRO4+uqrmTlzZgXVykvZWZD0T3j7Jsg4DJGt3ImetreZHZmInK/gmnDTq9D/JfeXMXtXw387w+4ksyOTSu6LHw/Re+ZaVu/+A3uAlX/3v5RXh8VzQXW72aGJiJjq8OHD/Pzzz4wfP57WrVvTtGlTpkyZQkZGBj/88AMASUlJ7Nixg/nz59OuXTuuueYapk+fziuvvEJ6errJNRAREZHKzrQ5bbOysti8eTPjx4/PszwxMZH169eXaB8ul4vjx49Tp04dz7INGzZw//335ynXs2fPIpO2mZmZZGZmel7nnoQ5HA4cDkeJYsmVW75U2x37FdtH/8D6+xYAnHEjcF0zCQKCoZTvXxa8qoMP8ff4QXXwFWVeh5aDIKo9AR+OwpL2PbxzM84Oo3Fd+U8IKPsk2vnE78/HTdw3G3t66U7m6WZjIiIFuuCCC2jRogXz5s2jffv22O12Xn75ZSIjI4mLiwPcnytatmxJ3bp1Pdv17NmTzMxMz1V/BSnLzxbFqQznW2ZR23lPbecdtZv31HbeU9t5p7zbraT7NS1pe/jwYZxOJ5GRkXmWR0ZGei5JKs706dM5efIkAwcO9Cw7ePBgqfc5efJkJk2alG95UlISoaGhJYrlXMnJySUqV/fYN7RNeQ2r6xRZtlC21R9Jqisekr7w6n3LUknr4Kv8PX5QHXxFWdfBGj2WS41FNPojGds3/+X49uVsajCGk8FRZfo+ubyJPyMjoxwikYqwM9V9s7Gf0tw3GxvRxX2zMXuA5q4VEcllsVhITk6mf//+1KhRA6vVSmRkJMuXL6dWrVpAwZ8rateuTVBQUIV/tihOZTjfMovazntqO++o3byntvOe2s475dVuJf28bVrSNpfFYsnz2jCMfMsKsmDBAiZOnMjHH39MRETeeflKu88JEyYwbtw4z+v09HTq1atHYmIiYWFhJamGh8PhIDk5mR49ehAYGFhEwVNYkx/D9uubALgu7oDl+pdpV7Me7Ur1jmWvxHXwUf4eP6gOvqJ863A92buXYfvsXmqd+pWrf5mEs9dUjFYDi9+0hM4nfl326X9cLoM31v/KM8t+JMvp4sIadqbd3IZuzS40OzQRkQozceLEAhOmZ9u4cSNxcXGMGTOGiIgI1q5dS0hICK+++irXXXcdGzduJDo6Gsj/uQIq9rNFcSrD+ZZZ1HbeU9t5R+3mPbWd99R23invdivp523Tkrbh4eHYbLZ831KnpaXl+0b7XIsWLWLEiBG89957XHPNNXnWRUVFlXqfdrsduz3/pcmBgYFeH5wit037Ed7/O6TtACzQ5X6sVz6C1eZbf0DnU39f4O/xg+rgK8qtDpf2c9+o7INRWPZ9ScAnY+DXNdBnWpnefNCb+P39mFU1acdP88B737Fm9x8AXNMigmduaq25a0Wkyrn77ru55ZZbiizToEEDvvjiCz777DOOHTvmSaTOmjWL5ORk3nzzTcaPH09UVFS+mxkfO3YMh8NR4Z8tilMZzrfMorbzntrOO2o376ntvKe28055tVtJ92la0jYoKIi4uDiSk5O54YYbPMtzL1MqzIIFCxg+fDgLFiygT58++dYnJCSQnJycZ17bpKQkOnXqVLYV8IZhwNa3YOlDkH0KqkXAjS9D46vMjkxEzFLzIhj2KayZBqunwHcL4beNMOA1qGv2uHvxB//beYgH3/+OoyezsAdYeey6WAZ3rF+iq1ZERCqb8PBwwsPDiy2Xe1mi1Zr3vsxWqxWXywW4P1c89dRTpKamekbeJiUlYbfbPfPeioiIiJQXU6dHGDduHEOGDCE+Pp6EhATmzJlDSkoKo0ePBtyXFh04cIB58+YB7oTt0KFDef7557n88ss9I2pDQkKoWbMmAPfddx9XXHEFzzzzDP379+fjjz/m888/Z926deZUMtfpdPhsLHy/2P268VVww8tQPaLIzUSkCrDaoPvD0LArLB4JR3+BV3tAj0lw+RhQ8k0KcNrh5KklO3nrK/fNxlpEh/HCLW1pqpuNiYgUKyEhgdq1azNs2DD+9a9/ERISwiuvvMLevXs9A0MSExOJjY1lyJAhTJ06laNHj/LAAw8watSoMp/mQERERORc1uKLlJ9BgwYxc+ZMnnjiCdq2bcuaNWtYunQpMTExAKSmppKSkuIp//LLL5Odnc1dd91FdHS053Hfffd5ynTq1ImFCxfyxhtv0Lp1a+bOncuiRYvo2LFjhdfP48AWeLmrO2FrscE1E+Fvi5WwFZG8YjrB6HXQ/DpwOWDFI/DOQDh52OzIxMfs+D2dvv9Z50nYjujSkI/u6qSErYhICYWHh7N8+XJOnDjBVVddRXx8POvWrePjjz+mTZs2ANhsNpYsWUJwcDCdO3dm4MCBXH/99UybNs3k6EVERKQqMP1GZGPGjGHMmDEFrps7d26e16tWrSrRPgcMGMCAAQPOMzIvuJxY9q3joqMbsOwLgwZd4JuX4fOJ7gRMzfruS57rdaj42ETEP4TWgUHzYeOrsOJR+CkJZneGG+dAo25mRycmc7kMXv9yL88u3+W52dj0m9twhW42JiJSavHx8axYsaLIMvXr1+ezzz6roIhEREREzjA9aVtp7PgElj9MQPrvxAPsmw0BdsjOdK9v0Q/6/QdCapkYpIj4BYsFOoyC+gnw/nA4vAvm9Yeu46D7BPCxmxZKxUhLP83/vfcta39yj7y+pkUkz9zUSjcbExERERERqYRMnR6h0tjxCbw7FNJ/z7s8N2HbfhgMnKeErYiUTlRL+MdK9/8QDFg7Hd64Fo7tMzsyqWCf7zhEr+fXsvanwwQHWnny+pa8MjROCVsREREREZFKSknb8+VywvKHAaPwMj9/DoarwkISkUokqBr0ewEGvAH2MPjtG/hvV/jhI7MjkwpwKsvJYx9tZ+S8TRw9mUWL6DA+u6cLgy+PwaIb1ImIVGlOl8HXe4+y+bCFr/cexekq4vOI5KG2ExGRwvhSH6HpEc7XvvX5R9ieK/2Au1zDrhUTk4hUPi1vhIvaw+KR8NtGeG8Y7Lkdek6GoFCzo5NysOP3dO5duJWf004AMKprQx7oeQn2AJvJkYmIiNmWf5/KpE93kPrXacDGvJ82EV0zmMf7xtKrZbTZ4fk0tZ2IVBVnJx8v2HuUhCYR2Kwa+FEUX+sjNNL2fJ04VLblREQKU7sB/H0ZdBkHWGDzXHjlKji0w+TApCy5XAavrt3D9S99yc9pJ4ioYeetER14tE+sErYiIsLy71O5c/6WnA+UZxz86zR3zt/C8u9TTYrM96ntRPyPL4169CfLv0+lyzNfMPj1Tcz7ycbg1zfR5Zkv9H+uCL7YR2ik7fmqHlm25UREimILhGseh4ZXwId3wB874ZUroefTED/cfRMz8VsF3Wzs2QGtqVMtyOTIRETEFzhdBpM+3VHgxGy5yx547zu+++2vPKOp8p0dWAped/ZphOWsNeeeXhS6TSHnIYXtN/+60seSd1+F18tlGDz/+U9Ftt2jH35PZFgw1e0BBAfaCA2yERJkIzjAhlWj0wCN3JOK5WujHv1FbvLx3P93ucnH2YPb+1T7GYaBy3D/f3G6DJyGgdPpfs52uXC5yPtsGGS7DLKdhudnlyvv89n78Oy3wDIunAY4nE5e+uKXQvsICzDp0x30iI2q0P95Stqer5hOEFYX0lMpeF5bi3t9TKeKjkxEKrPGV8LoL+GjO+HnZFgyDvascs9/G1IbXE4s+9Zx0dENWPaFQaMrwKpRmr6gsA87yTsO8dD733Isw0FwoJV/XhfLbR3qa+5aERHx+Gbv0XwjgM51IjObWat+qaCIKpcjJ7O4Ydb6AtcFB1oJCbQRGhRAcKCV0KAAQgJtBAfZCA3MSe7mJnpzXuc+h56z7uyEcG6ZIJvV5/t8JdC8p2R36flb4tFbuQnEbJfLk4jMdrnIdrqTjA6nK+c557XLlWe5u7xBttO9fVa2kyc+21nsl3vbD/yFyzjz/ucmTLNd5yZEXThd4HS5k5zOnDjOTYjm2Y+rgEeehOyZBKqvM4DUv07zzd6jJDS+oMLeV0nb82W1Qa9n4N2huHPvZ/+y5fwT7jVFyRIRKXvVL4Tb3oWvZsHnE2HnJ/D7Voi7HTa9RkD678QD7Jvt/vKo1zMQ28/cmKu4gj7sRIXZaRpZwzO6NjY6jBdubUuTiBrmBisiIj4n7XjRCdtcVzQNp9GF1QH3CKaznf3q7FXGWWvyLs8r7+4K2aYE+y1pLIX8mLONUeC6guI/cCyDLSl/UpxaIYFYLHDK4eS048zNpE87XJx2uDiW4Sh2H96wWshJCNsICbISGhiQJyF8biL43IRwyLkJ43PLBtoIsHk/O2JVSaCVByW7S68kVxX86+MfaBpRAwPjrGTnmeRltjMnwek8NyF6dpmcZ1dBCVKXJ1Gam0TNLZtv+3wJVff2+d6vgJ/NyFeeyMzmpZX+8eWexQIBVgtWi8X9bHU/23IeAVYrVivuZ0vOs/WcspYz5W3nrMt9/v3YKTbuO1ZsPCXth8uKkrZlIbYfDJwHyx/Oe1OysLruhK2SJCJSXqxW6HS3ezT/+8Ph2F744t/5y6Wnur9cGjhP/5POMWvWLKZOnUpqaiqXXnopM2fOpGvXsr9xZKEfdtIzOZieCehmYyIiUrSIGsElKndn9yYVOhLIH2z45Qi3vvJVseVmD47ztJ3LZXA628mpLCcZWU5OO9zPpxw5j6ycdQ4np3OW55bLXX4qy8kpR3bOs4tTWdl5yjmc7jMDl+FOpJzIzC63NgiyWc+MEi5s9O85Sd/QIBtBAVamJ+0uMoH2z5wEmj3QSoDV6kmM2Gzu5wCr1ZMgqUr8Kdlt5Ix8zMp2uR/Oc54LW3bWa4fTRWYBy3LLZRawrKD9n8zK5mSms8h4045ncvWM1RXUOhXLYoHA3L+j3L8hmzXn+czfU95l7uVHM7LYdfB4se9xRdNwmkTUIMBWeEI0N9lZkjLnPtz/B8BmtRZYJk/i1HLm/0WespaK+59R0j6ipP1wWVHStqzE9oPmfcjes4Zta1fQtmtPAnQ5sohUlIvaw6iV8FwLcJwqoEDOTDzLx0PzPvrflGPRokWMHTuWWbNm0blzZ15++WV69+7Njh07qF+/fpm9T1GjBXLVqRbE+N4tdKmciIgUqkPDOkTXDObgX6cLm5iNqJrBdGhYp6JD83netJ3VaiE0KIDQoADKKwXucLrco3qzCk4Ie34+K2HsTh5ncyrLdVZCOG+5sxPHuSOPs5zupFj66bJPDP9RwgRa7qi53KRObrLpTJLH4klC2XISU2cvy5MQPieBZfNsd9Yyz/7PlAksYN/u5fn3bbNaCTzn9dlJsvwxntkHwMRPCh8tagEe/+QH2tarjdMwcJyVtMxNfDoKSJJmOl15yhaXTM2TSD1r2dnlMnOWnTsa3tcFB1gJDrKdlcTMn+A8+xjmHuPA3N+T3HJFbF9ogjTPvvK/h2fbs7+4KOjnc2IKzBkp6q2SJh/15V5evtq/Kmlblqw2jJguHPghnTYxXZQUEZGKdej7QhK2uQxIPwD71kPDsh9J6o9mzJjBiBEjGDlyJAAzZ85kxYoVzJ49m8mTJ5fZ+5RkDsKjJ7MqfI4kERHxLzarhcf7xnLn/C2FTczG431j9QVgAXy17QJtVgJtVsKCA8tl/4ZhkJntyjtK+Kznc0cQ500IOzmVlc2ewyf47rf0Yt/LHmDFYsFzeXjB8YDDmbveVWCZqsIADqVncvnk/5kdSoFsVgtBNiuBNgtBATbsAVaCAqzuZQHudUEBVoICbDk/n73MSpDNlvNsOWuZu3xgzjL7WWUDzyq3MzWdB977rtgY3/h7B507n8NXk4++zlf7CCVtRUQqixOHyrZcJZeVlcXmzZsZP358nuWJiYmsX1/wTUgyMzPJzMz0vE5Pd3+AcTgcOByFz3GX+ufJEsWU+udJHI6wEpU1W259i6q3r/P3Ovh7/KA6+Apv6+DPdfZnvVpGM3tw+7PmyHSL0hyZxaqKbWexWAjOmf6gVqh3+yjpyL255yTQXGfN8ZntOnNzozw3UXKdmTP07JstZefbznWmrPPMTY/OvmGTe/3Z85DmzCvqec+8r4ved965Ss+OJ9uZf9/nOz9pUIAVu81KoCexeXaC1L3u3GW55fIkU88u59mn5UwC1bPdOcsC3MlZ+1nLzPzyp3lUGNOTdivx6AVfTT76A1/sI5S0FRGpLKpHlm25Su7w4cM4nU4iI/O2R2RkJAcPHixwm8mTJzNp0qR8y5OSkggNLfyT0J6/LEDxV1/s+WEbS3/bWmw5X5KcnGx2COfN3+vg7/GD6uArSluHjIyMcopEitOrZTQ9YqPY8HMaSWu/JrFrR92NvoTUdqXn7cg9q9WCvYpdfepyGTgNdyJ3/S9HGD53Y7HbLBjVkYTG4RUQnf9Q4vH8+GLy0V/4Wh+hpK2ISGUR08l9A8T0VPLfXxnA4l4f06miI/NpFkveDtgwjHzLck2YMIFx48Z5Xqenp1OvXj0SExMJCyt8hKzTZfD+9DUcSs8s4sOOnbsHXeE3J58Oh4Pk5GR69OhBYGD5XNJZ3vy9Dv4eP6gOvsLbOuRebSDmsFktdGxYhyM7DTo2rOM3/YcvUNuVjhJoJWe1WrBiIdAG3ZpdWMJkty7vL4gSj+fH15KP/sSX+gglbUVEKgurDXo9A+8OhcJOqXtN0XzbOcLDw7HZbPlG1aalpeUbfZvLbrdjt9vzLQ8MDCwy0REITOx3aTEfdi4l2B5Uukr4gOLq7g/8vQ7+Hj+oDr6itHXw9/qKSMkpgVZ6SnafPyUez48vJR/FO1azAxARkTIU2w8GzoOwc06cw+q6l8f2MycuHxQUFERcXFy+y4GTk5Pp1KnsRyPnftiJqhmcZ3lUzWBmD26vDzsiIiLi03q1jGbdw1cxf3g8Q5s6mT88nnUPX6VzmCLo/O/85SYe48KVeJSqRyNtRUQqm9h+0LwP2XvWsG3tCtp27UlAoys0wrYA48aNY8iQIcTHx5OQkMCcOXNISUlh9OjR5fJ+Gi0gIiIi/kwj90pP538i4i0lbUVEKiOrDSOmCwd+SKdNTBclbAsxaNAgjhw5whNPPEFqaiotW7Zk6dKlxMTElNt76sOOiIiISNWi8z8R8YaStiIiUqWNGTOGMWPGmB2GiIiIiIiIiIfmtBURERERERERERHxIUraioiIiIiIiIiIiPgQJW1FREREREREREREfIiStiIiIiIiIiIiIiI+RElbERERERERERERER+ipK2IiIiIiIiIiIiIDwkwOwBfZBgGAOnp6aXe1uFwkJGRQXp6OoGBgWUdWoXw9zr4e/ygOvgKf6/D+cSf+/8v9/+hFMzb/sLff7dAdfAF/h4/qA6+wts6qK8omfP5bFGcyvD7Zxa1nffUdt5Ru3lPbec9tZ13yrvdSnoOpaRtAY4fPw5AvXr1TI5ERMRcx48fp2bNmmaH4bPUX4iIqK8ojvoKERERKUhx51AWQ1+N5+Nyufj999+pUaMGFoulVNump6dTr1499u/fT1hYWDlFWL78vQ7+Hj+oDr7C3+twPvEbhsHx48epW7cuVqtm0imMt/2Fv/9ugergC/w9flAdfIW3dVBfUTLn89miOJXh988sajvvqe28o3bzntrOe2o775R3u5X0HEojbQtgtVq5+OKLz2sfYWFhfv8H4e918Pf4QXXwFf5eB2/j16ip4p1vf+Hvv1ugOvgCf48fVAdf4U0d1FcUryw+WxSnMvz+mUVt5z21nXfUbt5T23lPbeed8my3kpxD6StxERERERERERERER+ipK2IiIiIiIiIiIiID1HStozZ7XYef/xx7Ha72aF4zd/r4O/xg+rgK/y9Dv4ef2VWGY6N6mA+f48fVAdfURnqUFXp2HlPbec9tZ131G7eU9t5T23nHV9pN92ITERERERERERERMSHaKStiIiIiIiIiIiIiA9R0lZERERERERERETEhyhpKyIiIiIiIiIiIuJDlLQVERERERERERER8SFK2pahWbNm0bBhQ4KDg4mLi2Pt2rVmh1SoNWvW0LdvX+rWrYvFYuGjjz7Ks/7222/HYrHkeVx++eXmBFuI2bNn07p1a8LCwggLCyMhIYFly5Z51huGwcSJE6lbty4hISF0796dH374wcSIizZ58mQsFgtjx471LPOH43DgwAEGDx7MBRdcQGhoKG3btmXz5s2e9b5+HBo0aJCvjS0WC3fddRfgH8fg+PHjjB07lpiYGEJCQujUqRMbN270rPf1Y1AVqb+oOOorfIP6Ct+g/qLy8af+xCz+3o+ZpbL1n2bx137bLP5+vmCWynKeYgZfPzdS0raMLFq0iLFjx/Loo4+ydetWunbtSu/evUlJSTE7tAKdPHmSNm3a8OKLLxZaplevXqSmpnoeS5curcAIi3fxxRczZcoUNm3axKZNm7jqqqvo37+/5w/o2WefZcaMGbz44ots3LiRqKgoevTowfHjx02OPL+NGzcyZ84cWrdunW+dLx+HY8eO0blzZwIDA1m2bBk7duxg+vTp1KpVy1PG14/Dxo0b87RvcnIyADfffLOnjC8fA4CRI0eSnJzMW2+9xfbt20lMTOSaa67hwIEDgO8fg6pG/UXFUl9hPvUVvkP9ReXib/2JWfy9HzNLZeo/zeKv/bZZKsP5glkqy3mKGXz+3MiQMtGhQwdj9OjReZY1b97cGD9+vEkRlRxgfPjhh3mWDRs2zOjfv78p8ZyP2rVrG6+++qrhcrmMqKgoY8qUKZ51p0+fNmrWrGn897//NTHC/I4fP240bdrUSE5ONrp162bcd999nnW+fhwefvhho0uXLoWu96fjkOu+++4zGjdubLhcLsMwfP8YZGRkGDabzfjss8/yLG/Tpo3x6KOP+uUxqOzUX5hPfUXFUl/hG9RfVD7+3J+YpbL0Y2bxx/7TLP7cb5ulMp4vmMUfz1PM4A/nRhppWwaysrLYvHkziYmJeZYnJiayfv16k6I6f6tWrSIiIoJmzZoxatQo0tLSzA6pUE6nk4ULF3Ly5EkSEhLYu3cvBw8ezHNM7HY73bp187ljctddd9GnTx+uueaaAtf78nH45JNPiI+P5+abbyYiIoJ27drxyiuveNb703EA99/y/PnzGT58OBaLxbPcl49BdnY2TqeT4ODgPMtDQkJYt26d3x2Dyk79hbnUV5hDfYVvUH9RuVTW/sQsvv73azZ/7j/N4s/9tlkq2/mCWfz1PMUM/nBupKRtGTh8+DBOp5PIyMg8yyMjIzl48KBJUZ2f3r178/bbb/PFF18wffp0Nm7cyFVXXUVmZqbZoeWxfft2qlevjt1uZ/To0Xz44YfExsZ62t3Xj8nChQvZsmULkydPLnC9rx+HPXv2MHv2bJo2bcqKFSsYPXo09957L/PmzQPwm+OQ66OPPuLPP//k9ttv9yzz9WNQo0YNEhIS+Pe//83vv/+O0+lk/vz5fP3116SmpvrdMajs1F+YQ32FudRX+Ab1F5VLZexPzOIPf79m8ff+0yz+3m+bpbKdL5jFX89TzOAP50YBFfIuVcTZ32KAe8Lic5f5i0GDBnl+btmyJfHx8cTExLBkyRJuvPFGEyPL65JLLmHbtm38+eefLF68mGHDhrF69WrPel8+Jvv37+e+++4jKSkp3zc7uXz9OLhcLuLj43n66acBaNeuHT/88AOzZ89m6NChnnK+fBzO9tprr9G7d2/q1q3rWebrxwDgrbfeYvjw4Vx00UXYbDbat2/PbbfdxpYtWzxl/OUYVBWV6Xj4w9+I+gpzqa8w/xjkUn9R+eh4nT9/+fs1gz/3n2apDP22WSrb+YJZ/Pk8xQy+fm6kkbZlIDw8HJvNli/TnpaWli8j76+io6OJiYnhp59+MjuUPIKCgmjSpAnx8fFMnjyZNm3a8PzzzxMVFQXg08dk8+bNpKWlERcXR0BAAAEBAaxevZoXXniBgIAAnE5nvm187ThER0cTGxubZ1mLFi08N8Dwh+OQa9++fXz++eeMHDmyyHK+dgwAGjduzOrVqzlx4gT79+/nm2++weFw0LBhQ786BlWB+gtzqK8wl/oK36H+ovKoCv2JWXz179cM/tx/mqUy9NtmqUznC2bx9/MUM/j6uZGStmUgKCiIuLg4zx36ciUnJ9OpUyeToipbR44cYf/+/URHR5sdSpEMwyAzM9PzB3b2McnKymL16tU+c0yuvvpqtm/fzrZt2zyP+Ph4/va3v7Ft2zZsNlu+bXztOHTu3Jldu3blWbZ7925iYmIA/OI45HrjjTeIiIigT58+RZbztWNwtmrVqhEdHc2xY8dYsWIF/fv396tjUBWov/AN6isqlvoK36P+wv9Vhf7ELL7+92smf+o/zVIZ+m2zVKbzBbNUlvMUM/jsuVGF3O6sCli4cKERGBhovPbaa8aOHTuMsWPHGtWqVTN+/fVXs0Mr0PHjx42tW7caW7duNQBjxowZxtatW419+/YZx48fN/7v//7PWL9+vbF3715j5cqVRkJCgnHRRRcZ6enpZofuMWHCBGPNmjXG3r17je+++8545JFHDKvVaiQlJRmGYRhTpkwxatasaXzwwQfG9u3bjVtvvdWIjo72qTqc6+w7i/rDcfjmm2+MgIAA46mnnjJ++ukn4+233zZCQ0ON+fPne8r4w3FwOp1G/fr1jYcffjjPcn84BoZhGMuXLzeWLVtm7Nmzx0hKSjLatGljdOjQwcjKyjIMwz+OQVWi/qJiqa8wn/oK36H+onLxt/7ELP7ej5mlMvafZvG3ftssleV8wSyV4TzFDL5+bqSkbRl66aWXjJiYGCMoKMho3769sXr1arNDKtTKlSsNIN9j2LBhRkZGhpGYmGhceOGFRmBgoFG/fn1j2LBhRkpKitlh5zF8+HBPe1944YXG1Vdf7TmJMAzDcLlcxuOPP25ERUUZdrvduOKKK4zt27ebGHHxzu7Q/eU4fPrpp0bLli0Nu91uNG/e3JgzZ06e9f5wHFasWGEAxq5du/Is95djsGjRIqNRo0ZGUFCQERUVZdx1113Gn3/+6VnvD8egqlF/UXHUV/gG9RW+Qf1F5eNP/YlZ/L0fM0tl7D/N4o/9tlkqw/mCWSrDeYoZfP3cyGIYhlExY3pFREREREREREREpDia01ZERERERERERETEhyhpKyIiIiIiIiIiIuJDlLQVERERERERERER8SFK2oqIiIiIiIiIiIj4ECVtRURERERERERERHyIkrYiIiIiIiIiIiIiPkRJWxEREREREREREREfoqStSAX79ddfsVgsbNu2rcTbzJ07l1q1apVbTCIi4lvUV4iIiPgP9dsiUh6UtBURERERERERERHxIUraioiIiIiIiIiIiPgQJW1FysHy5cvp0qULtWrV4oILLuC6667jl19+KbDsqlWrsFgsLFmyhDZt2hAcHEzHjh3Zvn17vrIrVqygRYsWVK9enV69epGamupZt3HjRnr06EF4eDg1a9akW7dubNmypdzqKCIi50d9hYiIiP9Qvy0iFU1JW5FycPLkScaNG8fGjRv53//+h9Vq5YYbbsDlchW6zYMPPsi0adPYuHEjERER9OvXD4fD4VmfkZHBtGnTeOutt1izZg0pKSk88MADnvXHjx9n2LBhrF27lq+++oqmTZty7bXXcvz48XKtq4iIeEd9hYiIiP9Qvy0iFc4QkXKXlpZmAMb27duNvXv3GoCxdetWwzAMY+XKlQZgLFy40FP+yJEjRkhIiLFo0SLDMAzjjTfeMADj559/9pR56aWXjMjIyELfMzs726hRo4bx6aeflk+lRESkTKmvEBER8R/qt0WkvGmkrUg5+OWXX7jtttto1KgRYWFhNGzYEICUlJRCt0lISPD8XKdOHS655BJ27tzpWRYaGkrjxo09r6Ojo0lLS/O8TktLY/To0TRr1oyaNWtSs2ZNTpw4UeR7ioiIedRXiIiI+A/12yJS0QLMDkCkMurbty/16tXjlVdeoW7durhcLlq2bElWVlap9mOxWDw/BwYG5ltnGIbn9e23384ff/zBzJkziYmJwW63k5CQUOr3FBGRiqG+QkRExH+o3xaRiqakrUgZO3LkCDt37uTll1+ma9euAKxbt67Y7b766ivq168PwLFjx9i9ezfNmzcv8fuuXbuWWbNmce211wKwf/9+Dh8+7EUNRESkvKmvEBER8R/qt0XEDEraipSx2rVrc8EFFzBnzhyio6NJSUlh/PjxxW73xBNPcMEFFxAZGcmjjz5KeHg4119/fYnft0mTJrz11lvEx8eTnp7Ogw8+SEhIyHnUREREyov6ChEREf+hfltEzKA5bUXKmNVqZeHChWzevJmWLVty//33M3Xq1GK3mzJlCvfddx9xcXGkpqbyySefEBQUVOL3ff311zl27Bjt2rVjyJAh3HvvvURERJxPVUREpJyorxAREfEf6rdFxAwW4+wJU0Skwq1atYorr7ySY8eOUatWLbPDERERH6S+QkRExH+o3xaRsqCRtiIiIiIiIiIiIiI+RElbERERERERERERER+i6RFEREREREREREREfIhG2oqIiIiIiIiIiIj4ECVtRURERERERERERHyIkrYiIiIiIiIiIiIiPkRJWxEREREREREREREfoqStiIiIiIiIiIiIiA9R0lZERERERERERETEhyhpKyIiIiIiIiIiIuJDlLQVERERERERERER8SFK2oqIiIiIiIiIiIj4kP8Hg2m2nTDW8P8AAAAASUVORK5CYII=",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "cv_along = out_lr_fib['major_axis_length'] / 2 * model.dr / model.t_max\n",
+ "cv_across = out_lr_fib['minor_axis_length'] / 2 * model.dr / model.t_max\n",
+ "\n",
+ "fig, axs = plt.subplot_mosaic([[f'{i}' for i in range(7)],\n",
+ " ['axis_ratio'] * 2 + ['orientation']*2 +\n",
+ " ['min_max'] * 3],\n",
+ " figsize=(14, 7))\n",
+ "\n",
+ "mins = []\n",
+ "maxs = []\n",
+ "for i in range(len(alphas)):\n",
+ " ax = axs[f'{i}']\n",
+ " ax.imshow(images_lr_fib[i], cmap='jet', origin='lower')\n",
+ " ax.set_title(f'{np.degrees(alphas[i]):.0f}')\n",
+ "\n",
+ " mins.append(images_lr_fib[i].min())\n",
+ " maxs.append(images_lr_fib[i].max())\n",
+ " \n",
+ "\n",
+ "ax = axs['axis_ratio']\n",
+ "ax.plot(out_lr_fib['alpha'], cv_along, 'o-', label='Along')\n",
+ "ax.plot(out_lr_fib['alpha'], cv_across, 'o-', label='Across')\n",
+ "ax.set_xlabel('alpha')\n",
+ "ax.set_ylabel('CV, mm/ms')\n",
+ "ax.set_xticks(np.degrees(alphas))\n",
+ "ax.grid(True)\n",
+ "ax.legend()\n",
+ "\n",
+ "out_lr_fib.loc[out_lr_fib['orientation'] < 0, 'orientation'] += 180\n",
+ "\n",
+ "orientation = out_lr_fib['orientation'].values\n",
+ "orientation[orientation > 90] = 180 - orientation[orientation > 90]\n",
+ "\n",
+ "ax = axs['orientation']\n",
+ "ax.plot(out_lr_fib['alpha'], orientation, 'o-')\n",
+ "ax.set_xlabel('alpha')\n",
+ "ax.set_ylabel('orientation')\n",
+ "ax.set_xticks(np.degrees(alphas))\n",
+ "ax.set_yticks(np.degrees(alphas))\n",
+ "ax.grid(True)\n",
+ "\n",
+ "ax = axs['min_max']\n",
+ "ax.plot(np.degrees(alphas), mins, 'o-', label='min')\n",
+ "ax.plot(np.degrees(alphas), maxs, 'o-', label='max')\n",
+ "ax.set_xlabel('alpha')\n",
+ "ax.set_ylabel('min/max')\n",
+ "ax.set_xticks(np.degrees(alphas))\n",
+ "ax.grid(True)\n",
+ "\n",
+ "plt.tight_layout()\n",
+ "plt.show()"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.11.0"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Tutorials/RestitutionCurve.ipynb b/Tutorials/RestitutionCurve.ipynb
new file mode 100644
index 0000000..3598a12
--- /dev/null
+++ b/Tutorials/RestitutionCurve.ipynb
@@ -0,0 +1,531 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "e4bfc0ea-408e-45a9-a4fc-e026929f2cab",
+ "metadata": {},
+ "source": [
+ "## Restitution curve\n",
+ "\n",
+ "This tutorial demonstrates an implementation of the classical S1–S2 extrastimulus protocol for measuring APD restitution using the\n",
+ "Luo-Rudy 1991 cardiac electrophysiology model in a 2D tissue.\n",
+ "\n",
+ "Protocol Overview:\n",
+ "------------------\n",
+ "- Tissue: 2D grid of size 100×10\n",
+ "- Model: Luo-Rudy 1991 (LuoRudy912D)\n",
+ "- S1 stimulation:\n",
+ " - 10 beats at 400 ms cycle length\n",
+ " - Current stimulus applied to a small region near the top\n",
+ "- State saving:\n",
+ " - State saved at the end of the 10th beat (after ~3600 ms)\n",
+ "- S2 protocol:\n",
+ " - Single voltage stimulus applied at various coupling intervals (400 → 25 ms)\n",
+ " - Model resumes from saved S1 state\n",
+ " - Response recorded at the center of the domain\n",
+ " - APD90 and DI calculated from the S2 action potential\n",
+ "- Plot: APD90 vs DI — the restitution curve\n",
+ "\n",
+ "Reference:\n",
+ "----------\n",
+ "Protocol adapted from:\n",
+ "\n",
+ "Goldhaber JI, Xie L-H, Duong T, Motter C, Khuu K, Weiss JN.\n",
+ "\"Action Potential Duration Restitution and Alternans in Rabbit Ventricular Myocytes:\n",
+ "The Key Role of Intracellular Calcium Cycling.\"\n",
+ "Circulation Research. 2005 Jan 20;96(4):459–466.\n",
+ "https://doi.org/10.1161/01.RES.0000156891.66893.83"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "f9e47aa7-206a-4cd1-b410-4dd8b08d07be",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "import shutil\n",
+ "import finitewave as fw\n",
+ "\n",
+ "# Setup\n",
+ "ni = 100\n",
+ "nj = 10\n",
+ "cell = [ni//2, nj//2]\n",
+ "s1_cl = 400 # ms\n",
+ "num_s1 = 10 # number of S1 beats\n",
+ "s2_intervals = np.arange(400, 0, -25)\n",
+ "stim_amp = 50\n",
+ "stim_dur = 1 # ms\n",
+ "threshold_up = -20 # mV\n",
+ "save_time = (num_s1-1) * s1_cl"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4dd13fc6-ae95-44f1-ad0f-e1e54660ecdb",
+ "metadata": {},
+ "source": [
+ "### Step 1: Prepacing beats\n",
+ "\n",
+ "Finitewave’s `StateSaver` and `StateLoader` features are used to avoid\n",
+ "repeating the long S1 pacing train for every S2 interval. The model\n",
+ "is pre-paced once with 10 regular stimuli at 400 ms intervals to reach\n",
+ "steady state, and the state is saved after the final S1 beat."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "dec939d9-834a-4b32-b925-d070953e9f95",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running pre-pacing...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n",
+ "Running LuoRudy912D: 100%|██████████▉| 360000/360001 [00:32<00:00, 10982.81it/s]\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Pre-pace the tissue with 10 S1 beats\n",
+ "tissue = fw.CardiacTissue2D((ni, nj))\n",
+ "stim_sequence = fw.StimSequence()\n",
+ "for i in range(num_s1):\n",
+ " t = i * s1_cl\n",
+ " stim_sequence.add_stim(fw.StimCurrentCoord2D(t, stim_amp, stim_dur, \n",
+ " 0, 5,\n",
+ " 0, nj))\n",
+ "\n",
+ "# Save state after 10 S1 beats to reuse for S2 branches\n",
+ "state_savers = fw.StateSaverCollection()\n",
+ "state_savers.savers.append(fw.StateSaver(\"s1_state\", time=save_time))\n",
+ "\n",
+ "# set up tracker parameters:\n",
+ "tracker_sequence = fw.TrackerSequence()\n",
+ "action_pot_tracker = fw.ActionPotential2DTracker()\n",
+ "action_pot_tracker.cell_ind = [[5, 5]]\n",
+ "action_pot_tracker.step = 1\n",
+ "tracker_sequence.add_tracker(action_pot_tracker)\n",
+ "\n",
+ "model = fw.LuoRudy912D()\n",
+ "model.dt = 0.01\n",
+ "model.dr = 0.25\n",
+ "model.t_max = save_time + model.dt\n",
+ "model.cardiac_tissue = tissue\n",
+ "model.stim_sequence = stim_sequence\n",
+ "model.tracker_sequence = tracker_sequence\n",
+ "model.state_saver = state_savers\n",
+ "\n",
+ "print(\"Running pre-pacing...\")\n",
+ "model.run()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "bfa9d8be-dddd-4710-a2c3-1771ec833766",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# plot the action potential to visualize prepacing beats stimuli\n",
+ "time = np.arange(len(action_pot_tracker.output)) * model.dt\n",
+ "\n",
+ "fig, ax = plt.subplots(1, 1, figsize=(10, 5)) \n",
+ "plt.plot(time, action_pot_tracker.output, label=\"Action potential\")\n",
+ "plt.legend(title='Prepacing beats')\n",
+ "ax.set_xlabel('Time (ms)')\n",
+ "ax.set_ylabel('Membrane potential (mV)')\n",
+ "plt.grid()\n",
+ "plt.tight_layout()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "396b913c-279b-43a2-a02a-e214efd5c0a8",
+ "metadata": {},
+ "source": [
+ "## Step 2: S2 stimulus\n",
+ "\n",
+ "Restitution is assessed by applying a single S2 stimulus at progressively\n",
+ "shorter coupling intervals (i.e., varying delays after the last S1),\n",
+ "and measuring:\n",
+ " - APD90: Action potential duration at 90% repolarization\n",
+ " - DI: Diastolic interval (delay between end of S1 AP and start of S2)\n",
+ "\n",
+ "Only the S2 response is simulated in each run, making the protocol fast\n",
+ "and scalable."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "df61139b-4f33-4fed-97b1-8a59377e31dc",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +400 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:07<00:00, 11099.97it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +375 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:06<00:00, 11452.43it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +350 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:07<00:00, 10303.80it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +325 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:07<00:00, 10199.24it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +300 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:07<00:00, 10483.13it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +275 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|██████████████| 80000/80000 [00:08<00:00, 9968.72it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +250 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:07<00:00, 10221.69it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +225 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:07<00:00, 11230.84it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +200 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:07<00:00, 10743.75it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +175 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:07<00:00, 10595.38it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +150 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:07<00:00, 10554.29it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +125 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:06<00:00, 11687.73it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +100 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:06<00:00, 11733.73it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +75 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:06<00:00, 11506.06it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +50 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:06<00:00, 11694.09it/s]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running S2 at +25 ms...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running LuoRudy912D: 100%|█████████████| 80000/80000 [00:07<00:00, 11361.14it/s]\n"
+ ]
+ }
+ ],
+ "source": [
+ "di_values = []\n",
+ "apd90_values = []\n",
+ "\n",
+ "# Run S2 branches\n",
+ "for s2_delay in s2_intervals:\n",
+ " stim_sequence = fw.StimSequence()\n",
+ " s2_time = s2_delay\n",
+ " stim_sequence.add_stim(fw.StimVoltageCoord2D(s2_time, stim_amp,\n",
+ " 0, 5,\n",
+ " 0, nj))\n",
+ "\n",
+ " tracker_sequence = fw.TrackerSequence()\n",
+ " ap_tracker = fw.ActionPotential2DTracker()\n",
+ " ap_tracker.cell_ind = [cell]\n",
+ " ap_tracker.step = 1\n",
+ " tracker_sequence.add_tracker(ap_tracker)\n",
+ "\n",
+ " model = fw.LuoRudy912D()\n",
+ " model.dt = 0.01\n",
+ " model.dr = 0.25\n",
+ " model.t_max = 800 # allow repolarization\n",
+ " model.cardiac_tissue = tissue\n",
+ " model.stim_sequence = stim_sequence\n",
+ " model.tracker_sequence = tracker_sequence\n",
+ " model.state_loader = fw.StateLoader(\"s1_state\")\n",
+ "\n",
+ " print(f\"Running S2 at +{s2_delay} ms...\")\n",
+ " model.run()\n",
+ "\n",
+ " u = ap_tracker.output\n",
+ " t = np.arange(len(u)) * model.dt\n",
+ "\n",
+ " # Find upstroke\n",
+ " up = np.where((u[:-1] < threshold_up) & (u[1:] >= threshold_up))[0]\n",
+ " if len(up) == 0:\n",
+ " print(f\"Loss of capture at S2 interval = {s2_delay} ms.\")\n",
+ " break\n",
+ " ap_start = up[-1]\n",
+ "\n",
+ " peak = np.max(u[ap_start:])\n",
+ " repol_level = peak - 0.9 * (peak - np.min(u[ap_start:]))\n",
+ " repol_idx = np.where(u[ap_start:] < repol_level)[0]\n",
+ " if len(repol_idx) == 0:\n",
+ " continue\n",
+ " ap_end = ap_start + repol_idx[0]\n",
+ " apd90 = (ap_end - ap_start) * model.dt\n",
+ " di = s2_delay\n",
+ "\n",
+ " if di <= 0:\n",
+ " continue\n",
+ "\n",
+ " apd90_values.append(apd90)\n",
+ " di_values.append(di)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "23763527-7ef7-43a2-b648-2b23234ae50f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Plot restitution curve\n",
+ "plt.figure()\n",
+ "plt.plot(di_values, apd90_values, 'o-')\n",
+ "plt.xlabel(\"Diastolic Interval (ms)\")\n",
+ "plt.ylabel(\"APD90 (ms)\")\n",
+ "plt.title(\"S1–S2 Restitution Curve (Luo-Rudy 2D)\")\n",
+ "plt.grid()\n",
+ "plt.tight_layout()\n",
+ "plt.show()\n",
+ "\n",
+ "# Cleanup saved state\n",
+ "shutil.rmtree(\"s1_state\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2be432a7-63b4-49e4-9c30-0ef1ee06e0f9",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.11.0"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Tutorials/SpiralWaves2D.ipynb b/Tutorials/SpiralWaves2D.ipynb
new file mode 100644
index 0000000..d8342fa
--- /dev/null
+++ b/Tutorials/SpiralWaves2D.ipynb
@@ -0,0 +1,416 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Spiral Wave Initiation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Temporal block"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running AlievPanfilov2D: 100%|██████████| 1000/1000 [00:00<00:00, 3580.19it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 3600/3601 [00:00<00:00, 4181.81it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 10398/10400 [00:02<00:00, 4158.74it/s]\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "import finitewave as fw\n",
+ "\n",
+ "\n",
+ "class UpdateMesh(fw.Command):\n",
+ " \"\"\"\n",
+ " Update the mesh of the cardiac tissue during the simulation.\n",
+ " \"\"\"\n",
+ " def __init__(self, time, updated_mesh):\n",
+ " \"\"\"\n",
+ " Initialize the command with the time and the updated mesh.\n",
+ "\n",
+ " Args:\n",
+ " time (int): The time at which the mesh is updated.\n",
+ " updated_mesh (numpy.ndarray): The updated mesh.\n",
+ " \"\"\"\n",
+ " super().__init__(time)\n",
+ " self.updated_mesh = updated_mesh\n",
+ "\n",
+ " def execute(self, model):\n",
+ " model.cardiac_tissue.mesh = self.updated_mesh\n",
+ " model.compute_weights()\n",
+ "\n",
+ "\n",
+ "# set up the tissue:\n",
+ "n = 256\n",
+ "tissue = fw.CardiacTissue2D([n, n])\n",
+ "tissue.mesh[n//2, :n//2] = 2\n",
+ "\n",
+ "mesh_without_block = tissue.mesh.copy()\n",
+ "mesh_without_block[n//2, :n//2] = 1\n",
+ "\n",
+ "# set up stimulation parameters:\n",
+ "stim_sequence = fw.StimSequence()\n",
+ "stim_sequence.add_stim(fw.StimVoltageCoord2D(time=0, volt_value=1,\n",
+ " x1=0, x2=n//2, y1=0, y2=5))\n",
+ "# stim_sequence.add_stim(fw.StimVoltageCoord2D(time=50, volt_value=1,\n",
+ "# x1=n//2, x2=n, y1=0, y2=n))\n",
+ "\n",
+ "command_sequence = fw.CommandSequence()\n",
+ "command_sequence.add_command(UpdateMesh(45, mesh_without_block))\n",
+ "\n",
+ "# create model object:\n",
+ "model = fw.AlievPanfilov2D()\n",
+ "# set up numerical parameters:\n",
+ "model.dt = 0.01\n",
+ "model.dr = 0.3\n",
+ "model.t_max = 10\n",
+ "\n",
+ "# add the tissue and the stim parameters to the model object:\n",
+ "model.cardiac_tissue = tissue\n",
+ "model.stim_sequence = stim_sequence\n",
+ "model.command_sequence = command_sequence\n",
+ "\n",
+ "model.run()\n",
+ "u_10 = model.u.copy()\n",
+ "\n",
+ "model.t_max = 46\n",
+ "model.run(initialize=False)\n",
+ "u_46 = model.u.copy()\n",
+ "\n",
+ "model.t_max = 150\n",
+ "model.run(initialize=False)\n",
+ "u_150 = model.u.copy()\n",
+ "\n",
+ "\n",
+ "fig, axs = plt.subplots(ncols=3)\n",
+ "axs[0].imshow(u_10, cmap='hot')\n",
+ "axs[1].imshow(u_46, cmap='hot')\n",
+ "axs[2].imshow(u_150, cmap='hot')\n",
+ "plt.show()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Two cross stimuls (S1S2)\n",
+ "\n",
+ "This section demonstrates how to initiate a **spiral wave** in 2D cardiac tissue \n",
+ "using a classical **cross-field S1–S2 stimulation** protocol.\n",
+ "\n",
+ "The protocol applies two stimuli:\n",
+ "1. **S1**: a planar wave from one edge (top to bottom)\n",
+ "2. **S2**: a transverse wave from one side (left to right)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running AlievPanfilov2D: 100%|██████████| 5100/5100 [00:01<00:00, 4119.51it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 14900/14901 [00:03<00:00, 4153.31it/s]\n"
+ ]
+ }
+ ],
+ "source": [
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "import finitewave as fw\n",
+ "\n",
+ "# set up the tissue:\n",
+ "n = 256\n",
+ "tissue = fw.CardiacTissue2D([n, n])\n",
+ "\n",
+ "\n",
+ "# set up stimulation parameters:\n",
+ "stim_sequence = fw.StimSequence()\n",
+ "stim_sequence.add_stim(fw.StimVoltageCoord2D(time=0, volt_value=1,\n",
+ " x1=0, x2=n, y1=0, y2=5))\n",
+ "stim_sequence.add_stim(fw.StimVoltageCoord2D(time=50, volt_value=1,\n",
+ " x1=n//2, x2=n, y1=0, y2=n))\n",
+ "\n",
+ "# create model object:\n",
+ "model = fw.AlievPanfilov2D()\n",
+ "# set up numerical parameters:\n",
+ "model.dt = 0.01\n",
+ "model.dr = 0.3\n",
+ "model.t_max = 51\n",
+ "# add the tissue and the stim parameters to the model object:\n",
+ "model.cardiac_tissue = tissue\n",
+ "model.stim_sequence = stim_sequence\n",
+ "\n",
+ "model.run()\n",
+ "\n",
+ "u_s2 = model.u.copy() # save the model at the moment of the second stimulation\n",
+ "\n",
+ "model.t_max = 200\n",
+ "model.run(initialize=False)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# show the spiral waves initiation (t = 51) and final stabilization (t = 251)\n",
+ "fig, axs = plt.subplots(ncols=2)\n",
+ "axs[0].imshow(u_s2, cmap='hot')\n",
+ "axs[0].set_title(\"t = 51\")\n",
+ "axs[1].imshow(model.u, cmap='hot')\n",
+ "axs[1].set_title(\"t = 251\")\n",
+ "plt.tight_layout()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Equvidistant Stimulation\n",
+ "This section demonstrates **periodic stimulation** (paced activation) of 2D cardiac tissue with **diffuse fibrosis** that is finaly causing instability due to a high fibrosis density.\n",
+ "Here we use 35% randomly distributed **diffuse fibrosis** using `Diffuse2DPattern` - this introduces structural heterogeneity and **wavefront breakup**.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running AlievPanfilov2D: 100%|█████████▉| 9999/10000 [00:01<00:00, 5216.09it/s]\n",
+ "Running AlievPanfilov2D: 100%|██████████| 20000/20000 [00:03<00:00, 5326.11it/s]\n"
+ ]
+ }
+ ],
+ "source": [
+ "\n",
+ "import numpy as np\n",
+ "np.random.seed(123) # for reproducibility \n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "import finitewave as fw\n",
+ "\n",
+ "\n",
+ "# set up the tissue:\n",
+ "n = 256\n",
+ "tissue = fw.CardiacTissue2D([n, n])\n",
+ "tissue.add_pattern(fw.Diffuse2DPattern(0.35))\n",
+ "\n",
+ "# set up stimulation parameters:\n",
+ "stim_sequence = fw.StimSequence()\n",
+ "\n",
+ "# stimulate the tissue at the top border with a time step of 28:\n",
+ "for t in [0, 28, 56, 84]:\n",
+ " stim_sequence.add_stim(fw.StimVoltageCoord2D(time=t, volt_value=1,\n",
+ " x1=0, x2=n, y1=0, y2=5))\n",
+ "\n",
+ "# create model object:\n",
+ "model = fw.AlievPanfilov2D()\n",
+ "# set up numerical parameters:\n",
+ "model.dt = 0.01\n",
+ "model.dr = 0.3\n",
+ "model.t_max = 100\n",
+ "# add the tissue and the stim parameters to the model object:\n",
+ "model.cardiac_tissue = tissue\n",
+ "model.stim_sequence = stim_sequence\n",
+ "\n",
+ "model.run()\n",
+ "u_s2 = model.u.copy() # save the model during the fragmentation process\n",
+ "\n",
+ "model.t_max = 300\n",
+ "model.run(initialize=False)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# show the wavefront fragmentation process t = 100) and the instability (t = 300) \n",
+ "fig, axs = plt.subplots(ncols=2)\n",
+ "axs[0].imshow(u_s2, cmap='hot')\n",
+ "axs[0].set_title(\"t = 100\")\n",
+ "axs[1].imshow(model.u, cmap='hot')\n",
+ "axs[1].set_title(\"t = 300\")\n",
+ "plt.tight_layout()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### S1S2 protocol with shorter S2\n",
+ "\n",
+ "In this section we initiate a **spiral wave** with **26% diffuse fibrosis**. Here we also use \n",
+ "**S1–S2 protocol**, where the final extrastimulus (S2) is delivered at a shorter coupling interval \n",
+ "than the preceding regular pacing beats (S1)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Running AlievPanfilov2D: 100%|██████████| 16000/16000 [00:03<00:00, 4936.90it/s]\n",
+ "Running AlievPanfilov2D: 100%|█████████▉| 24000/24001 [00:04<00:00, 4842.59it/s]\n"
+ ]
+ }
+ ],
+ "source": [
+ "np.random.seed(27)\n",
+ "import matplotlib.pyplot as plt\n",
+ "import finitewave as fw\n",
+ "\n",
+ "# set up the tissue:\n",
+ "n = 256\n",
+ "tissue = fw.CardiacTissue2D([n, n])\n",
+ "tissue.add_pattern(fw.Diffuse2DPattern(0.26))\n",
+ "\n",
+ "# set up stimulation parameters:\n",
+ "stim_sequence = fw.StimSequence()\n",
+ "# stimulate the tissue with a 2x45 prebeats, 3x30 s1 and 1x23 s2:\n",
+ "prebeats = np.array([0, 45])\n",
+ "s1 = prebeats[-1] + np.array([30, 2 * 30, 3 * 30])\n",
+ "s2 = s1[-1] + np.array([23])\n",
+ "for t in np.concatenate([prebeats, s1, s2]):\n",
+ " stim_sequence.add_stim(fw.StimVoltageCoord2D(time=t, volt_value=1,\n",
+ " x1=0, x2=n, y1=0, y2=5))\n",
+ "\n",
+ "# create model object:\n",
+ "model = fw.AlievPanfilov2D()\n",
+ "# set up numerical parameters:\n",
+ "model.dt = 0.01\n",
+ "model.dr = 0.3\n",
+ "model.t_max = s2[-1] + 2\n",
+ "# add the tissue and the stim parameters to the model object:\n",
+ "model.cardiac_tissue = tissue\n",
+ "model.stim_sequence = stim_sequence\n",
+ "\n",
+ "model.run()\n",
+ "u_s2 = model.u.copy()\n",
+ "\n",
+ "model.t_max = 400\n",
+ "model.run(initialize=False)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# show the wavefront sequence (t = 159) and the stable spiral wave (t = 400)\n",
+ "fig, axs = plt.subplots(ncols=2)\n",
+ "axs[0].imshow(u_s2, cmap='hot')\n",
+ "axs[0].set_title(f\"t = {s2[-1] + 1}\")\n",
+ "axs[1].imshow(model.u, cmap='hot')\n",
+ "axs[1].set_title(\"t = 400\")\n",
+ "plt.tight_layout()\n",
+ "plt.show()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "base",
+ "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.12.6"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/examples/README.md b/examples/README.md
old mode 100755
new mode 100644
index b66d1a5..a495d95
--- a/examples/README.md
+++ b/examples/README.md
@@ -1,22 +1,50 @@
-# Finitewave examples
+# Finitewave Examples
-This directory contains a collection of examples that demonstrate the usage and capabilities of the Finitewave package. These examples are organized into different sections to help you get started with basic simulations and explore more advanced tools, such as trackers.
+This directory contains a collection of **example scripts** demonstrating how to use the Finitewave framework for cardiac electrophysiology simulations.
-## Recommendations
+The examples are organized into subdirectories by topic. They cover a range of use cases — from basic functionality to advanced simulation setups.
-To run an example, navigate to the corresponding directory and execute the script. For instance, to run the Aliev-Panfilov 2D Anisotropic simulation:
+## Structure
-```sh
-cd basic
-python aliev_panfilov_2D_aniso.py
-```
+### 📁 `basics/`
-## Examples structure
+Examples of **basic framework usage** and common cardiac phenomena:
-*/basic*
+- How to initialize and run 2D and 3D simulations
+- Visualization of wave propagation
+- Modeling of typical phenomena such as **spiral waves/reentry**
-This section introduces the fundamental usage of the Finitewave package, providing minimal examples that demonstrate how to set up and execute simple cardiac simulations.
+### 📁 `fibrosis/`
-*/trackers/*
+Examples of **simulations in fibrotic tissue**:
-This section showcases the usage of various tracking tools provided by Finitewave. Trackers are used to perform measurements and gather data during simulations, which is crucial for analyzing the behavior of the cardiac models.
\ No newline at end of file
+- Preparing fibrosis maps
+- Studying wave behavior in heterogeneous tissue
+
+### 📁 `models/`
+
+**Minimal working examples** for each of the **electrophysiological models** implemented in Finitewave:
+
+- Demonstrate basic usage of each model in isolation
+
+### 📁 `stimulation/`
+
+Examples of different **stimulation protocols**:
+
+- stimulation by current/voltage
+- stimulation by coordinates, matrices
+- making stimulation sequences
+
+### 📁 `trackers/`
+
+Examples of using **trackers** included in the framework:
+
+- How to measure activation times, APD, egm, period maps, etc.
+- How to record and analyze simulation results during runtime
+
+## How to run
+
+You can run any example by executing it as a Python script:
+
+```bash
+python examples//
diff --git a/examples/README.rst b/examples/README.rst
new file mode 100644
index 0000000..8bd31c7
--- /dev/null
+++ b/examples/README.rst
@@ -0,0 +1,4 @@
+Examples
+===========
+
+This directory contains examples of how to use the finitewave library.
\ No newline at end of file
diff --git a/examples/basic/2D/aliev_panfilov_2D_aniso.py b/examples/basic/2D/aliev_panfilov_2D_aniso.py
deleted file mode 100755
index ae1e37d..0000000
--- a/examples/basic/2D/aliev_panfilov_2D_aniso.py
+++ /dev/null
@@ -1,50 +0,0 @@
-
-#
-# Aniosotropic tissue (fibers at 45 degrees) with the Aliev-Panfilov model.
-# Anisotropy is set by specifying a fiber array (CardiacTissue class) and
-# diffusion coefficients D_al, D_ac (diffusion along and across fibers).
-# Alqways use AsymmetricStencil for weights computations in case of anisotropic tissue.
-#
-
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 400
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n])
-tissue.add_boundaries()
-# add fibers orientation vectors
-tissue.fibers = np.zeros([n, n, 2])
-tissue.fibers[:, :, 0] = np.cos(0.25 * np.pi)
-tissue.fibers[:, :, 1] = np.sin(0.25 * np.pi)
-# add numeric method stencil for weights computations
-tissue.stencil = fw.AsymmetricStencil2D()
-tissue.D_al = 1
-tissue.D_ac = tissue.D_al/9
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov2D()
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 30
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, n//2 - 3, n//2 + 3,
- n//2 - 3, n//2 + 3))
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-
-aliev_panfilov.run()
-
-# show the potential map at the end of calculations:
-# plt.figure()
-plt.imshow(aliev_panfilov.u)
-plt.show()
diff --git a/examples/basic/2D/aliev_panfilov_2D_conductivity.py b/examples/basic/2D/aliev_panfilov_2D_conductivity.py
deleted file mode 100644
index 4d85008..0000000
--- a/examples/basic/2D/aliev_panfilov_2D_conductivity.py
+++ /dev/null
@@ -1,47 +0,0 @@
-
-#
-# The basic example of running simple simuations with the Aliev-Panfilov model.
-# The model is a 2D model with isotropic stencil.
-# The model is stimulated with a voltage pulse in the center of the tissue.
-# Conductivity is set to 0.3 in the center of the tissue - this will deform the wavefront at the top of the square due to the slow propagation.
-#
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-import finitewave as fw
-
-
-# number of nodes on the side
-n = 400
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# add a conductivity array, all elements = 1.0 -> normal conductvity:
-tissue.conductivity = np.ones([n, n])
-tissue.conductivity[n//4 - n//10: n//4 + n//10,
- n//4 : n//4*3] = 0.3
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov2D()
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 30
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, n//2 - 3, n//2 + 3,
- n//2 - 3, n//2 + 3))
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-
-aliev_panfilov.run()
-
-# show the potential map at the end of calculations:
-plt.imshow(aliev_panfilov.u)
-plt.show()
diff --git a/examples/basic/2D/aliev_panfilov_2D_iso.py b/examples/basic/2D/aliev_panfilov_2D_iso.py
deleted file mode 100755
index 3d23be2..0000000
--- a/examples/basic/2D/aliev_panfilov_2D_iso.py
+++ /dev/null
@@ -1,43 +0,0 @@
-
-#
-# The basic example of running simple simuations with the Aliev-Panfilov model.
-# The model is a 2D model with isotropic stencil.
-# The model is stimulated with a voltage pulse in the center of the tissue.
-#
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 400
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n])
-tissue.add_boundaries()
-# add numeric method stencil for weights computations
-# IsotropicStencil is default stencil and will be ised if no stencil was specified
-tissue.stencil = fw.IsotropicStencil2D()
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov2D()
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 30
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, n//2 - 3, n//2 + 3,
- n//2 - 3, n//2 + 3))
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-
-aliev_panfilov.run()
-
-# show the potential map at the end of calculations:
-plt.imshow(aliev_panfilov.u)
-plt.show()
diff --git a/examples/basic/2D/commands_interruption.py b/examples/basic/2D/commands_interruption.py
deleted file mode 100644
index 8111d77..0000000
--- a/examples/basic/2D/commands_interruption.py
+++ /dev/null
@@ -1,61 +0,0 @@
-
-#
-# Sometimes you need to add nonstandard actions in your calculations.
-# Use the Command and CommandSequence classes to do this.
-# Every command must be initialized with execute() method in the Command-inherited class (Command class).
-# This method must have only one argument - model, that gives an access to its fields and methods.
-# To use this command first check the model implementation and define which parameters you are going
-# to modify (and in what time).
-#
-# In this example we are going to interrupt calculations when the propagation wave reaches the opposite side.
-# We will check the opposite side every 10 time units.
-# The calculation stops around 5% of its maximal time.
-#
-
-import numpy as np
-
-import finitewave as fw
-
-
-# number of nodes on the side
-n = 300
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-# add a conductivity array, all elements = 1.0 -> normal conductvity:
-tissue.cond = np.ones([n, n])
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov2D()
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 1000
-
-# Define the command:
-class InterruptCommand(fw.Command):
- def execute(self, model):
- if np.any(model.u[:, 298] > 0.5):
- # increase the calculation step to stop the execution loop.
- model.step = np.inf
-
-# We want to check the opposite side every 10 time units.
-# Thus we have a list of commands with the same method but different times.
-command_sequence = fw.CommandSequence()
-for i in range(0, 200, 10):
- command_sequence.add_command(InterruptCommand(i))
-
-aliev_panfilov.command_sequence = command_sequence
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, n, 0, 5))
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-
-aliev_panfilov.run()
diff --git a/examples/basic/2D/matrix_area_activation.py b/examples/basic/2D/matrix_area_activation.py
deleted file mode 100755
index ce4c14a..0000000
--- a/examples/basic/2D/matrix_area_activation.py
+++ /dev/null
@@ -1,45 +0,0 @@
-
-#
-# You can apply matrix area stimulation using StimVoltageMatrix2D.
-# stim_area - a boolean matrix of 0 (non-activated) and 1 (activated) points.
-#
-
-
-import matplotlib.pyplot as plt
-from skimage import draw
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 400
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n])
-tissue.add_boundaries()
-# add numeric method stencil for weights computations
-tissue.D_al = 1
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov2D()
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 30
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_area = np.full([400, 400], False, dtype=bool)
-ii, jj = draw.disk([200, 200], 10) # center/radius
-stim_area[ii, jj] = True
-stim_sequence.add_stim(fw.StimVoltageMatrix2D(0, 1, stim_area))
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-
-aliev_panfilov.run()
-
-# show the potential map at the end of calculations:
-# plt.figure()
-plt.imshow(aliev_panfilov.u)
-plt.show()
diff --git a/examples/basic/2D/sequential_stimulation.py b/examples/basic/2D/sequential_stimulation.py
deleted file mode 100644
index b2a1afd..0000000
--- a/examples/basic/2D/sequential_stimulation.py
+++ /dev/null
@@ -1,62 +0,0 @@
-
-#
-# Sequential stimulation that can be used for high pacing protocol simulation.
-# In this example we stimulate the tissue at 0, 30, 60, 90 time points with planar wave.
-# Here se used Current stimulation
-# Check the stim_sequence.mp4 to see the result.
-#
-
-import numpy as np
-import shutil
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 400
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n])
-tissue.add_boundaries()
-# add numeric method stencil for weights computations
-# IsotropicStencil is default stencil and will be ised if no stencil was specified
-tissue.stencil = fw.IsotropicStencil2D()
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov2D()
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 100
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-
-for t in [0, 30, 60, 90]: # time sequence (time, curr value, curr stim time, rectangular area)
- stim_sequence.add_stim(fw.StimCurrentCoord2D(t, 3, 0.1, 0, int(n*0.03),
- 0, n))
-
-tracker_sequence = fw.TrackerSequence()
-# add action potential tracker
-animation_tracker = fw.Animation2DTracker()
-# We want to write the animation for the voltage variable. Use string value
-# to specify the required array.anim_data
-animation_tracker.target_array = "u"
-# Folder name:
-animation_tracker.dir_name = "anim_data"
-animation_tracker.step = 1
-tracker_sequence.add_tracker(animation_tracker)
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-aliev_panfilov.run()
-
-animation_builder = fw.AnimationBuilder()
-animation_builder.dir_name = "anim_data"
-animation_builder.write_2d_mp4("stim_sequence.mp4")
-
-# remove the snapshots folder:
-shutil.rmtree("anim_data")
diff --git a/examples/basic/2D/using_states.py b/examples/basic/2D/using_states.py
deleted file mode 100755
index afb84f3..0000000
--- a/examples/basic/2D/using_states.py
+++ /dev/null
@@ -1,82 +0,0 @@
-
-#
-# In cases of heavy computations, it may be useful to dump the model state
-# and load it in the next session.
-# Use classes that inherit from StateKeeper to manage the model state.
-# Use the record_save string to define the folder where the state will be saved.
-# Use the record_load string to load the state from a specified folder.
-#
-
-import matplotlib.pyplot as plt
-import numpy as np
-import gc
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 100
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-# add a conductivity array, all elements = 1.0 -> normal conductvity:
-tissue.cond = np.ones([n, n])
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov2D()
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 5
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, n, 0, 3))
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-
-# save the "state" dir with model variables:
-model_state = fw.StateKeeper()
-model_state.record_save = "state"
-
-aliev_panfilov.state_keeper = model_state
-
-aliev_panfilov.run()
-
-# show the potential map at the end of calculations:
-plt.imshow(aliev_panfilov.u)
-plt.show()
-
-# We delete model and use gc.collect() to ask the virtual machine remove objects from memory.
-# Though it's not necessary to do this.
-del aliev_panfilov
-gc.collect()
-
-# # # # # # # # #
-
-# Here we create a new model and load state from the previous calculation to continue.
-
-# recreate the model
-aliev_panfilov = fw.AlievPanfilov2D()
-
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 4
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-
-# load the state dir:
-model_state = fw.StateKeeper()
-model_state.record_load = "state"
-
-aliev_panfilov.state_keeper = model_state
-
-aliev_panfilov.run()
-
-plt.imshow(aliev_panfilov.u)
-plt.show()
diff --git a/examples/basic/3D/aliev_panfilov_3D_aniso.py b/examples/basic/3D/aliev_panfilov_3D_aniso.py
deleted file mode 100644
index bc217e3..0000000
--- a/examples/basic/3D/aliev_panfilov_3D_aniso.py
+++ /dev/null
@@ -1,66 +0,0 @@
-
-#
-# The model is a 3D Aliev-Panfilov model with anisotropic stencil.
-# The model is stimulated with a voltage pulse in the center of the tissue.
-# Anisotropy is set by specifying a fiber array (CardiacTissue class) and
-# diffusion coefficients D_al, D_ac (diffusion along and across fibers).
-#
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 100
-
-tissue = fw.CardiacTissue3D((n, n, n))
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n, n])
-tissue.add_boundaries()
-# add fibers orientation vectors
-theta, alpha = 0.25*np.pi, 0.1*np.pi/4
-tissue.fibers = np.zeros((n, n, n, 3))
-tissue.fibers[:, :, :, 0] = np.cos(theta) * np.cos(alpha)
-tissue.fibers[:, :, :, 1] = np.cos(theta) * np.sin(alpha)
-tissue.fibers[:, :, :, 2] = np.sin(theta)
-# add numeric method stencil for weights computations
-tissue.stencil = fw.AsymmetricStencil3D()
-tissue.D_al = 1
-tissue.D_ac = tissue.D_al/9
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov3D()
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 10
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, n//2 - 5, n//2 + 5,
- n//2 - 5, n//2 + 5,
- n//2 - 5, n//2 + 5))
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-# initialize model: compute weights, add stimuls, trackers etc.
-aliev_panfilov.run()
-
-
-# show the potential map in axial, coronal and sagittal planes:
-fig, axs = plt.subplots(1, 3)
-axs[0].imshow(aliev_panfilov.u[:, :, n//2])
-axs[1].imshow(aliev_panfilov.u[:, n//2, :])
-axs[2].imshow(aliev_panfilov.u[n//2, :, :])
-axs[0].set_title('Axial')
-axs[1].set_title('Coronal')
-axs[2].set_title('Sagittal')
-plt.show()
-
-vis_mesh = tissue.mesh.copy()
-vis_mesh[n//2:, n//2:, n//2:] = 0
-
-mesh_builder = fw.VisMeshBuilder3D()
-grid = mesh_builder.build_mesh(vis_mesh)
-grid = mesh_builder.add_scalar(aliev_panfilov.u, 'u')
-grid.plot(clim=[0, 1], cmap='viridis')
diff --git a/examples/basic/3D/aliev_panfilov_3D_iso.py b/examples/basic/3D/aliev_panfilov_3D_iso.py
deleted file mode 100644
index 3fbd1c4..0000000
--- a/examples/basic/3D/aliev_panfilov_3D_iso.py
+++ /dev/null
@@ -1,54 +0,0 @@
-#
-# The model is a 3D Aliev-Panfilov model with isotropic stencil.
-# The model is stimulated with a voltage pulse in the center of the tissue.
-#
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 100
-
-tissue = fw.CardiacTissue3D((n, n, n))
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n, n])
-tissue.add_boundaries()
-# add numeric method stencil for weights computations
-tissue.stencil = fw.IsotropicStencil3D()
-
-aliev_panfilov = fw.AlievPanfilov3D()
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 7
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 45, 55, 45, 55, 45, 55))
-# add the tissue and the stim parameters to the model object:
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-
-aliev_panfilov.run()
-
-# show the potential map in axial, coronal and sagittal planes:
-fig, axs = plt.subplots(1, 3)
-axs[0].imshow(aliev_panfilov.u[:, :, n//2])
-axs[1].imshow(aliev_panfilov.u[:, n//2, :])
-axs[2].imshow(aliev_panfilov.u[n//2, :, :])
-axs[0].set_title('Axial')
-axs[1].set_title('Coronal')
-axs[2].set_title('Sagittal')
-plt.show()
-
-# visualize the potential map in 3D
-vis_mesh = tissue.mesh.copy()
-vis_mesh[n//2:, n//2:, n//2:] = 0
-
-mesh_builder = fw.VisMeshBuilder3D()
-grid = mesh_builder.build_mesh(vis_mesh)
-grid = mesh_builder.add_scalar(aliev_panfilov.u, 'u')
-grid.plot(clim=[0, 1], cmap='viridis')
diff --git a/examples/basic/3D/aliev_panfilov_3D_ventricle.py b/examples/basic/3D/aliev_panfilov_3D_ventricle.py
deleted file mode 100644
index becfacc..0000000
--- a/examples/basic/3D/aliev_panfilov_3D_ventricle.py
+++ /dev/null
@@ -1,60 +0,0 @@
-
-#
-# Left ventricle simlation with the Aliev-Panfilov model.
-# Mesh and fibers were taken from Niderer's data storage (https://zenodo.org/records/3890034)
-# Fibers were generated with Rule-based algorithm.
-# Ventricle is stimulated from the apex.
-
-from pathlib import Path
-import numpy as np
-import pyvista as pv
-import matplotlib.pyplot as plt
-
-import finitewave as fw
-
-
-path = Path(__file__).parent
-
-# Load mesh as cubic array
-mesh = np.load(path.joinpath("data", "mesh.npy"))
-
-# Load fibers as list of 3D vectors (x, y, z)
-fibers_list = np.load(path.joinpath("data", "fibers.npy"))
-fibers = np.zeros(mesh.shape + (3,), dtype=float)
-fibers[mesh > 0] = fibers_list
-
-tissue = fw.CardiacTissue3D(mesh.shape)
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = mesh
-tissue.add_boundaries()
-# add fibers orientation vectors
-tissue.fibers = fibers
-# add numeric method stencil for weights computations
-tissue.stencil = fw.AsymmetricStencil3D()
-tissue.D_al = 1
-tissue.D_ac = tissue.D_al/9
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov3D()
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 40
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, mesh.shape[0],
- 0, mesh.shape[0],
- 0, 20))
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-# initialize model: compute weights, add stimuls, trackers etc.
-aliev_panfilov.run()
-
-# show the potential map at the end of calculations
-
-# visualize the ventricle in 3D
-mesh_builder = fw.VisMeshBuilder3D()
-mesh_grid = mesh_builder.build_mesh(tissue.mesh)
-mesh_grid = mesh_builder.add_scalar(aliev_panfilov.u, 'u')
-mesh_grid.plot(clim=[0, 1], cmap='viridis')
diff --git a/examples/basic/3D/matrix_ventricle_stimulation_3D.py b/examples/basic/3D/matrix_ventricle_stimulation_3D.py
deleted file mode 100644
index 58b4cbc..0000000
--- a/examples/basic/3D/matrix_ventricle_stimulation_3D.py
+++ /dev/null
@@ -1,61 +0,0 @@
-
-#
-# Left ventricle simlation with the Aliev-Panfilov model.
-# Mesh and fibers were taken from Niderer's data storage (https://zenodo.org/records/3890034)
-# Here we use matrix stimlation to simultaneusly stimulate ventricle from apex and base.
-# After the end of the simulation you will see two waves propagating from the apex and the base.
-
-from pathlib import Path
-import numpy as np
-import pyvista as pv
-import matplotlib.pyplot as plt
-
-import finitewave as fw
-
-
-path = Path(__file__).parent
-
-# Load mesh as cubic array
-mesh = np.load(path.joinpath("data", "mesh.npy"))
-
-tissue = fw.CardiacTissue3D(mesh.shape)
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = mesh
-tissue.add_boundaries()
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov3D()
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 15
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-
-stim_array = np.zeros(mesh.shape)
-# stim array for the apex stimulation
-stim_array[:, :, :20] = 1
-
-# stim array for the base stimulation
-stim_array[:, :, -10:] = 1
-
-# Note: you can select only existing (=1) mesh points by applying the mask
-# mask = mesh == 1
-# But the stimulation classes already do this for you.
-
-stim_sequence.add_stim(fw.StimVoltageMatrix3D(0, 1, stim_array))
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-# initialize model: compute weights, add stimuls, trackers etc.
-aliev_panfilov.run()
-
-# show the potential map at the end of calculations
-
-# visualize the ventricle in 3D
-mesh_builder = fw.VisMeshBuilder3D()
-mesh_grid = mesh_builder.build_mesh(tissue.mesh)
-mesh_grid = mesh_builder.add_scalar(aliev_panfilov.u, 'u')
-mesh_grid.plot(clim=[0, 1], cmap='viridis')
diff --git a/examples/basic/3D/vtk_mesh_builder.py b/examples/basic/3D/vtk_mesh_builder.py
deleted file mode 100644
index 88ca850..0000000
--- a/examples/basic/3D/vtk_mesh_builder.py
+++ /dev/null
@@ -1,56 +0,0 @@
-from pathlib import Path
-import numpy as np
-import pyvista as pv
-import finitewave as fw
-
-
-path = Path(__file__).parent
-
-fibers = np.load(path.joinpath("data", "fibers.npy"))
-u = np.load(path.joinpath("data", "ap_rotor.npy"))
-mesh = np.load(path.joinpath("data", "mesh.npy"))
-distance = np.load(path.joinpath("data", "distance.npy"))
-
-u_mesh = np.zeros_like(mesh, dtype=float)
-u_mesh[mesh > 0] = u
-
-fibers_mesh = np.zeros(mesh.shape + (3,), dtype=float)
-fibers_mesh[mesh > 0] = fibers
-
-distance_mesh = np.zeros_like(mesh, dtype=float)
-distance_mesh[mesh > 0] = distance
-
-mesh_builder = fw.VisMeshBuilder3D()
-mesh_grid = mesh_builder.build_mesh(mesh)
-mesh_grid = mesh_builder.add_scalar(u_mesh, name='U')
-mesh_grid = mesh_builder.add_scalar(distance_mesh, name='Endo Distance')
-mesh_grid = mesh_builder.add_vector(fibers_mesh, name='Fibers')
-
-# # Save the mesh to a file
-# mesh_grid.save('mesh.vtk')
-
-# Show every 3rd fiber to reduce the number of arrows for better
-# performance. This is not necessary if number of fibers is small.
-# mesh_grid can be used directly to create the glyphs.
-cent = np.argwhere(mesh[::3, ::3, ::3] > 0)
-cent = cent * 3
-arrow_mesh = np.zeros_like(mesh)
-arrow_mesh[cent[:, 0], cent[:, 1], cent[:, 2]] = 1
-
-mesh_builder = fw.VisMeshBuilder3D()
-mesh_builder.build_mesh(arrow_mesh)
-mesh_builder.add_scalar(distance_mesh, 'Endo Distance')
-mesh_builder.add_vector(fibers_mesh, 'direction')
-arrow_grid = mesh_builder.grid
-arrow_grid = arrow_grid.glyph(orient='direction', factor=20, scale=True,
- geom=pv.Arrow(tip_resolution=3,
- shaft_resolution=3))
-
-pl = pv.Plotter(shape=(1, 2))
-pl.add_mesh(mesh_grid, clim=[0, 2], cmap='viridis', scalars='mesh')
-
-pl.subplot(0, 1)
-pl.add_mesh(arrow_grid, scalars='Endo Distance', cmap='viridis', clim=[0, 1])
-
-pl.link_views()
-pl.show()
diff --git a/examples/basics/2D/anisotropic_medium_2d.py b/examples/basics/2D/anisotropic_medium_2d.py
new file mode 100755
index 0000000..2c5e99f
--- /dev/null
+++ b/examples/basics/2D/anisotropic_medium_2d.py
@@ -0,0 +1,84 @@
+
+"""
+Aliev-Panfilov 2D Model (Anisotropic)
+=====================================
+
+Overview:
+---------
+This example demonstrates how to simulate the Aliev-Panfilov model in a
+two-dimensional anisotropic cardiac tissue. Unlike the isotropic case,
+anisotropy is introduced by specifying a fiber orientation array, which
+modifies the diffusion properties of the tissue.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 400×400 cardiac tissue domain is created.
+- Anisotropic Diffusion: Fiber orientation is set using a direction field.
+- Fiber Orientation: Defined by an angle alpha = 0.25 * pi.
+- Stimulation: A localized stimulus is applied at the center of the domain.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 30
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid with fiber orientation.
+2. Define and apply a stimulus at the center.
+3. Set up and initialize the Aliev-Panfilov model.
+4. Run the simulation to compute wave propagation in an anisotropic medium.
+5. Visualize the membrane potential distribution at the final timestep.
+
+Anisotropic Diffusion:
+----------------------
+Anisotropy is implemented by defining a fiber orientation field for the
+CardiacTissue object. The model automatically selects the appropriate stencil
+to calculate the diffusion term based on fiber direction.
+
+Visualization:
+--------------
+The final membrane potential distribution is displayed using matplotlib,
+showing how the excitation wave propagates in the anisotropic medium.
+"""
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import finitewave as fw
+
+# number of nodes on the side
+n = 400
+# fiber orientation angle
+alpha = 0.25 * np.pi
+tissue = fw.CardiacTissue2D([n, n])
+# create a mesh of cardiomyocytes (elems = 1):
+tissue.mesh = np.ones([n, n])
+tissue.add_boundaries()
+# add fibers orientation vectors
+tissue.fibers = np.zeros([n, n, 2])
+tissue.fibers[:, :, 0] = np.cos(alpha)
+tissue.fibers[:, :, 1] = np.sin(alpha)
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, n//2 - 3, n//2 + 3,
+ n//2 - 3, n//2 + 3))
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov2D()
+# set up numerical parameters:
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 30
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+
+aliev_panfilov.run()
+
+# show the potential map at the end of calculations:
+plt.figure()
+plt.imshow(aliev_panfilov.u)
+plt.colorbar()
+plt.show()
diff --git a/examples/basics/2D/change_conductivity_2d.py b/examples/basics/2D/change_conductivity_2d.py
new file mode 100644
index 0000000..aa1a9cc
--- /dev/null
+++ b/examples/basics/2D/change_conductivity_2d.py
@@ -0,0 +1,78 @@
+
+"""
+Aliev-Panfilov 2D Model (Conductivity)
+======================================
+
+Overview:
+---------
+This example demonstrates how to simulate the Aliev-Panfilov model in a
+two-dimensional isotropic cardiac tissue with spatially varying conductivity.
+Conductivity variations affect wave propagation, simulating regions of different
+electrophysiological properties.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 400×400 cardiac tissue domain.
+- Isotropic Diffusion: Conductivity is uniform within regions but varies across the tissue.
+- Conductivity Variation:
+ - The default conductivity is set to 1.0.
+ - The bottom-right quadrant (n/2:, n/2:) has reduced conductivity (0.3).
+- Stimulation: A localized stimulus is applied at the center.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 30
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid and define spatial conductivity variations.
+2. Apply a stimulus at the center.
+3. Set up and initialize the Aliev-Panfilov model.
+4. Run the simulation to observe how conductivity affects wave propagation.
+5. Visualize the final membrane potential distribution.
+
+Effect of Conductivity:
+-----------------------
+The lower conductivity region slows down wave propagation, potentially leading
+to conduction block or reentrant wave formation. This feature is useful for modeling
+heterogeneous tissue properties such as fibrosis or ischemic regions.
+
+Visualization:
+--------------
+The final membrane potential distribution is displayed using matplotlib,
+illustrating the impact of conductivity variations on wave propagation.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# create a tissue of size 400x400 with cardiomycytes:
+n = 400
+tissue = fw.CardiacTissue2D([n, n])
+tissue.conductivity = np.ones([n, n], dtype=float)
+tissue.conductivity[n//2:, n//2:] = 0.3
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1,
+ n//2 - 3, n//2 + 3,
+ n//2 - 3, n//2 + 3))
+
+# create model object and set up parameters:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 30
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+
+# run the model:
+aliev_panfilov.run()
+
+# show the potential map at the end of calculations:
+plt.imshow(aliev_panfilov.u)
+plt.colorbar()
+plt.show()
diff --git a/examples/basics/2D/chaotic_pattern.py b/examples/basics/2D/chaotic_pattern.py
new file mode 100644
index 0000000..f50e00f
--- /dev/null
+++ b/examples/basics/2D/chaotic_pattern.py
@@ -0,0 +1,73 @@
+"""
+Spiral Wave Breakup and Induced Chaos (Aliev-Panfilov 2D)
+==========================================================
+
+Overview:
+---------
+This example demonstrates how to initiate a spiral wave in a 2D excitable
+medium using the Aliev-Panfilov model and subsequently destabilize it with
+two additional stimuli. This approach leads to spiral wave breakup and the
+onset of chaotic, fibrillation-like activity in a homogeneous tissue.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 200×200 homogeneous cardiac tissue domain.
+- Model: Aliev-Panfilov 2D model.
+- Stimulation Protocol:
+ - **S1 (t = 0 ms)**: Planar stimulus to the top half of the tissue.
+ - **S2 (t = 31 ms)**: Vertical stimulus on the left half to induce wave rotation (spiral).
+ - **S3–S4 (t = 75 ms, 125 ms)**: Localized current pulses in the bottom center
+ to destabilize the spiral and trigger wave breakup.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01 ms
+ - Spatial resolution (dr): 0.25 mm
+ - Total simulation time (t_max): 195 ms
+
+Execution:
+----------
+1. A planar wave is launched at the top to propagate downward.
+2. A second stimulus creates a partial reentry and initiates a spiral.
+3. Two well-timed localized stimuli are applied near the spiral core,
+ leading to fragmentation and chaotic wave propagation.
+4. The model is integrated over time to observe the evolution of excitation.
+
+Expected Outcome:
+-----------------
+- Formation of a spiral wave pattern.
+- Spiral destabilization due to extra stimuli.
+- Emergence of complex, self-sustaining chaotic patterns resembling electrical fibrillation.
+
+Visualization:
+--------------
+The final membrane potential is visualized using matplotlib.
+Chaotic activity is indicated by irregular, fragmented wavefronts.
+
+"""
+
+import matplotlib.pyplot as plt
+import finitewave as fw
+
+n = 200
+tissue = fw.CardiacTissue2D((n, n))
+
+stim_sequence = fw.StimSequence()
+
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, n, 0, n//2))
+stim_sequence.add_stim(fw.StimVoltageCoord2D(31, 1, 0, n//2, 0, n))
+# extra stimuli to break the spiral waves:
+stim_sequence.add_stim(fw.StimCurrentCoord2D(75, 3, 3, 90, 100, n//2, n))
+stim_sequence.add_stim(fw.StimCurrentCoord2D(125, 3, 3, 90, 100, n//2, n))
+
+# Set up the Aliev-Panfilov model:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 195
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+
+aliev_panfilov.run()
+
+plt.imshow(aliev_panfilov.u, cmap='plasma')
+plt.title("Chaotic pattern")
+plt.show()
diff --git a/examples/basics/2D/commands.py b/examples/basics/2D/commands.py
new file mode 100644
index 0000000..f1d44a8
--- /dev/null
+++ b/examples/basics/2D/commands.py
@@ -0,0 +1,103 @@
+"""
+Fenton-Karma 2D Model (Interrupt via Custom Command)
+====================================================
+
+Overview:
+---------
+This example demonstrates how to use the `Command` and `CommandSequence` interfaces in Finitewave
+to inject custom logic into a cardiac electrophysiology simulation. Specifically, we interrupt the
+simulation when the wave of excitation reaches the far edge of the tissue. This demonstrates how
+to trigger actions based on the state of the system.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 300×300 cardiac tissue domain.
+- Mesh: Entire domain is active tissue (`1.0` values).
+- Model: Fenton-Karma 2D model is used for wave propagation.
+- Stimulation: A voltage stimulus is applied along the entire left edge.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01 ms
+ - Spatial resolution (dr): 0.25 mm
+ - Total simulation time (t_max): 1000 ms
+
+Command Usage:
+--------------
+- Custom command `InterruptCommand` inherits from `Command`.
+- At every 10 ms of simulation time (from 0 to 190 ms), the command checks if the wave has
+ reached the far-right side (`x = 298`).
+- If any value of the membrane potential exceeds 0.5 on this edge, the simulation is terminated
+ early by setting `model.step = np.inf`.
+
+Execution:
+----------
+1. Initialize a square 2D tissue with a full mesh of excitable tissue.
+2. Apply a uniform voltage stimulus along the leftmost edge (columns `0–1`).
+3. Set up a sequence of `InterruptCommand` checks at regular intervals.
+4. Run the simulation. It will self-interrupt once the wave reaches the far side.
+
+Effect of Custom Command:
+-------------------------
+This feature is useful for:
+- Saving computational time by stopping early based on user-defined conditions.
+- Triggering intermediate analysis, adaptive pacing, or feedback-based protocols.
+- Debugging or validation of wave speed and tissue responsiveness.
+
+Visualization:
+--------------
+No visualization is included in this example, but users can integrate `matplotlib` or export
+model states using built-in Finitewave I/O utilities.
+
+Notes:
+------
+- The `Command` and `CommandSequence` classes allow flexible integration of logic and control flow
+ without modifying the core model.
+- This technique is extendable to more complex use cases such as region-specific feedback, pacing adjustment,
+ or custom logging.
+
+"""
+
+import numpy as np
+
+import finitewave as fw
+
+
+# number of nodes on the side
+n = 300
+
+tissue = fw.CardiacTissue2D([n, n])
+# create a mesh of cardiomyocytes (elems = 1):
+tissue.mesh = np.ones([n, n], dtype=float)
+# add empty nodes on the sides (elems = 0):
+
+# create model object:
+fenton_karma = fw.FentonKarma2D()
+# set up numerical parameters:
+fenton_karma.dt = 0.01
+fenton_karma.dr = 0.25
+fenton_karma.t_max = 1000
+
+# Define the command:
+class InterruptCommand(fw.Command):
+ def execute(self, model):
+ if np.any(model.u[:, 298] > 0.5):
+ # increase the calculation step to stop the execution loop.
+ model.step = np.inf
+ print ("Propagation wave reached the opposite side. Stop calculation.")
+
+# We want to check the opposite side every 10 time units.
+# Thus we have a list of commands with the same method but different times.
+command_sequence = fw.CommandSequence()
+for i in range(0, 200, 10):
+ command_sequence.add_command(InterruptCommand(i))
+
+fenton_karma.command_sequence = command_sequence
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, n, 0, 5))
+
+# add the tissue and the stim parameters to the model object:
+fenton_karma.cardiac_tissue = tissue
+fenton_karma.stim_sequence = stim_sequence
+
+fenton_karma.run()
\ No newline at end of file
diff --git a/examples/basics/2D/isotropic_medium_2d.py b/examples/basics/2D/isotropic_medium_2d.py
new file mode 100755
index 0000000..cfb6f60
--- /dev/null
+++ b/examples/basics/2D/isotropic_medium_2d.py
@@ -0,0 +1,65 @@
+"""
+Aliev-Panfilov 2D Model (Isotropic)
+====================================
+
+Overview:
+---------
+This example demonstrates how to simulate the Aliev-Panfilov model in a
+two-dimensional isotropic medium using the Finitewave framework. The model
+describes the propagation of electrical waves in excitable media, such as
+cardiac tissue, and captures fundamental excitation and recovery dynamics.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 400×400 homogeneous cardiac tissue is created.
+- Isotropic Stencil: Diffusion is uniform in all directions.
+- Stimulation: A localized stimulus is applied at the center of the domain.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 30
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Define and apply a stimulus at the center.
+3. Set up and initialize the Aliev-Panfilov model.
+4. Run the simulation to compute wave propagation.
+5. Visualize the membrane potential map at the final timestep.
+
+Visualization:
+--------------
+The final membrane potential distribution is displayed using `matplotlib`,
+showing the resulting excitation wave pattern.
+"""
+
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# create a tissue of size 400x400 with cardiomycytes:
+n = 400
+tissue = fw.CardiacTissue2D([n, n])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, n//2 - 3, n//2 + 3,
+ n//2 - 3, n//2 + 3))
+
+# create model object and set up parameters:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 30
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+
+# run the model:
+aliev_panfilov.run()
+
+# show the potential map at the end of calculations:
+plt.figure()
+plt.imshow(aliev_panfilov.u)
+plt.colorbar()
+plt.show()
diff --git a/examples/basics/2D/matrix_stimulation.py b/examples/basics/2D/matrix_stimulation.py
new file mode 100755
index 0000000..c91e97f
--- /dev/null
+++ b/examples/basics/2D/matrix_stimulation.py
@@ -0,0 +1,85 @@
+
+"""
+Matrix Stimulation in 2D Cardiac Tissue
+=======================================
+
+Overview:
+---------
+This example demonstrates how to apply matrix-based stimulation
+in a two-dimensional cardiac tissue model using the Fenton-Karma
+equations. Instead of a single stimulus source, this method applies
+stimulation at multiple predefined locations across the tissue.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 400×400 cardiac tissue domain.
+- Multiple Stimulus Areas: Stimulation is applied at four distinct points.
+- Stimulation Shape: Each stimulus is applied over a circular area (radius = 5).
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 10
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Define four circular stimulation areas using `skimage.draw.disk`.
+3. Apply the stimuli as a matrix using `StimVoltageMatrix2D`.
+4. Initialize and configure the Fenton-Karma model.
+5. Run the simulation to observe how multiple stimulation sites influence
+ wave propagation.
+6. Visualize the final membrane potential distribution.
+
+Application:
+------------
+This method is useful for simulating paced activation patterns seen
+in electrophysiology studies, where multiple sites are excited
+simultaneously. It can help analyze conduction velocity, wavefront
+interactions, and reentry formation.
+
+Visualization:
+--------------
+The final membrane potential distribution is displayed using matplotlib,
+showing how excitation spreads from the stimulated regions.
+"""
+
+
+import matplotlib.pyplot as plt
+from skimage import draw
+import numpy as np
+
+import finitewave as fw
+
+# set up cardiac tissue:
+n = 400
+tissue = fw.CardiacTissue2D([n, n])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_area = np.full([400, 400], False, dtype=bool)
+ii, jj = draw.disk([100, 100], 5)
+stim_area[ii, jj] = True
+ii, jj = draw.disk([100, 300], 5)
+stim_area[ii, jj] = True
+ii, jj = draw.disk([300, 100], 5)
+stim_area[ii, jj] = True
+ii, jj = draw.disk([300, 300], 5)
+stim_area[ii, jj] = True
+stim_sequence.add_stim(fw.StimVoltageMatrix2D(0, 1, stim_area))
+
+# create model object:
+fenton_karma = fw.FentonKarma2D()
+# set up numerical parameters:
+fenton_karma.dt = 0.01
+fenton_karma.dr = 0.25
+fenton_karma.t_max = 10
+# add the tissue and the stim parameters to the model object:
+fenton_karma.cardiac_tissue = tissue
+fenton_karma.stim_sequence = stim_sequence
+
+fenton_karma.run()
+
+# show the potential map at the end of calculations:
+# plt.figure()
+plt.imshow(fenton_karma.u)
+plt.show()
diff --git a/examples/basics/2D/reentry.py b/examples/basics/2D/reentry.py
new file mode 100644
index 0000000..8dc7156
--- /dev/null
+++ b/examples/basics/2D/reentry.py
@@ -0,0 +1,80 @@
+"""
+Spiral Wave Formation in 2D Cardiac Tissue
+==========================================
+
+Overview:
+---------
+This example demonstrates how to initiate and observe a spiral wave
+in a two-dimensional cardiac tissue model using the Aliev-Panfilov equations.
+Spiral waves are a key phenomenon in cardiac electrophysiology, often linked to
+arrhythmias and reentrant activity.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 256×256 cardiac tissue domain.
+- Spiral Wave Initiation:
+ - First stimulus: Applied along the top boundary at time 0.
+ - Second stimulus: Applied to the right half of the domain at time 50.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.3
+ - Total simulation time (t_max): 150
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Apply two sequential stimulations:
+ - The first stimulus excites a wavefront across the tissue.
+ - The second stimulus, applied after a delay, breaks the wavefront,
+ leading to spiral wave formation.
+3. Initialize and configure the Aliev-Panfilov model.
+4. Run the simulation to observe spiral wave dynamics.
+5. Visualize the final membrane potential distribution.
+
+Spiral Wave Mechanism:
+----------------------
+Spiral waves emerge due to the interaction of an initial wave and a secondary
+stimulus applied at a critical time and location. These waves are relevant
+to studying:
+- Reentrant arrhythmias (such as ventricular tachycardia).
+- Excitation wave turbulence in cardiac tissue.
+- Wavefront stability and self-sustained oscillations.
+
+Visualization:
+--------------
+The final membrane potential distribution is displayed using matplotlib,
+revealing the characteristic spiral pattern.
+"""
+
+
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# set up the tissue:
+n = 256
+tissue = fw.CardiacTissue2D([n, n])
+
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(time=0, volt_value=1,
+ x1=0, x2=n, y1=0, y2=5))
+stim_sequence.add_stim(fw.StimVoltageCoord2D(time=50, volt_value=1,
+ x1=n//2, x2=n, y1=0, y2=n))
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov2D()
+# set up numerical parameters:
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.3
+aliev_panfilov.t_max = 150
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+
+aliev_panfilov.run()
+
+# show the potential map at the end of calculations:
+plt.imshow(aliev_panfilov.u)
+plt.show()
diff --git a/examples/basics/2D/using_states.py b/examples/basics/2D/using_states.py
new file mode 100644
index 0000000..d34d335
--- /dev/null
+++ b/examples/basics/2D/using_states.py
@@ -0,0 +1,147 @@
+"""
+StateKeeper Example: Saving and Loading Simulation States
+=========================================================
+
+Overview:
+---------
+This example demonstrates how to use the StateKeeper functionality in
+Finitewave to save and restore the state of a 2D cardiac simulation.
+This allows a simulation to be paused and resumed at a later time
+without restarting from the beginning.
+
+Key Features:
+-------------
+- State Saving: The model saves intermediate states at specific times.
+- State Loading: The simulation is resumed from a saved state.
+- Multiple Runs: The model is executed in three phases:
+ 1. First run (0 - 20): The initial simulation run.
+ 2. Second run (10 - 20): Resumes from a saved state at t = 10.
+ 3. Third run (20 - 30): Resumes from a saved state at t = 20.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 400×400 cardiac tissue domain.
+- Stimulation: A small localized stimulus applied at the center.
+- State Saving:
+ - The state is saved at t = 10 ("state_0").
+ - The final state is saved at t = 20 ("state_1").
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - First run duration: 0 - 20
+ - Second and third run durations: 10 - 20 each.
+
+Execution Workflow:
+-------------------
+1. Run the first simulation and save the state at t = 10 and t = 20.
+2. Delete the model instance and clear memory using `gc.collect()`.
+3. Create a new model instance and load "state_0", then continue the
+ simulation from t = 10 to 20.
+4. Create another new instance, load "state_1", and run from t = 20 to 30.
+5. Visualize the results:
+ - First run (t=0 to 20)
+ - Second run (t=10 to 20)
+ - Third run (t=20 to 30)
+6. Delete saved states to clean up temporary files.
+
+Application:
+------------
+State saving is useful for:
+- Long simulations: Avoids restarting from scratch in case of interruptions.
+- Parameter tuning: Allows resuming simulations from intermediate states.
+- Multi-stage analysis: Investigates different scenarios from a common starting point.
+
+Visualization:
+--------------
+The final results are displayed using matplotlib, showing the progression of
+the simulation across the three phases.
+"""
+
+import matplotlib.pyplot as plt
+import gc
+import shutil
+
+import finitewave as fw
+
+# number of nodes on the side
+# create a tissue of size 400x400 with cardiomycytes:
+n = 400
+tissue = fw.CardiacTissue2D([n, n])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, n//2 - 5, n//2 + 5,
+ n//2 - 5, n//2 + 5))
+
+# set up state saver parameters:
+# to save only one state you can use StateSaver directly
+state_savers = fw.StateSaverCollection()
+state_savers.savers.append(fw.StateSaver("state_0", time=10)) # will save at t=10
+state_savers.savers.append(fw.StateSaver("state_1")) # will save at t=20 (at the end of the run)
+
+# create model object and set up parameters:
+mitchell_schaeffer = fw.MitchellSchaeffer2D()
+mitchell_schaeffer.dt = 0.01
+mitchell_schaeffer.dr = 0.25
+mitchell_schaeffer.t_max = 20
+# add the tissue and the stim parameters to the model object:
+mitchell_schaeffer.cardiac_tissue = tissue
+mitchell_schaeffer.stim_sequence = stim_sequence
+mitchell_schaeffer.state_saver = state_savers
+
+# run the model:
+mitchell_schaeffer.run()
+
+u_before = mitchell_schaeffer.u.copy()
+
+# We delete model and use gc.collect() to ask the virtual machine remove
+# objects from memory. Though it's not necessary to do this.
+del mitchell_schaeffer
+gc.collect()
+
+# # # # # # # # #
+
+# Here we create a new model and load states from the previous calculation to
+# continue.
+
+
+# recreate the model
+mitchell_schaeffer = fw.MitchellSchaeffer2D()
+
+# set up numerical parameters:
+mitchell_schaeffer.dt = 0.01
+mitchell_schaeffer.dr = 0.25
+mitchell_schaeffer.t_max = 10
+# add the tissue and the state_loader to the model object:
+mitchell_schaeffer.cardiac_tissue = tissue
+mitchell_schaeffer.state_loader = fw.StateLoader("state_0")
+
+mitchell_schaeffer.run()
+u_after = mitchell_schaeffer.u.copy()
+
+# recreate the model
+mitchell_schaeffer = fw.MitchellSchaeffer2D()
+
+# set up numerical parameters:
+mitchell_schaeffer.dt = 0.01
+mitchell_schaeffer.dr = 0.25
+mitchell_schaeffer.t_max = 10
+# add the tissue and the state_loader to the model object:
+mitchell_schaeffer.cardiac_tissue = tissue
+mitchell_schaeffer.state_loader = fw.StateLoader("state_1")
+
+mitchell_schaeffer.run()
+
+# plot the results
+fig, axs = plt.subplots(1, 3, figsize=(10, 5))
+axs[0].imshow(u_before)
+axs[0].set_title("First run from t=0 to t=20")
+axs[1].imshow(u_after)
+axs[1].set_title("Second run from t=10 to t=20")
+axs[2].imshow(mitchell_schaeffer.u)
+axs[2].set_title("Third run from t=20 to t=30")
+plt.show()
+
+# remove the state directory
+shutil.rmtree("state_0")
+shutil.rmtree("state_1")
diff --git a/examples/basics/3D/slab_with_fibers_3d.py b/examples/basics/3D/slab_with_fibers_3d.py
new file mode 100644
index 0000000..fc33f36
--- /dev/null
+++ b/examples/basics/3D/slab_with_fibers_3d.py
@@ -0,0 +1,97 @@
+"""
+3D Slab with Rotating Fibers
+============================
+
+This example demonstrates how to create a 3D slab of cardiac tissue
+with smoothly rotating fiber orientation along the depth (z-axis).
+Such setups are used to mimic myocardial fiber architecture in
+ventricular walls, where fiber orientation rotates across the wall.
+
+A central stimulus initiates activation, and the resulting
+wave propagation is influenced by the local fiber direction at each depth.
+
+Fiber Setup:
+------------
+- Domain size: 200×200×100 (i, j, k)
+- Fiber rotation:
+ • Varies linearly from -π/3 to +π/2 along the k-axis (depth)
+ • In-plane rotation only (z-component of fibers = 0)
+ • Represented as 3D unit vectors: (cos(ϕ), sin(ϕ), 0)
+
+Model & Stimulation:
+--------------------
+- Model: Mitchell-Schaeffer 3D
+- Time: 15 time units total
+- Stimulus:
+ • Applied at the center of the i-j plane
+ • Extends fully along the z-axis (column stimulation)
+ • Time: t = 0
+ • Strength: 1 (voltage)
+
+Numerical Setup:
+----------------
+- Time step (dt): 0.01
+- Space step (dr): 0.25
+
+Visualization:
+--------------
+- The slab is rendered using `VisMeshBuilder3D`
+- The upper half is clipped away for a better internal view
+- Voltage (`u`) is shown using a colormap
+
+Applications:
+-------------
+- Mimics realistic ventricular transmural fiber rotation
+- Useful for studying anisotropic conduction, twist in scroll waves,
+ and depth-dependent activation patterns
+"""
+
+
+import finitewave as fw
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+# number of nodes on the side
+n_i = 200
+n_j = 200
+n_k = 100
+
+# set up the cardiac tissue:
+tissue = fw.CardiacTissue3D((n_i, n_j, n_k))
+# orientation of fibers changes along the z-axis from -pi/3 to pi/2
+phi_k = np.linspace(- np.pi / 3, np.pi / 2, n_k - 2)
+# add fibers orientation vectors
+tissue.fibers = np.zeros((n_i, n_j, n_k, 3))
+for k, phi in enumerate(phi_k):
+ tissue.fibers[:, :, k + 1, 0] = np.cos(phi)
+ tissue.fibers[:, :, k + 1, 1] = np.sin(phi)
+ tissue.fibers[:, :, k + 1, 2] = 0
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1,
+ n_i // 2 - 5, n_i // 2 + 5,
+ n_j // 2 - 5, n_j // 2 + 5,
+ 0, n_k))
+# create model object:
+mitchell_schaeffer = fw.MitchellSchaeffer3D()
+# set up numerical parameters:
+mitchell_schaeffer.dt = 0.01
+mitchell_schaeffer.dr = 0.25
+mitchell_schaeffer.t_max = 15
+# add the tissue and the stim parameters to the model object:
+mitchell_schaeffer.cardiac_tissue = tissue
+mitchell_schaeffer.stim_sequence = stim_sequence
+# initialize model: compute weights, add stimuls, trackers etc.
+mitchell_schaeffer.run()
+
+# visualize the potential map in 3D
+vis_mesh = tissue.mesh.copy()
+vis_mesh[n_i//2:, n_j//2:, :] = 0
+
+mesh_builder = fw.VisMeshBuilder3D()
+grid = mesh_builder.build_mesh(vis_mesh)
+grid = mesh_builder.add_scalar(mitchell_schaeffer.u, 'u')
+grid.plot(clim=[0, 1], cmap='viridis')
\ No newline at end of file
diff --git a/examples/basics/3D/spiral_wave_3d.py b/examples/basics/3D/spiral_wave_3d.py
new file mode 100644
index 0000000..f5105ca
--- /dev/null
+++ b/examples/basics/3D/spiral_wave_3d.py
@@ -0,0 +1,116 @@
+"""
+Spiral Waves on a 3D Spherical Shell
+====================================
+
+This example demonstrates how to simulate spiral (scroll) waves inside
+a 3D spherical shell using the Aliev-Panfilov model with Finitewave.
+
+A hollow sphere is embedded inside a 3D Cartesian grid. The propagation
+of electrical activity is initiated by sequential stimuli, creating a
+scroll wave that circulates within the curved geometry.
+
+The resulting potential distribution is visualized with Finitewave's
+3D mesh tools.
+
+Geometry Setup:
+---------------
+- Domain size: 200×200×200 grid
+- Geometry: Spherical shell created using a binary mask
+ - Outer radius: 95 voxels
+ - Inner radius: 90 voxels
+ - Mesh values: 1 inside the shell, 0 outside
+- The sphere is centered in the domain
+
+Stimulation Protocol:
+---------------------
+- Stimulus 1:
+ - Time: t = 0
+ - Location: One side of the sphere (thin planar region near the edge)
+- Stimulus 2:
+ - Time: t = 50
+ - Location: One hemisphere only
+- This breaks the initial wave symmetry and initiates a scroll wave
+
+Model:
+------
+- Aliev-Panfilov 3D reaction-diffusion model
+- Time step (dt): 0.01
+- Space step (dr): 0.25
+- Total simulation time: 100
+
+Visualization:
+--------------
+The 3D scalar field (`u`) is rendered on the shell mesh using
+Finitewave’s `VisMeshBuilder3D`.
+
+Applications:
+-------------
+- Simulation of scroll wave dynamics in spherical domains
+- Study of wave breakups, phase singularities, and 3D reentry
+- Modeling electrical activity in simplified anatomical geometries
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import finitewave as fw
+
+
+# Create a spherical mask within a 100x100x100 cube
+def create_sphere_mask(shape, radius, center):
+ z, y, x = np.indices(shape)
+ distance = np.sqrt((x - center[0])**2 +
+ (y - center[1])**2 +
+ (z - center[2])**2)
+ mask = distance <= radius
+ return mask
+
+
+# set up the cardiac tissue:
+n = 200
+shape = (n, n, n)
+tissue = fw.CardiacTissue3D((n, n, n))
+tissue.mesh = np.zeros((n, n, n))
+tissue.mesh[create_sphere_mask(tissue.mesh.shape,
+ n//2-5,
+ (n//2, n//2, n//2))] = 1
+tissue.mesh[create_sphere_mask(tissue.mesh.shape,
+ n//2-10,
+ (n//2, n//2, n//2))] = 0
+
+# set up stimulation parameters:
+min_x = np.where(tissue.mesh)[0].min()
+
+stim1 = fw.StimVoltageCoord3D(0, 1,
+ min_x, min_x + 3,
+ 0, n,
+ 0, n)
+
+stim2 = fw.StimVoltageCoord3D(50, 1,
+ 0, n,
+ 0, n//2,
+ 0, n)
+
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(stim1)
+stim_sequence.add_stim(stim2)
+
+aliev_panfilov = fw.AlievPanfilov3D()
+# set up numerical parameters:
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 100
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+
+aliev_panfilov.run()
+
+# visualize the potential map in 3D
+vis_mesh = tissue.mesh.copy()
+# vis_mesh[n//2:, n//2:, n//2:] = 0
+
+mesh_builder = fw.VisMeshBuilder3D()
+grid = mesh_builder.build_mesh(vis_mesh)
+grid = mesh_builder.add_scalar(aliev_panfilov.u, 'u')
+grid.plot(clim=[0, 1], cmap='viridis')
\ No newline at end of file
diff --git a/examples/basics/3D/ventricle_geometry_3d.py b/examples/basics/3D/ventricle_geometry_3d.py
new file mode 100644
index 0000000..c4b3ed2
--- /dev/null
+++ b/examples/basics/3D/ventricle_geometry_3d.py
@@ -0,0 +1,93 @@
+"""
+Left Ventricle Simulation with Anatomical Mesh and Fibers
+----------------------------------------------------------
+
+This example demonstrates how to simulate electrical activity in a
+realistic left ventricular (LV) geometry using the Aliev-Panfilov
+model in 3D.
+
+The LV mesh and corresponding fiber orientations are loaded from
+external data (available at https://zenodo.org/records/3890034).
+The mesh is embedded in a regular grid, and fiber directions are
+assigned to the myocardium using a vector field.
+
+Stimulation is applied at the base of the ventricle to initiate
+activation, and wave propagation is visualized in 3D.
+
+Data Requirements:
+------------------
+This example assumes the following files exist in the `data/` directory:
+- `mesh.npy`: 3D binary array (1 = myocardium, 0 = empty)
+- `fibers.npy`: Flattened array of fiber vectors (same shape as mesh[mesh > 0])
+
+Simulation Setup:
+-----------------
+- Model: Aliev-Panfilov 3D
+- Mesh: Realistic LV shape, embedded in a cubic grid
+- Fibers: Anatomically derived vectors per voxel
+- Stimulus:
+ - Type: Voltage
+ - Location: Basal region (first 20 z-slices)
+ - Time: t = 0
+- Time step (dt): 0.01
+- Space step (dr): 0.25
+- Total time: 40
+
+Visualization:
+--------------
+- The scalar voltage field (`u`) is rendered in 3D using
+ Finitewave’s `VisMeshBuilder3D`.
+
+Applications:
+-------------
+- Realistic whole-ventricle simulations
+- Exploration of fiber-driven anisotropic conduction
+- Foundation for further patient-specific modeling or ECG computation
+"""
+
+
+from pathlib import Path
+import numpy as np
+
+import finitewave as fw
+
+
+path = Path(__file__).parent
+
+# Load mesh as cubic array
+mesh = np.load(path.joinpath("..", "..", "data", "mesh.npy"))
+
+# Load fibers as cubic array
+fibers_list = np.load(path.joinpath("..", "..", "data", "fibers.npy"))
+fibers = np.zeros(mesh.shape + (3,), dtype=float)
+fibers[mesh > 0] = fibers_list
+
+# set up the tissue with fibers orientation:
+tissue = fw.CardiacTissue3D(mesh.shape)
+tissue.mesh = mesh
+tissue.add_boundaries()
+tissue.fibers = fibers
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, mesh.shape[0],
+ 0, mesh.shape[0],
+ 0, 20))
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov3D()
+# set up numerical parameters:
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 40
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+# initialize model: compute weights, add stimuls, trackers etc.
+aliev_panfilov.run()
+
+# visualize the ventricle in 3D
+mesh_builder = fw.VisMeshBuilder3D()
+mesh_grid = mesh_builder.build_mesh(tissue.mesh)
+mesh_grid = mesh_builder.add_scalar(aliev_panfilov.u, 'u')
+mesh_grid.plot(clim=[0, 1], cmap='viridis')
\ No newline at end of file
diff --git a/examples/basic/3D/data/ap_rotor.npy b/examples/data/ap_rotor.npy
similarity index 100%
rename from examples/basic/3D/data/ap_rotor.npy
rename to examples/data/ap_rotor.npy
diff --git a/examples/basic/3D/data/distance.npy b/examples/data/distance.npy
similarity index 100%
rename from examples/basic/3D/data/distance.npy
rename to examples/data/distance.npy
diff --git a/examples/basic/3D/data/fibers.npy b/examples/data/fibers.npy
similarity index 100%
rename from examples/basic/3D/data/fibers.npy
rename to examples/data/fibers.npy
diff --git a/examples/basic/3D/data/mesh.npy b/examples/data/mesh.npy
similarity index 100%
rename from examples/basic/3D/data/mesh.npy
rename to examples/data/mesh.npy
diff --git a/examples/fibrosis/2D/diffuse_fibrosis_2d.py b/examples/fibrosis/2D/diffuse_fibrosis_2d.py
new file mode 100644
index 0000000..6bfd6ac
--- /dev/null
+++ b/examples/fibrosis/2D/diffuse_fibrosis_2d.py
@@ -0,0 +1,38 @@
+"""
+2D Diffuse Fibrosis Pattern (20% Density)
+=========================================
+
+This example demonstrates how to generate a 2D cardiac tissue with
+a diffuse fibrosis pattern using the `Diffuse2DPattern` class in Finitewave.
+
+Fibrotic tissue regions are marked as non-conductive areas in the mesh,
+and this affects wave propagation in subsequent simulations.
+
+Setup:
+------
+- Grid size: 200 × 200
+- Fibrosis type: Diffuse (random spatial distribution)
+- Fibrosis density: 20% (i.e., 20% of cells are fibrotic/non-conductive)
+
+Visualization:
+--------------
+The generated tissue is shown as a 2D image:
+- Green cells represent healthy (conductive) tissue
+- Yellow cells represent fibrotic (non-conductive) areas
+
+This mesh can be used in simulations to study how diffuse fibrosis alters
+electrical propagation, reentry, and arrhythmogenesis.
+"""
+
+import matplotlib.pyplot as plt
+import finitewave as fw
+
+n = 200
+# create mesh
+tissue = fw.CardiacTissue2D((n, n))
+tissue.add_pattern(fw.Diffuse2DPattern(0.2))
+
+plt.title("2D Diffuse Fibrosis Medium with 20% Fibrosis Density")
+plt.imshow(tissue.mesh)
+plt.colorbar()
+plt.show()
\ No newline at end of file
diff --git a/examples/fibrosis/2D/interstitial_fibrosis_2d.py b/examples/fibrosis/2D/interstitial_fibrosis_2d.py
new file mode 100644
index 0000000..aefa2e6
--- /dev/null
+++ b/examples/fibrosis/2D/interstitial_fibrosis_2d.py
@@ -0,0 +1,49 @@
+"""
+2D Interstitial Fibrosis Pattern (20% Density, 4-Pixel Length)
+==============================================================
+
+This example demonstrates how to generate a 2D cardiac tissue with
+an interstitial fibrosis pattern using the `Structural2DPattern` class
+from Finitewave.
+
+Interstitial fibrosis is modeled as thin, linear fibrotic structures
+or strands, typically aligned along fibers or tissue direction. These
+structures act as barriers to conduction, affecting wave propagation.
+
+Setup:
+------
+- Grid size: 200 × 200
+- Fibrosis type: Interstitial (structured linear insertions)
+- Fibrosis density: 20%
+- Strand dimensions:
+ • i-direction thickness: 1 pixel
+ • j-direction length: 4 pixels
+- Fibrosis applied uniformly over the whole domain
+
+Visualization:
+--------------
+The generated tissue is shown as a 2D image:
+- Green regions: healthy, conductive tissue
+- Yellow linear elements: fibrotic, non-conductive strands (interstitial fibrosis)
+
+Application:
+------------
+This type of structured pattern is useful for simulating how thin fibrotic
+barriers affect action potential propagation, slow conduction, and create
+substrates for reentrant activity.
+
+"""
+
+
+import matplotlib.pyplot as plt
+import finitewave as fw
+
+n = 200
+# create mesh
+tissue = fw.CardiacTissue2D((n, n))
+tissue.add_pattern(fw.Structural2DPattern(density=0.2, length_i=1, length_j=4, x1=0, x2=n, y1=0, y2=n))
+
+plt.title("2D Interstitial Fibrosis Medium with 20% Fibrosis Density and 4 pixels length")
+plt.imshow(tissue.mesh)
+plt.colorbar()
+plt.show()
\ No newline at end of file
diff --git a/examples/fibrosis/2D/labyrinth_propagation.py b/examples/fibrosis/2D/labyrinth_propagation.py
new file mode 100644
index 0000000..706576c
--- /dev/null
+++ b/examples/fibrosis/2D/labyrinth_propagation.py
@@ -0,0 +1,84 @@
+"""
+Simulation in Complex Labyrinth-Like Geometry
+=============================================
+
+This example demonstrates wave propagation through a 2D cardiac tissue
+with a custom-designed labyrinth-like structure. The geometry is created
+manually by setting up regions of obstacles (non-conductive) within a
+conductive domain. The resulting structure mimics pathways similar to
+fibrotic maze-like or post-surgical scarred tissue.
+
+Wavefront propagation is visualized using Finitewave’s Animation2DTracker,
+and the result shows how the wave navigates through the complex network
+of narrow channels and dead-ends.
+
+Setup:
+------
+- Tissue size: 300 × 300
+- Geometry:
+ • Obstacles are placed in alternating vertical bands
+ • Bands are offset to form a labyrinth pattern
+ • `tissue.mesh` uses 1 (myocytes) and 0 (obstacles)
+- Stimulus:
+ • A short planar stimulus applied to a small strip on the left side
+ • Time: t = 0 ms
+- Model:
+ • Aliev-Panfilov 2D model
+ • Total time: 200 ms
+- Visualization:
+ • Voltage (`u`) is tracked every 10 steps
+ • Animation frames are saved and compiled to visualize dynamics
+
+Output:
+-------
+To visualize the result, refer to the generated animation (e.g.,
+`complex_geometry.mp4`) showing how wavefronts propagate within the complex structure.
+
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+import shutil
+
+import finitewave as fw
+
+# number of nodes on the side
+n = 300
+
+tissue = fw.CardiacTissue2D([n, n])
+# create a mesh of cardiomyocytes (elems = 1):
+for i in range(0, 40, 5):
+ if i%10 == 0:
+ tissue.mesh[10*i:10*(i+3), :250] = 0
+ else:
+ tissue.mesh[10*i:10*(i+3), 50:] = 0
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov2D()
+# set up numerical parameters:
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 200
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, int(n*0.03),
+ 0, n))
+
+tracker_sequence = fw.TrackerSequence()
+animation_tracker = fw.Animation2DTracker()
+animation_tracker.variable_name = "u" # Specify the variable to track
+animation_tracker.dir_name = "anim_data"
+animation_tracker.step = 10
+animation_tracker.overwrite = True # Remove existing files in dir_name
+tracker_sequence.add_tracker(animation_tracker)
+
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+aliev_panfilov.run()
+
+# write animation and clear the snapshot folder
+animation_tracker.write(shape_scale=5, clear=True, fps=30)
diff --git a/examples/fibrosis/2D/structural_anisotropy_2d.py b/examples/fibrosis/2D/structural_anisotropy_2d.py
new file mode 100644
index 0000000..956b7fb
--- /dev/null
+++ b/examples/fibrosis/2D/structural_anisotropy_2d.py
@@ -0,0 +1,79 @@
+"""
+Structural Anisotropy in 2D Due to Interstitial Fibrosis
+=========================================================
+
+This example demonstrates how interstitial fibrosis can create structural
+anisotropy in a 2D cardiac tissue. The fibrotic pattern causes directionally
+preferential conduction, leading to an elliptical spread of excitation from a
+point stimulus.
+
+Unlike fiber-based anisotropy, which is driven by directional conductivity,
+this anisotropy arises purely from the geometry of the fibrotic microstructure.
+
+Setup:
+------
+- Tissue: 2D grid of size 400×400
+- Fibrosis:
+ • Type: Interstitial (structured, linear obstacles)
+ • Density: 15%
+ • Strand size: 1 pixel wide × 4 pixels long (aligned in j-direction)
+- Stimulus:
+ • Type: Voltage stimulus
+ • Location: Center of the tissue
+ • Shape: Square (10×10 pixels)
+ • Time: Applied at t = 0 ms
+
+Model:
+------
+- Aliev-Panfilov 2D reaction-diffusion model
+- Simulation time: 30 ms
+- Time step: 0.01 ms
+- Spatial resolution: 0.25 mm
+
+Observation:
+------------
+Due to the aligned fibrotic obstacles, the excitation wavefront becomes
+elliptical, spreading more easily in the direction perpendicular
+to the fibrosis strands. This mimics real-world structural anisotropy seen
+in interstitial fibrosis.
+
+Applications:
+-------------
+This example is useful for exploring:
+- Structural sources of conduction anisotropy
+- Functional impact of interstitial fibrosis geometry
+- Wavefront deformation and vulnerability to reentry
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import finitewave as fw
+
+n = 400
+# create mesh
+tissue = fw.CardiacTissue2D((n, n))
+tissue.add_pattern(fw.Structural2DPattern(density=0.15, length_i=1, length_j=4, x1=0, x2=n, y1=0, y2=n))
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, n//2 - 5, n//2 + 5,
+ n//2 - 5, n//2 + 5))
+
+# create model object and set up parameters:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 30
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+
+# run the model:
+aliev_panfilov.run()
+
+# show the potential map at the end of calculations:
+plt.title("Structural Anisotropy 2D")
+plt.imshow(aliev_panfilov.u)
+plt.colorbar()
+plt.show()
diff --git a/examples/fibrosis/2D/wave_propagation_delay_2d.py b/examples/fibrosis/2D/wave_propagation_delay_2d.py
new file mode 100644
index 0000000..ba73f9b
--- /dev/null
+++ b/examples/fibrosis/2D/wave_propagation_delay_2d.py
@@ -0,0 +1,81 @@
+"""
+Propagation Delay Due to Diffuse Fibrosis
+=========================================
+
+This example compares wave propagation in two 2D cardiac tissues:
+one healthy (no fibrosis) and one with 20% diffuse fibrosis.
+
+A planar wave stimulus is applied from the left side of the tissue,
+and propagation is simulated using the Aliev-Panfilov model.
+
+The resulting transmembrane potential maps clearly show how diffuse
+fibrosis slows down the conduction, causing a visible delay in
+activation front propagation compared to the healthy tissue.
+
+Setup:
+------
+- Tissue size: 300 × 300
+- Fibrosis type: Diffuse (random spatial blockage)
+- Fibrosis density: 20% (in fibrotic case)
+- Stimulus:
+ • Type: Voltage
+ • Applied on leftmost 5 columns of the tissue
+ • Time: t = 0 ms
+- Model: Aliev-Panfilov 2D
+- Time window: 20 ms
+
+Visualization:
+--------------
+The resulting `u` (voltage) maps are plotted side by side to highlight
+the delayed wavefront in the fibrotic tissue.
+
+"""
+import matplotlib.pyplot as plt
+import finitewave as fw
+
+n = 300
+stim_x1, stim_x2 = 0, 5 # planar stimulus strip
+
+def setup_tissue(with_fibrosis):
+ tissue = fw.CardiacTissue2D((n, n))
+ if with_fibrosis:
+ tissue.add_pattern(fw.Diffuse2DPattern(density=0.2))
+ return tissue
+
+def run_simulation(tissue):
+ stim_sequence = fw.StimSequence()
+ stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1,
+ x1=stim_x1, x2=stim_x2,
+ y1=0, y2=n))
+
+ model = fw.AlievPanfilov2D()
+ model.dt = 0.01
+ model.dr = 0.25
+ model.t_max = 20
+ model.cardiac_tissue = tissue
+ model.stim_sequence = stim_sequence
+ model.run()
+ return model
+
+# Run simulations
+print("Running healthy tissue...")
+healthy_tissue = setup_tissue(with_fibrosis=False)
+healthy_model = run_simulation(healthy_tissue)
+
+print("Running fibrotic tissue (20% diffuse)...")
+fibrotic_tissue = setup_tissue(with_fibrosis=True)
+fibrotic_model = run_simulation(fibrotic_tissue)
+
+# Plot results
+fig, axs = plt.subplots(1, 2, figsize=(12, 5))
+axs[0].imshow(healthy_model.u, cmap="viridis", origin="lower")
+axs[0].set_title("Healthy Tissue (No Fibrosis)")
+axs[0].axis("off")
+
+axs[1].imshow(fibrotic_model.u, cmap="viridis", origin="lower")
+axs[1].set_title("Diffuse Fibrosis (20%)")
+axs[1].axis("off")
+
+fig.suptitle("Propagation Delay Due to Fibrosis", fontsize=16)
+plt.tight_layout()
+plt.show()
diff --git a/examples/models/2D/aliev_panfilov_2d.py b/examples/models/2D/aliev_panfilov_2d.py
new file mode 100644
index 0000000..7b77dba
--- /dev/null
+++ b/examples/models/2D/aliev_panfilov_2d.py
@@ -0,0 +1,71 @@
+"""
+Running the Aliev-Panfilov Model in 2D
+======================================
+
+Overview:
+---------
+This example demonstrates how to run a basic 2D simulation of the
+Aliev-Panfilov model using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5 cardiac tissue domain.
+- Stimulation:
+ - A square side stimulus is applied at t = 0.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 50
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Apply a stimulus along the upper boundary to initiate excitation.
+3. Set up and run the Aliev-Panfilov model.
+4. Visualize the transmembrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# create a tissue:
+n = 100
+m = 5
+tissue = fw.CardiacTissue2D([n, m])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 5, 0, m))
+
+# create model object and set up parameters:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 50
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential2DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+# run the model:
+aliev_panfilov.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * aliev_panfilov.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3")
+plt.legend(title='Aliev-Panfilov')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
diff --git a/examples/models/2D/barkley_2d.py b/examples/models/2D/barkley_2d.py
new file mode 100644
index 0000000..7a7f63d
--- /dev/null
+++ b/examples/models/2D/barkley_2d.py
@@ -0,0 +1,86 @@
+"""
+Running the Barkley Model in 2D
+======================================
+
+Overview:
+---------
+This example demonstrates how to run a basic 2D simulation of the
+Barkley model using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5 cardiac tissue domain.
+- Stimulation:
+ - A square side stimulus is applied at t = 0.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 10
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Apply a stimulus along the upper boundary to initiate excitation.
+3. Set up and run the Barkley model.
+4. Visualize the transmembrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# create a tissue:
+n = 100
+m = 5
+tissue = fw.CardiacTissue2D([n, m])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 5, 0, m))
+
+# create model object and set up parameters:
+barkley = fw.Barkley2D()
+barkley.dt = 0.01
+barkley.dr = 0.25
+barkley.t_max = 10
+# add the tissue and the stim parameters to the model object:
+barkley.cardiac_tissue = tissue
+barkley.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+# add the variable tracker:
+multivariable_tracker = fw.MultiVariable2DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+multivariable_tracker.cell_ind = [50, 3]
+multivariable_tracker.var_list = ["u", "v"]
+tracker_sequence.add_tracker(multivariable_tracker)
+barkley.tracker_sequence = tracker_sequence
+
+# run the model:
+barkley.run()
+
+# plot the action potential
+plt.figure(figsize=(10, 5))
+
+# Subplot 1: Phase plot (u vs v)
+plt.subplot(1, 2, 1)
+plt.plot(multivariable_tracker.output["u"], multivariable_tracker.output["v"], label="cell_50_3")
+plt.legend(title='Barkley')
+plt.title('Phase (u vs v)')
+plt.xlabel('u')
+plt.ylabel('v')
+plt.grid()
+
+# Subplot 2: Time vs u
+plt.subplot(1, 2, 2)
+time = np.arange(len(multivariable_tracker.output["u"])) * barkley.dt
+plt.plot(time, multivariable_tracker.output["u"], label="cell_50_3")
+plt.legend(title='Barkley')
+plt.title('Action potential')
+plt.xlabel('Time')
+plt.ylabel('u')
+plt.grid()
+
+plt.show()
\ No newline at end of file
diff --git a/examples/models/2D/bueno_orovio_2d.py b/examples/models/2D/bueno_orovio_2d.py
new file mode 100644
index 0000000..b9fe309
--- /dev/null
+++ b/examples/models/2D/bueno_orovio_2d.py
@@ -0,0 +1,72 @@
+"""
+Running the Bueno-Orovio Model in 2D
+======================================
+
+Overview:
+---------
+This example demonstrates how to run a basic 2D simulation of the
+Bueno-Orovio model using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5 cardiac tissue domain.
+- Stimulation:
+ - A square side stimulus is applied at t = 0.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 500
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Apply a stimulus along the upper boundary to initiate excitation.
+3. Set up and run the Bueno-Orovio model.
+4. Visualize the transmembrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# create a tissue:
+n = 100
+m = 5
+tissue = fw.CardiacTissue2D([n, m])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 5, 0, m))
+
+# create model object and set up parameters:
+bueno_orovio = fw.BuenoOrovio2D()
+bueno_orovio.dt = 0.01
+bueno_orovio.dr = 0.25
+bueno_orovio.t_max = 500
+# add the tissue and the stim parameters to the model object:
+bueno_orovio.cardiac_tissue = tissue
+bueno_orovio.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential2DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+bueno_orovio.tracker_sequence = tracker_sequence
+
+# run the model:
+bueno_orovio.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * bueno_orovio.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3")
+plt.legend(title='Bueno-Orovio')
+plt.xlabel('Time (ms)')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
diff --git a/examples/models/2D/courtemanche_2d.py b/examples/models/2D/courtemanche_2d.py
new file mode 100644
index 0000000..ee16430
--- /dev/null
+++ b/examples/models/2D/courtemanche_2d.py
@@ -0,0 +1,79 @@
+"""
+Running the Courtemanche Model in 2D Cardiac Tissue
+===========================================
+
+Overview:
+---------
+This example demonstrates how to run a 2D simulation of the
+Courtemanche model for atrial cardiomyocytes
+using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5 cardiac tissue domain.
+- Stimulation:
+ - A planar stimulus is applied along the top edge (rows 0 to 5) at t = 0 ms
+ to initiate wave propagation.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01 ms
+ - Spatial resolution (dr): 0.25 mm
+ - Total simulation time (t_max): 500 ms
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Apply a stimulus to initiate excitation.
+3. Set up and run the TP06 model.
+4. Visualize the membrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import finitewave as fw
+
+n = 100
+m = 5
+# create mesh
+tissue = fw.CardiacTissue2D((n, m))
+
+# set up stimulation parameters
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 5, 0, m))
+
+# create model object and set up parameters
+courtemanche = fw.Courtemanche2D()
+courtemanche.dt = 0.01
+courtemanche.dr = 0.25
+courtemanche.t_max = 500
+
+# Here, we increase g_Kur by a factor of 3 to better match physiological AP shape
+# with a visible plateau and realistic repolarization.
+courtemanche.gkur_coeff *= 3
+
+# add the tissue and the stim parameters to the model object
+courtemanche.cardiac_tissue = tissue
+courtemanche.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential2DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+courtemanche.tracker_sequence = tracker_sequence
+
+# run the model:
+courtemanche.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * courtemanche.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3")
+plt.legend(title='Courtemanche')
+plt.xlabel('Time (ms)')
+plt.ylabel('Voltage (mV)')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
\ No newline at end of file
diff --git a/examples/models/2D/fenton_karma_2d.py b/examples/models/2D/fenton_karma_2d.py
new file mode 100644
index 0000000..c82f350
--- /dev/null
+++ b/examples/models/2D/fenton_karma_2d.py
@@ -0,0 +1,72 @@
+"""
+Running the Fentom-Karma Model in 2D
+======================================
+
+Overview:
+---------
+This example demonstrates how to run a basic 2D simulation of the
+Fentom-Karma model using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5 cardiac tissue domain.
+- Stimulation:
+ - A square side stimulus is applied at t = 0.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 500
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Apply a stimulus along the upper boundary to initiate excitation.
+3. Set up and run the Fentom-Karma model.
+4. Visualize the transmembrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# create a tissue:
+n = 100
+m = 5
+tissue = fw.CardiacTissue2D([n, m])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 5, 0, m))
+
+# create model object and set up parameters:
+fentom_karma = fw.FentonKarma2D()
+fentom_karma.dt = 0.01
+fentom_karma.dr = 0.25
+fentom_karma.t_max = 500
+# add the tissue and the stim parameters to the model object:
+fentom_karma.cardiac_tissue = tissue
+fentom_karma.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential2DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+fentom_karma.tracker_sequence = tracker_sequence
+
+# run the model:
+fentom_karma.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * fentom_karma.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3")
+plt.legend(title='Fenton-Karma')
+plt.xlabel('Time (ms)')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
diff --git a/examples/models/2D/luo_rudy_2d.py b/examples/models/2D/luo_rudy_2d.py
new file mode 100644
index 0000000..0a055ec
--- /dev/null
+++ b/examples/models/2D/luo_rudy_2d.py
@@ -0,0 +1,74 @@
+"""
+Running the Luo-Rudy 1991 Model in 2D Cardiac Tissue
+====================================================
+
+Overview:
+---------
+This example demonstrates how to run a 2D simulation of the
+Luo-Rudy 1991 ventricular action potential model using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5 cardiac tissue domain.
+- Stimulation:
+ - A planar stimulus is applied along the top edge of the domain at t = 0 ms
+ to initiate wavefront propagation.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01 ms
+ - Spatial resolution (dr): 0.25 mm
+ - Total simulation time (t_max): 500 ms
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Apply a stimulus along the upper boundary to initiate excitation.
+3. Set up and run the Luo-Rudy 1991 model.
+4. Visualize the transmembrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import finitewave as fw
+
+n = 100
+m = 5
+# create mesh
+tissue = fw.CardiacTissue2D((n, m))
+
+# set up stimulation parameters
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 5, 0, m))
+
+# create model object and set up parameters
+luo_rudy = fw.LuoRudy912D()
+luo_rudy.dt = 0.01
+luo_rudy.dr = 0.25
+luo_rudy.t_max = 500
+
+# add the tissue and the stim parameters to the model object
+luo_rudy.cardiac_tissue = tissue
+luo_rudy.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential2DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+luo_rudy.tracker_sequence = tracker_sequence
+
+# run the model:
+luo_rudy.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * luo_rudy.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3")
+plt.legend(title='Luo-Rudy 1991')
+plt.xlabel('Time (ms)')
+plt.ylabel('Voltage (mV)')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
\ No newline at end of file
diff --git a/examples/models/2D/mitchell_schaeffer_2d.py b/examples/models/2D/mitchell_schaeffer_2d.py
new file mode 100644
index 0000000..1980251
--- /dev/null
+++ b/examples/models/2D/mitchell_schaeffer_2d.py
@@ -0,0 +1,72 @@
+"""
+Running the Mitchell-Schaeffer Model in 2D
+======================================
+
+Overview:
+---------
+This example demonstrates how to run a basic 2D simulation of the
+Mitchell-Schaeffer model using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5 cardiac tissue domain.
+- Stimulation:
+ - A square side stimulus is applied at t = 0.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 500
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Apply a stimulus along the upper boundary to initiate excitation.
+3. Set up and run the Mitchell-Schaeffer model.
+4. Visualize the transmembrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# create a tissue:
+n = 100
+m = 5
+tissue = fw.CardiacTissue2D([n, m])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 5, 0, m))
+
+# create model object and set up parameters:
+mitchell_schaeffer = fw.MitchellSchaeffer2D()
+mitchell_schaeffer.dt = 0.01
+mitchell_schaeffer.dr = 0.25
+mitchell_schaeffer.t_max = 500
+# add the tissue and the stim parameters to the model object:
+mitchell_schaeffer.cardiac_tissue = tissue
+mitchell_schaeffer.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential2DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+mitchell_schaeffer.tracker_sequence = tracker_sequence
+
+# run the model:
+mitchell_schaeffer.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * mitchell_schaeffer.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3")
+plt.legend(title='Mitchell-Schaeffer')
+plt.xlabel('Time (ms)')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
diff --git a/examples/models/2D/tp06_2d.py b/examples/models/2D/tp06_2d.py
new file mode 100644
index 0000000..20518d9
--- /dev/null
+++ b/examples/models/2D/tp06_2d.py
@@ -0,0 +1,75 @@
+"""
+Running the TP06 Model in 2D Cardiac Tissue
+===========================================
+
+Overview:
+---------
+This example demonstrates how to run a 2D simulation of the
+ten Tusscher–Panfilov 2006 (TP06) model for ventricular cardiomyocytes
+using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5 cardiac tissue domain.
+- Stimulation:
+ - A planar stimulus is applied along the top edge (rows 0 to 5) at t = 0 ms
+ to initiate wave propagation.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01 ms
+ - Spatial resolution (dr): 0.25 mm
+ - Total simulation time (t_max): 500 ms
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Apply a stimulus to initiate excitation.
+3. Set up and run the TP06 model.
+4. Visualize the membrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import finitewave as fw
+
+n = 100
+m = 5
+# create mesh
+tissue = fw.CardiacTissue2D((n, m))
+
+# set up stimulation parameters
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 5, 0, m))
+
+# create model object and set up parameters
+tp06 = fw.TP062D()
+tp06.dt = 0.01
+tp06.dr = 0.25
+tp06.t_max = 500
+
+# add the tissue and the stim parameters to the model object
+tp06.cardiac_tissue = tissue
+tp06.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential2DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+tp06.tracker_sequence = tracker_sequence
+
+# run the model:
+tp06.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * tp06.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3")
+plt.legend(title='Ten Tusscher-Panfilov 2006')
+plt.xlabel('Time (ms)')
+plt.ylabel('Voltage (mV)')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
\ No newline at end of file
diff --git a/examples/models/3D/aliev_panfilov_3d.py b/examples/models/3D/aliev_panfilov_3d.py
new file mode 100644
index 0000000..185c171
--- /dev/null
+++ b/examples/models/3D/aliev_panfilov_3d.py
@@ -0,0 +1,72 @@
+"""
+Running the Aliev-Panfilov Model in 3D
+======================================
+
+Overview:
+---------
+This example demonstrates how to run a basic 3D simulation of the
+Aliev-Panfilov model using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5×3 cardiac tissue domain.
+- Stimulation:
+ - A square side stimulus is applied at t = 0.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 50
+
+Execution:
+----------
+1. Create a 3D cardiac tissue grid.
+2. Apply a stimulus along the upper boundary to initiate excitation.
+3. Set up and run the Aliev-Panfilov model.
+4. Visualize the transmembrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# create a tissue:
+n = 100
+m = 5
+k = 3
+tissue = fw.CardiacTissue3D([n, m, k])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, 5, 0, m, 0, k))
+
+# create model object and set up parameters:
+aliev_panfilov = fw.AlievPanfilov3D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 50
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential3DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3, 1]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+# run the model:
+aliev_panfilov.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * aliev_panfilov.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3_1")
+plt.legend(title='Aliev-Panfilov')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
diff --git a/examples/models/3D/barkley_3d.py b/examples/models/3D/barkley_3d.py
new file mode 100644
index 0000000..c12af0a
--- /dev/null
+++ b/examples/models/3D/barkley_3d.py
@@ -0,0 +1,72 @@
+"""
+Running the Barkley Model in 3D
+======================================
+
+Overview:
+---------
+This example demonstrates how to run a basic 3D simulation of the
+Barkley model using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5×3 cardiac tissue domain.
+- Stimulation:
+ - A square side stimulus is applied at t = 0.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 10
+
+Execution:
+----------
+1. Create a 3D cardiac tissue grid.
+2. Apply a stimulus along the upper boundary to initiate excitation.
+3. Set up and run the Barkley model.
+4. Visualize the transmembrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# create a tissue:
+n = 100
+m = 5
+k = 3
+tissue = fw.CardiacTissue3D([n, m, k])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, 5, 0, m, 0, k))
+
+# create model object and set up parameters:
+barkley = fw.Barkley3D()
+barkley.dt = 0.01
+barkley.dr = 0.25
+barkley.t_max = 10
+# add the tissue and the stim parameters to the model object:
+barkley.cardiac_tissue = tissue
+barkley.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential3DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3, 1]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+barkley.tracker_sequence = tracker_sequence
+
+# run the model:
+barkley.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * barkley.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3_1")
+plt.legend(title='Barkley')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
diff --git a/examples/models/3D/bueno_orovio_3d.py b/examples/models/3D/bueno_orovio_3d.py
new file mode 100644
index 0000000..0684033
--- /dev/null
+++ b/examples/models/3D/bueno_orovio_3d.py
@@ -0,0 +1,73 @@
+"""
+Running the Bueno-Orovio Model in 3D
+======================================
+
+Overview:
+---------
+This example demonstrates how to run a basic 3D simulation of the
+Bueno-Orovio model using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5×3 cardiac tissue domain.
+- Stimulation:
+ - A square side stimulus is applied at t = 0.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 500
+
+Execution:
+----------
+1. Create a 3D cardiac tissue grid.
+2. Apply a stimulus along the upper boundary to initiate excitation.
+3. Set up and run the Bueno-Orovio model.
+4. Visualize the transmembrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# create a tissue:
+n = 100
+k = 5
+m = 3
+tissue = fw.CardiacTissue3D([n, m, k])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, 5, 0, m, 0, k))
+
+# create model object and set up parameters:
+bueno_orovio = fw.BuenoOrovio3D()
+bueno_orovio.dt = 0.01
+bueno_orovio.dr = 0.25
+bueno_orovio.t_max = 500
+# add the tissue and the stim parameters to the model object:
+bueno_orovio.cardiac_tissue = tissue
+bueno_orovio.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential3DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3, 1]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+bueno_orovio.tracker_sequence = tracker_sequence
+
+# run the model:
+bueno_orovio.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * bueno_orovio.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3_1")
+plt.legend(title='Bueno-Orovio')
+plt.xlabel('Time (ms)')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
diff --git a/examples/models/3D/courtemanche_3d.py b/examples/models/3D/courtemanche_3d.py
new file mode 100644
index 0000000..7684f73
--- /dev/null
+++ b/examples/models/3D/courtemanche_3d.py
@@ -0,0 +1,79 @@
+"""
+Running the Courtemanche Model in 3D Cardiac Tissue
+====================================================
+
+Overview:
+---------
+This example demonstrates how to run a 3D simulation of the
+Courtemanche ventricular action potential model using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5×3 cardiac tissue domain.
+- Stimulation:
+ - A planar stimulus is applied along the top edge of the domain at t = 0 ms
+ to initiate wavefront propagation.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01 ms
+ - Spatial resolution (dr): 0.25 mm
+ - Total simulation time (t_max): 500 ms
+
+Execution:
+----------
+1. Create a 3D cardiac tissue grid.
+2. Apply a stimulus along the upper boundary to initiate excitation.
+3. Set up and run the Courtemanche model.
+4. Visualize the transmembrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import finitewave as fw
+
+n = 100
+m = 5
+k = 3
+# create mesh
+tissue = fw.CardiacTissue3D((n, m, k))
+
+# set up stimulation parameters
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, 5, 0, m, 0, k))
+
+# create model object and set up parameters
+courtemanche = fw.Courtemanche3D()
+courtemanche.dt = 0.01
+courtemanche.dr = 0.25
+courtemanche.t_max = 500
+
+# Here, we increase g_Kur by a factor of 3 to better match physiological AP shape
+# with a visible plateau and realistic repolarization.
+courtemanche.gkur_coeff *= 3
+
+# add the tissue and the stim parameters to the model object
+courtemanche.cardiac_tissue = tissue
+courtemanche.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential3DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3, 1]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+courtemanche.tracker_sequence = tracker_sequence
+
+# run the model:
+courtemanche.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * courtemanche.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3_1")
+plt.legend(title='Courtemanche')
+plt.xlabel('Time (ms)')
+plt.ylabel('Voltage (mV)')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
\ No newline at end of file
diff --git a/examples/models/3D/fenton_karma_3d.py b/examples/models/3D/fenton_karma_3d.py
new file mode 100644
index 0000000..1268582
--- /dev/null
+++ b/examples/models/3D/fenton_karma_3d.py
@@ -0,0 +1,73 @@
+"""
+Running the Fentom-Karma Model in 3D
+======================================
+
+Overview:
+---------
+This example demonstrates how to run a basic 3D simulation of the
+Fentom-Karma model using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5×3 cardiac tissue domain.
+- Stimulation:
+ - A square side stimulus is applied at t = 0.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 500
+
+Execution:
+----------
+1. Create a 3D cardiac tissue grid.
+2. Apply a stimulus along the upper boundary to initiate excitation.
+3. Set up and run the Fentom-Karma model.
+4. Visualize the transmembrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# create a tissue:
+n = 100
+m = 5
+k = 3
+tissue = fw.CardiacTissue3D([n, m, k])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, 5, 0, m, 0, k))
+
+# create model object and set up parameters:
+fentom_karma = fw.FentonKarma3D()
+fentom_karma.dt = 0.01
+fentom_karma.dr = 0.25
+fentom_karma.t_max = 500
+# add the tissue and the stim parameters to the model object:
+fentom_karma.cardiac_tissue = tissue
+fentom_karma.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential3DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3, 1]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+fentom_karma.tracker_sequence = tracker_sequence
+
+# run the model:
+fentom_karma.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * fentom_karma.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3_1")
+plt.legend(title='Fentom-Karma')
+plt.xlabel('Time (ms)')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
\ No newline at end of file
diff --git a/examples/models/3D/luo_rudy_3d.py b/examples/models/3D/luo_rudy_3d.py
new file mode 100644
index 0000000..4736900
--- /dev/null
+++ b/examples/models/3D/luo_rudy_3d.py
@@ -0,0 +1,75 @@
+"""
+Running the Luo-Rudy 1991 Model in 3D Cardiac Tissue
+====================================================
+
+Overview:
+---------
+This example demonstrates how to run a 3D simulation of the
+Luo-Rudy 1991 ventricular action potential model using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5×3 cardiac tissue domain.
+- Stimulation:
+ - A planar stimulus is applied along the top edge of the domain at t = 0 ms
+ to initiate wavefront propagation.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01 ms
+ - Spatial resolution (dr): 0.25 mm
+ - Total simulation time (t_max): 500 ms
+
+Execution:
+----------
+1. Create a 3D cardiac tissue grid.
+2. Apply a stimulus along the upper boundary to initiate excitation.
+3. Set up and run the Luo-Rudy 1991 model.
+4. Visualize the transmembrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import finitewave as fw
+
+n = 100
+m = 5
+k = 3
+# create mesh
+tissue = fw.CardiacTissue3D((n, m, k))
+
+# set up stimulation parameters
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, 5, 0, m, 0, k))
+
+# create model object and set up parameters
+luo_rudy = fw.LuoRudy913D()
+luo_rudy.dt = 0.01
+luo_rudy.dr = 0.25
+luo_rudy.t_max = 500
+
+# add the tissue and the stim parameters to the model object
+luo_rudy.cardiac_tissue = tissue
+luo_rudy.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential3DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3, 1]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+luo_rudy.tracker_sequence = tracker_sequence
+
+# run the model:
+luo_rudy.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * luo_rudy.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3_1")
+plt.legend(title='Luo-Rudy 1991')
+plt.xlabel('Time (ms)')
+plt.ylabel('Voltage (mV)')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
\ No newline at end of file
diff --git a/examples/models/3D/mitchell_schaeffer_3d.py b/examples/models/3D/mitchell_schaeffer_3d.py
new file mode 100644
index 0000000..4ee7837
--- /dev/null
+++ b/examples/models/3D/mitchell_schaeffer_3d.py
@@ -0,0 +1,73 @@
+"""
+Running the Mitchell-Schaeffer Model in 3D
+======================================
+
+Overview:
+---------
+This example demonstrates how to run a basic 3D simulation of the
+Mitchell-Schaeffer model using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5×3 cardiac tissue domain.
+- Stimulation:
+ - A square side stimulus is applied at t = 0.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 500
+
+Execution:
+----------
+1. Create a 3D cardiac tissue grid.
+2. Apply a stimulus along the upper boundary to initiate excitation.
+3. Set up and run the Mitchell-Schaeffer model.
+4. Visualize the transmembrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# create a tissue:
+n = 100
+m = 5
+k = 3
+tissue = fw.CardiacTissue3D([n, m, k])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, 5, 0, m, 0, k))
+
+# create model object and set up parameters:
+mitchell_schaeffer = fw.MitchellSchaeffer3D()
+mitchell_schaeffer.dt = 0.01
+mitchell_schaeffer.dr = 0.25
+mitchell_schaeffer.t_max = 500
+# add the tissue and the stim parameters to the model object:
+mitchell_schaeffer.cardiac_tissue = tissue
+mitchell_schaeffer.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential3DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3, 1]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+mitchell_schaeffer.tracker_sequence = tracker_sequence
+
+# run the model:
+mitchell_schaeffer.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * mitchell_schaeffer.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3_1")
+plt.legend(title='Mitchell-Schaeffer')
+plt.xlabel('Time (ms)')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
diff --git a/examples/models/3D/tp06_3d.py b/examples/models/3D/tp06_3d.py
new file mode 100644
index 0000000..964cef4
--- /dev/null
+++ b/examples/models/3D/tp06_3d.py
@@ -0,0 +1,76 @@
+"""
+Running the TP06 Model in 3D Cardiac Tissue
+===========================================
+
+Overview:
+---------
+This example demonstrates how to run a 3D simulation of the
+ten Tusscher–Panfilov 2006 (TP06) model for ventricular cardiomyocytes
+using the Finitewave framework.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×5×3 cardiac tissue domain.
+- Stimulation:
+ - A planar stimulus is applied along the top edge (rows 0 to 5) at t = 0 ms
+ to initiate wave propagation.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01 ms
+ - Spatial resolution (dr): 0.25 mm
+ - Total simulation time (t_max): 500 ms
+
+Execution:
+----------
+1. Create a 3D cardiac tissue grid.
+2. Apply a stimulus to initiate excitation.
+3. Set up and run the TP06 model.
+4. Visualize the membrane potential.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import finitewave as fw
+
+n = 100
+m = 5
+k = 3
+# create mesh
+tissue = fw.CardiacTissue3D((n, m, k))
+
+# set up stimulation parameters
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, 5, 0, m, 0, k))
+
+# create model object and set up parameters
+tp06 = fw.TP063D()
+tp06.dt = 0.01
+tp06.dr = 0.25
+tp06.t_max = 500
+
+# add the tissue and the stim parameters to the model object
+tp06.cardiac_tissue = tissue
+tp06.stim_sequence = stim_sequence
+
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential3DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[50, 3, 1]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+tp06.tracker_sequence = tracker_sequence
+
+# run the model:
+tp06.run()
+
+# plot the action potential
+plt.figure()
+time = np.arange(len(action_pot_tracker.output)) * tp06.dt
+plt.plot(time, action_pot_tracker.output, label="cell_50_3_1")
+plt.legend(title='Ten Tusscher-Panfilov 2006')
+plt.xlabel('Time (ms)')
+plt.ylabel('Voltage (mV)')
+plt.title('Action Potential')
+plt.grid()
+plt.show()
\ No newline at end of file
diff --git a/examples/stimulation/3d_stimulation.py b/examples/stimulation/3d_stimulation.py
new file mode 100644
index 0000000..884b528
--- /dev/null
+++ b/examples/stimulation/3d_stimulation.py
@@ -0,0 +1,70 @@
+"""
+Stimulation in 3D
+==================================
+
+Overview:
+---------
+This example demonstrates how to apply two opposite planar waves in 3D tissue using:
+- `StimVoltageCoord3D`: voltage stimulation with spatial bounds (`x1`, `x2`, `y1`, `y2`, `z1`, `z2`)
+- `StimCurrentMatrix3D`: matrix-based current stimulation with a 3D boolean array.
+
+The example highlights that 3D stimulation setup is identical to 2D,
+with the only difference being the inclusion of the Z-axis (`z1`, `z2` or 3D matrix).
+
+Simulation Setup:
+-----------------
+- Tissue: 3D slab (200×200×10)
+- Stimulus 1: Voltage-based planar wave on the left face at `t=0`
+- Stimulus 2: Current-based planar wave on the right face at `t=0`
+- Duration: 10 time units
+
+Application:
+------------
+- Demonstrates stimulation syntax for 3D using both coordinate and matrix methods.
+- Visualizes resulting voltage (`u`) distribution in 3D using PyVista.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import pyvista as pv
+import finitewave as fw
+
+# tissue setup
+nx = 200
+ny = 200
+nz = 30
+tissue = fw.CardiacTissue3D([nx, ny, nz])
+tissue.mesh = np.ones((nx, ny, nz), dtype=np.uint8)
+
+# stimulus 1: VoltageCoord3D on left face
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(
+ fw.StimVoltageCoord3D(time=0, volt_value=1.0,
+ x1=0, x2=5,
+ y1=0, y2=ny,
+ z1=0, z2=nz)
+)
+
+# stimulus 2: CurrentMatrix3D on right face
+stim_matrix = np.zeros((nx, ny, nz), dtype=bool)
+stim_matrix[nx - 5:nx, :, :] = True # Right face
+stim_sequence.add_stim(
+ fw.StimCurrentMatrix3D(time=0, curr_value=10, duration=0.5, matrix=stim_matrix)
+)
+
+# model setup:
+model = fw.AlievPanfilov3D()
+model.dt = 0.01
+model.dr = 0.25
+model.t_max = 10
+model.cardiac_tissue = tissue
+model.stim_sequence = stim_sequence
+
+# run the model:
+model.run()
+
+# visualization with PyVista:
+mesh_builder = fw.VisMeshBuilder3D()
+mesh_grid = mesh_builder.build_mesh(tissue.mesh)
+mesh_grid = mesh_builder.add_scalar(model.u, name='Membrane Potential (u)')
+mesh_grid.plot(cmap='viridis', clim=[0, 1])
\ No newline at end of file
diff --git a/examples/stimulation/coordinates_stimulation.py b/examples/stimulation/coordinates_stimulation.py
new file mode 100644
index 0000000..27296e2
--- /dev/null
+++ b/examples/stimulation/coordinates_stimulation.py
@@ -0,0 +1,35 @@
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# set up the tissue:
+n = 200
+tissue = fw.CardiacTissue2D([n, n])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+# stimulate the corner of the tissue with a square pulse (10 nodes on the side)
+# of 1.0 V at t=0.
+# coordinates are always form a reactangular (slab in 3D) area of stimulation.
+stim_sequence.add_stim(fw.StimVoltageCoord2D(time=0,
+ volt_value=1.0,
+ x1=0, x2=10,
+ y1=0, y2=10))
+
+# create model object and set up parameters:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 25
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+
+# run the model:
+aliev_panfilov.run()
+
+# show the potential map at the end of calculations:
+plt.figure()
+plt.imshow(aliev_panfilov.u)
+plt.colorbar()
+plt.show()
\ No newline at end of file
diff --git a/examples/stimulation/current_stimulation.py b/examples/stimulation/current_stimulation.py
new file mode 100644
index 0000000..94f25e1
--- /dev/null
+++ b/examples/stimulation/current_stimulation.py
@@ -0,0 +1,71 @@
+"""
+Using StimCurrentCoord2D for Current-Based Stimulation
+=======================================================
+
+Overview:
+---------
+This example demonstrates how to apply a current-based stimulus in a 2D cardiac tissue
+using the `StimCurrentCoord2D` class from Finitewave.
+
+Stimulation Setup:
+------------------
+- The center of the tissue is stimulated with a small square pulse (2×2 nodes).
+- A current of 18 units is applied for 0.4 at t = 0.
+- Unlike voltage stimulation, current-based stimulation allows effective excitation
+ of very small regions, which is especially useful for avoiding sink-source mismatch
+ problems in tightly localized areas.
+
+Simulation Parameters:
+----------------------
+- Model: Aliev-Panfilov 2D
+- Grid size: 200 × 200
+- Time step (dt): 0.01
+- Space step (dr): 0.25
+- Total simulation time: 10
+
+Application:
+------------
+This example is ideal for understanding how to trigger depolarization waves using
+current injection. The `StimCurrentCoord2D` class allows flexible control of both
+current strength and duration, enabling fine-tuned stimulus delivery.
+"""
+
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# set up the tissue:
+n = 200
+tissue = fw.CardiacTissue2D([n, n])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+# All stimulation object have two types of stimulation: by current and by voltage.
+# In case of current stimulation, we use two parameters: current strength and duration.
+# stimulate the center of the tissue with a square pulse (2 nodes on the side)
+# сurrent stimulation is set by current strength (18) and stimulation duration (0.4 model time units).
+# Current stimulation allows to bypass the problem of sink-source mismatch
+# and stimulate even small areas of tissue to start a depolarization wave:
+stim_sequence.add_stim(fw.StimCurrentCoord2D(time=0,
+ curr_value=18,
+ duration=0.4,
+ x1=n//2 - 1, x2=n//2 + 1,
+ y1=n//2 - 1, y2=n//2 + 1))
+
+# create model object and set up parameters:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 10
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+
+# run the model:
+aliev_panfilov.run()
+
+# show the potential map at the end of calculations:
+plt.figure()
+plt.imshow(aliev_panfilov.u)
+plt.colorbar()
+plt.show()
\ No newline at end of file
diff --git a/examples/stimulation/matrix_stimulation.py b/examples/stimulation/matrix_stimulation.py
new file mode 100644
index 0000000..b75c4ea
--- /dev/null
+++ b/examples/stimulation/matrix_stimulation.py
@@ -0,0 +1,75 @@
+"""
+Matrix-Based Stimulation with StimVoltageMatrix2D
+=========================================================
+
+Overview:
+---------
+This example demonstrates how to define complex spatial stimulation patterns
+in 2D cardiac tissue using the `StimVoltageMatrix2D` class in Finitewave.
+
+Stimulation Setup:
+------------------
+- A 2D boolean matrix of the same size as the tissue is used to define the
+ stimulated regions.
+- Two 10×10 square regions in opposite corners of the tissue are stimulated
+ at t = 0 with 1.0 V voltage.
+- This flexible approach allows arbitrary spatial patterns and can be
+ generated from images, data arrays, or procedural logic.
+
+Simulation Parameters:
+----------------------
+- Model: Aliev-Panfilov 2D
+- Grid size: 200 × 200
+- Time step (dt): 0.01
+- Space step (dr): 0.25
+- Total simulation time: 15
+
+Application:
+------------
+This technique is ideal for:
+- Designing realistic stimulation setups.
+- Applying stimuli based on experimental data or anatomical maps.
+- Studying the effect of spatial heterogeneity in excitation.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# set up the tissue:
+n = 200
+tissue = fw.CardiacTissue2D([n, n])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+# stimulate two opposite corners of the tissue with a square pulse (10 nodes on the side)
+# of 1.0 V at t=0.
+# we create a 2D boolean matrix of the same size as the tissue
+# and set the stimulated nodes to True:
+stimulation_area = np.full([n, n], False, dtype=bool)
+stimulation_area[0:10, 0:10] = True
+stimulation_area[n-10:n, n-10:n] = True
+
+stim_sequence.add_stim(fw.StimVoltageMatrix2D(time=0,
+ volt_value=1.0,
+ matrix=stimulation_area))
+
+# create model object and set up parameters:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 15
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+
+# run the model:
+aliev_panfilov.run()
+
+# show the potential map at the end of calculations:
+plt.figure()
+plt.imshow(aliev_panfilov.u)
+plt.colorbar()
+plt.show()
\ No newline at end of file
diff --git a/examples/stimulation/sequential_stimulation.py b/examples/stimulation/sequential_stimulation.py
new file mode 100644
index 0000000..d677cf4
--- /dev/null
+++ b/examples/stimulation/sequential_stimulation.py
@@ -0,0 +1,99 @@
+"""
+Sequential Multi-Type Stimulation in 2D Tissue
+==============================================
+
+Overview:
+---------
+This example demonstrates how to define a sequence of heterogeneous stimuli
+using different stimulation classes in a single simulation using Finitewave.
+Stimuli are applied from multiple locations at different times, combining
+`StimVoltageCoord2D`, `StimCurrentMatrix2D`, and `StimVoltageCoord2D`.
+
+Stimulation Setup:
+------------------
+1. t = 0: Voltage-based stimulation in the top-left corner (5×5 region).
+2. t = 70: Matrix-based *current* stimulation (5×5 region in top-right).
+3. t = 140: Voltage-based stimulation in the bottom-right corner (10×10).
+
+Simulation Parameters:
+----------------------
+- Model: Aliev-Panfilov 2D
+- Grid size: 200 × 200
+- Time step (dt): 0.01
+- Space step (dr): 0.25
+- Total simulation time: 170
+
+Tracking:
+---------
+- Animation tracker records membrane potential (`u`) every 10 steps.
+- Results are saved to the "anim_data" folder and exported as a 2D animation.
+
+Application:
+------------
+This setup is ideal for:
+- Exploring sequential pacing protocols.
+- Testing responses to multiple localized perturbations.
+- Demonstrating how to combine different stimulation methods in a single run.
+
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import finitewave as fw
+
+# set up the tissue:
+n = 200
+tissue = fw.CardiacTissue2D([n, n])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+# Here we create a sequence of stimuli from different corners of a square mesh.
+# The stimulation object in the sequence can be of any type (class).
+stim_sequence.add_stim(
+ fw.StimVoltageCoord2D(time=0,
+ volt_value=1.0,
+ x1=0, x2=5,
+ y1=0, y2=5)
+)
+
+stim_matrix = np.full([n, n], False, dtype=bool)
+stim_matrix[0:5, n-5:n] = True
+stim_sequence.add_stim(
+ fw.StimCurrentMatrix2D(time=70,
+ curr_value=5,
+ duration=0.6,
+ matrix=stim_matrix)
+)
+
+stim_sequence.add_stim(
+ fw.StimVoltageCoord2D(time=140,
+ volt_value=0.5,
+ x1=n-10, x2=n,
+ y1=n-10, y2=n)
+)
+
+# set up tracker parameters:
+tracker_sequence = fw.TrackerSequence()
+animation_tracker = fw.Animation2DTracker()
+animation_tracker.variable_name = "u" # Specify the variable to track
+animation_tracker.dir_name = "anim_data"
+animation_tracker.step = 10
+animation_tracker.overwrite = True # Remove existing files in dir_name
+tracker_sequence.add_tracker(animation_tracker)
+
+# create model object and set up parameters:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 170
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+# run the model:
+aliev_panfilov.run()
+
+# write animation and clear the snapshot folder
+animation_tracker.write(shape_scale=5, clear=True, fps=60)
\ No newline at end of file
diff --git a/examples/stimulation/voltage_stimulation.py b/examples/stimulation/voltage_stimulation.py
new file mode 100644
index 0000000..edec1f4
--- /dev/null
+++ b/examples/stimulation/voltage_stimulation.py
@@ -0,0 +1,69 @@
+"""
+Using StimVoltageCoord in 2D Tissue
+=====================================
+
+Overview:
+---------
+This example demonstrates how to use the `StimVoltageCoord2D` class in Finitewave
+to apply a voltage-based stimulus to a rectangular region in a 2D cardiac tissue.
+
+Stimulation Setup:
+------------------
+- The `StimVoltageCoord2D` class is used to define the stimulated region by its coordinates.
+- A square region (6×6 nodes) at the center of the tissue is stimulated at t = 0 .
+- The voltage value is set to 1.0, which for the Aliev-Panfilov model corresponds
+ to the peak excitation potential (resting = 0, peak = 1).
+
+Simulation Parameters:
+----------------------
+- Model: Aliev-Panfilov 2D
+- Grid size: 200 × 200
+- Time step (dt): 0.01
+- Space step (dr): 0.25
+- Total simulation time: 10
+
+Application:
+------------
+This example is useful for learning how to define spatially localized voltage
+stimuli in 2D using coordinate-based methods. The `StimVoltageCoord2D` class
+is particularly useful for applying custom rectangular stimulation zones.
+"""
+
+
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# set up the tissue:
+n = 200
+tissue = fw.CardiacTissue2D([n, n])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+# stimulate the center of the tissue with a square pulse (6 nodes on the side)
+# we use voltage value = 1.0 V at t=0.
+# The voltage value should be set between the resting potential and the peak potential of
+# the model to ensure the stimulation is effective.
+# in case of Aliev-Panfilov model, the resting potential is 0 and the peak potential is 1:
+stim_sequence.add_stim(fw.StimVoltageCoord2D(time=0,
+ volt_value=1.0,
+ x1=n//2 - 3, x2=n//2 + 3,
+ y1=n//2 - 3, y2=n//2 + 3))
+
+# create model object and set up parameters:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 10
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+
+# run the model:
+aliev_panfilov.run()
+
+# show the potential map at the end of calculations:
+plt.figure()
+plt.imshow(aliev_panfilov.u)
+plt.colorbar()
+plt.show()
\ No newline at end of file
diff --git a/examples/trackers/2D/act_time_2d_tracker.py b/examples/trackers/2D/act_time_2d_tracker.py
deleted file mode 100755
index 2498c30..0000000
--- a/examples/trackers/2D/act_time_2d_tracker.py
+++ /dev/null
@@ -1,56 +0,0 @@
-
-#
-# Use the ActivationTime2DTracker to create an activation time map.
-#
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 200
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# don't forget to add the fibers array even if you have an anisotropic tissue:
-tissue.fibers = np.zeros([n, n, 2])
-
-# create model object:
-# aliev_panfilov = AlievPanfilov2D()
-aliev_panfilov = fw.AlievPanfilov2D()
-
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 50
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 3, 0, n))
-
-tracker_sequence = fw.TrackerSequence()
-# add action potential tracker
-act_time_tracker = fw.ActivationTime2DTracker()
-act_time_tracker.threshold = 0.5
-tracker_sequence.add_tracker(act_time_tracker)
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-aliev_panfilov.run()
-
-X, Y = np.mgrid[0:n-2:1, 0:n-2:1]
-levels = np.arange(0., 120, 10)
-
-fig, ax = plt.subplots()
-ax.imshow(act_time_tracker.act_t[1:-1, 1:-1])
-CS = ax.contour(X, Y, np.transpose(act_time_tracker.act_t[1:-1, 1:-1]), colors='black')
-ax.clabel(CS, inline=True, fontsize=10)
-plt.show()
diff --git a/examples/trackers/2D/action_potential_2d_tracker.py b/examples/trackers/2D/action_potential_2d_tracker.py
new file mode 100644
index 0000000..e5529be
--- /dev/null
+++ b/examples/trackers/2D/action_potential_2d_tracker.py
@@ -0,0 +1,97 @@
+
+"""
+Tracking Action Potentials in 2D Cardiac Tissue
+===============================================
+
+Overview:
+---------
+This example demonstrates how to track action potentials at specific
+cell locations in a 2D cardiac tissue simulation using the
+ActionPotential2DTracker class in Finitewave. Action potential tracking
+is crucial for analyzing electrophysiological responses at different
+tissue points.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×100 cardiac tissue domain.
+- Stimulation:
+ - A left-side stimulus is applied at time t = 0.
+ - The excitation wave propagates across the tissue.
+- Action Potential Tracking:
+ - Action potentials are recorded at two specific cells:
+ - Cell at (30, 30)
+ - Cell at (70, 70)
+ - Sampling step: Every time step (1 ms).
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 50
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Apply stimulation at the left boundary.
+3. Set up an action potential tracker:
+ - The tracker records the membrane potential over time at specified
+ cell indices.
+4. Run the Aliev-Panfilov model to simulate wave propagation.
+5. Extract and visualize action potential waveforms.
+
+Application:
+------------
+Tracking action potentials is useful for:
+- Studying cardiac excitability at different spatial locations.
+- Comparing action potential durations across various tissue points.
+- Analyzing arrhythmias or conduction abnormalities in excitable media.
+
+Visualization:
+--------------
+The action potentials recorded at the selected cells are plotted over time
+using matplotlib. The graph shows the voltage dynamics of the
+excited regions.
+
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import finitewave as fw
+
+# create a mesh of cardiomyocytes (elems = 1):
+n = 100
+m = 100
+tissue = fw.CardiacTissue2D([m, n])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 3, 0, n))
+
+# set up tracker parameters:
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential2DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[30, 30], [70, 70]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+
+# create model object and set up parameters:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 50
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+aliev_panfilov.run()
+
+# plot the action potential
+time = np.arange(len(action_pot_tracker.output)) * aliev_panfilov.dt
+
+plt.figure()
+plt.plot(time, action_pot_tracker.output[:, 0], label="cell_30_30")
+plt.plot(time, action_pot_tracker.output[:, 1], label="cell_70_70")
+plt.legend(title='Aliev-Panfilov')
+plt.show()
diff --git a/examples/trackers/2D/animation_2d_tracker.py b/examples/trackers/2D/animation_2d_tracker.py
old mode 100755
new mode 100644
index b5b60c0..c1360b8
--- a/examples/trackers/2D/animation_2d_tracker.py
+++ b/examples/trackers/2D/animation_2d_tracker.py
@@ -1,62 +1,89 @@
+"""
+Creating an Animation of Action Potential in 2D
+===============================================
-#
-# Use the Animation2DTracker to make a folder with snapshots if model variable (voltage in this example)
-# Then use the AnimationBuilder to create mp4 animation based on snapshots folder.
-# Keep in mind: you have to install ffmpeg on your system.
-#
+Overview:
+---------
+This example demonstrates how to use the `Animation2DTracker` to generate an
+animation of the action potential (or any other variablse you choose) in a 2D cardiac tissue simulation.
+The animation is saved as a sequence of frames and can be exported as a video or GIF.
+Simulation Setup:
+-----------------
+- Tissue Grid: A 200×200 cardiac tissue domain.
+- Stimulation:
+ - First stimulus is applied to the bottom half of the domain at t = 0.
+ - Second stimulus is applied to the left half at t = 31 to initiate wave break and spiral formation.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 100
-import matplotlib.pyplot as plt
-import numpy as np
-import shutil
+Animation Tracker:
+------------------
+- Tracks the transmembrane potential `u` during the simulation.
+- Records a frame every 10 steps (`step = 10`).
+- Frames are saved into the `anim_data/` directory.
+- Existing data in the directory will be overwritten.
+- After the simulation, `write()` is called to render the animation:
+ - `shape_scale`: Zoom factor for each frame.
+ - `clear=True`: Deletes all raw frame data after animation is generated.
+ - `fps=30`: Frames per second for the output video.
-import finitewave as fw
+Execution:
+----------
+1. Set up cardiac tissue and stimulation sequence.
+2. Attach `Animation2DTracker` to the tracker sequence.
+3. Run the Aliev-Panfilov model with configured simulation and tracking.
+4. Call `write()` to generate and optionally clean up the animation.
-# number of nodes on the side
-n = 100
+Application:
+------------
+- Useful for visualizing wave propagation and reentry.
+- Can be used in presentations, publications, or model comparisons.
+- Helps in debugging wave dynamics and understanding tissue behavior.
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
+Output:
+-------
+The animation is written to disk in the specified folder (`anim_data`).
+It shows the evolution of the transmembrane potential over time in the tissue.
-# don't forget to add the fibers array even if you have an anisotropic tissue:
-tissue.fibers = np.zeros([n, n, 2])
+"""
-# create model object:
-aliev_panfilov = fw.AlievPanfilov2D()
+import numpy as np
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 50
+import finitewave as fw
+
+# set up the tissue:
+n = 200
+tissue = fw.CardiacTissue2D([n, n])
# set up stimulation parameters:
stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, n, 0, 5))
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, n, 0, n//2))
+stim_sequence.add_stim(fw.StimVoltageCoord2D(31, 1, 0, n//2, 0, n))
+# set up tracker parameters:
tracker_sequence = fw.TrackerSequence()
-# add action potential tracker
animation_tracker = fw.Animation2DTracker()
-# We want to write the animation for the voltage variable. Use string value
-# to specify the required array.anim_data
-animation_tracker.target_array = "u"
-# Folder name:
+animation_tracker.variable_name = "u" # Specify the variable to track
animation_tracker.dir_name = "anim_data"
-animation_tracker.step = 1
+animation_tracker.step = 10
+animation_tracker.overwrite = True # Remove existing files in dir_name
tracker_sequence.add_tracker(animation_tracker)
+# create model object:
+aliev_panfilov = fw.AlievPanfilov2D()
+# set up numerical parameters:
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 100
# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
aliev_panfilov.tracker_sequence = tracker_sequence
-
+# run the model:
aliev_panfilov.run()
-animation_builder = fw.AnimationBuilder()
-animation_builder.dir_name = "anim_data"
-animation_builder.write_2d_mp4("animation.mp4")
-
-# remove the snapshots folder:
-shutil.rmtree("anim_data")
+# write animation and clear the snapshot folder
+animation_tracker.write(shape_scale=5, clear=True, fps=30, clim=[0, 1]) # !Note: for ionic models use clim=[-90, 40] or similar to show the activity correctly
\ No newline at end of file
diff --git a/examples/trackers/2D/ecg_2d_tracker.py b/examples/trackers/2D/ecg_2d_tracker.py
index 5866239..5dc74d5 100755
--- a/examples/trackers/2D/ecg_2d_tracker.py
+++ b/examples/trackers/2D/ecg_2d_tracker.py
@@ -1,48 +1,105 @@
+"""
+Electrocardiogram (ECG) Tracking in 2D Cardiac Tissue
+=====================================================
-#
-# Use the Period2DTracker to measure wave period (e.g spiral wave).
-#
+Overview:
+---------
+This example demonstrates how to use the ECG2DTracker to record an
+electrocardiogram (ECG) from a 2D cardiac tissue simulation. The ECG
+signal is obtained from multiple measurement points at a given distance
+from the tissue.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 400×400 cardiac tissue domain.
+- Stimulation:
+ - A left-side stimulus is applied at time t = 0.
+ - The excitation wave propagates across the tissue.
+- ECG Tracking:
+ - Three measurement points are positioned at increasing vertical distances.
+ - The signal strength is computed using an inverse distance power law.
+ - Measurement points:
+ - (n/2, n/4, 10)
+ - (n/2, n/2, 10)
+ - (n/2, 3n/4, 10)
+ - Sampling step: Every 10 time steps.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.001
+ - Spatial resolution (dr): 0.1
+ - Total simulation time (t_max): 50
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Apply stimulation along the left boundary.
+3. Set up an ECG tracker:
+ - Records electrical activity from multiple measurement points.
+ - Uses an inverse distance weighting (power = 2) to compute the
+ potential at each location.
+4. Run the Aliev-Panfilov model to simulate cardiac wave propagation.
+5. Extract and visualize the ECG waveform.
+
+Application:
+------------
+ECG tracking in a simulated tissue is useful for:
+- Studying ECG signal characteristics in controlled environments.
+- Understanding the relationship between wave propagation and ECG morphology.
+- Testing the effect of different tissue properties on the ECG signal.
+
+Visualization:
+--------------
+The recorded ECG signal is plotted over time using matplotlib,
+illustrating how electrical wave activity in cardiac tissue translates
+into an observable ECG trace.
+
+"""
import matplotlib.pyplot as plt
import numpy as np
import finitewave as fw
-# number of nodes on the side
+# set up the tissue:
n = 200
tissue = fw.CardiacTissue2D([n, n])
# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# don't forget to add the fibers array even if you have an anisotropic tissue:
-tissue.fibers = np.zeros([n, n, 2])
# create model object:
-for model in [fw.AlievPanfilov2D]:
- aliev_panfilov = model()
- aliev_panfilov.dt = 0.01
- aliev_panfilov.dr = 0.25
- aliev_panfilov.t_max = 100
-
- # set up stimulation parameters:
- stim_sequence = fw.StimSequence()
- stim_sequence.add_stim(fw.StimVoltageCoord2D(10, 1, 0, n, 0, 3))
- # stim_sequence.add_stim(StimVoltageCoord2D(31, 1, 0, 100, 0, n))
-
- tracker_sequence = fw.TrackerSequence()
- ecg_tracker = fw.ECG2DTracker()
- ecg_tracker.measure_points = np.array([[100, 100, 10]])
- tracker_sequence.add_tracker(ecg_tracker)
-
- # add the tissue and the stim parameters to the model object:
- aliev_panfilov.cardiac_tissue = tissue
- aliev_panfilov.stim_sequence = stim_sequence
- aliev_panfilov.tracker_sequence = tracker_sequence
-
- aliev_panfilov.run()
-
- plt.plot(ecg_tracker.ecg[0])
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.0015
+aliev_panfilov.dr = 0.1
+aliev_panfilov.t_max = 50
+
+# induce the spiral wave:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1,
+ 0, n,
+ 0, 5))
+
+tracker_sequence = fw.TrackerSequence()
+# create an ECG tracker:
+ecg_tracker = fw.ECG2DTracker()
+ecg_tracker.start_time = 0
+ecg_tracker.step = 100
+ecg_tracker.measure_coords = np.array([[n//2, n//2, 10],
+ [n//4, n//2, 10],
+ [3*n//4, 3*n//4, 10]])
+
+tracker_sequence.add_tracker(ecg_tracker)
+
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+aliev_panfilov.run()
+
+colors = ['tab:blue', 'tab:orange', 'tab:green']
+plt.figure()
+for i, y in enumerate(ecg_tracker.output.T):
+ x = np.arange(len(y)) * aliev_panfilov.dt * ecg_tracker.step
+ plt.plot(x, y, '-o', color=colors[i], label='precomputed distances')
+
+plt.legend(title='ECG computed with')
plt.show()
diff --git a/examples/trackers/2D/local_activation_times_2d_tracker.py b/examples/trackers/2D/local_activation_times_2d_tracker.py
new file mode 100644
index 0000000..06d9b40
--- /dev/null
+++ b/examples/trackers/2D/local_activation_times_2d_tracker.py
@@ -0,0 +1,129 @@
+"""
+Tracking Local Activation Time in 2D Cardiac Tissue
+===================================================
+
+Overview:
+---------
+This example demonstrates how to use the `LocalActivationTime2DTracker` to
+track multiple local activation events over time in a 2D cardiac tissue
+simulation using the Aliev-Panfilov model. Unlike `ActivationTime2DTracker`,
+which stores only the first activation time per cell, this tracker captures
+all threshold crossings during a specified time window.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 200×200 cardiac tissue domain.
+- Spiral Wave Initiation:
+ - First stimulus at t = 0 along the top edge.
+ - Second stimulus at t = 50 applied to the right half of the tissue.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.3
+ - Total simulation time (t_max): 200
+
+Local Activation Time Tracking:
+-------------------------------
+- Threshold: 0.5 (value of `u` used to detect activation).
+- Records all threshold crossings per cell during:
+ - `start_time = 100`
+ - `end_time = 200`
+- Data is recorded every `step = 10` simulation steps.
+- The tracker outputs a 3D array (num_events, x, y) with activation times.
+
+Execution:
+----------
+1. Set up a 2D tissue grid and stimulation pattern to induce spiral activity.
+2. Configure the `LocalActivationTime2DTracker`.
+3. Run the simulation using the Aliev-Panfilov model.
+4. Extract and visualize activation maps for selected time points.
+
+Application:
+------------
+- Ideal for analyzing wave reentry, rotation, or drift.
+- Helps evaluate activation frequency and reactivation patterns.
+- Useful in quantifying arrhythmogenic behavior over time.
+
+Visualization:
+--------------
+Activation time maps are plotted for selected reference time bases (e.g. 150, 170),
+showing the most recent activation at each location relative to that time base.
+
+Output:
+-------
+A set of color-mapped images visualizing activation wavefronts at different times,
+with all threshold-crossing events taken into account.
+
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import finitewave as fw
+
+# number of nodes on the side
+n = 200
+tissue = fw.CardiacTissue2D([n, n])
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov2D()
+# set up numerical parameters:
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.3
+aliev_panfilov.t_max = 200
+
+# induce spiral wave:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(time=0, volt_value=1, x1=0, x2=n,
+ y1=0, y2=5))
+stim_sequence.add_stim(fw.StimVoltageCoord2D(time=50, volt_value=1, x1=n//2,
+ x2=n, y1=0, y2=n))
+
+# set up the tracker:
+tracker_sequence = fw.TrackerSequence()
+act_time_tracker = fw.LocalActivationTime2DTracker()
+act_time_tracker.threshold = 0.5
+act_time_tracker.step = 10
+act_time_tracker.start_time = 100
+act_time_tracker.end_time = 200
+tracker_sequence.add_tracker(act_time_tracker)
+
+# connect model with tissue, stim and tracker:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+# run the simulation:
+aliev_panfilov.run()
+
+# plot the activation time map:
+time_bases = [150, 170] # time bases to plot the activation time map
+lats = act_time_tracker.output
+print(f'Number of LATs: {len(act_time_tracker.output)}')
+
+X, Y = np.mgrid[0:n:1, 0:n:1]
+
+fig, axs = plt.subplots(ncols=len(time_bases), figsize=(15, 5))
+
+if len(time_bases) == 1:
+ axs = [axs]
+
+for i, ax in enumerate(axs):
+ # Select the activation times next closest to the time base
+ mask = np.any(lats >= time_bases[i], axis=0)
+ ids = np.argmax(lats >= time_bases[i], axis=0)
+ ids = tuple((ids[mask], *np.where(mask)))
+
+ act_time = np.full([n, n], np.nan)
+ act_time[mask] = lats[ids]
+
+ act_time_min = time_bases[i]
+ act_time_max = time_bases[i] + 30
+
+ ax.imshow(act_time,
+ vmin=act_time_min,
+ vmax=act_time_max,
+ cmap='viridis')
+ ax.set_title(f'Activation time: {time_bases[i]} ms')
+ cbar = fig.colorbar(ax.images[0], ax=ax, orientation='vertical')
+ cbar.set_label('Activation Time (ms)')
+plt.show()
\ No newline at end of file
diff --git a/examples/trackers/2D/mult_act_time_2d_tracker.py b/examples/trackers/2D/mult_act_time_2d_tracker.py
deleted file mode 100755
index 27fad16..0000000
--- a/examples/trackers/2D/mult_act_time_2d_tracker.py
+++ /dev/null
@@ -1,60 +0,0 @@
-
-#
-# Use the ActivationTime2DTracker to create an activation time map.
-#
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 200
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# don't forget to add the fibers array even if you have an anisotropic tissue:
-tissue.fibers = np.zeros([n, n, 2])
-
-# create model object:
-# aliev_panfilov = AlievPanfilov2D()
-aliev_panfilov = fw.AlievPanfilov2D()
-
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 300
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 3, 0, n))
-stim_sequence.add_stim(fw.StimVoltageCoord2D(100, 1, 0, 3, 0, n))
-stim_sequence.add_stim(fw.StimVoltageCoord2D(200, 1, 0, 3, 0, n))
-
-tracker_sequence = fw.TrackerSequence()
-# add action potential tracker
-act_time_tracker = fw.MultiActivationTime2DTracker()
-act_time_tracker.threshold = 0.5
-tracker_sequence.add_tracker(act_time_tracker)
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-aliev_panfilov.run()
-
-print (len(act_time_tracker.act_t))
-
-#X, Y = np.mgrid[0:n-2:1, 0:n-2:1]
-#levels = np.arange(0., 120, 10)
-
-#fig, ax = plt.subplots()
-#ax.imshow(act_time_tracker.act_t[1:-1, 1:-1])
-#CS = ax.contour(X, Y, np.transpose(act_time_tracker.act_t[1:-1, 1:-1]), colors='black')
-#ax.clabel(CS, inline=True, fontsize=10)
-#plt.show()
diff --git a/examples/trackers/2D/multi_variable_2d_tracker.py b/examples/trackers/2D/multi_variable_2d_tracker.py
deleted file mode 100755
index 64dba9c..0000000
--- a/examples/trackers/2D/multi_variable_2d_tracker.py
+++ /dev/null
@@ -1,54 +0,0 @@
-
-#
-# Here we use the ActionPotential2DTracker to plot a voltage variable graph for the cell 30, 30.
-#
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 100
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# don't forget to add the fibers array even if you have an anisotropic tissue:
-tissue.fibers = np.zeros([n, n, 2])
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov2D()
-
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 100
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 3, 0, n))
-
-tracker_sequence = fw.TrackerSequence()
-# add action potential tracker
-multivariable_tracker = fw.MultiVariable2DTracker()
-# to specify the mesh node under the measuring - use the cell_ind field:
-multivariable_tracker.cell_ind = [30, 30]
-multivariable_tracker.var_list = ["u", "v"]
-tracker_sequence.add_tracker(multivariable_tracker)
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-
-aliev_panfilov.run()
-
-time = np.arange(len(multivariable_tracker.vars["u"]))*aliev_panfilov.dt
-plt.plot(time, multivariable_tracker.vars["u"])
-plt.plot(time, multivariable_tracker.vars["v"])
-plt.show()
diff --git a/examples/trackers/2D/period_2d_tracker.py b/examples/trackers/2D/period_2d_tracker.py
deleted file mode 100755
index 516ec98..0000000
--- a/examples/trackers/2D/period_2d_tracker.py
+++ /dev/null
@@ -1,57 +0,0 @@
-
-#
-# Use the Period2DTracker to measure wave period (e.g spiral wave).
-#
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 200
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# don't forget to add the fibers array even if you have an anisotropic tissue:
-tissue.fibers = np.zeros([n, n, 2])
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov2D()
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 300
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, n, 0, n//2))
-stim_sequence.add_stim(fw.StimVoltageCoord2D(31, 1, 0, n//2, 0, n))
-
-tracker_sequence = fw.TrackerSequence()
-# add action potential tracker
-# # add period tracker:
-period_tracker = fw.Period2DTracker()
-# Here we create an int array of period detectors, where 1 means detector, 0 means no detector.
-# First we create positions list (two coordinates for 2D), then use this list as indices
-# for the detectors array.
-detectors = np.zeros([n, n], dtype="uint8")
-positions = np.array([[1,1], [5,5], [7,3], [9,1]])
-detectors[positions[:, 0], positions[:, 1]] = 1
-period_tracker.detectors = detectors
-period_tracker.threshold = 0.5
-tracker_sequence.add_tracker(period_tracker)
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-aliev_panfilov.run()
-
-print ("Periods:")
-for key in period_tracker.output:
- print(key + ":", period_tracker.output[key][-1][1])
diff --git a/examples/trackers/2D/period_map_2d_tracker.py b/examples/trackers/2D/period_map_2d_tracker.py
deleted file mode 100755
index 73fed3b..0000000
--- a/examples/trackers/2D/period_map_2d_tracker.py
+++ /dev/null
@@ -1,54 +0,0 @@
-import matplotlib.pyplot as plt
-import numpy as np
-import shutil
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 200
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# add fibers (oriented along X):
-tissue.fibers = np.zeros([n, n, 2])
-tissue.fibers[:,:,0] = 0.
-tissue.fibers[:,:,1] = 1.
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov2D()
-
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 120
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, n, 0, 100))
-stim_sequence.add_stim(fw.StimVoltageCoord2D(31, 1, 0, 100, 0, n))
-
-tracker_sequence = fw.TrackerSequence()
-period_map_tracker = fw.PeriodMap2DTracker()
-period_map_tracker.dir_name = "period_map"
-period_map_tracker.threshold = 0.3
-period_map_tracker.step = 1
-tracker_sequence.add_tracker(period_map_tracker)
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-aliev_panfilov.run()
-
-animation_builder = fw.AnimationBuilder()
-animation_builder.dir_name = "period_map"
-animation_builder.vmin = 15
-animation_builder.vmax = 26
-animation_builder.write_2d_mp4("period_map.mp4")
-
-shutil.rmtree("period_map")
diff --git a/examples/trackers/2D/simple_activation_time_2d_tracker.py b/examples/trackers/2D/simple_activation_time_2d_tracker.py
new file mode 100755
index 0000000..93da0ce
--- /dev/null
+++ b/examples/trackers/2D/simple_activation_time_2d_tracker.py
@@ -0,0 +1,86 @@
+"""
+Tracking Activation Time in 2D Cardiac Tissue
+=============================================
+
+Overview:
+---------
+This example demonstrates how to track activation times during a
+2D cardiac tissue simulation using the ActivationTime2DTracker
+class in Finitewave. Activation time tracking helps analyze the propagation
+of electrical waves and conduction delays in excitable media.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 200×200 cardiac tissue domain.
+- Stimulation:
+ - A left-side stimulus is applied at time t = 0.
+ - The excitation propagates across the tissue.
+- Activation Time Tracking:
+ - Threshold: 0.5 (membrane potential value used to define activation).
+ - Sampling interval: Every 100 steps.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 50
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Apply stimulation along the left boundary to initiate wave propagation.
+3. Set up an activation time tracker:
+ - The tracker records the time of first activation for each tissue element.
+4. Run the Aliev-Panfilov model to simulate wave dynamics.
+5. Extract and visualize the activation time map.
+
+Application:
+------------
+Tracking activation times is useful for:
+- Analyzing conduction velocity in cardiac tissue.
+- Detecting conduction blocks or delays in pathological conditions.
+- Comparing different tissue properties (e.g., isotropic vs. anisotropic).
+
+Visualization:
+--------------
+The activation time map is displayed using matplotlib, with a color-coded
+representation of activation delays across the tissue.
+
+"""
+
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# create a mesh of cardiomyocytes (elems = 1):
+n = 200
+tissue = fw.CardiacTissue2D([n, n])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(time=0, volt_value=1,
+ x1=0, x2=3, y1=0, y2=n))
+
+# set up tracker parameters:
+tracker_sequence = fw.TrackerSequence()
+act_time_tracker = fw.ActivationTime2DTracker()
+act_time_tracker.threshold = 0.5
+act_time_tracker.step = 100 # calculate activation time every 100 steps
+tracker_sequence.add_tracker(act_time_tracker)
+
+# create model object and set up parameters:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 50
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+aliev_panfilov.run()
+
+# plot the activation time map
+plt.imshow(act_time_tracker.output, cmap="viridis")
+cbar = plt.colorbar()
+cbar.ax.set_ylabel('Time (model units)', rotation=270, labelpad=15)
+plt.title("Activation time map")
+plt.show()
diff --git a/examples/trackers/2D/spiral_wave_core_2d_tracker.py b/examples/trackers/2D/spiral_wave_core_2d_tracker.py
new file mode 100755
index 0000000..c59062f
--- /dev/null
+++ b/examples/trackers/2D/spiral_wave_core_2d_tracker.py
@@ -0,0 +1,96 @@
+
+"""
+Tracking Spiral Wave Core in 2D Cardiac Tissue
+==============================================
+
+Overview:
+---------
+This example demonstrates how to use the SpiralWaveCore2DTracker to track
+the core of a spiral wave in a 2D cardiac tissue simulation. Spiral
+waves are essential phenomena in cardiac electrophysiology and are closely
+related to reentrant arrhythmias.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 200×200 cardiac tissue domain.
+- Spiral Wave Initiation:
+ - A first stimulus excites the lower half of the tissue at t = 0.
+ - A second stimulus is applied to the left half at t = 31,
+ breaking the wavefront and initiating spiral wave formation.
+- Spiral Core Tracking:
+ - Threshold: 0.5 (voltage level used to detect the wave core).
+ - Tracking start time: 50 (after wave formation).
+ - Recording interval: Every 100 steps.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 300
+
+Execution:
+----------
+1. Create a 2D cardiac tissue grid.
+2. Apply two sequential stimulations to induce a spiral wave.
+3. Set up a spiral wave core tracker:
+ - Tracks the movement of the wave’s center over time.
+4. Run the Aliev-Panfilov model to simulate wave dynamics.
+5. Extract and visualize the spiral wave trajectory.
+
+Application:
+------------
+Tracking the spiral wave core is useful for:
+- Analyzing reentrant arrhythmias and spiral wave stability.
+- Studying spiral wave drift and anchoring in different tissue conditions.
+- Testing anti-arrhythmic strategies by analyzing wave behavior.
+
+Visualization:
+--------------
+The spiral wave trajectory is plotted over the final membrane potential
+distribution using matplotlib, showing how the wave core moves over time.
+
+"""
+
+import matplotlib.pyplot as plt
+
+import finitewave as fw
+
+# set up the tissue:
+n = 200
+tissue = fw.CardiacTissue2D([n, n])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, n, 0, n//2))
+stim_sequence.add_stim(fw.StimVoltageCoord2D(31, 1, 0, n//2, 0, n))
+
+# set up tracker parameters:
+tracker_sequence = fw.TrackerSequence()
+sw_core_tracker = fw.SpiralWaveCore2DTracker()
+sw_core_tracker.threshold = 0.5
+sw_core_tracker.start_time = 50
+sw_core_tracker.step = 100 # Record the spiral wave core every 1 time unit
+tracker_sequence.add_tracker(sw_core_tracker)
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 300
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+aliev_panfilov.run()
+
+sw_core = sw_core_tracker.output
+
+# plot the spiral wave trajectory:
+plt.imshow(aliev_panfilov.u, cmap='viridis', origin='lower')
+plt.plot(sw_core['x'], sw_core['y'], 'r')
+plt.title('Spiral Wave Trajectory')
+plt.xlabel('x')
+plt.ylabel('y')
+plt.xlim(0, n)
+plt.ylim(0, n)
+
+plt.show()
diff --git a/examples/trackers/2D/spiral_wave_period_2d_tracker.py b/examples/trackers/2D/spiral_wave_period_2d_tracker.py
new file mode 100644
index 0000000..0a5540e
--- /dev/null
+++ b/examples/trackers/2D/spiral_wave_period_2d_tracker.py
@@ -0,0 +1,108 @@
+"""
+Measuring Wave Period in 2D Cardiac Tissue
+==========================================
+
+Overview:
+---------
+This example demonstrates how to use the `Period2DTracker` to measure the
+wave period at specific locations in a 2D cardiac tissue simulation.
+This is particularly useful for analyzing repetitive wave activity, such as
+spiral waves or regular pacing, and for determining local cycle lengths.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 200×200 cardiac tissue domain.
+- Stimulation:
+ - First stimulus applied to the bottom half of the domain at t = 0.
+ - Second stimulus applied to the left half at t = 31 to initiate reentry.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 300
+
+Wave Period Tracking:
+---------------------
+- A list of detector positions is provided through the `cell_ind` parameter:
+ - Positions: (1,1), (5,5), (7,3), (9,1), (100,100), (150,3), (100,150)
+- The tracker monitors threshold crossings at each specified cell to calculate
+ the local activation period.
+- Tracking starts at `start_time = 100` and is evaluated every `step = 10` steps.
+- Threshold voltage for detection is set to `0.5`.
+
+Execution:
+----------
+1. Create and configure a 2D cardiac tissue grid.
+2. Apply sequential stimulation to induce spiral or repetitive wave activity.
+3. Configure the `Period2DTracker` with desired cell indices.
+4. Run the Aliev-Panfilov model and track the period at each specified location.
+5. Plot the average and standard deviation of the measured periods.
+
+Application:
+------------
+- Useful for analyzing cycle lengths during sustained wave activity.
+- Applicable in reentry studies, tissue heterogeneity analysis, or pacing experiments.
+- Helps evaluate the spatial variability of wave dynamics and rhythm regularity.
+
+Output:
+-------
+The resulting plot shows the mean wave period at each detector location,
+along with error bars indicating standard deviation over time.
+
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import finitewave as fw
+
+# number of nodes on the side
+n = 200
+tissue = fw.CardiacTissue2D([n, n])
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov2D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 300
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, n, 0, n//2))
+stim_sequence.add_stim(fw.StimVoltageCoord2D(31, 1, 0, n//2, 0, n))
+
+tracker_sequence = fw.TrackerSequence()
+# add action potential tracker
+# # add period tracker:
+period_tracker = fw.Period2DTracker()
+# Here we create an int array of detectors as a list of positions in which we want to calculate the period.
+positions = np.array([[1, 1], [5, 5], [7, 3], [9, 1],
+ [100, 100], [150, 3], [100, 150]])
+period_tracker.cell_ind = positions
+period_tracker.threshold = 0.5
+period_tracker.start_time = 100
+period_tracker.step = 10
+tracker_sequence.add_tracker(period_tracker)
+
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+aliev_panfilov.run()
+
+# get the wave period as a pandas Series with the cell index as the index:
+periods = period_tracker.output
+
+# plot the wave period:
+plt.figure()
+plt.errorbar(range(len(positions)),
+ periods.apply(lambda x: x.mean()),
+ yerr=periods.apply(lambda x: x.std()),
+ fmt='o')
+plt.xticks(range(len(positions)), [f'({x[0]}, {x[1]})' for x in positions],
+ rotation=45)
+plt.xlabel('Cell Index')
+plt.ylabel('Period')
+plt.title('Wave period')
+plt.tight_layout()
+plt.show()
\ No newline at end of file
diff --git a/examples/trackers/2D/tips_2d_tracker.py b/examples/trackers/2D/tips_2d_tracker.py
deleted file mode 100755
index da80152..0000000
--- a/examples/trackers/2D/tips_2d_tracker.py
+++ /dev/null
@@ -1,49 +0,0 @@
-
-#
-# The example of Spiral2DTracker usage to record the spiral wave trajectory.
-# Keep in mind that yu can use this tracker with fibrotic tissue.
-#
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 200
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# don't forget to add the fibers array even if you have an anisotropic tissue:
-tissue.fibers = np.zeros([n, n, 2])
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov2D()
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 300
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, n, 0, 100))
-stim_sequence.add_stim(fw.StimVoltageCoord2D(31, 1, 0, 100, 0, n))
-
-tracker_sequence = fw.TrackerSequence()
-spiral_2d_tracker = fw.Spiral2DTracker()
-tracker_sequence.add_tracker(spiral_2d_tracker)
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-aliev_panfilov.run()
-
-swcore = np.array(spiral_2d_tracker.swcore)
-
-plt.plot(swcore[:,2], swcore[:,3])
-plt.show()
diff --git a/examples/trackers/2D/variables_2d_tracker.py b/examples/trackers/2D/variables_2d_tracker.py
new file mode 100644
index 0000000..27c869c
--- /dev/null
+++ b/examples/trackers/2D/variables_2d_tracker.py
@@ -0,0 +1,92 @@
+"""
+Tracking State Variables in 2D Cardiac Tissue
+=============================================
+
+Overview:
+---------
+This example demonstrates how to use the `MultiVariable2DTracker` to record
+the values of multiple state variables (such as `u` and `v`) at a specific
+cell in a 2D cardiac tissue simulation using the Aliev-Panfilov model.
+
+Simulation Setup:
+-----------------
+- Tissue Grid: A 100×100 cardiac tissue domain.
+- Stimulation:
+ - A stimulus is applied to the left edge of the domain at t = 0 to initiate wave propagation.
+- Time and Space Resolution:
+ - Temporal step (dt): 0.01
+ - Spatial resolution (dr): 0.25
+ - Total simulation time (t_max): 100
+
+State Variable Tracking:
+------------------------
+- The `MultiVariable2DTracker` is used to track both:
+ - `u`: Transmembrane potential
+ - `v`: Recovery variable
+- Tracking location is set via `cell_ind = [30, 30]`.
+- Variable values are recorded at every time step.
+
+Execution:
+----------
+1. Set up a 2D cardiac tissue grid and stimulation pattern.
+2. Attach the `MultiVariable2DTracker` to record `u` and `v` at one node.
+3. Run the simulation using the Aliev-Panfilov model.
+4. Plot the recorded values over time to analyze the local action potential dynamics.
+
+Application:
+------------
+- Useful for analyzing the temporal dynamics of variables at specific tissue points.
+- Can help validate model behavior or compare different cell locations.
+- Ideal for creating time series data for further signal analysis or machine learning tasks.
+
+Output:
+-------
+The resulting plot shows the evolution of both `u` and `v` at the selected cell,
+providing insight into the local electrophysiological response to stimulation.
+
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import finitewave as fw
+
+# number of nodes on the side
+n = 100
+tissue = fw.CardiacTissue2D([n, n])
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov2D()
+
+# set up numerical parameters:
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 100
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 3, 0, n))
+
+tracker_sequence = fw.TrackerSequence()
+
+# add the variable tracker:
+multivariable_tracker = fw.MultiVariable2DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+multivariable_tracker.cell_ind = [30, 30]
+multivariable_tracker.var_list = ["u", "v"]
+tracker_sequence.add_tracker(multivariable_tracker)
+
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+aliev_panfilov.run()
+
+# plot the action potential and state variable v at the measuring point
+time = np.arange(len(multivariable_tracker.output["u"])) * aliev_panfilov.dt
+
+plt.plot(time, multivariable_tracker.output["u"], label="u")
+plt.plot(time, multivariable_tracker.output["v"], label="v")
+plt.legend(title=aliev_panfilov.__class__.__name__)
+plt.show()
\ No newline at end of file
diff --git a/examples/trackers/2D/velocity_2d_tracker.py b/examples/trackers/2D/velocity_2d_tracker.py
deleted file mode 100755
index 9dbcdde..0000000
--- a/examples/trackers/2D/velocity_2d_tracker.py
+++ /dev/null
@@ -1,48 +0,0 @@
-
-#
-# Use the Velocity2DTracker measure the wave front velocity.
-# The Velocity2DTracker gives a list of velocities for each wave front node.
-#
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 200
-
-tissue = fw.CardiacTissue2D([n, n])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# don't forget to add the fibers array even if you have an anisotropic tissue:
-tissue.fibers = np.zeros([n, n, 2])
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov2D()
-
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 15
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 95, 105, 95, 105))
-
-tracker_sequence = fw.TrackerSequence()
-velocity_tracker = fw.Velocity2DTracker()
-velocity_tracker.threshold = 0.5
-tracker_sequence.add_tracker(velocity_tracker)
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-aliev_panfilov.run()
-
-print ("Mean wave front velocity: ", np.mean(velocity_tracker.compute_velocity_front()))
diff --git a/examples/trackers/3D/act_pot_3d_tracker.py b/examples/trackers/3D/act_pot_3d_tracker.py
deleted file mode 100755
index 8be0e39..0000000
--- a/examples/trackers/3D/act_pot_3d_tracker.py
+++ /dev/null
@@ -1,53 +0,0 @@
-
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 100
-nj = 100
-nk = 10
-
-tissue = fw.CardiacTissue3D([n, nj, nk])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, nj, nk], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# add fibers (oriented along X):
-tissue.fibers = np.zeros([n, nj, nk, 3])
-tissue.fibers[:,:,:,0] = 1
-tissue.fibers[:,:,:,1] = 0
-tissue.fibers[:,:,:,2] = 0
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov3D()
-
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 50
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, 3, 0, nj, 0, nk))
-
-tracker_sequence = fw.TrackerSequence()
-# add action potential tracker
-act_pot_tracker = fw.ActionPotential3DTracker()
-# to specify the mesh node under the measuring - use the cell_ind field:
-act_pot_tracker.cell_ind = [30, 30, 5]
-tracker_sequence.add_tracker(act_pot_tracker)
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-aliev_panfilov.run()
-
-plt.plot(np.arange(len(act_pot_tracker.output)) * aliev_panfilov.dt,
- act_pot_tracker.output)
-plt.show()
diff --git a/examples/trackers/3D/act_time_3d_tracker.py b/examples/trackers/3D/act_time_3d_tracker.py
deleted file mode 100755
index 125556e..0000000
--- a/examples/trackers/3D/act_time_3d_tracker.py
+++ /dev/null
@@ -1,53 +0,0 @@
-
-import numpy as np
-import finitewave as fw
-
-# number of nodes on the side
-n = 100
-nj = 100
-nk = 10
-
-tissue = fw.CardiacTissue3D([n, nj, nk])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, nj, nk], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# add a conductivity array, all elements = 1.0 -> normal conductvity:
-tissue.cond = np.ones([n, nj, nk])
-
-# add fibers (oriented along X):
-tissue.fibers = np.zeros([n, nj, nk, 3])
-tissue.fibers[:, :, 0] = 1.
-tissue.fibers[:, :, 1] = 0.
-tissue.fibers[:, :, 2] = 0.
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov3D()
-
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 60
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, 3, 0, nj, 0, nk))
-
-tracker_sequence = fw.TrackerSequence()
-act_time_tracker = fw.ActivationTime3DTracker()
-act_time_tracker.target_model = aliev_panfilov
-act_time_tracker.threshold = 0.5
-tracker_sequence.add_tracker(act_time_tracker)
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-aliev_panfilov.run()
-
-mesh_builder = fw.VisMeshBuilder3D()
-grid = mesh_builder.build_mesh(tissue.mesh)
-grid = mesh_builder.add_scalar(act_time_tracker.act_t, name='Activation Time')
-grid.plot(cmap='viridis')
diff --git a/examples/trackers/3D/action_potential_3d_tracker.py b/examples/trackers/3D/action_potential_3d_tracker.py
new file mode 100644
index 0000000..c29be1c
--- /dev/null
+++ b/examples/trackers/3D/action_potential_3d_tracker.py
@@ -0,0 +1,85 @@
+"""
+ActionPotential3DTracker
+=========================
+
+This example demonstrates how to use the ActionPotential3DTracker in a 3D tissue
+simulation with the Aliev-Panfilov model.
+
+Overview:
+---------
+The ActionPotential3DTracker allows you to monitor and record the transmembrane
+potential (u) over time at specific locations within the 3D cardiac tissue.
+
+Simulation Setup:
+-----------------
+- Tissue: A 3D slab of size 100×100×10 with default isotropic mesh.
+- Stimulation: Planar stimulation applied at the left boundary (x ∈ [0, 3]).
+- Tracking:
+ - Two measurement points are selected:
+ - [30, 30, 5]
+ - [70, 70, 8]
+ - Tracker records the value of `u` at every time step.
+
+Execution:
+----------
+1. A 3D tissue is created and stimulated from one side.
+2. The ActionPotential3DTracker records action potentials at the given cell
+ locations throughout the simulation.
+3. The recorded time series is visualized using matplotlib.
+
+Applications:
+-------------
+- Useful for analyzing wave propagation, latency, and signal morphology.
+- Can be used for APD measurement, restitution curve analysis, or comparing
+ regional tissue responses in 3D.
+
+Output:
+-------
+A plot showing transmembrane potential over time for each measurement point.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import finitewave as fw
+
+# number of nodes on the side
+n = 100
+nj = 100
+nk = 10
+
+tissue = fw.CardiacTissue3D([n, nj, nk])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, 3, 0, nj, 0, nk))
+
+# set up tracker parameters:
+tracker_sequence = fw.TrackerSequence()
+action_pot_tracker = fw.ActionPotential3DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+# eather list or list of lists can be used
+action_pot_tracker.cell_ind = [[30, 30, 5], [70, 70, 8]]
+action_pot_tracker.step = 1
+tracker_sequence.add_tracker(action_pot_tracker)
+
+# create model object and set up parameters:
+aliev_panfilov = fw.AlievPanfilov3D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 50
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+aliev_panfilov.run()
+
+# plot the action potential
+time = np.arange(len(action_pot_tracker.output)) * aliev_panfilov.dt
+
+plt.figure()
+plt.plot(time, action_pot_tracker.output[:, 0], label="cell_30_30_5")
+plt.plot(time, action_pot_tracker.output[:, 1], label="cell_70_70_8")
+plt.legend(title='Aliev-Panfilov')
+plt.show()
\ No newline at end of file
diff --git a/examples/trackers/3D/animation_3D_tracker.py b/examples/trackers/3D/animation_3D_tracker.py
deleted file mode 100644
index e6442cb..0000000
--- a/examples/trackers/3D/animation_3D_tracker.py
+++ /dev/null
@@ -1,60 +0,0 @@
-
-#
-# Use the Animation3DTracker to create a snapshot dir with the model variables.
-# The write method of the tracker will call the Animation3DBuilder to create
-# the animation.
-#
-
-import math
-import numpy as np
-import matplotlib.pyplot as plt
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 200
-nj = 200
-nk = 10
-
-tissue = fw.CardiacTissue3D([n, nj, nk])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, nj, nk], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# add a conductivity array, all elements = 1.0 -> normal conductvity:
-tissue.cond = np.ones([n, nj, nk])
-
-# add fibers (oriented along X):
-tissue.fibers = np.zeros([n, nj, nk, 3])
-tissue.fibers[:, :, 0] = 1
-tissue.fibers[:, :, 1] = 0
-tissue.fibers[:, :, 2] = 0
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov3D()
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 150
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, n, 0, 100, 0, nk))
-stim_sequence.add_stim(fw.StimVoltageCoord3D(31, 1, 0, 100, 0, n, 0, nk))
-
-# set up animation tracker:
-animation_tracker = fw.Animation3DTracker()
-animation_tracker.step = 3
-animation_tracker.start = 50
-animation_tracker.target_array = "u"
-# add the tracker to the model:
-tracker_sequence = fw.TrackerSequence()
-tracker_sequence.add_tracker(animation_tracker)
-# add the sequence to the model:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-aliev_panfilov.run()
-# write the animation:
-animation_tracker.write(format='mp4', framerate=5, quality=9,
- clear=True)
diff --git a/examples/trackers/3D/animation_3d_tracker.py b/examples/trackers/3D/animation_3d_tracker.py
new file mode 100644
index 0000000..089d4d6
--- /dev/null
+++ b/examples/trackers/3D/animation_3d_tracker.py
@@ -0,0 +1,81 @@
+"""
+Animation3DTracker Example
+==========================
+
+This example demonstrates how to use the Animation3DTracker to generate a
+visualization of transmembrane potential (u) over time in a 3D cardiac tissue
+simulation using the Aliev-Panfilov model.
+
+Overview:
+---------
+The tracker captures snapshots of the selected variable during the simulation
+and later compiles them into an animation (e.g. .mp4 video).
+
+Simulation Setup:
+-----------------
+- Tissue: A 3D slab of size 100×100×10.
+- Stimulation:
+ - First wave is initiated from the lower half of the tissue at t = 0.
+ - Second wave is initiated from the left half at t = 31 to create
+ wavefront interactions.
+- Tracking:
+ - The transmembrane potential (`u`) is recorded every 10 steps.
+ - Snapshots are stored in the folder `anim_data` and compiled into a .mp4.
+
+Execution:
+----------
+1. Simulate wave propagation using the Aliev-Panfilov model.
+2. Save snapshots of `u` at regular intervals.
+3. Compile snapshots into an animation after the simulation.
+
+Applications:
+-------------
+- Useful for visualizing wave dynamics in 3D, such as propagation, collision,
+ or reentry.
+- Supports model validation, presentation, and educational use.
+
+Output:
+-------
+An `.mp4` animation file in the `anim_data` folder, showing how `u` evolves
+over time in the 3D domain.
+"""
+
+import numpy as np
+
+import finitewave as fw
+
+# set up the tissue:
+n = 100
+nk = 10
+tissue = fw.CardiacTissue3D([n, n, nk])
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, n, 0, n//2, 0, nk))
+stim_sequence.add_stim(fw.StimVoltageCoord3D(31, 1, 0, n//2, 0, n, 0, nk))
+
+# set up tracker parameters:
+tracker_sequence = fw.TrackerSequence()
+animation_tracker = fw.Animation3DTracker()
+animation_tracker.variable_name = "u" # Specify the variable to track
+animation_tracker.dir_name = "anim_data"
+animation_tracker.step = 10
+animation_tracker.overwrite = True # Remove existing files in dir_name
+tracker_sequence.add_tracker(animation_tracker)
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov3D()
+# set up numerical parameters:
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 100
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+# run the model:
+aliev_panfilov.run()
+
+# write animation and clear the snapshot folder
+animation_tracker.write(format='mp4', framerate=10, quality=9,
+ clear=True, clim=[0, 1]) # !Note: for ionic models use clim=[-90, 40] or similar to show the activity correctly
\ No newline at end of file
diff --git a/examples/trackers/3D/animation_slice_3d_tracker.py b/examples/trackers/3D/animation_slice_3d_tracker.py
deleted file mode 100755
index 99e9172..0000000
--- a/examples/trackers/3D/animation_slice_3d_tracker.py
+++ /dev/null
@@ -1,69 +0,0 @@
-
-#
-# Use the Animation2DTracker to make a folder with snapshots if model variable (voltage in this example)
-# Then use the AnimationBuilder to create mp4 animation based on snapshots folder.
-# Keep in mind: you have to install ffmpeg on your system.
-#
-
-import matplotlib.pyplot as plt
-import numpy as np
-import shutil
-
-import finitewave as fw
-
-
-# number of nodes on the side
-n = 100
-nj = 100
-nk = 10
-
-tissue = fw.CardiacTissue3D([n, nj, nk])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, nj, nk], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# add a conductivity array, all elements = 1.0 -> normal conductvity:
-tissue.C = np.ones([n, nj, nk])
-
-# add fibers (oriented along X):
-tissue.fibers = np.zeros([n, nj, nk, 3])
-tissue.fibers[:,:,0] = 1
-tissue.fibers[:,:,1] = 0
-tissue.fibers[:,:,2] = 0
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov3D()
-
-# set up numerical parameters:
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 50
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, 10, 0, nj, 0, nk))
-
-tracker_sequence = fw.TrackerSequence()
-animation_tracker = fw.AnimationSlice3DTracker()
-animation_tracker.target_model = aliev_panfilov
-# We want to write the animation for the voltage variable. Use string value
-# to specify the required array.anim_data
-animation_tracker.target_array = "u"
-animation_tracker.dir_name = "anim_data"
-animation_tracker.step = 1
-animation_tracker.slice_n = 5
-tracker_sequence.add_tracker(animation_tracker)
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-aliev_panfilov.run()
-
-animation_builder = fw.AnimationBuilder()
-animation_builder.dir_name = "anim_data"
-animation_builder.write_2d_mp4("animation.mp4")
-
-shutil.rmtree("anim_data")
diff --git a/examples/trackers/3D/ecg_3d_tracker.py b/examples/trackers/3D/ecg_3d_tracker.py
index 2613dfe..3e13fee 100644
--- a/examples/trackers/3D/ecg_3d_tracker.py
+++ b/examples/trackers/3D/ecg_3d_tracker.py
@@ -1,7 +1,49 @@
-#
-# Use the Period3DTracker to measure wave period (e.g spiral wave).
-#
+"""
+ECG in 3D Slab
+==============
+
+This example demonstrates how to use the ECG3DTracker to simulate extracellular
+electrograms (pseudo-ECG signals) generated by a 3D cardiac tissue slab
+using the Aliev-Panfilov model.
+
+Overview:
+---------
+The ECG3DTracker computes simplified ECG-like signals based on the transmembrane
+currents in the tissue and their distance to virtual electrode positions located
+outside the slab.
+
+Simulation Setup:
+-----------------
+- Tissue: A 3D slab of size 200×200×5.
+- Stimulation:
+ - A planar voltage stimulus is applied at the bottom edge (y=0 to y=5) at t = 0 ms.
+- Measurement:
+ - Virtual electrodes are placed above the slab (z = nk + 3).
+ - Three positions are used:
+ - Center: [100, 100, 8]
+ - Left-center: [ 50, 100, 8]
+ - Bottom-right: [150, 150, 8]
+ - Transmembrane potentials are sampled every 100 time steps.
+
+Tracker:
+--------
+- ECG3DTracker integrates the contribution of the transmembrane current from all
+ active tissue elements to each measurement point, using a distance-based
+ approximation of the extracellular potential.
+
+Output:
+-------
+A matplotlib plot showing ECG signals at the three electrode positions over time.
+This allows visualizing the propagation of electrical activity through the tissue
+as detected externally.
+
+Applications:
+-------------
+- Educational visualizations of how wavefronts generate extracellular signals.
+- Comparison of ECG morphology at different electrode locations.
+- Study of pacing, reentry, or arrhythmic patterns via pseudo-ECG.
+"""
import matplotlib.pyplot as plt
import numpy as np
@@ -9,40 +51,34 @@
import finitewave as fw
# number of nodes on the side
-n = 100
-m = 10
+n = 200
+nk = 5
-tissue = fw.CardiacTissue3D([n, n, m])
+tissue = fw.CardiacTissue3D([n, n, nk])
# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, n, m], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-theta, alpha = 0.25*np.pi, 0.1*np.pi/4
-tissue.fibers = np.zeros((n, n, m, 3))
-tissue.fibers[:, :, :, 0] = np.cos(theta) * np.cos(alpha)
-tissue.fibers[:, :, :, 1] = np.cos(theta) * np.sin(alpha)
-tissue.fibers[:, :, :, 2] = np.sin(theta)
-# add numeric method stencil for weights computations
-tissue.stencil = fw.AsymmetricStencil3D()
-tissue.D_al = 1
-tissue.D_ac = tissue.D_al/9
# create model object:
aliev_panfilov = fw.AlievPanfilov3D()
aliev_panfilov.dt = 0.0015
aliev_panfilov.dr = 0.1
-aliev_panfilov.t_max = 30
+aliev_panfilov.t_max = 50
-# set up stimulation parameters:
+# induce the spiral wave:
stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 1, 5, 1, n-1, 1, m-1))
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1,
+ 0, n,
+ 0, 5,
+ 0, nk))
tracker_sequence = fw.TrackerSequence()
+# create an ECG tracker:
ecg_tracker = fw.ECG3DTracker()
-ecg_tracker.measure_coords = np.array([[n//2, n//2, m+3],
- [n//4, n//2, m+3],
- [3*n//4, 3*n//4, m+3]])
+ecg_tracker.start_time = 0
+ecg_tracker.step = 100
+ecg_tracker.measure_coords = np.array([[n//2, n//2, nk+3],
+ [n//4, n//2, nk+3],
+ [3*n//4, 3*n//4, nk+3]])
+
tracker_sequence.add_tracker(ecg_tracker)
# add the tissue and the stim parameters to the model object:
@@ -52,8 +88,11 @@
aliev_panfilov.run()
-
+colors = ['tab:blue', 'tab:orange', 'tab:green']
plt.figure()
-for y in ecg_tracker.ecg:
- plt.plot(np.arange(y.shape[0]) * aliev_panfilov.dt * ecg_tracker.step, y)
-plt.show()
+for i, y in enumerate(ecg_tracker.output.T):
+ x = np.arange(len(y)) * aliev_panfilov.dt * ecg_tracker.step
+ plt.plot(x, y, '-o', color=colors[i], label='precomputed distances')
+
+plt.legend(title='ECG computed with')
+plt.show()
\ No newline at end of file
diff --git a/examples/trackers/3D/local_activation_times_3d_tracker.py b/examples/trackers/3D/local_activation_times_3d_tracker.py
new file mode 100644
index 0000000..4c5474f
--- /dev/null
+++ b/examples/trackers/3D/local_activation_times_3d_tracker.py
@@ -0,0 +1,124 @@
+"""
+Local Activation Time in 3D
+===========================
+
+This example demonstrates how to use the LocalActivationTime3DTracker to track
+the local activation times in a 3D cardiac tissue slab using the Aliev–Panfilov model.
+
+Overview:
+---------
+The LocalActivationTime3DTracker records activation times at each node when the
+membrane potential crosses a defined threshold. Unlike standard activation time
+trackers, it can store multiple activations (e.g., from reentry or spiral waves)
+and enables detailed temporal analysis of wavefront propagation.
+
+Simulation Setup:
+-----------------
+- Tissue: A 3D slab of size 200×200×10.
+- Stimulation:
+ - First stimulus: a planar front at y=0–5, applied at t=0.
+ - Second stimulus: half of the domain (x=n/2 to n), applied at t=50.
+- Model:
+ - Aliev–Panfilov in 3D with dt = 0.01 and dr = 0.3 units.
+ - Total simulation time: 200.
+- Tracker:
+ - `LocalActivationTime3DTracker` activated from t=100 to t=200.
+ - Records activation times every 10 steps (step=10).
+ - Activation threshold set to 0.5.
+
+Visualization:
+--------------
+- Two time points (150 and 170) are visualized.
+- For each, a 3D scatter plot shows all nodes activated at or after the given time.
+- Activation time is color-coded using a viridis colormap.
+
+Applications:
+-------------
+- Visualization of reentrant waves in 3D.
+- Analysis of wavefront timing and conduction delays.
+- Studying effects of geometry, fibrosis, or heterogeneity on activation dynamics.
+
+Output:
+-------
+- Two 3D plots showing activation times at specified time bases.
+- Printed number of LATs (activation events) recorded by the tracker.
+"""
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import finitewave as fw
+
+# number of nodes on the side
+n = 200
+nk = 10
+tissue = fw.CardiacTissue3D([n, n, nk])
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov3D()
+# set up numerical parameters:
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.3
+aliev_panfilov.t_max = 200
+
+# induce spiral wave:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(time=0, volt_value=1, x1=0, x2=n,
+ y1=0, y2=5, z1=0, z2=nk))
+stim_sequence.add_stim(fw.StimVoltageCoord3D(time=50, volt_value=1, x1=n//2,
+ x2=n, y1=0, y2=n, z1=0, z2=nk))
+
+# set up the tracker:
+tracker_sequence = fw.TrackerSequence()
+act_time_tracker = fw.LocalActivationTime3DTracker()
+act_time_tracker.threshold = 0.5
+act_time_tracker.step = 10
+act_time_tracker.start_time = 100
+act_time_tracker.end_time = 200
+tracker_sequence.add_tracker(act_time_tracker)
+
+# connect model with tissue, stim and tracker:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+# run the simulation:
+aliev_panfilov.run()
+
+# plot the activation time map:
+time_bases = [150, 170] # time bases to plot the activation time map
+lats = act_time_tracker.output
+print(f'Number of LATs: {len(act_time_tracker.output)}')
+
+fig = plt.figure(figsize=(15, 5))
+
+for i, time_base in enumerate(time_bases):
+ ax = fig.add_subplot(1, len(time_bases), i + 1, projection='3d')
+
+ # Select the activation times next closest to the time base
+ mask = np.any(lats >= time_base, axis=0)
+ ids = np.argmax(lats >= time_base, axis=0)
+ ids = tuple((ids[mask], *np.where(mask)))
+
+ act_time = np.full([n, n, nk], np.nan)
+ act_time[mask] = lats[ids]
+
+ act_time_min = time_base
+ act_time_max = time_base + 30
+
+ # Create a 3D scatter plot
+ x, y, z = np.where(~np.isnan(act_time))
+ values = act_time[~np.isnan(act_time)]
+
+ scatter = ax.scatter(x, y, z, c=values, cmap='viridis', vmin=act_time_min, vmax=act_time_max)
+ ax.set_title(f'Activation time: {time_base} ms')
+ ax.set_xlabel('X')
+ ax.set_ylabel('Y')
+ ax.set_zlabel('Z')
+
+ cbar = fig.colorbar(scatter, ax=ax, orientation='vertical', pad=0.1)
+ cbar.set_label('Activation Time (ms)')
+
+plt.tight_layout()
+plt.show()
\ No newline at end of file
diff --git a/examples/trackers/3D/period_3d_tracker.py b/examples/trackers/3D/period_3d_tracker.py
deleted file mode 100755
index 81e1866..0000000
--- a/examples/trackers/3D/period_3d_tracker.py
+++ /dev/null
@@ -1,61 +0,0 @@
-
-#
-# Use the Period3DTracker to measure wave period (e.g spiral wave).
-#
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 200
-nj = 200
-nk = 10
-
-tissue = fw.CardiacTissue3D([n, nj, nk])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, nj, nk], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# add a conductivity array, all elements = 1.0 -> normal conductvity:
-tissue.cond = np.ones([n, nj, nk])
-
-# add fibers (oriented along X):
-tissue.fibers = np.zeros([n, nj, nk, 3])
-tissue.fibers[:,:,0] = 1
-tissue.fibers[:,:,1] = 0
-tissue.fibers[:,:,2] = 0
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov3D()
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 150
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, n, 0, 100, 0, nk))
-stim_sequence.add_stim(fw.StimVoltageCoord3D(31, 1, 0, 100, 0, n, 0, nk))
-
-tracker_sequence = fw.TrackerSequence()
-period_tracker = fw.Period3DTracker()
-detectors = np.zeros([n, nj, nk], dtype="uint8")
-positions = np.array([[1,1,1], [5,5,2], [7,3,3], [9,1,4]])
-detectors[positions[:, 0], positions[:, 1], positions[:, 2]] = 1
-period_tracker.detectors = detectors
-period_tracker.threshold = 0.5
-# add tracker to the model
-tracker_sequence.add_tracker(period_tracker)
-
-# add the tissue and the stim parameters to the model object:
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-aliev_panfilov.run()
-
-print ("Periods:")
-for key in period_tracker.output:
- print(key + ":", period_tracker.output[key][-1][1])
diff --git a/examples/trackers/3D/simple_activation_3d_tracker.py b/examples/trackers/3D/simple_activation_3d_tracker.py
new file mode 100644
index 0000000..914d7b0
--- /dev/null
+++ b/examples/trackers/3D/simple_activation_3d_tracker.py
@@ -0,0 +1,94 @@
+"""
+Activation Time in 3D
+=====================
+
+This example demonstrates how to compute and visualize activation times in a
+3D cardiac tissue model using the Aliev–Panfilov model and the
+ActivationTime3DTracker in Finitewave.
+
+Overview:
+---------
+The ActivationTime3DTracker records the time when the membrane potential at
+each node first crosses a specified threshold. This is a useful way to visualize
+the propagation of the activation wave across the tissue volume.
+
+Simulation Setup:
+-----------------
+- Domain: 3D slab of size 100×100×10 with uniform cardiomyocytes (value = 1).
+- Boundaries: Added using `add_boundaries()` to define no-flux edges.
+- Conductivity: Uniform (1.0) across the tissue.
+- Fiber orientation: Longitudinal (along the x-axis).
+- Stimulation: Applied to a thin slab at x = 0–3 across the entire yz-plane at t=0.
+- Model: Aliev–Panfilov 3D with dt = 0.01, dr = 0.25 units, and t_max = 60.
+- Tracker: ActivationTime3DTracker with threshold = 0.5.
+
+Visualization:
+--------------
+- Activation times are rendered using `VisMeshBuilder3D`.
+- The output is color-coded using the "viridis" colormap to show propagation fronts.
+
+Applications:
+-------------
+- Analysis of conduction velocity and wavefront dynamics.
+- Testing isotropic and anisotropic propagation scenarios.
+- Foundation for conduction delay studies in healthy and fibrotic tissue.
+
+Output:
+-------
+- A 3D scalar field plot of activation times using the internal visualization
+ tools of Finitewave.
+"""
+
+
+import numpy as np
+import finitewave as fw
+
+# number of nodes on the side
+n = 100
+nj = 100
+nk = 10
+
+tissue = fw.CardiacTissue3D([n, nj, nk])
+# create a mesh of cardiomyocytes (elems = 1):
+tissue.mesh = np.ones([n, nj, nk], dtype="uint8")
+# add empty nodes on the sides (elems = 0):
+tissue.add_boundaries()
+
+# add a conductivity array, all elements = 1.0 -> normal conductvity:
+tissue.cond = np.ones([n, nj, nk])
+
+# add fibers (oriented along X):
+tissue.fibers = np.zeros([n, nj, nk, 3])
+tissue.fibers[:, :, 0] = 1.
+tissue.fibers[:, :, 1] = 0.
+tissue.fibers[:, :, 2] = 0.
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov3D()
+
+# set up numerical parameters:
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 60
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, 3, 0, nj, 0, nk))
+
+tracker_sequence = fw.TrackerSequence()
+act_time_tracker = fw.ActivationTime3DTracker()
+act_time_tracker.target_model = aliev_panfilov
+act_time_tracker.threshold = 0.5
+tracker_sequence.add_tracker(act_time_tracker)
+
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+aliev_panfilov.run()
+
+mesh_builder = fw.VisMeshBuilder3D()
+grid = mesh_builder.build_mesh(tissue.mesh)
+grid = mesh_builder.add_scalar(act_time_tracker.act_t, name='Activation Time')
+grid.plot(cmap='viridis')
\ No newline at end of file
diff --git a/examples/trackers/3D/spiral_wave_core_3d_tracker.py b/examples/trackers/3D/spiral_wave_core_3d_tracker.py
new file mode 100644
index 0000000..a2a52bb
--- /dev/null
+++ b/examples/trackers/3D/spiral_wave_core_3d_tracker.py
@@ -0,0 +1,101 @@
+
+"""
+Spiral Wave Core Tracking in 3D
+===============================
+
+This example demonstrates how to use the SpiralWaveCore3DTracker in Finitewave
+to locate and track the core of a scroll wave (3D spiral wave) over time in
+a simulated cardiac tissue using the Aliev–Panfilov model.
+
+Overview:
+---------
+- A planar wave is first initiated from the bottom of the tissue.
+- A second stimulus is delivered from the left half to induce a scroll wave.
+- The SpiralWaveCore3DTracker identifies the locations in the tissue where
+ phase singularities form — these correspond to the spiral wave cores.
+
+Simulation Setup:
+-----------------
+- Tissue: 200×200×10 3D slab
+- Time and Space:
+ - Time step (dt): 0.01
+ - Space step (dr): 0.25
+ - Simulation duration: 150
+- Stimulation:
+ - t = 0 : Stimulus along the bottom edge
+ - t = 31: Stimulus from the left half — creates a broken wavefront
+
+Core Tracking:
+--------------
+- Threshold: 0.5 (voltage level to define wavefront)
+- Start Time: 40 (after wave has developed)
+- Step: 100 steps between core detections
+- Output: x, y, z coordinates of scroll wave core and corresponding time points
+
+Visualization:
+--------------
+The scroll wave core trajectory is visualized as a 3D scatter plot using `matplotlib`,
+with the color mapped to the corresponding time of core appearance.
+
+Applications:
+-------------
+- Useful for studying scroll wave dynamics and anchoring
+- Helps analyze stability and drift of reentrant waves
+- Can assist in identifying vulnerable tissue regions in 3D models
+
+Note:
+-----
+This tracker provides sparse detection (once every `step`), and is best used
+to observe long-term scroll wave motion rather than high-frequency detail.
+"""
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import finitewave as fw
+
+# number of nodes on the side
+n = 200
+nk = 10
+
+tissue = fw.CardiacTissue3D([n, n, nk])
+# create a mesh of cardiomyocytes (elems = 1):
+tissue.mesh = np.ones([n, n, nk], dtype="uint8")
+# add empty nodes on the sides (elems = 0):
+tissue.add_boundaries()
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov3D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 150
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, n, 0, n//2, 0, nk))
+stim_sequence.add_stim(fw.StimVoltageCoord3D(31, 1, 0, n//2, 0, n, 0, nk))
+
+tracker_sequence = fw.TrackerSequence()
+spiral_3d_tracker = fw.SpiralWaveCore3DTracker()
+spiral_3d_tracker.threshold = 0.5
+spiral_3d_tracker.start_time = 40
+spiral_3d_tracker.step = 100
+tracker_sequence.add_tracker(spiral_3d_tracker)
+
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+aliev_panfilov.run()
+
+swcore = spiral_3d_tracker.output
+
+fig = plt.figure()
+ax = fig.add_subplot(111, projection='3d')
+ax.scatter(swcore['x'], swcore['y'], swcore['z'], c=swcore['time'],
+ cmap='plasma', s=30)
+ax.set_xlim(0, n)
+ax.set_ylim(0, n)
+ax.set_zlim(0, nk)
+plt.show()
\ No newline at end of file
diff --git a/examples/trackers/3D/spiral_wave_period_3d_tracker.py b/examples/trackers/3D/spiral_wave_period_3d_tracker.py
new file mode 100644
index 0000000..f34bb31
--- /dev/null
+++ b/examples/trackers/3D/spiral_wave_period_3d_tracker.py
@@ -0,0 +1,115 @@
+"""
+Wave Period in 3D Tissue
+========================
+
+This example demonstrates how to use the Period3DTracker in Finitewave to measure
+the wave period at specific locations in a 3D cardiac tissue simulation using
+the Aliev–Panfilov model.
+
+Overview:
+---------
+The Period3DTracker detects threshold crossings (e.g., wave upstrokes) at
+specified cells to estimate the local activation period. This is useful for
+analyzing rhythm stability in sustained wave activity such as spiral or scroll waves.
+
+Simulation Setup:
+-----------------
+- Tissue Size: 100×100×10
+- Initial Conditions: Fully excitable tissue with no fibrosis
+- Boundary Handling: No-flux boundaries using `add_boundaries()`
+- Stimulation:
+ - First planar stimulus at t = 0, applied to lower half of Y domain
+ - Second planar stimulus at t = 31, applied to left half of X domain
+ - This induces spiral-like propagation dynamics
+
+Period Measurement:
+-------------------
+- Tracker: Period3DTracker
+- Target Cells: 7 manually selected positions within the mid-slice (z = 5)
+- Threshold: 0.5 (voltage level for upstroke detection)
+- Start Time: 100 (to allow initiation to settle)
+- Step: 10 (check voltage every 10 steps)
+
+Output:
+-------
+- Mean and standard deviation of measured periods per cell
+- A matplotlib errorbar plot shows variability across spatial locations
+
+Application:
+------------
+- Useful for scroll/spiral wave analysis
+- Can help detect regions with rhythm instability or alternans
+- Supports investigation of how geometry or fibrosis affects pacing regularity
+
+Note:
+-----
+For full local activation time maps and wavefront tracking, consider using
+`LocalActivationTime3DTracker`.
+"""
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import finitewave as fw
+
+# number of nodes on the side
+n = 100
+nk = 10
+
+tissue = fw.CardiacTissue3D([n, n, nk])
+# create a mesh of cardiomyocytes (elems = 1):
+tissue.mesh = np.ones([n, n, nk], dtype="uint8")
+# add empty nodes on the sides (elems = 0):
+tissue.add_boundaries()
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov3D()
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 300
+
+# induce spiral wave:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, n, 0, n//2, 0, nk))
+stim_sequence.add_stim(fw.StimVoltageCoord3D(31, 1, 0, n//2, 0, n, 0, nk))
+
+tracker_sequence = fw.TrackerSequence()
+period_tracker = fw.Period3DTracker()
+positions = np.array([[1, 1, 5],
+ [5, 5, 5],
+ [7, 3, 5],
+ [9, 1, 5],
+ [50, 50, 5],
+ [75, 3, 5],
+ [50, 75, 5]])
+period_tracker.cell_ind = positions
+period_tracker.threshold = 0.5
+period_tracker.start_time = 100
+period_tracker.step = 10
+tracker_sequence.add_tracker(period_tracker)
+
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+aliev_panfilov.run()
+
+# get the wave period as a pandas Series with the cell index as the index:
+periods = period_tracker.output
+
+# plot the wave period:
+plt.figure()
+plt.errorbar(range(len(positions)),
+ periods.apply(lambda x: x.mean()),
+ yerr=periods.apply(lambda x: x.std()),
+ fmt='o')
+plt.xticks(range(len(positions)),
+ [f'({x[0]}, {x[1]}, {x[2]})' for x in positions],
+ rotation=45)
+plt.xlabel('Cell Index')
+plt.ylabel('Period')
+plt.title('Wave period')
+plt.tight_layout()
+plt.show()
\ No newline at end of file
diff --git a/examples/trackers/3D/tips_3d_tracker.py b/examples/trackers/3D/tips_3d_tracker.py
deleted file mode 100755
index 73bddef..0000000
--- a/examples/trackers/3D/tips_3d_tracker.py
+++ /dev/null
@@ -1,55 +0,0 @@
-
-
-import matplotlib.pyplot as plt
-from mpl_toolkits.mplot3d import Axes3D
-import numpy as np
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 200
-nj = 200
-nk = 10
-
-tissue = fw.CardiacTissue3D([n, nj, nk])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, nj, nk], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# add a conductivity array, all elements = 1.0 -> normal conductvity:
-tissue.cond = np.ones([n, nj, nk])
-
-# add fibers (oriented along X):
-tissue.fibers = np.zeros([n, nj, nk, 3])
-tissue.fibers[:,:,0] = 1
-tissue.fibers[:,:,1] = 0
-tissue.fibers[:,:,2] = 0
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov3D()
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 150
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, n, 0, 100, 0, nk))
-stim_sequence.add_stim(fw.StimVoltageCoord3D(31, 1, 0, 100, 0, n, 0, nk))
-
-tracker_sequence = fw.TrackerSequence()
-spiral_3d_tracker = fw.Spiral3DTracker()
-tracker_sequence.add_tracker(spiral_3d_tracker)
-
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-aliev_panfilov.run()
-
-swcore = np.array(spiral_3d_tracker.swcore)
-
-fig = plt.figure()
-ax = fig.add_subplot(111, projection='3d')
-ax.plot(swcore[:,2], swcore[:,3], swcore[:,4])
-plt.show()
diff --git a/examples/trackers/3D/variables_3d_tracker.py b/examples/trackers/3D/variables_3d_tracker.py
new file mode 100644
index 0000000..d739586
--- /dev/null
+++ b/examples/trackers/3D/variables_3d_tracker.py
@@ -0,0 +1,100 @@
+"""
+Tracking State Variables in 3D Cardiac Tissue
+=============================================
+
+This example demonstrates how to use the `Variable3DTracker` and
+`MultiVariable3DTracker` classes in Finitewave to monitor the evolution of
+model state variables (e.g., transmembrane potential `u` and recovery variable `v`)
+at specific cell locations within a 3D cardiac tissue model.
+
+Overview:
+---------
+- The Aliev–Panfilov model is run on a 3D slab of tissue.
+- Two trackers are used:
+ 1. `Variable3DTracker` — tracks a single variable `u` at cell (40, 40, 5).
+ 2. `MultiVariable3DTracker` — tracks both `u` and `v` at cell (30, 30, 5).
+- A planar stimulus is applied from one side to generate an action potential.
+
+Simulation Setup:
+-----------------
+- Tissue: 100×100×10 3D grid of cardiomyocytes
+- Time step: 0.01
+- Space step: 0.25
+- Total duration: 100
+- Stimulation: Small region at the front-left corner
+
+Tracker Details:
+----------------
+- `Variable3DTracker` is ideal for lightweight tracking of a single variable.
+- `MultiVariable3DTracker` allows simultaneous tracking of multiple state variables
+ at the same spatial location.
+
+Visualization:
+--------------
+The results are plotted using `matplotlib` to compare:
+- The `u` values from both trackers.
+- The evolution of `v` at the measurement location.
+
+Applications:
+-------------
+- Useful for action potential shape analysis.
+- Helps compare transmembrane dynamics across different cell locations.
+- Can be used to validate ionic models or study parameter sensitivity.
+"""
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import finitewave as fw
+
+# number of nodes on the side
+n = 100
+nk = 10
+
+# create tissue object:
+tissue = fw.CardiacTissue3D([n, n, nk])
+tissue.mesh = np.ones([n, n, nk], dtype="uint8")
+tissue.add_boundaries()
+
+# create model object:
+aliev_panfilov = fw.AlievPanfilov3D()
+
+# set up numerical parameters:
+aliev_panfilov.dt = 0.01
+aliev_panfilov.dr = 0.25
+aliev_panfilov.t_max = 100
+
+# set up stimulation parameters:
+stim_sequence = fw.StimSequence()
+stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 1, 3, 1, n, 1, nk))
+
+tracker_sequence = fw.TrackerSequence()
+# add one variable tracker:
+variable_tracker = fw.Variable3DTracker()
+variable_tracker.var_name = "u"
+variable_tracker.cell_ind = [40, 40, 5]
+tracker_sequence.add_tracker(variable_tracker)
+
+# add the multi variable tracker:
+multivariable_tracker = fw.MultiVariable3DTracker()
+# to specify the mesh node under the measuring - use the cell_ind field:
+multivariable_tracker.cell_ind = [30, 30, 5]
+multivariable_tracker.var_list = ["u", "v"]
+tracker_sequence.add_tracker(multivariable_tracker)
+
+# add the tissue and the stim parameters to the model object:
+aliev_panfilov.cardiac_tissue = tissue
+aliev_panfilov.stim_sequence = stim_sequence
+aliev_panfilov.tracker_sequence = tracker_sequence
+
+aliev_panfilov.run()
+
+# plot the action potential and state variable v at the measuring point
+time = np.arange(len(multivariable_tracker.output["u"])) * aliev_panfilov.dt
+
+plt.plot(time, variable_tracker.output, label="u")
+plt.plot(time, multivariable_tracker.output["u"], label="u")
+plt.plot(time, multivariable_tracker.output["v"], label="v")
+plt.legend(title=aliev_panfilov.__class__.__name__)
+plt.show()
\ No newline at end of file
diff --git a/examples/trackers/3D/vtk_frame_3d_tracker.py b/examples/trackers/3D/vtk_frame_3d_tracker.py
deleted file mode 100755
index ca46402..0000000
--- a/examples/trackers/3D/vtk_frame_3d_tracker.py
+++ /dev/null
@@ -1,57 +0,0 @@
-
-#
-# Use the VTKFrame3DTracker to create a snapshot folder with vtk files suitable for building animation.
-# Load the snapshot dir in paraview as series (it's possible to create animation with series).
-#
-
-import math
-import numpy as np
-import matplotlib.pyplot as plt
-
-import finitewave as fw
-
-# number of nodes on the side
-n = 200
-nj = 200
-nk = 10
-
-tissue = fw.CardiacTissue3D([n, nj, nk])
-# create a mesh of cardiomyocytes (elems = 1):
-tissue.mesh = np.ones([n, nj, nk], dtype="uint8")
-# add empty nodes on the sides (elems = 0):
-tissue.add_boundaries()
-
-# add a conductivity array, all elements = 1.0 -> normal conductvity:
-tissue.cond = np.ones([n, nj, nk])
-
-# add fibers (oriented along X):
-tissue.fibers = np.zeros([n, nj, nk, 3])
-tissue.fibers[:, :, 0] = 1
-tissue.fibers[:, :, 1] = 0
-tissue.fibers[:, :, 2] = 0
-
-# create model object:
-aliev_panfilov = fw.AlievPanfilov3D()
-aliev_panfilov.dt = 0.01
-aliev_panfilov.dr = 0.25
-aliev_panfilov.t_max = 150
-
-# set up stimulation parameters:
-stim_sequence = fw.StimSequence()
-stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, n, 0, 100, 0, nk))
-stim_sequence.add_stim(fw.StimVoltageCoord3D(31, 1, 0, 100, 0, n, 0, nk))
-
-tracker_sequence = fw.TrackerSequence()
-vtk_frame_tracker = fw.VTKFrame3DTracker()
-# We want to write the animation for the voltage variable. Use string value
-# to specify the required array.anim_data
-vtk_frame_tracker.target_array = "u"
-# write every 3 time unit.
-vtk_frame_tracker.step = 3
-tracker_sequence.add_tracker(vtk_frame_tracker)
-
-aliev_panfilov.cardiac_tissue = tissue
-aliev_panfilov.stim_sequence = stim_sequence
-aliev_panfilov.tracker_sequence = tracker_sequence
-
-aliev_panfilov.run()
diff --git a/finite_wave_chapter.pdf b/finite_wave_chapter.pdf
new file mode 100644
index 0000000..68d3b68
Binary files /dev/null and b/finite_wave_chapter.pdf differ
diff --git a/finitewave/README.md b/finitewave/README.md
deleted file mode 100755
index 885e014..0000000
--- a/finitewave/README.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# finitewave
-
-Package for a wide range of tasks in modeling cardiac electrophysiology using finite-difference methods.
-
-## Package structure
-
-*/core*
-Base classes subpackage. Use this subpackage to create your own implementation and incorporate it in the package logic.
-
-*/cpuwave2D*
-Ready-to-use implementation for 2D problems. Contains prepared models, tissue generation methods, optimized numerical schemes and specialized tools.
-
-*/cpuwave3D*
-Ready-to-use implementation for 3D problems. Contains prepared models, tissue generation methods, optimized numerical schemes and specialized tools.
-
-*/tools*
-Additional methods to treat the results, perform statistical analysis and make different visual representations.
diff --git a/finitewave/README.rst b/finitewave/README.rst
new file mode 100755
index 0000000..67631d2
--- /dev/null
+++ b/finitewave/README.rst
@@ -0,0 +1,32 @@
+finitewave
+===========
+
+Package for a wide range of tasks in modeling cardiac electrophysiology using
+finite-difference methods.
+
+Package structure
+-----------------
+
+core
+"""""
+
+Base classes subpackage. Use this subpackage to create your own implementation
+and incorporate it in the package logic.
+
+cpuwave2D
+"""""""""
+
+Ready-to-use implementation for 2D problems. Contains prepared models,
+tissue generation methods, optimized numerical schemes and specialized tools.
+
+cpuwave3D
+"""""""""
+
+Ready-to-use implementation for 3D problems. Contains prepared models, tissue
+generation methods, optimized numerical schemes and specialized tools.
+
+tools
+""""""
+
+Additional methods to treat the results, perform statistical analysis and make
+different visual representations.
diff --git a/finitewave/__init__.py b/finitewave/__init__.py
index f199be1..4380b0f 100755
--- a/finitewave/__init__.py
+++ b/finitewave/__init__.py
@@ -1,9 +1,28 @@
+
+"""
+finitewave
+==========
+
+A Python package for simulating cardiac electrophysiology in 2D and 3D using
+the finite difference method.
+
+This package provides a set of tools for simulating cardiac electrophysiology
+in 2D and 3D using the finite difference method. The package includes classes
+for creating cardiac tissue models, tracking electrical activity, and
+visualizing simulation results. The package is designed to be flexible and
+extensible, allowing users to create custom models and trackers for their
+specific research needs.
+
+"""
+
from finitewave.core import (
Command,
CommandSequence,
FibrosisPattern,
CardiacModel,
- StateKeeper,
+ StateLoader,
+ StateSaver,
+ StateSaverCollection,
Stencil,
StimCurrent,
StimSequence,
@@ -17,24 +36,19 @@
from finitewave.cpuwave2D import (
IncorrectWeightsModeError2D,
Diffuse2DPattern,
- ScarGauss2DPattern,
- ScarRect2DPattern,
Structural2DPattern,
- diffuse_kernel_2d_iso,
- diffuse_kernel_2d_aniso,
- _parallel,
AlievPanfilov2D,
- AlievPanfilovKernels2D,
+ Barkley2D,
+ MitchellSchaeffer2D,
+ FentonKarma2D,
+ BuenoOrovio2D,
LuoRudy912D,
- LuoRudy91Kernels2D,
TP062D,
- TP06Kernels2D,
- LuoRudy912D,
- LuoRudy91Kernels2D,
- TP062D,
- TP06Kernels2D,
+ Courtemanche2D,
AsymmetricStencil2D,
+ SymmetricStencil2D,
IsotropicStencil2D,
+ StimCurrentArea2D,
StimCurrentCoord2D,
StimVoltageCoord2D,
StimCurrentMatrix2D,
@@ -44,55 +58,52 @@
ActivationTime2DTracker,
Animation2DTracker,
ECG2DTracker,
- MultiActivationTime2DTracker,
+ LocalActivationTime2DTracker,
MultiVariable2DTracker,
Period2DTracker,
- PeriodMap2DTracker,
- Spiral2DTracker,
+ PeriodAnimation2DTracker,
+ SpiralWaveCore2DTracker,
Variable2DTracker,
- Velocity2DTracker
)
+
from finitewave.cpuwave3D import (
Diffuse3DPattern,
Structural3DPattern,
- diffuse_kernel_3d_iso,
- diffuse_kernel_3d_aniso,
- _parallel,
AlievPanfilov3D,
- AlievPanfilovKernels3D,
- LuoRudy913D,
- LuoRudy91Kernels3D,
- TP063D,
- TP06Kernels3D,
+ Barkley3D,
+ MitchellSchaeffer3D,
+ FentonKarma3D,
+ BuenoOrovio3D,
LuoRudy913D,
- LuoRudy91Kernels3D,
TP063D,
- TP06Kernels3D,
+ Courtemanche3D,
AsymmetricStencil3D,
IsotropicStencil3D,
StimCurrentCoord3D,
StimVoltageCoord3D,
StimCurrentMatrix3D,
StimVoltageMatrix3D,
+ StimVoltageListMatrix3D,
+ StimCurrentArea3D,
CardiacTissue3D,
ActionPotential3DTracker,
ActivationTime3DTracker,
+ LocalActivationTime3DTracker,
AnimationSlice3DTracker,
ECG3DTracker,
Period3DTracker,
- PeriodMap3DTracker,
- Spiral3DTracker,
+ SpiralWaveCore3DTracker,
Variable3DTracker,
- Velocity3DTracker,
+ MultiVariable3DTracker,
VTKFrame3DTracker,
- Animation3DTracker
+ Animation3DTracker,
+ PeriodAnimation3DTracker
)
from finitewave.tools import (
- AnimationBuilder,
- DriftVelocityCalculation,
- PotentialPeriodAnimationBuilder,
- VTKMeshBuilder,
+ Animation2DBuilder,
+ Animation3DBuilder,
VisMeshBuilder3D,
- Animation3DBuilder
+ Velocity2DCalculation,
+ Velocity3DCalculation,
)
diff --git a/finitewave/core/__init__.py b/finitewave/core/__init__.py
index 1e5e3d4..f3fac0e 100755
--- a/finitewave/core/__init__.py
+++ b/finitewave/core/__init__.py
@@ -1,7 +1,7 @@
from finitewave.core.command import Command, CommandSequence
from finitewave.core.fibrosis import FibrosisPattern
from finitewave.core.model import CardiacModel
-from finitewave.core.state import StateKeeper
+from finitewave.core.state import StateLoader, StateSaver, StateSaverCollection
from finitewave.core.stencil import Stencil
from finitewave.core.stimulation import StimCurrent, StimSequence, StimVoltage, Stim
from finitewave.core.tissue import CardiacTissue
diff --git a/finitewave/core/command/command.py b/finitewave/core/command/command.py
index 12563b1..a6cc5ec 100755
--- a/finitewave/core/command/command.py
+++ b/finitewave/core/command/command.py
@@ -1,21 +1,19 @@
-class Command:
+from abc import ABC, abstractmethod
+
+
+class Command(ABC):
"""Base class for a command to be executed during a simulation.
Attributes
----------
t : float
The time at which the command should be executed.
-
+
passed : bool
Flag indicating whether the command has been executed.
-
- Methods
- -------
- execute(model)
- Abstract method to be implemented by subclasses for executing the command.
"""
-
- def __init__(self, time):
+
+ def __init__(self, time=None):
"""
Initializes a Command instance with the specified execution time.
@@ -27,10 +25,12 @@ def __init__(self, time):
self.t = time
self.passed = False
+ @abstractmethod
def execute(self, model):
"""
- Abstract method for executing the command. This method should be implemented
- by subclasses to define the specific behavior of the command.
+ Abstract method for executing the command. This method should be
+ implemented by subclasses to define the specific behavior of the
+ command.
Parameters
----------
@@ -38,3 +38,15 @@ def execute(self, model):
The cardiac model instance on which the command will be executed.
"""
pass
+
+ def update_status(self, model):
+ """
+ Marks the command as executed.
+
+ Parameters
+ ----------
+ model : CardiacModel
+ The cardiac model instance on which the command was executed
+ """
+ self.passed = model.t >= self.t
+ return self.passed
diff --git a/finitewave/core/command/command_sequence.py b/finitewave/core/command/command_sequence.py
index 8627b39..dad8e95 100755
--- a/finitewave/core/command/command_sequence.py
+++ b/finitewave/core/command/command_sequence.py
@@ -1,40 +1,26 @@
+
+
class CommandSequence:
"""Manages a sequence of commands to be executed during a simulation.
Attributes
----------
sequence : list
- A list of `Command` instances representing the sequence of commands to be executed.
-
+ A list of ``Command`` instances representing the sequence of commands
+ to be executed.
+
model : CardiacModel
The cardiac model instance on which commands will be executed.
-
- Methods
- -------
- initialize(model)
- Initializes the sequence with the specified model and marks all commands as not passed.
-
- add_command(command)
- Adds a `Command` instance to the sequence.
-
- remove_commands()
- Clears the sequence of all commands.
-
- execute_next()
- Executes commands whose time has arrived and which have not been executed yet.
"""
-
+
def __init__(self):
- """
- Initializes a CommandSequence instance with an empty sequence and no model.
- """
self.sequence = []
self.model = None
def initialize(self, model):
"""
- Initializes the CommandSequence with the specified model and resets the execution status
- of all commands.
+ Initializes the CommandSequence with the specified model and resets
+ the execution status of all commands.
Parameters
----------
@@ -47,7 +33,7 @@ def initialize(self, model):
def add_command(self, command):
"""
- Adds a `Command` instance to the sequence.
+ Adds a ``Command`` instance to the sequence.
Parameters
----------
@@ -64,9 +50,10 @@ def remove_commands(self):
def execute_next(self):
"""
- Executes commands whose time has arrived and which have not been executed yet.
+ Executes commands whose time has arrived and which have not been
+ executed yet.
"""
for command in self.sequence:
- if self.model.t >= command.t and not command.passed:
+ if not command.passed and command.update_status(self.model):
command.execute(self.model)
- command.passed = True
+
diff --git a/finitewave/core/exception/__init__.py b/finitewave/core/exception/__init__.py
index d2005f9..eda2bff 100644
--- a/finitewave/core/exception/__init__.py
+++ b/finitewave/core/exception/__init__.py
@@ -1 +1 @@
-from finitewave.core.exception.exceptions import IncorrectWeightsShapeError
\ No newline at end of file
+from finitewave.core.exception.exceptions import IncorrectNumberOfWeights
\ No newline at end of file
diff --git a/finitewave/core/exception/exceptions.py b/finitewave/core/exception/exceptions.py
index 333b0fc..c33e258 100644
--- a/finitewave/core/exception/exceptions.py
+++ b/finitewave/core/exception/exceptions.py
@@ -1,42 +1,46 @@
+
+
class IncorrectWeightsShapeError(Exception):
- """Exception raised for errors in the shape of weights in the CardiacTissue class.
+ def __init__(self, *args: object) -> None:
+ super().__init__(*args)
+
- This exception is used to indicate that the shape of weights provided does not match the expected
- dimensions. It includes details about the incorrect shape and the expected shapes.
+class IncorrectNumberOfWeights(Exception):
+ """Exception raised for errors in the shape of weights in the
+ ``CardiacTissue`` class.
- Attributes
+ This exception is used to indicate that the shape of weights provided does
+ not match the expected dimensions. It includes details about the incorrect
+ shape and the expected shapes.
+
+ Parameters
----------
- shape : tuple
- The incorrect shape of the weights that caused the error.
-
+ number_of_weights : int
+ The number of weights in the incorrect shape.
+
n1 : int
- The expected number of weights in one of the dimensions.
-
- n2 : int
- The expected number of weights in another dimension.
+ The target number of weights in one dimension.
- Methods
- -------
- __init__(shape, n1, n2)
- Initializes the exception with the incorrect shape and the expected dimensions.
+ n2 : int
+ The target number of weights in another dimension.
"""
-
- def __init__(self, shape, n1, n2):
+
+ def __init__(self, number_of_weights, n1, n2):
"""
- Initializes the IncorrectWeightsShapeError with details about the incorrect shape and expected dimensions.
+ Initializes the ``IncorrectNumberOfWeights`` with details about the
+ incorrect shape and expected dimensions.
Parameters
----------
- shape : tuple
- The actual shape of the weights array that is incorrect.
-
+ number_of_weights : int
+ The number of weights in the incorrect shape.
+
n1 : int
The target number of weights in one dimension.
-
+
n2 : int
The target number of weights in another dimension.
"""
- self.message = ('CardiacTissue weights {} is incorrect. '.format(shape) +
- 'Shape should be {} or {}'.format((*shape[:-1], n1),
- (*shape[:-1], n2)))
+ self.message = (f"Number of weights provided ({number_of_weights})" +
+ f"does not match the expected {n1} or {n2}.")
super().__init__(self.message)
diff --git a/finitewave/core/fibrosis/fibrosis_pattern.py b/finitewave/core/fibrosis/fibrosis_pattern.py
index 7838c14..2b956a5 100755
--- a/finitewave/core/fibrosis/fibrosis_pattern.py
+++ b/finitewave/core/fibrosis/fibrosis_pattern.py
@@ -1,33 +1,28 @@
-from abc import ABCMeta, abstractmethod
-
-class FibrosisPattern:
- """Abstract base class for generating and applying fibrosis patterns to cardiac tissue.
-
- This class defines an interface for creating fibrosis patterns and applying them to cardiac tissue models.
- Subclasses must implement the `generate` method to define specific patterns. The `apply` method uses
- the generated pattern to modify the mesh of the cardiac tissue.
-
- Methods
- -------
- generate(size, mesh=None)
- Abstract method to generate a fibrosis pattern based on the given size and optionally the mesh.
-
- apply(cardiac_tissue)
- Applies the generated fibrosis pattern to the provided cardiac tissue object.
- """
+from abc import ABC, abstractmethod
+
- __metaclass__ = ABCMeta
+class FibrosisPattern(ABC):
+ """Abstract base class for generating and applying fibrosis patterns to
+ cardiac tissue.
+
+ This class defines an interface for creating fibrosis patterns and applying
+ them to cardiac tissue models. Subclasses must implement the ``generate``
+ method to define specific patterns. The ``apply`` method uses the generated
+ pattern to modify the mesh of the cardiac tissue.
+ """
+ def __init__(self):
+ pass
@abstractmethod
- def generate(self, size, mesh=None):
+ def generate(self, shape=None, mesh=None):
"""
- Generates a fibrosis pattern for the given size and optionally based on the provided mesh.
+ Generates a fibrosis pattern for the given shape and optionally based
+ on the provided mesh.
Parameters
----------
- size : tuple
+ shape : tuple
The shape of the mesh (e.g., (ni, nj) or (ni, nj, nk)).
-
mesh : numpy.ndarray, optional
The existing mesh to base the pattern on. Default is None.
@@ -36,19 +31,21 @@ def generate(self, size, mesh=None):
numpy.ndarray
A new mesh array with the applied fibrosis pattern.
"""
- pass
def apply(self, cardiac_tissue):
"""
- Applies the generated fibrosis pattern to the specified cardiac tissue object.
+ Applies the generated fibrosis pattern to the specified cardiac tissue
+ object.
- This method calls the `generate` method to create the pattern and then updates the `mesh` attribute
- of the `cardiac_tissue` object with the generated pattern.
+ This method calls the ``generate`` method to create the pattern and
+ then updates the ``mesh`` attribute of the ``cardiac_tissue`` object
+ with the generated pattern.
Parameters
----------
cardiac_tissue : CardiacTissue
- The cardiac tissue object to which the fibrosis pattern will be applied. The `mesh` attribute
- of this object will be updated with the generated pattern.
+ The cardiac tissue object to which the fibrosis pattern will be
+ applied. The ``mesh`` attribute of this object will be updated with
+ the generated pattern.
"""
- cardiac_tissue.mesh = self.generate(cardiac_tissue.mesh.shape, cardiac_tissue.mesh)
+ cardiac_tissue.mesh = self.generate(mesh=cardiac_tissue.mesh)
diff --git a/finitewave/core/model/cardiac_model.py b/finitewave/core/model/cardiac_model.py
index 60e302b..888aa5e 100755
--- a/finitewave/core/model/cardiac_model.py
+++ b/finitewave/core/model/cardiac_model.py
@@ -1,218 +1,178 @@
-from abc import ABCMeta, abstractmethod
+from abc import ABC, abstractmethod
+import copy
+import warnings
from tqdm import tqdm
import numpy as np
-import copy
-import os
+import numba
-class CardiacModel:
+class CardiacModel(ABC):
"""
Base class for electrophysiological models.
- This class serves as the base for implementing various cardiac models. It provides methods for
- initializing the model, running simulations, and managing the state of the simulation.
+ This class serves as the base for implementing various cardiac models.
+ It provides methods for initializing the model, running simulations,
+ and managing the state of the simulation.
Attributes
----------
cardiac_tissue : CardiacTissue
The tissue object that represents the cardiac tissue in the simulation.
-
stim_sequence : StimSequence
The sequence of stimuli applied to the cardiac tissue.
-
tracker_sequence : TrackerSequence
The sequence of trackers used to monitor the simulation.
-
command_sequence : CommandSequence
The sequence of commands to execute during the simulation.
-
- state_keeper : StateKeeper
- The object responsible for saving and loading the state of the simulation.
-
+ state_loader : StateLoader
+ The object responsible for loading the state of the simulation.
+ state_saver : StateSaver
+ The object responsible for saving the state of the simulation.
stencil : Stencil
The stencil used for numerical computations.
-
u : ndarray
Array representing the action potential (mV) across the tissue.
-
u_new : ndarray
Array for storing the updated action potential values.
-
dt : float
Time step for the simulation.
-
dr : float
Spatial step for the simulation.
-
t_max : float
Maximum time for the simulation (model units).
-
t : float
Current time in the simulation (model units).
-
step : int
Current step or iteration in the simulation.
-
+ D_model : float
+ Model-specific diffusion coefficient.
prog_bar : bool
- Flag to enable or disable the progress bar during simulation.
-
+ Whether to display a progress bar during simulation.
+ npfloat : type
+ The floating-point type used for numerical computations.
state_vars : list
- List of state variables to be saved and restored.
-
- Methods
- -------
- run_ionic_kernel()
- Abstract method to be implemented by subclasses for running the ionic kernel.
-
- diffuse_kernel(u_new, u, w, mesh)
- Abstract method to be implemented by subclasses for diffusion computation.
-
- save_state(path)
- Abstract method to be implemented by subclasses for saving the simulation state.
-
- load_state(path)
- Abstract method to be implemented by subclasses for loading the simulation state.
-
- initialize()
- Initializes the model for simulation, setting up arrays and computing weights.
-
- run(initialize=True)
- Runs the simulation loop, handling stimuli, diffusion, ionic kernel updates, and tracking.
-
- run_diffuse_kernel()
- Runs the diffusion kernel computation.
-
- clone()
- Creates a deep copy of the current model instance.
+ List of state variables to save and load during simulation.
"""
-
- __metaclass__ = ABCMeta
-
def __init__(self):
- """
- Initializes the CardiacModel instance with default parameters and attributes.
- """
+ self.meta = {}
self.cardiac_tissue = None
self.stim_sequence = None
self.tracker_sequence = None
self.command_sequence = None
- self.state_keeper = None
+ self.state_loader = None
+ self.state_saver = None
self.stencil = None
+ self.diffusion_kernel = None
+ self.ionic_kernel = None
+
self.u = np.ndarray
self.u_new = np.ndarray
+ self.weights = np.ndarray
self.dt = 0.
self.dr = 0.
self.t_max = 0.
self.t = 0
self.step = 0
+ self.D_model = 1.
self.prog_bar = True
+ self.npfloat = np.float64
self.state_vars = []
@abstractmethod
def run_ionic_kernel(self):
"""
- Abstract method for running the ionic kernel. Must be implemented by subclasses.
- """
- pass
-
- @abstractmethod
- def diffuse_kernel(u_new, u, w, mesh):
- """
- Abstract method for diffusion computation. Must be implemented by subclasses.
-
- Parameters
- ----------
- u_new : ndarray
- The array to store updated action potential values.
-
- u : ndarray
- The current action potential array.
-
- w : ndarray
- The weights for the diffusion computation.
-
- mesh : ndarray
- The tissue mesh.
- """
- pass
-
- @abstractmethod
- def save_state(self, path):
- """
- Abstract method for saving the simulation state. Must be implemented by subclasses.
-
- Parameters
- ----------
- path : str
- The directory path where the state will be saved.
- """
- if not os.path.exists(path):
- os.makedirs(path)
-
- @abstractmethod
- def load_state(self, path):
- """
- Abstract method for loading the simulation state. Must be implemented by subclasses.
-
- Parameters
- ----------
- path : str
- The directory path from where the state will be loaded.
+ Abstract method for running the ionic kernel. Must be implemented by
+ subclasses.
"""
pass
def initialize(self):
"""
- Initializes the model for simulation. Sets up arrays, computes weights, and initializes stimuli,
- trackers, and commands.
+ Initializes the model for simulation. Sets up arrays, computes weights,
+ and initializes stimuli, trackers, and commands.
"""
- shape = self.cardiac_tissue.mesh.shape
- self.u = np.zeros(shape, dtype=self.npfloat)
+ self.u = np.zeros_like(self.cardiac_tissue.mesh, dtype=self.npfloat)
self.u_new = self.u.copy()
- self.cardiac_tissue.compute_weights(self.dr, self.dt)
- self.cardiac_tissue.set_dtype(self.npfloat)
-
self.step = 0
self.t = 0
+ self.compute_weights()
+ self.diffusion_kernel = self.stencil.select_diffusion_kernel()
+
if self.stim_sequence:
self.stim_sequence.initialize(self)
+
if self.tracker_sequence:
self.tracker_sequence.initialize(self)
+
if self.command_sequence:
self.command_sequence.initialize(self)
- if self.state_keeper and self.state_keeper.record_load:
- self.state_keeper.load(self)
+ if self.state_loader:
+ self.state_loader.initialize(self)
+
+ if self.state_saver:
+ self.state_saver.initialize(self)
+
+ def compute_weights(self):
+ """
+ Computes the weights for the stencil.
+ """
+ self.cardiac_tissue.compute_myo_indexes()
+
+ if self.stencil is None:
+ self.stencil = self.select_stencil(self.cardiac_tissue)
+
+ self.weights = self.stencil.compute_weights(self, self.cardiac_tissue)
- def run(self, initialize=True):
+ def run(self, initialize=True, num_of_theads=None):
"""
- Runs the simulation loop. Handles stimuli, diffusion, ionic kernel updates, and tracking.
+ Runs the simulation loop. Handles stimuli, diffusion, ionic kernel
+ updates, and tracking.
Parameters
----------
initialize : bool, optional
- Whether to (re)initialize the model before running the simulation. Default is True.
+ Whether to (re)initialize the model before running the simulation.
+ Default is True.
"""
if initialize:
self.initialize()
- if self.prog_bar:
- pbar = tqdm(total=int(np.ceil(self.t_max / self.dt)))
+ numba.set_num_threads(numba.config.NUMBA_NUM_THREADS)
+
+ if num_of_theads is not None:
+ if num_of_theads > numba.config.NUMBA_NUM_THREADS:
+ warnings.warn(
+ f"Selected number of threads ({num_of_theads}) exceeds the available threads ({numba.config.NUMBA_NUM_THREADS}). "
+ f"Using the maximum available threads instead."
+ )
+ num_of_theads = min(num_of_theads, numba.config.NUMBA_NUM_THREADS)
+ numba.set_num_threads(num_of_theads)
+
+ if self.t_max < self.t:
+ raise ValueError("t_max must be greater than current t.")
+
+ if self.state_loader:
+ self.state_loader.load()
+
+ iters = int(np.ceil((self.t_max - self.t) / self.dt))
+ bar_desc = f"Running {self.__class__.__name__}"
+
+ for _ in tqdm(range(iters), total=iters, desc=bar_desc,
+ disable=not self.prog_bar):
- while self.step < np.ceil(self.t_max / self.dt):
if self.stim_sequence:
self.stim_sequence.stimulate_next()
- self.run_diffuse_kernel()
+ self.run_diffusion_kernel()
+ self.run_ionic_kernel()
if self.tracker_sequence:
self.tracker_sequence.tracker_next()
- self.run_ionic_kernel()
-
self.t += self.dt
self.step += 1
self.u_new, self.u = self.u, self.u_new
@@ -220,20 +180,52 @@ def run(self, initialize=True):
if self.command_sequence:
self.command_sequence.execute_next()
- if pbar:
- pbar.update()
- if pbar:
- pbar.close()
+ if self.state_saver:
+ self.state_saver.save()
- if self.state_keeper and self.state_keeper.record_save:
- self.state_keeper.save(self)
+ if self.check_termination():
+ if self.state_saver:
+ self.state_saver.save()
+ break
- def run_diffuse_kernel(self):
+ def check_termination(self):
"""
- Executes the diffusion kernel computation using the current parameters and tissue weights.
+ Checks whether the simulation should terminate based on the current
+ time. The ``CommandSequence`` may change the ``t_max`` value during
+ execution to control the simulation duration.
+
+ Returns
+ -------
+ bool
+ True if the simulation should terminate, False otherwise.
+ """
+ max_iters = int(np.ceil(self.t_max / self.dt))
+ return (self.t > self.t_max) or (self.step > max_iters)
+
+ def run_diffusion_kernel(self):
+ """
+ Executes the diffusion kernel computation using the current parameters
+ and tissue weights.
+ """
+ self.diffusion_kernel(self.u_new, self.u, self.weights,
+ self.cardiac_tissue.myo_indexes)
+
+ @abstractmethod
+ def select_stencil(self, cardiac_tissue):
"""
- self.diffuse_kernel(self.u_new, self.u, self.cardiac_tissue.weights,
- self.cardiac_tissue.mesh)
+ Selects the appropriate stencil based on the cardiac tissue properties.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue
+ The tissue object representing the cardiac tissue.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to use for diffusion computations.
+ """
+ pass
def clone(self):
"""
diff --git a/finitewave/core/state/__init__.py b/finitewave/core/state/__init__.py
index dc0ec20..ef40641 100755
--- a/finitewave/core/state/__init__.py
+++ b/finitewave/core/state/__init__.py
@@ -1 +1,2 @@
-from finitewave.core.state.state_keeper import StateKeeper
\ No newline at end of file
+from finitewave.core.state.state_loader import StateLoader
+from finitewave.core.state.state_saver import StateSaver, StateSaverCollection
\ No newline at end of file
diff --git a/finitewave/core/state/state_keeper.py b/finitewave/core/state/state_keeper.py
deleted file mode 100755
index 42070bf..0000000
--- a/finitewave/core/state/state_keeper.py
+++ /dev/null
@@ -1,105 +0,0 @@
-import os
-import numpy as np
-
-class StateKeeper:
- """Handles saving and loading the state of a simulation model.
-
- This class provides functionality to save and load the state of a simulation model, including
- all relevant variables specified in the model's `state_vars` attribute. It handles file operations
- for saving to and loading from numpy `.npy` files.
-
- Attributes
- ----------
- record_save : str
- Directory path where the simulation state will be saved.
-
- record_load : str
- Directory path from where the simulation state will be loaded.
-
- Methods
- -------
- save(model)
- Saves the state of the provided model to the specified directory.
-
- load(model)
- Loads the state from the specified directory and sets the state variables in the provided model.
-
- _save_variable(var_path, var)
- Helper method to save a variable to a numpy `.npy` file.
-
- _load_variable(var_path)
- Helper method to load a variable from a numpy `.npy` file.
- """
-
- def __init__(self):
- """
- Initializes the StateKeeper with default paths for saving and loading state.
- """
- self.record_save = ""
- self.record_load = ""
-
- def save(self, model):
- """
- Saves the state of the given model to the specified `record_save` directory.
-
- This method creates the necessary directories if they do not exist and saves each variable
- listed in the model's `state_vars` attribute as a numpy `.npy` file.
-
- Parameters
- ----------
- model : object
- The model object whose state is to be saved. The model must have a `state_vars` attribute
- listing the state variables to be saved.
- """
- if not os.path.exists(self.record_save):
- os.makedirs(self.record_save)
- for var in model.state_vars:
- self._save_variable(os.path.join(self.record_save, var + ".npy"),
- model.__dict__[var])
-
- def load(self, model):
- """
- Loads the state from the specified `record_load` directory and sets it in the given model.
-
- This method loads each variable listed in the model's `state_vars` attribute from numpy `.npy`
- files and sets these variables in the model.
-
- Parameters
- ----------
- model : object
- The model object to which the state is to be loaded. The model must have a `state_vars` attribute
- which will be updated with the loaded variables.
- """
- for var in model.state_vars:
- setattr(model, var, self._load_variable(os.path.join(
- self.record_load, var + ".npy")))
-
- def _save_variable(self, var_path, var):
- """
- Saves a variable to a numpy `.npy` file.
-
- Parameters
- ----------
- var_path : str
- The file path where the variable will be saved.
-
- var : numpy.ndarray
- The variable to be saved.
- """
- np.save(var_path, var)
-
- def _load_variable(self, var_path):
- """
- Loads a variable from a numpy `.npy` file.
-
- Parameters
- ----------
- var_path : str
- The file path from which the variable will be loaded.
-
- Returns
- -------
- numpy.ndarray
- The variable loaded from the file.
- """
- return np.load(var_path)
diff --git a/finitewave/core/state/state_loader.py b/finitewave/core/state/state_loader.py
new file mode 100644
index 0000000..e7e3ae1
--- /dev/null
+++ b/finitewave/core/state/state_loader.py
@@ -0,0 +1,80 @@
+from pathlib import Path
+import numpy as np
+
+
+class StateLoader:
+ """ This class provides functionality to load the state of a simulation
+ model, including all relevant variables specified in the model's
+ ``state_vars`` attribute.
+ Attributes
+ ----------
+ path : str
+ Directory path from where the simulation state will be loaded.
+ passed : bool
+ Whether the state has been loaded.
+ model : CardiacModel
+ The model instance for which the state will be saved or loaded.
+ """
+
+ def __init__(self, path=""):
+ """
+ Initializes the state keeper with the given path.
+
+ Parameters
+ ----------
+ path : str, optional
+ The directory path from where the simulation state will be loaded.
+ """
+ self.path = path
+ self.passed = True
+ self.model = None
+
+ def initialize(self, model):
+ """
+ Initializes the state keeper with the given model.
+
+ Parameters
+ ----------
+ model : CardiacModel
+ The model instance for which the state will be saved or loaded.
+ """
+ self.model = model
+ self.passed = self.path == ""
+
+ if not Path(self.path).exists():
+ message = (f"Unable to load state from {self.path}. " +
+ "Directory does not exist.")
+ raise FileNotFoundError(message)
+
+ def load(self):
+ """
+ Loads the state from the specified ``path`` directory and sets
+ it in the given model.
+
+ This method loads each variable listed in the model's ``state_vars``
+ attribute from numpy files and sets these variables in the model.
+ """
+ if self.passed:
+ return
+
+ for var in self.model.state_vars:
+ val = self._load_variable(Path(self.path).joinpath(var + ".npy"))
+ setattr(self.model, var, val)
+
+ self.passed = True
+
+ def _load_variable(self, var_path):
+ """
+ Loads a state variable from a numpy file.
+
+ Parameters
+ ----------
+ var_path : str
+ The file path from which the variable will be loaded.
+
+ Returns
+ -------
+ numpy.ndarray
+ The variable loaded from the file.
+ """
+ return np.load(var_path)
diff --git a/finitewave/core/state/state_saver.py b/finitewave/core/state/state_saver.py
new file mode 100644
index 0000000..61fff02
--- /dev/null
+++ b/finitewave/core/state/state_saver.py
@@ -0,0 +1,122 @@
+from pathlib import Path
+import numpy as np
+
+
+class StateSaver:
+ """ This class provides functionality to save the state of a
+ simulation model, including all relevant variables specified in the model's
+ ``state_vars`` attribute.
+
+ Attributes
+ ----------
+ path : str
+ Directory path where the simulation state will be saved.
+ passed : bool
+ Whether the state has been saved.
+ model : CardiacModel
+ The model instance for which the state will be saved or saved.
+ time : float
+ The time at which to save the state of the simulation.
+ """
+
+ def __init__(self, path=".", time=-1):
+ """
+ Initializes the state keeper with the given path.
+
+ Parameters
+ ----------
+ path : str, optional
+ The directory path where the simulation state will be saved.
+ The default is ".".
+ time : float, optional
+ The time at which to save the state of the simulation.
+ The default is -1 (save at the end of the simulation).
+ """
+ self.path = path
+ self.passed = False
+ self.model = None
+ self.time = time
+
+ def initialize(self, model):
+ """
+ Initializes the state keeper with the given model.
+
+ Parameters
+ ----------
+ model : CardiacModel
+ The model instance for which the state will be saved or saved.
+ """
+ self.model = model
+ self.passed = self.path == ""
+
+ def save(self):
+ """
+ Saves the state of the given model to the specified ``path``
+ directory.
+
+ This method creates the necessary directories if they do not exist and
+ saves each variable listed in the model's ``state_vars`` attribute as
+ a numpy file.
+ """
+ if self.passed:
+ return
+
+ if self.time < 0 and self.model.t < self.model.t_max:
+ return
+
+ if self.time >= 0 and self.model.t < self.time:
+ return
+
+ if not Path(self.path).exists():
+ Path(self.path).mkdir(parents=True, exist_ok=True)
+
+ for var in self.model.state_vars:
+ self._save_variable(Path(self.path).joinpath(var + ".npy"),
+ self.model.__dict__[var])
+
+ self.passed = True
+
+ def _save_variable(self, var_path, var):
+ """
+ Saves a variable to a numpy file.
+
+ Parameters
+ ----------
+ var_path : str
+ The file path where the variable will be saved.
+
+ var : numpy.ndarray
+ The variable to be saved.
+ """
+ np.save(var_path, var)
+
+
+class StateSaverCollection(StateSaver):
+ """ This class saves multiple states of a simulation model.
+
+ Attributes
+ ----------
+ savers : list
+ List of StateSaver objects.
+ """
+ def __init__(self):
+ super().__init__()
+ self.savers = []
+
+ def initialize(self, model):
+ """ Initializes the state saver collection with the given model.
+
+ Parameters
+ ----------
+ model : CardiacModel
+ The model instance for which the state will be saved or saved.
+ """
+ for saver in self.savers:
+ saver.initialize(model)
+
+ def save(self):
+ """ Applies the save method to each StateSaver object in the
+ collection.
+ """
+ for saver in self.savers:
+ saver.save()
diff --git a/finitewave/core/stencil/stencil.py b/finitewave/core/stencil/stencil.py
index 65435be..07c1abd 100644
--- a/finitewave/core/stencil/stencil.py
+++ b/finitewave/core/stencil/stencil.py
@@ -1,70 +1,46 @@
-from abc import ABCMeta, abstractmethod
-from collections import defaultdict
+from abc import ABC, abstractmethod
-class Stencil:
- """Base class for calculating stencil weights used in numerical simulations.
- This abstract base class defines the interface for calculating stencil weights for numerical
- simulations. It includes a caching mechanism to optimize performance by reducing the number of
- symbolic calculations.
+class Stencil(ABC):
+ """Base class for calculating stencil weights used in numerical
+ simulations.
- Attributes
- ----------
- cache : dict
- A dictionary used to cache previously computed stencil weights to improve performance
- by avoiding redundant calculations.
-
- Methods
- -------
- get_weights(mesh, conductivity, fibers, D_al, D_ac, dt, dr)
- Abstract method that must be implemented by subclasses to compute and return stencil weights.
+ This abstract base class defines the interface for calculating stencil
+ weights for numerical simulations. It includes a caching mechanism to
+ optimize performance by reducing the number of symbolic calculations. Also,
+ it handles the boundary conditions for the numerical scheme.
"""
-
- __metaclass__ = ABCMeta
-
- def __init__(self):
- """
- Initializes the Stencil object with an empty cache.
- """
- self.cache = defaultdict()
-
@abstractmethod
- def get_weights(self, mesh, conductivity, fibers, D_al, D_ac, dt, dr):
+ def compute_weights(self, model, cardiac_tissue):
"""
- Computes and returns the stencil weights based on the provided parameters.
+ Computes the stencil weights based on the provided parameters.
- This method must be implemented by subclasses to compute the stencil weights used for
- numerical simulations. The weights are calculated based on the tissue mesh, conductivity,
- fibers orientation, diffusion coefficients, time step, and spatial step.
+ This method must be implemented by subclasses to compute the stencil
+ weights used for numerical simulations. The weights are calculated
+ based on the tissue mesh and spatial step. Additional parameters can
+ be passed as arguments or keyword arguments.
Parameters
----------
- mesh : np.ndarray
- A 2D or 3D numpy array representing the tissue mesh where each value indicates the type
- of tissue (e.g., cardiomyocyte, fibrosis).
-
- conductivity : np.ndarray or float
- A numpy array or constant value representing the coefficient for imitating low conductance
- (fibrosis) areas. This affects the diffusion coefficients.
-
- fibers : np.ndarray
- A 2D or 3D numpy array representing the orientation vectors of the fibers within the tissue.
-
- D_al : float
- The diffusion coefficient along the fibers direction.
-
- D_ac : float
- The diffusion coefficient across the fibers direction.
-
- dt : float
- The time step used in the simulation.
-
- dr : float
- The spatial step used in the simulation.
+ model : CardiacModel
+ A model object containing the simulation parameters.
+ cardiac_tissue : CardiacTissue
+ A tissue object representing the cardiac tissue.
Returns
-------
np.ndarray
- A numpy array of stencil weights computed based on the provided parameters.
+ A numpy array containing the stencil weights.
+ """
+ pass
+
+ @abstractmethod
+ def select_diffusion_kernel():
+ """
+ Builds the diffusion kernel for the numerical scheme.
+
+ This method must be implemented by subclasses to build the diffusion
+ kernel used for the numerical scheme. The kernel is used to compute the
+ diffusion of the potential in the tissue mesh.
"""
pass
diff --git a/finitewave/core/stimulation/stim.py b/finitewave/core/stimulation/stim.py
index 76b34f4..9fe9fbf 100755
--- a/finitewave/core/stimulation/stim.py
+++ b/finitewave/core/stimulation/stim.py
@@ -1,30 +1,24 @@
-class Stim:
+from abc import ABC, abstractmethod
+
+
+class Stim(ABC):
"""Base class for stimulation in cardiac models.
- The `Stim` class represents a general stimulation object used in cardiac simulations. It provides methods
- to manage the timing and state of stimulation. Subclasses should implement specific stimulation behaviors.
+ The ``Stim`` class represents a general stimulation object used in cardiac
+ simulations. It provides methods to manage the timing and state of
+ stimulation. Subclasses should implement specific stimulation behaviors.
Attributes
----------
t : float
The time at which the stimulation is to occur.
-
+ duration : float
+ The duration for which the stimulation will be applied.
passed : bool
A flag indicating whether the stimulation has been applied.
-
- Methods
- -------
- stimulate(model)
- Applies the stimulation to the provided model. This method should be implemented by subclasses.
-
- ready()
- Prepares the stimulation for application. This method should be implemented by subclasses.
-
- done()
- Marks the stimulation as completed. This method should be implemented by subclasses.
"""
- def __init__(self, time):
+ def __init__(self, time, duration=0.0):
"""
Initializes the Stim object with the specified time.
@@ -32,44 +26,31 @@ def __init__(self, time):
----------
time : float
The time at which the stimulation is scheduled to occur.
+ duration : float, optional
+ The duration for which the stimulation will be applied. The default
+ value is 0.0, indicating that the stimulation will be applied
+ instantaneously.
"""
self.t = time
+ self.duration = duration
self.passed = False
+ @abstractmethod
def stimulate(self, model):
"""
Applies the stimulation to the provided model.
-
- Parameters
- ----------
- model : CardiacModel
- The simulation model to which the stimulation will be applied.
-
- Notes
- -----
- This is an abstract method that should be implemented by subclasses to define specific
- stimulation behaviors.
"""
pass
- def ready(self):
+ @abstractmethod
+ def initialize(self, model):
"""
Prepares the stimulation for application.
-
- Notes
- -----
- This is an abstract method that should be implemented by subclasses to define how
- the stimulation is prepared before being applied.
"""
pass
- def done(self):
+ def update_status(self, model):
"""
Marks the stimulation as completed.
-
- Notes
- -----
- This is an abstract method that should be implemented by subclasses to define how
- the stimulation state is updated after application.
"""
- pass
+ self.passed = model.t >= (self.t + self.duration)
diff --git a/finitewave/core/stimulation/stim_current.py b/finitewave/core/stimulation/stim_current.py
index 8cf9a6f..6b7a9fa 100755
--- a/finitewave/core/stimulation/stim_current.py
+++ b/finitewave/core/stimulation/stim_current.py
@@ -1,37 +1,21 @@
from finitewave.core.stimulation.stim import Stim
+
class StimCurrent(Stim):
"""A stimulation class that applies a current value to the cardiac model.
- This class represents a type of stimulation where a current is applied to the model for a specified
- duration. It extends the base `Stim` class and includes methods for preparing the stimulation and
- updating its status based on elapsed time.
+ This class represents a type of stimulation where a current is applied to
+ the model for a specified duration. It extends the base ``Stim`` class and
+ includes methods for preparing the stimulation and updating its status
+ based on elapsed time.
Attributes
----------
curr_value : float
The current value to be applied during the stimulation.
-
- curr_time : float
- The duration for which the current is applied.
-
- _acc_time : float
- Accumulated time remaining for the current stimulation (used internally).
-
- _dt : float
- Time step of the simulation (used internally).
-
- Methods
- -------
- ready(model)
- Prepares the stimulation by initializing accumulated time and setting the simulation time step.
-
- done()
- Updates the stimulation status based on the elapsed time and marks the stimulation as completed
- if the current time has elapsed.
"""
- def __init__(self, time, curr_value, curr_time):
+ def __init__(self, time, curr_value, duration):
"""
Initializes the StimCurrent object with the specified parameters.
@@ -39,46 +23,22 @@ def __init__(self, time, curr_value, curr_time):
----------
time : float
The time at which the current stimulation is to start.
-
curr_value : float
The current value to be applied during the stimulation.
-
- curr_time : float
+ duration : float
The duration for which the current will be applied.
"""
- Stim.__init__(self, time)
+ super().__init__(time, duration)
self.curr_value = curr_value
- self.curr_time = curr_time
-
- self._acc_time = curr_time
- self._dt = 0
- def ready(self, model):
+ def initialize(self, model):
"""
Prepares the stimulation for application.
- This method initializes the accumulated time with the current duration and sets the time step
- of the simulation. The `passed` flag is set to `False` indicating that the stimulation has not
- yet been applied.
-
Parameters
----------
model : CardiacModel
- The simulation model to which the current stimulation will be applied.
+ The simulation model to which the current stimulation will be
+ applied.
"""
- self._acc_time = self.curr_time
- self._dt = model.dt
self.passed = False
-
- def done(self):
- """
- Updates the stimulation status based on the elapsed time.
-
- This method decreases the accumulated time by the simulation time step and checks if the
- current stimulation duration has elapsed. If the time has elapsed, the `passed` flag is set
- to `True`, indicating that the stimulation is completed.
- """
- if self._acc_time >= 0:
- self._acc_time -= self._dt
- else:
- self.passed = True
diff --git a/finitewave/core/stimulation/stim_sequence.py b/finitewave/core/stimulation/stim_sequence.py
index 2652d84..239526a 100755
--- a/finitewave/core/stimulation/stim_sequence.py
+++ b/finitewave/core/stimulation/stim_sequence.py
@@ -1,36 +1,26 @@
class StimSequence:
"""A sequence of stimuli to be applied to the cardiac model.
- This class manages a list of stimulation objects and applies them to the model based on the
- simulation time. It handles the initialization of stimuli, adding and removing stimuli,
- and applying the next set of stimuli in the sequence.
+ This class manages a list of stimulation objects and applies them to the
+ model based on the simulation time. It handles the initialization of
+ stimuli, adding and removing stimuli, and applying the next set of stimuli
+ in the sequence.
Attributes
----------
sequence : list
- A list of `Stim` objects representing the sequence of stimuli to be applied to the model.
+ A list of ``Stim`` objects representing the sequence of stimuli to be
+ applied to the model.
model : CardiacModel, optional
- The cardiac model to which the stimuli will be applied. This is set during initialization.
-
- Methods
- -------
- initialize(model)
- Prepares each stimulus in the sequence for application based on the provided model.
-
- add_stim(stim)
- Adds a `Stim` object to the sequence of stimuli.
-
- remove_stim()
- Clears the sequence of stimuli, removing all stimuli from the list.
-
- stimulate_next()
- Applies the next set of stimuli based on the current time in the model.
+ The cardiac model to which the stimuli will be applied. This is set
+ during initialization.
"""
def __init__(self):
"""
- Initializes the StimSequence object with an empty sequence and no associated model.
+ Initializes the StimSequence object with an empty sequence and no
+ associated model.
"""
self.sequence = []
self.model = None
@@ -39,8 +29,9 @@ def initialize(self, model):
"""
Prepares each stimulus in the sequence for application.
- This method sets up each stimulus based on the provided model, ensuring that each stimulus
- is ready to be applied according to its specified start time.
+ This method sets up each stimulus based on the provided model
+ ensuring that each stimulus is ready to be applied according to its
+ specified start time.
Parameters
----------
@@ -49,7 +40,7 @@ def initialize(self, model):
"""
self.model = model
for stim in self.sequence:
- stim.ready(model)
+ stim.initialize(model)
def add_stim(self, stim):
"""
@@ -58,7 +49,7 @@ def add_stim(self, stim):
Parameters
----------
stim : Stim
- The `Stim` object to be added to the sequence.
+ The ``Stim`` object to be added to the sequence.
"""
self.sequence.append(stim)
@@ -66,7 +57,8 @@ def remove_stim(self):
"""
Removes all stimuli from the sequence.
- This method clears the sequence, effectively removing all stimuli that were previously added.
+ This method clears the sequence, effectively removing all stimuli that
+ were previously added.
"""
self.sequence = []
@@ -74,11 +66,12 @@ def stimulate_next(self):
"""
Applies the next set of stimuli based on the current time in the model.
- This method checks each stimulus in the sequence to determine if it should be applied based
- on the current simulation time. If a stimulus is due to be applied and has not yet been
- marked as passed, it is stimulated and then marked as done.
+ This method checks each stimulus in the sequence to determine if it
+ should be applied based on the current simulation time. If a stimulus
+ is due to be applied and has not yet been marked as passed, it is
+ stimulated and then marked as done.
"""
for stim in self.sequence:
if self.model.t >= stim.t and not stim.passed:
stim.stimulate(self.model)
- stim.done()
+ stim.update_status(self.model)
diff --git a/finitewave/core/stimulation/stim_voltage.py b/finitewave/core/stimulation/stim_voltage.py
index 4b773b7..814da0a 100755
--- a/finitewave/core/stimulation/stim_voltage.py
+++ b/finitewave/core/stimulation/stim_voltage.py
@@ -1,58 +1,49 @@
from finitewave.core.stimulation.stim import Stim
+
class StimVoltage(Stim):
"""A stimulation class that sets a voltage value in the cardiac model.
- This class represents a specific type of stimulation where a voltage value is applied to the model
- at a specified time. It extends the base `Stim` class and provides functionality for managing the
- stimulation process, including preparing and finalizing the stimulation.
+ This class represents a specific type of stimulation where a voltage value
+ is applied to the model at a specified time. It extends the base ``Stim``
+ class and provides functionality for managing the stimulation process,
+ including preparing and finalizing the stimulation.
Attributes
----------
volt_value : float
The voltage value to be applied during the stimulation.
-
- Methods
- -------
- ready(model)
- Prepares the stimulation for application at the specified time.
-
- done()
- Marks the stimulation as completed.
"""
-
- def __init__(self, time, volt_value):
+ def __init__(self, time, volt_value, duration=0.0):
"""
- Initializes the StimVoltage object with the specified time and voltage value.
+ Initializes the StimVoltage object with the specified time and
+ voltage value.
Parameters
----------
time : float
The time at which the voltage stimulation is to occur.
-
volt_value : float
The voltage value to be applied during the stimulation.
+ duration : float, optional
+ The duration for which the voltage will be applied. The default
+ value is 0.0, indicating that the voltage will be applied
+ instantaneously.
"""
- Stim.__init__(self, time)
+ super().__init__(time, duration)
self.volt_value = volt_value
- def ready(self, model):
+ def initialize(self, model):
"""
Prepares the stimulation for application.
- This method sets the `passed` flag to `False`, indicating that the stimulation has not yet been applied.
+ This method sets the ``passed`` flag to ``False``, indicating that the
+ stimulation has not yet been applied.
Parameters
----------
model : CardiacModel
- The simulation model to which the voltage stimulation will be applied.
+ The simulation model to which the voltage stimulation will be
+ applied.
"""
self.passed = False
-
- def done(self):
- """
- Marks the stimulation as completed.
-
- This method sets the `passed` flag to `True`, indicating that the stimulation has been applied.
- """
- self.passed = True
diff --git a/finitewave/core/tissue/cardiac_tissue.py b/finitewave/core/tissue/cardiac_tissue.py
index d0b9953..05918b9 100755
--- a/finitewave/core/tissue/cardiac_tissue.py
+++ b/finitewave/core/tissue/cardiac_tissue.py
@@ -1,92 +1,72 @@
-from abc import ABCMeta, abstractmethod
-import numpy as np
+from abc import ABC, abstractmethod
import copy
+import numpy as np
-class CardiacTissue:
+class CardiacTissue(ABC):
"""Base class for a model tissue.
- This class represents the tissue model used in cardiac simulations. It includes attributes and methods
- for defining the tissue structure, its properties, and handling fibrosis patterns.
+ This class represents the tissue model used in cardiac simulations.
+ It includes attributes and methods for defining the tissue structure,
+ ts properties, and handling fibrosis patterns.
Attributes
----------
- mesh : numpy.ndarray
- A 2D or 3D array of integers representing the tissue grid, where:
- - `0` denotes empty points (non-cardiac tissue).
- - `1` denotes cardiomyocytes (healthy cardiac tissue).
- - `2` denotes fibrosis (damaged or non-conductive tissue).
-
- conductivity : numpy.ndarray or float, default: 1.0
- A 2D or 3D array of floats in the range [0, 1], representing the conductivity of the tissue.
- Conductivity values are multiplied with diffusion coefficients to model varying conductance in fibrosis areas.
-
- fibers : numpy.ndarray
- A 2D or 3D array where each node contains a 2D or 3D vector specifying the direction of the fibers at that location.
-
- D_al : float
- Diffusion coefficient along the fiber direction. This determines the rate of diffusion parallel to the fibers.
-
- D_ac : float
- Diffusion coefficient across the fiber direction. This determines the rate of diffusion perpendicular to the fibers.
-
- weights : numpy.ndarray
- A 2D or 3D array of weights computed based on the tissue mesh, including cardiomyocytes, empty nodes, and fibrosis nodes.
-
- shape : list or tuple
- The shape of the mesh as a list or tuple, e.g., `[ni, nj]` for 2D or `[ni, nj, nk]` for 3D.
-
meta : dict
- A dictionary to store additional metadata about the tissue.
-
- Methods
- -------
- add_boundaries()
- Abstract method to be implemented by subclasses for adding boundary conditions to the tissue mesh.
-
- compute_weights()
- Abstract method to be implemented by subclasses for computing weights based on the tissue properties and structure.
+ A dictionary containing metadata about the tissue.
+ special_boundaries : np.ndarray
+ An array containing labels for special boundaries in the tissue mesh.
+ This array is used to define Dirichlet boundary conditions as points
+ with non-zero values are ignored in the solver.
+ """
+ def __init__(self):
+ self.meta = {}
+ self.special_boundaries = None
- add_pattern(fibro_pattern)
- Applies a fibrosis pattern to the tissue mesh.
+ @property
+ def mesh(self):
+ """
+ Gets the tissue mesh array.
- clean()
- Removes all fibrosis points from the mesh, setting them to `1` (healthy tissue).
+ Returns
+ -------
+ numpy.ndarray
+ The tissue mesh array.
+ """
+ return self._mesh
- clone()
- Creates a deep copy of the current `CardiacTissue` instance.
+ @mesh.setter
+ def mesh(self, mesh):
+ """
+ Sets the tissue mesh array.
- set_dtype(dtype)
- Sets the data type for the `weights` and `mesh` arrays.
- """
+ Parameters
+ ----------
+ mesh : numpy.ndarray
+ The tissue mesh array.
+ """
+ if mesh.ndim != self.meta['dim']:
+ raise ValueError("Mesh dimension must match the tissue dimension.")
- __metaclass__ = ABCMeta
+ self._mesh = mesh
+ self.add_boundaries()
- def __init__(self):
+ def compute_myo_indexes(self):
"""
- Initializes the CardiacTissue instance with default attributes.
+ Computes flat indices of the myocytes in the tissue mesh.
"""
- self.mesh = np.array([], dtype="int8")
- self.conductivity = np.array([])
- self.fibers = np.array([])
- self.D_al = 1
- self.D_ac = 1
- self.weights = np.array([])
- self.boundary = np.array([], dtype="int16")
- self.shape = []
- self.meta = dict()
+ if self.special_boundaries is not None:
+ self.myo_indexes = np.flatnonzero((self.mesh == 1) &
+ (self.special_boundaries == 0))
+ return
- @abstractmethod
- def add_boundaries(self):
- """
- Abstract method to be implemented by subclasses for adding boundary conditions to the tissue mesh.
- """
- pass
+ self.myo_indexes = np.flatnonzero(self.mesh == 1)
@abstractmethod
- def compute_weights(self):
+ def add_boundaries(self):
"""
- Abstract method to be implemented by subclasses for computing weights based on the tissue properties and structure.
+ Abstract method to be implemented by subclasses for adding boundary
+ conditions to the tissue mesh.
"""
pass
@@ -97,35 +77,24 @@ def add_pattern(self, fibro_pattern):
Parameters
----------
fibro_pattern : FibrosisPattern
- An instance of a `FibrosisPattern` class that defines the pattern of fibrosis to be applied.
+ A fibrosis pattern object to apply to the tissue mesh.
"""
fibro_pattern.apply(self)
def clean(self):
"""
- Removes all fibrosis points from the mesh, setting them to `1` (healthy tissue).
+ Removes all fibrosis points from the mesh, setting them to ``1``
+ (healthy tissue).
"""
self.mesh[self.mesh == 2] = 1
def clone(self):
"""
- Creates a deep copy of the current `CardiacTissue` instance.
+ Creates a deep copy of the current ``CardiacTissue`` instance.
Returns
-------
CardiacTissue
- A deep copy of the current `CardiacTissue` instance.
+ A deep copy of the current ``CardiacTissue`` instance.
"""
return copy.deepcopy(self)
-
- def set_dtype(self, dtype):
- """
- Sets the data type for the `weights` and `mesh` arrays.
-
- Parameters
- ----------
- dtype : type
- The data type to which the `weights` and `mesh` arrays will be cast.
- """
- self.weights = self.weights.astype(dtype)
- self.mesh = self.mesh.astype(dtype)
diff --git a/finitewave/core/tracker/tracker.py b/finitewave/core/tracker/tracker.py
index 95c6ea5..0f28ae5 100755
--- a/finitewave/core/tracker/tracker.py
+++ b/finitewave/core/tracker/tracker.py
@@ -1,54 +1,56 @@
-from abc import ABCMeta, abstractmethod
+from pathlib import Path
+from abc import ABC, abstractmethod
import copy
+import numpy as np
-class Tracker:
+
+class Tracker(ABC):
"""Base class for trackers used in simulations.
- This class provides a base implementation for trackers that monitor and record various aspects of the
- simulation. Trackers can be used to gather data such as activation times, wave dynamics, or ECG readings.
+ This class provides a base implementation for trackers that monitor and
+ record various aspects of the simulation. Trackers can be used to gather
+ data such as activation times, wave dynamics, or ECG readings.
Attributes
----------
model : CardiacModel
- The simulation model to which the tracker is attached. This allows the tracker to access the model's state
- and data during the simulation.
-
+ The simulation model to which the tracker is attached. This allows
+ the tracker to access the model's state and data during the simulation.
+
file_name : str
- The name of the file where the tracked data will be saved. Default is an empty string.
-
- path : str
- The directory path where the tracked data will be saved. Default is the current directory.
+ The name of the file where the tracked data will be saved.
+ Default is an empty string.
- Methods
- -------
- initialize(model)
- Abstract method to be implemented by subclasses for initializing the tracker with the simulation model.
+ path : str
+ The directory path where the tracked data will be saved.
+ Default is the current directory.
- track()
- Abstract method to be implemented by subclasses for tracking and recording data during the simulation.
+ start_time : float
+ The time step at which tracking will begin. Default is 0.
- clone()
- Creates a deep copy of the current tracker instance.
+ end_time : float
+ The time step at which tracking will end. Default is infinity.
- write()
- Abstract method to be implemented by subclasses for writing the tracked data to a file.
+ step : int
+ The frequency at which tracking will occur. Default is 1.
"""
- __metaclass__ = ABCMeta
+ # __metaclass__ = ABCMeta
def __init__(self):
- """
- Initializes the Tracker instance with default attributes.
- """
self.model = None
- self.file_name = ""
+ self.file_name = "tracked_data"
self.path = "."
+ self.start_time = 0
+ self.end_time = np.inf
+ self.step = 1
@abstractmethod
def initialize(self, model):
"""
- Abstract method to be implemented by subclasses for initializing the tracker with the simulation model.
+ Abstract method to be implemented by subclasses for initializing
+ the tracker with the simulation model.
Parameters
----------
@@ -58,12 +60,28 @@ def initialize(self, model):
pass
@abstractmethod
- def track(self):
+ def _track(self):
"""
- Abstract method to be implemented by subclasses for tracking and recording data during the simulation.
+ Abstract method to be implemented by subclasses for tracking and
+ recording data during the simulation.
"""
pass
+ def track(self):
+ """
+ Tracks and records data during the simulation.
+
+ This method calls the ``_track`` method at the specified tracking
+ frequency and within the specified time range.
+ """
+ if self.start_time > self.model.t or self.model.t > self.end_time:
+ return
+ # Check if the current time step is within the tracking frequency
+ if self.model.step % self.step != 0:
+ return
+
+ self._track()
+
def clone(self):
"""
Creates a deep copy of the current tracker instance.
@@ -75,9 +93,9 @@ def clone(self):
"""
return copy.deepcopy(self)
- @abstractmethod
def write(self):
"""
- Abstract method to be implemented by subclasses for writing the tracked data to a file.
+ Writes the tracked data to a file.
"""
- pass
+ np.save(Path(self.path, self.file_name).with_suffix('.npy'),
+ self.output)
diff --git a/finitewave/core/tracker/tracker_sequence.py b/finitewave/core/tracker/tracker_sequence.py
index 37f490d..deb548c 100755
--- a/finitewave/core/tracker/tracker_sequence.py
+++ b/finitewave/core/tracker/tracker_sequence.py
@@ -1,31 +1,21 @@
class TrackerSequence:
"""Manages a sequence of trackers for a simulation.
- The `TrackerSequence` class allows for the management of multiple `Tracker` instances. It provides methods
- to initialize trackers, add or remove trackers from the sequence, and iterate over the trackers to perform
+ The ``TrackerSequence`` class allows for the management of multiple
+ ``Tracker`` instances. It provides methods to initialize trackers, add or
+ remove trackers from the sequence, and iterate over the trackers to perform
their tracking functions.
Attributes
----------
sequence : list of Tracker
- List containing the trackers in the sequence. The trackers are executed in the order they are added.
-
- model : CardiacModel or None
- The simulation model to which the trackers are attached. It is set during initialization.
-
- Methods
- -------
- initialize(model)
- Initializes all trackers in the sequence with the provided simulation model.
-
- add_tracker(tracker)
- Adds a new tracker to the end of the sequence.
+ List containing the trackers in the sequence. The trackers are executed
+ in the order they are added.
- remove_trackers()
- Removes all trackers from the sequence.
+ model : CardiacModel or None
+ The simulation model to which the trackers are attached. It is set
+ during initialization.
- tracker_next()
- Executes the `track` method of each tracker in the sequence.
"""
def __init__(self):
@@ -37,7 +27,8 @@ def __init__(self):
def initialize(self, model):
"""
- Initializes all trackers in the sequence with the provided simulation model.
+ Initializes all trackers in the sequence with the provided simulation
+ model.
Parameters
----------
diff --git a/finitewave/cpuwave2D/__init__.py b/finitewave/cpuwave2D/__init__.py
index 0f845fe..fff3150 100755
--- a/finitewave/cpuwave2D/__init__.py
+++ b/finitewave/cpuwave2D/__init__.py
@@ -1,7 +1,29 @@
-from finitewave.cpuwave2D.exception import IncorrectWeightsModeError2D
-from finitewave.cpuwave2D.fibrosis import Diffuse2DPattern, ScarGauss2DPattern, ScarRect2DPattern, Structural2DPattern
-from finitewave.cpuwave2D.model import diffuse_kernel_2d_iso, diffuse_kernel_2d_aniso, _parallel, AlievPanfilov2D, AlievPanfilovKernels2D, LuoRudy912D, LuoRudy91Kernels2D, TP062D, TP06Kernels2D, LuoRudy912D, LuoRudy91Kernels2D, TP062D, TP06Kernels2D
-from finitewave.cpuwave2D.stencil import AsymmetricStencil2D, IsotropicStencil2D
-from finitewave.cpuwave2D.stimulation import StimCurrentCoord2D, StimVoltageCoord2D, StimCurrentMatrix2D, StimVoltageMatrix2D
-from finitewave.cpuwave2D.tissue import CardiacTissue2D
-from finitewave.cpuwave2D.tracker import ActionPotential2DTracker, ActivationTime2DTracker, Animation2DTracker, ECG2DTracker, MultiActivationTime2DTracker, MultiVariable2DTracker, Period2DTracker, PeriodMap2DTracker, Spiral2DTracker, Variable2DTracker, Velocity2DTracker
+from .exception import IncorrectWeightsModeError2D
+from .fibrosis import (
+ Diffuse2DPattern,
+ Structural2DPattern
+)
+from .model import (
+ AlievPanfilov2D,
+ Barkley2D,
+ MitchellSchaeffer2D,
+ FentonKarma2D,
+ BuenoOrovio2D,
+ LuoRudy912D,
+ TP062D,
+ Courtemanche2D
+)
+from .stencil import (
+ AsymmetricStencil2D,
+ IsotropicStencil2D,
+ SymmetricStencil2D
+)
+from .stimulation import (
+ StimCurrentArea2D,
+ StimCurrentCoord2D,
+ StimVoltageCoord2D,
+ StimCurrentMatrix2D,
+ StimVoltageMatrix2D
+)
+from .tissue import CardiacTissue2D
+from .tracker import *
diff --git a/finitewave/cpuwave2D/fibrosis/__init__.py b/finitewave/cpuwave2D/fibrosis/__init__.py
index 444f7ee..bfede4f 100755
--- a/finitewave/cpuwave2D/fibrosis/__init__.py
+++ b/finitewave/cpuwave2D/fibrosis/__init__.py
@@ -1,4 +1,2 @@
-from finitewave.cpuwave2D.fibrosis.diffuse_2d_pattern import Diffuse2DPattern
-from finitewave.cpuwave2D.fibrosis.scar_gauss_2d_pattern import ScarGauss2DPattern
-from finitewave.cpuwave2D.fibrosis.scar_rect_2d_pattern import ScarRect2DPattern
-from finitewave.cpuwave2D.fibrosis.structural_2d_pattern import Structural2DPattern
+from .diffuse_2d_pattern import Diffuse2DPattern
+from .structural_2d_pattern import Structural2DPattern
diff --git a/finitewave/cpuwave2D/fibrosis/diffuse_2d_pattern.py b/finitewave/cpuwave2D/fibrosis/diffuse_2d_pattern.py
index ede5c70..9855f93 100755
--- a/finitewave/cpuwave2D/fibrosis/diffuse_2d_pattern.py
+++ b/finitewave/cpuwave2D/fibrosis/diffuse_2d_pattern.py
@@ -9,6 +9,8 @@ class Diffuse2DPattern(FibrosisPattern):
Attributes
----------
+ density : float
+ The density of the fibrosis in the specified area
x1 : int
The starting x-coordinate of the fibrosis area.
x2 : int
@@ -17,23 +19,16 @@ class Diffuse2DPattern(FibrosisPattern):
The starting y-coordinate of the fibrosis area.
y2 : int
The ending y-coordinate of the fibrosis area.
- dens : float
- The density of the fibrosis, where a value between 0 and 1 represents the probability
- of fibrosis in each cell of the specified area.
-
- Methods
- -------
- generate(size, mesh=None):
- Generates the fibrosis pattern and updates the provided mesh. If no mesh is provided,
- a new mesh is created with the given size.
"""
- def __init__(self, x1, x2, y1, y2, dens):
+ def __init__(self, density, x1=None, x2=None, y1=None, y2=None):
"""
Initializes the Diffuse2DPattern with the specified parameters.
Parameters
----------
+ density : float
+ The density of the fibrosis in the specified area.
x1 : int
The starting x-coordinate of the fibrosis area.
x2 : int
@@ -42,43 +37,51 @@ def __init__(self, x1, x2, y1, y2, dens):
The starting y-coordinate of the fibrosis area.
y2 : int
The ending y-coordinate of the fibrosis area.
- dens : float
- The density of the fibrosis, where a value between 0 and 1 represents the probability
- of fibrosis in each cell of the specified area.
"""
self.x1 = x1
self.x2 = x2
self.y1 = y1
self.y2 = y2
- self.dens = dens
+ self.density = density
- def generate(self, size, mesh=None):
+ def generate(self, shape=None, mesh=None):
"""
- Generates and applies the diffuse fibrosis pattern to the mesh.
-
- If no mesh is provided, a new mesh of zeros with the given size is created. The method
- fills the specified area of the mesh with fibrosis based on the defined density.
+ Generates a diffuse 2D fibrosis pattern for the given shape and mesh.
+ The resulting pattern is applied to the mesh within the specified
+ area.
Parameters
----------
- size : tuple of int
- The size of the mesh to create if no mesh is provided.
- mesh : np.ndarray, optional
- The mesh to which the fibrosis pattern is applied. If None, a new mesh is created
- with the given size.
+ shape : tuple
+ The shape of the mesh.
+ mesh : numpy.ndarray, optional
+ The existing mesh to base the pattern on. Default is None.
Returns
-------
- np.ndarray
- The mesh with the applied diffuse fibrosis pattern.
+ numpy.ndarray
+ A new mesh array with the applied fibrosis pattern.
+
+ Notes
+ -----
+ If both parameters are provided, first non-None parameter is used.
"""
- if mesh is None:
- mesh = np.zeros(size)
- # Apply the fibrosis pattern to the specified area of the mesh
- msh_area = mesh[self.x1:self.x2, self.y1:self.y2]
- fib_area = np.random.uniform(size=[self.x2-self.x1, self.y2-self.y1])
- fib_area = np.where(fib_area < self.dens, 2, msh_area)
- mesh[self.x1:self.x2, self.y1:self.y2] = fib_area
+ if shape is None and mesh is None:
+ message = "Either shape or mesh must be provided."
+ raise ValueError(message)
+ if shape is not None:
+ mesh = np.ones(shape, dtype=np.int8)
+ fibr = self._generate(mesh.shape)
+ mesh[self.x1: self.x2, self.y1: self.y2] = fibr[self.x1: self.x2,
+ self.y1: self.y2]
+ return mesh
+
+ fibr = self._generate(mesh.shape)
+ mesh[self.x1: self.x2, self.y1: self.y2] = fibr[self.x1: self.x2,
+ self.y1: self.y2]
return mesh
+
+ def _generate(self, shape):
+ return 1 + (np.random.random(shape) <= self.density).astype(np.int8)
diff --git a/finitewave/cpuwave2D/fibrosis/scar_gauss_2d_pattern.py b/finitewave/cpuwave2D/fibrosis/scar_gauss_2d_pattern.py
deleted file mode 100755
index 9cdfd02..0000000
--- a/finitewave/cpuwave2D/fibrosis/scar_gauss_2d_pattern.py
+++ /dev/null
@@ -1,81 +0,0 @@
-import numpy as np
-
-from finitewave.core.fibrosis.fibrosis_pattern import FibrosisPattern
-
-
-class ScarGauss2DPattern(FibrosisPattern):
- """
- Class for generating a 2D fibrosis pattern using a Gaussian distribution.
-
- Attributes
- ----------
- mean : list of float
- The mean values for the Gaussian distribution in the x and y dimensions.
- std : list of float
- The standard deviations for the Gaussian distribution in the x and y dimensions.
- corr : float
- The correlation coefficient between the x and y dimensions of the Gaussian distribution.
- size : tuple of int
- The size of the Gaussian distribution sample.
-
- Methods
- -------
- generate(size, mesh=None):
- Generates the Gaussian fibrosis pattern and updates the provided mesh. If no mesh is provided,
- a new mesh is created with the given size.
- """
-
- def __init__(self, mean, std, corr, size):
- """
- Initializes the ScarGauss2DPattern with the specified parameters.
-
- Parameters
- ----------
- mean : list of float
- The mean values for the Gaussian distribution in the x and y dimensions.
- std : list of float
- The standard deviations for the Gaussian distribution in the x and y dimensions.
- corr : float
- The correlation coefficient between the x and y dimensions of the Gaussian distribution.
- size : tuple of int
- The size of the Gaussian distribution sample.
- """
- self.mean = mean
- self.std = std
- self.corr = corr
- self.size = size
-
- def generate(self, size, mesh=None):
- """
- Generates and applies the Gaussian fibrosis pattern to the mesh.
-
- If no mesh is provided, a new mesh of zeros with the given size is created. The method
- generates a Gaussian distribution of fibrosis locations and applies them to the mesh.
-
- Parameters
- ----------
- size : tuple of int
- The size of the mesh to create if no mesh is provided.
- mesh : np.ndarray, optional
- The mesh to which the fibrosis pattern is applied. If None, a new mesh is created
- with the given size.
-
- Returns
- -------
- np.ndarray
- The mesh with the applied Gaussian fibrosis pattern.
- """
- if mesh is None:
- mesh = np.zeros(size)
-
- # Define covariance matrix for the Gaussian distribution
- covs = [[self.std[0]**2, self.std[0]*self.std[1]*self.corr],
- [self.std[0]*self.std[1]*self.corr, self.std[1]**2]]
-
- # Sample from the multivariate normal distribution
- nrm = np.random.multivariate_normal(self.mean, covs, self.size).T
-
- # Apply the Gaussian fibrosis pattern to the mesh
- mesh[nrm[0].astype(int), nrm[1].astype(int)] = 2
-
- return mesh
diff --git a/finitewave/cpuwave2D/fibrosis/scar_rect_2d_pattern.py b/finitewave/cpuwave2D/fibrosis/scar_rect_2d_pattern.py
deleted file mode 100755
index 2e936a2..0000000
--- a/finitewave/cpuwave2D/fibrosis/scar_rect_2d_pattern.py
+++ /dev/null
@@ -1,74 +0,0 @@
-import numpy as np
-
-from finitewave.core.fibrosis.fibrosis_pattern import FibrosisPattern
-
-
-class ScarRect2DPattern(FibrosisPattern):
- """
- Class for generating a rectangular fibrosis pattern in a 2D mesh.
-
- Attributes
- ----------
- x1 : int
- The starting x-coordinate of the rectangular region.
- x2 : int
- The ending x-coordinate of the rectangular region.
- y1 : int
- The starting y-coordinate of the rectangular region.
- y2 : int
- The ending y-coordinate of the rectangular region.
-
- Methods
- -------
- generate(size, mesh=None):
- Generates a rectangular fibrosis pattern and updates the provided mesh. If no mesh is provided,
- a new mesh is created with the given size.
- """
-
- def __init__(self, x1, x2, y1, y2):
- """
- Initializes the ScarRect2DPattern with the specified rectangular region.
-
- Parameters
- ----------
- x1 : int
- The starting x-coordinate of the rectangular region.
- x2 : int
- The ending x-coordinate of the rectangular region.
- y1 : int
- The starting y-coordinate of the rectangular region.
- y2 : int
- The ending y-coordinate of the rectangular region.
- """
- self.x1 = x1
- self.x2 = x2
- self.y1 = y1
- self.y2 = y2
-
- def generate(self, size, mesh=None):
- """
- Generates and applies a rectangular fibrosis pattern to the mesh.
-
- If no mesh is provided, a new mesh of zeros with the given size is created. The method
- generates a rectangular region of fibrosis and applies it to the mesh.
-
- Parameters
- ----------
- size : tuple of int
- The size of the mesh to create if no mesh is provided.
- mesh : np.ndarray, optional
- The mesh to which the fibrosis pattern is applied. If None, a new mesh is created
- with the given size.
-
- Returns
- -------
- np.ndarray
- The mesh with the applied rectangular fibrosis pattern.
- """
- if mesh is None:
- mesh = np.zeros(size)
-
- # Apply the rectangular fibrosis pattern to the mesh
- mesh[self.x1:self.x2, self.y1:self.y2] = 2
-
- return mesh
diff --git a/finitewave/cpuwave2D/fibrosis/structural_2d_pattern.py b/finitewave/cpuwave2D/fibrosis/structural_2d_pattern.py
index 0957a49..e8edb59 100755
--- a/finitewave/cpuwave2D/fibrosis/structural_2d_pattern.py
+++ b/finitewave/cpuwave2D/fibrosis/structural_2d_pattern.py
@@ -21,21 +21,15 @@ class Structural2DPattern(FibrosisPattern):
The starting y-coordinate of the area where blocks can be placed.
y2 : int
The ending y-coordinate of the area where blocks can be placed.
- dens : float
+ density : float
The density of the fibrosis blocks, represented as a probability.
length_i : int
The width of each block.
length_j : int
The height of each block.
-
- Methods
- -------
- generate(size, mesh=None):
- Generates and applies a structural fibrosis pattern to the mesh. If no mesh is provided,
- a new mesh is created with the given size.
"""
- def __init__(self, x1, x2, y1, y2, dens, length_i, length_j):
+ def __init__(self, density, length_i, length_j, x1, x2, y1, y2):
"""
Initializes the Structural2DPattern with the specified parameters.
@@ -49,7 +43,7 @@ def __init__(self, x1, x2, y1, y2, dens, length_i, length_j):
The starting y-coordinate of the area where blocks can be placed.
y2 : int
The ending y-coordinate of the area where blocks can be placed.
- dens : float
+ density : float
The density of the fibrosis blocks, represented as a probability.
length_i : int
The width of each block.
@@ -60,37 +54,51 @@ def __init__(self, x1, x2, y1, y2, dens, length_i, length_j):
self.x2 = x2
self.y1 = y1
self.y2 = y2
- self.dens = dens
+ self.density = density
self.length_i = length_i
self.length_j = length_j
- def generate(self, size, mesh=None):
+ def generate(self, shape=None, mesh=None):
"""
Generates and applies a structural fibrosis pattern to the mesh.
The mesh is divided into blocks of size `length_i` by `length_j`, with each block having
- a probability `dens` of being filled with fibrosis. The function ensures that blocks do not
+ a probability `density` of being filled with fibrosis. The function ensures that blocks do not
extend beyond the specified region.
Parameters
----------
- size : tuple of int
- The size of the mesh to create if no mesh is provided.
- mesh : np.ndarray, optional
- The mesh to which the fibrosis pattern is applied. If None, a new mesh is created
- with the given size.
+ shape : tuple
+ The shape of the mesh.
+ mesh : numpy.ndarray, optional
+ The existing mesh to base the pattern on. Default is None..
Returns
-------
- np.ndarray
- The mesh with the applied structural fibrosis pattern.
+ numpy.ndarray
+ A new mesh array with the applied fibrosis pattern.
"""
- if mesh is None:
- mesh = np.zeros(size)
+ if shape is None and mesh is None:
+ message = "Either shape or mesh must be provided."
+ raise ValueError(message)
+
+ if shape is not None:
+ mesh = np.ones(shape, dtype=np.int8)
+ fibr = self._generate(mesh.shape)
+ mesh[self.x1: self.x2, self.y1: self.y2] = fibr[self.x1: self.x2,
+ self.y1: self.y2]
+ return mesh
+
+ fibr = self._generate(mesh.shape)
+ mesh[self.x1: self.x2, self.y1: self.y2] = fibr[self.x1: self.x2,
+ self.y1: self.y2]
+ return mesh
+ def _generate(self, shape):
+ mesh = np.ones(shape, dtype=np.int8)
for i in range(self.x1, self.x2, self.length_i):
for j in range(self.y1, self.y2, self.length_j):
- if random.random() <= self.dens:
+ if random.random() <= self.density:
i_s = 0
j_s = 0
if i + self.length_i <= self.x2:
@@ -103,6 +111,6 @@ def generate(self, size, mesh=None):
else:
j_s = self.length_j - (j + self.length_j - self.y2)
- mesh[i:i + i_s, j:j + j_s] = 2
+ mesh[i:i + i_s, j:j + j_s] = 2 # fibrosis element
return mesh
diff --git a/finitewave/cpuwave2D/model/__init__.py b/finitewave/cpuwave2D/model/__init__.py
index 32f3af1..42a87cd 100755
--- a/finitewave/cpuwave2D/model/__init__.py
+++ b/finitewave/cpuwave2D/model/__init__.py
@@ -1,10 +1,8 @@
-from finitewave.cpuwave2D.model.diffuse_kernels_2d import diffuse_kernel_2d_iso, diffuse_kernel_2d_aniso, _parallel
-
-from finitewave.cpuwave2D.model.aliev_panfilov_2d.aliev_panfilov_2d import AlievPanfilov2D
-from finitewave.cpuwave2D.model.aliev_panfilov_2d.aliev_panfilov_kernels_2d import AlievPanfilovKernels2D
-
-from finitewave.cpuwave2D.model.luo_rudy91_2d.luo_rudy91_2d import LuoRudy912D
-from finitewave.cpuwave2D.model.luo_rudy91_2d.luo_rudy91_kernels_2d import LuoRudy91Kernels2D
-
-from finitewave.cpuwave2D.model.tp06_2d.tp06_2d import TP062D
-from finitewave.cpuwave2D.model.tp06_2d.tp06_kernels_2d import TP06Kernels2D
+from .aliev_panfilov_2d import AlievPanfilov2D
+from .barkley_2d import Barkley2D
+from .mitchell_schaeffer_2d import MitchellSchaeffer2D
+from .fenton_karma_2d import FentonKarma2D
+from .bueno_orovio_2d import BuenoOrovio2D
+from .luo_rudy91_2d import LuoRudy912D
+from .tp06_2d import TP062D
+from .courtemanche_2d import Courtemanche2D
diff --git a/finitewave/cpuwave2D/model/aliev_panfilov_2d.py b/finitewave/cpuwave2D/model/aliev_panfilov_2d.py
new file mode 100755
index 0000000..fc49db8
--- /dev/null
+++ b/finitewave/cpuwave2D/model/aliev_panfilov_2d.py
@@ -0,0 +1,203 @@
+import numpy as np
+from numba import njit, prange
+
+from finitewave.core.model.cardiac_model import CardiacModel
+from finitewave.cpuwave2D.stencil.asymmetric_stencil_2d import (
+ AsymmetricStencil2D
+)
+from finitewave.cpuwave2D.stencil.isotropic_stencil_2d import (
+ IsotropicStencil2D
+)
+
+
+class AlievPanfilov2D(CardiacModel):
+ """
+ Two-dimensional implementation of the Aliev–Panfilov model of cardiac excitation.
+
+ The Aliev–Panfilov model is a phenomenological two-variable model designed to
+ reproduce basic features of cardiac excitation, including wave propagation and
+ reentry, while remaining computationally efficient. It uses a single recovery
+ variable coupled with a cubic nonlinearity to simulate action potential dynamics
+ in excitable media.
+
+ Attributes
+ ----------
+ u : np.ndarray
+ Transmembrane potential (dimensionless, normalized to [0,1]).
+ v : np.ndarray
+ Recovery variable describing refractoriness.
+ D_model : float
+ Diffusion coefficient used for simulating spatial propagation.
+ state_vars : list of str
+ Names of the state variables to be saved and restored.
+ npfloat : str
+ Floating-point precision used in the simulation (default: 'float64').
+
+ Model Parameters
+ ----------------
+ a : float
+ Excitability threshold parameter.
+ k : float
+ Strength of the nonlinear source term (governs spike shape).
+ eap : float
+ Baseline recovery rate.
+ mu_1 : float
+ Recovery rate coefficient (scales v feedback).
+ mu_2 : float
+ Recovery rate offset (modulates u-dependence of recovery).
+
+ Paper
+ -----
+ Rubin R. Aliev, Alexander V. Panfilov,
+ A simple two-variable model of cardiac excitation,
+ Chaos, Solitons & Fractals,
+ Volume 7, Issue 3,
+ 1996,
+ Pages 293-301,
+ ISSN 0960-0779,
+ https://doi.org/10.1016/0960-0779(95)00089-5.
+
+ Attributes
+ ----------
+ v : np.ndarray
+ Array for the recovery variable.
+ w : np.ndarray
+ Array for diffusion weights.
+ D_model : float
+ Model specific diffusion coefficient
+ state_vars : list
+ List of state variables to be saved and restored.
+ npfloat : str
+ Data type used for floating-point operations, default is 'float64'.
+ """
+
+ def __init__(self):
+ """
+ Initializes the AlievPanfilov2D instance with default parameters.
+ """
+ super().__init__()
+ self.v = np.ndarray
+
+ self.D_model = 1.
+
+ self.state_vars = ["u", "v"]
+ self.npfloat = 'float64'
+
+ # model parameters
+ self.a = 0.1
+ self.k = 8.0
+ self.eap = 0.01
+ self.mu_1 = 0.2
+ self.mu_2 = 0.3
+
+ # initial conditions
+ self.init_u = 0.0
+ self.init_v = 0.0
+
+ def initialize(self):
+ """
+ Initializes the model for simulation.
+ """
+ super().initialize()
+ self.u = self.init_u * np.ones_like(self.u, dtype=self.npfloat)
+ self.v = self.init_v * np.ones_like(self.u, dtype=self.npfloat)
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel for the Aliev-Panfilov model.
+ """
+ ionic_kernel_2d(self.u_new, self.u, self.v, self.cardiac_tissue.myo_indexes, self.dt,
+ self.a, self.k, self.eap, self.mu_1, self.mu_2)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue2D
+ A tissue object representing the cardiac tissue.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to use for diffusion computations.
+ """
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil2D()
+
+ return AsymmetricStencil2D()
+
+@njit
+def calc_v(v, u, dt, a, k, eap, mu_1, mu_2):
+ """
+ Computes the update of the recovery variable v for the Aliev–Panfilov model.
+
+ This function implements the ordinary differential equation governing the
+ evolution of the recovery variable `v`, which models the refractoriness of
+ the cardiac tissue. The rate of recovery depends on both `v` and `u`, with a
+ nonlinear interaction term involving a cubic expression in `u`.
+
+ Parameters
+ ----------
+ v : float
+ Current value of the recovery variable.
+ u : float
+ Current value of the transmembrane potential.
+ dt : float
+ Time step for integration.
+ a : float
+ Excitability threshold.
+ k : float
+ Strength of the nonlinear source term.
+ eap : float
+ Baseline recovery rate.
+ mu_1 : float
+ Recovery scaling parameter.
+ mu_2 : float
+ Offset parameter for recovery rate.
+
+ Returns
+ -------
+ float
+ Updated value of the recovery variable `v`.
+ """
+
+ v += (- dt * (eap + (mu_1 * v) / (mu_2 + u)) *
+ (v + k * u * (u - a - 1.)))
+ return v
+
+
+@njit(parallel=True)
+def ionic_kernel_2d(u_new, u, v, indexes, dt, a, k, eap, mu_1, mu_2):
+ """
+ Computes the ionic kernel for the Aliev-Panfilov 2D model.
+
+ Parameters
+ ----------
+ u_new : np.ndarray
+ Array to store the updated action potential values.
+ u : np.ndarray
+ Current action potential array.
+ v : np.ndarray
+ Recovery variable array.
+ indexes : np.ndarray
+ Array of indices where the kernel should be computed (``mesh == 1``).
+ dt : float
+ Time step for the simulation.
+ """
+
+ n_j = u.shape[1]
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = int(ii / n_j)
+ j = ii % n_j
+
+ v[i, j] = calc_v(v[i, j], u[i, j], dt, a, k, eap, mu_1, mu_2)
+
+ u_new[i, j] += dt * (- k * u[i, j] * (u[i, j] - a) * (u[i, j] - 1.) -
+ u[i, j] * v[i, j])
+
diff --git a/finitewave/cpuwave2D/model/aliev_panfilov_2d/__init__.py b/finitewave/cpuwave2D/model/aliev_panfilov_2d/__init__.py
deleted file mode 100644
index 479ebc4..0000000
--- a/finitewave/cpuwave2D/model/aliev_panfilov_2d/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from finitewave.cpuwave2D.model.aliev_panfilov_2d.aliev_panfilov_2d import AlievPanfilov2D
diff --git a/finitewave/cpuwave2D/model/aliev_panfilov_2d/aliev_panfilov_2d.py b/finitewave/cpuwave2D/model/aliev_panfilov_2d/aliev_panfilov_2d.py
deleted file mode 100755
index 6952e5f..0000000
--- a/finitewave/cpuwave2D/model/aliev_panfilov_2d/aliev_panfilov_2d.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import numpy as np
-
-from finitewave.core.model.cardiac_model import CardiacModel
-from finitewave.cpuwave2D.model.aliev_panfilov_2d.aliev_panfilov_kernels_2d import AlievPanfilovKernels2D
-
-_npfloat = "float64"
-
-
-class AlievPanfilov2D(CardiacModel):
- """
- Implementation of the Aliev-Panfilov 2D cardiac model.
-
- This model simulates the electrical activity in cardiac tissue using the
- Aliev-Panfilov equations. It extends the CardiacModel base class and provides
- methods to initialize the model, run the ionic kernel, and handle simulation state.
-
- Attributes
- ----------
- v : np.ndarray
- Array for the recovery variable.
- w : np.ndarray
- Array for diffusion weights.
- state_vars : list
- List of state variables to be saved and restored.
- npfloat : str
- Data type used for floating-point operations, default is 'float64'.
- diffuse_kernel : function
- Function for performing diffusion computations.
- ionic_kernel : function
- Function for performing ionic computations.
- """
-
- def __init__(self):
- """
- Initializes the AlievPanfilov2D instance with default parameters.
- """
- CardiacModel.__init__(self)
- self.v = np.ndarray
- self.w = np.ndarray
- self.state_vars = ["u", "v"]
- self.npfloat = 'float64'
-
- def initialize(self):
- """
- Initializes the model for simulation.
-
- This method sets up the diffusion and ionic kernel functions, initializes
- arrays for the action potential and recovery variable, and prepares the model
- for simulation. It calls the base class initialization method and sets up
- the diffusion and ionic kernels specific to the Aliev-Panfilov model.
- """
- super().initialize()
- weights_shape = self.cardiac_tissue.weights.shape
- shape = self.cardiac_tissue.mesh.shape
- self.diffuse_kernel = AlievPanfilovKernels2D().get_diffuse_kernel(weights_shape)
- self.ionic_kernel = AlievPanfilovKernels2D().get_ionic_kernel()
- self.v = np.zeros(shape, dtype=self.npfloat)
-
- def run_ionic_kernel(self):
- """
- Executes the ionic kernel for the Aliev-Panfilov model.
-
- This method updates the action potential and recovery variable arrays using
- the ionic kernel function retrieved during initialization.
-
- It applies the Aliev-Panfilov equations to compute the next state of the
- action potential and recovery variable based on the current state of the model.
- """
- self.ionic_kernel(self.u_new, self.u, self.v, self.cardiac_tissue.mesh, self.dt)
diff --git a/finitewave/cpuwave2D/model/aliev_panfilov_2d/aliev_panfilov_kernels_2d.py b/finitewave/cpuwave2D/model/aliev_panfilov_2d/aliev_panfilov_kernels_2d.py
deleted file mode 100644
index a99fed3..0000000
--- a/finitewave/cpuwave2D/model/aliev_panfilov_2d/aliev_panfilov_kernels_2d.py
+++ /dev/null
@@ -1,106 +0,0 @@
-from numba import njit, prange
-
-from finitewave.core.exception.exceptions import IncorrectWeightsShapeError
-from finitewave.cpuwave2D.model.diffuse_kernels_2d import diffuse_kernel_2d_iso, diffuse_kernel_2d_aniso, _parallel
-
-
-@njit(parallel=_parallel)
-def ionic_kernel_2d(u_new, u, v, mesh, dt):
- """
- Computes the ionic kernel for the Aliev-Panfilov 2D model.
-
- This function updates the action potential (u) and recovery variable (v)
- based on the Aliev-Panfilov model equations.
-
- Parameters
- ----------
- u_new : np.ndarray
- Array to store the updated action potential values.
- u : np.ndarray
- Current action potential array.
- v : np.ndarray
- Recovery variable array.
- mesh : np.ndarray
- Tissue mesh array indicating tissue types.
- dt : float
- Time step for the simulation.
- """
- a = 0.1
- k_ = 8.0
- eap = 0.01
- mu_1 = 0.2
- mu_2 = 0.3
-
- n_i = u.shape[0]
- n_j = u.shape[1]
-
- for ii in prange(n_i * n_j):
- i = int(ii / n_j)
- j = ii % n_j
- if mesh[i, j] != 1:
- continue
-
- v[i, j] += (- dt * (eap + (mu_1 * v[i, j]) / (mu_2 + u[i, j])) *
- (v[i, j] + k_ * u[i, j] * (u[i, j] - a - 1.)))
-
- u_new[i, j] += dt * (- k_ * u[i, j] * (u[i, j] - a) * (u[i, j] - 1.) -
- u[i, j] * v[i, j])
-
-
-class AlievPanfilovKernels2D:
- """
- Provides kernel functions for the Aliev-Panfilov 2D model.
-
- This class includes methods for retrieving diffusion and ionic kernels
- specific to the Aliev-Panfilov 2D model.
-
- Methods
- -------
- get_diffuse_kernel(shape)
- Returns the appropriate diffusion kernel function based on the shape of weights.
-
- get_ionic_kernel()
- Returns the ionic kernel function for the Aliev-Panfilov 2D model.
- """
-
- def __init__(self):
- pass
-
- @staticmethod
- def get_diffuse_kernel(shape):
- """
- Retrieves the diffusion kernel function based on the shape of weights.
-
- Parameters
- ----------
- shape : tuple
- The shape of the weights array used for determining the diffusion kernel.
-
- Returns
- -------
- function
- The appropriate diffusion kernel function.
-
- Raises
- ------
- IncorrectWeightsShapeError
- If the shape of the weights array is not recognized.
- """
- if shape[-1] == 5:
- return diffuse_kernel_2d_iso
- if shape[-1] == 9:
- return diffuse_kernel_2d_aniso
- else:
- raise IncorrectWeightsShapeError(shape, 5, 9)
-
- @staticmethod
- def get_ionic_kernel():
- """
- Retrieves the ionic kernel function for the Aliev-Panfilov 2D model.
-
- Returns
- -------
- function
- The ionic kernel function.
- """
- return ionic_kernel_2d
diff --git a/finitewave/cpuwave2D/model/barkley_2d.py b/finitewave/cpuwave2D/model/barkley_2d.py
new file mode 100644
index 0000000..9ca3d2d
--- /dev/null
+++ b/finitewave/cpuwave2D/model/barkley_2d.py
@@ -0,0 +1,166 @@
+import numpy as np
+from numba import njit, prange
+
+from finitewave.core.model.cardiac_model import CardiacModel
+from finitewave.cpuwave2D.stencil.asymmetric_stencil_2d import (
+ AsymmetricStencil2D
+)
+from finitewave.cpuwave2D.stencil.isotropic_stencil_2d import (
+ IsotropicStencil2D
+)
+
+
+class Barkley2D(CardiacModel):
+ """
+ Two-dimensional implementation of the Barkley model for excitable media.
+
+ The Barkley model is a simplified two-variable reaction–diffusion system
+ originally developed to study wave propagation in excitable media. While it is
+ not biophysically detailed, it captures essential qualitative features of
+ cardiac-like excitation dynamics such as spiral waves, wave break, and reentry.
+
+ This implementation is included for benchmarking, educational purposes,
+ and comparison against more detailed cardiac models.
+
+ Attributes
+ ----------
+ u : np.ndarray
+ Excitation variable (analogous to membrane potential).
+ v : np.ndarray
+ Recovery variable controlling excitability.
+ D_model : float
+ Diffusion coefficient for excitation variable.
+ state_vars : list of str
+ Names of variables saved during simulation.
+ npfloat : str
+ Floating-point precision (default: 'float64').
+
+ Model Parameters
+ ----------------
+ a : float
+ Threshold-like parameter controlling excitability.
+ b : float
+ Recovery time scale.
+ eap : float
+ Controls sharpness of the activation term (nonlinear gain).
+
+ Paper
+ -----
+ Barkley, D. (1991).
+ A model for fast computer simulation of waves in excitable media.
+ Physica D: Nonlinear Phenomena, 61-70.
+ https://doi.org/10.1016/0167-2789(86)90198-1.
+
+ """
+
+ def __init__(self):
+ """
+ Initializes the Barkley2D instance with default parameters.
+ """
+ super().__init__()
+ self.v = np.ndarray
+
+ self.D_model = 1.
+
+ self.state_vars = ["u", "v"]
+ self.npfloat = 'float64'
+
+ # model parameters
+ self.a = 0.75
+ self.b = 0.02
+ self.eap = 0.02
+
+ # initial conditions
+ self.init_u = 0.0
+ self.init_v = 0
+
+ def initialize(self):
+ """
+ Initializes the model for simulation.
+ """
+ super().initialize()
+ self.u = self.init_u * np.ones_like(self.u, dtype=self.npfloat)
+ self.v = self.init_v * np.ones_like(self.u, dtype=self.npfloat)
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel for the Barkley model.
+ """
+ ionic_kernel_2d(self.u_new, self.u, self.v, self.cardiac_tissue.myo_indexes, self.dt,
+ self.a, self.b, self.eap)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue2D
+ A tissue object representing the cardiac tissue.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to use for diffusion computations.
+ """
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil2D()
+
+ return AsymmetricStencil2D()
+
+@njit
+def calc_v(v, u, dt):
+ """
+ Updates the recovery variable v for the Barkley model.
+
+ The recovery variable follows a simple linear relaxation toward the
+ excitation variable `u`, simulating return to the resting state after excitation.
+
+ Parameters
+ ----------
+ v : float
+ Current value of the recovery variable.
+ u : float
+ Current value of the excitation variable.
+ dt : float
+ Time step for numerical integration.
+
+ Returns
+ -------
+ float
+ Updated value of the recovery variable.
+ """
+
+ v += dt*(u-v)
+ return v
+
+
+@njit(parallel=True)
+def ionic_kernel_2d(u_new, u, v, indexes, dt, a, b, eap):
+ """
+ Computes the ionic kernel for the Barkley 2D model.
+
+ Parameters
+ ----------
+ u_new : np.ndarray
+ Array to store the updated action potential values.
+ u : np.ndarray
+ Current action potential array.
+ indexes : np.ndarray
+ Array of indices where the kernel should be computed (``mesh == 1``).
+ dt : float
+ Time step for the simulation.
+ """
+
+ n_j = u.shape[1]
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = int(ii / n_j)
+ j = ii % n_j
+
+ v[i, j] = calc_v(v[i, j], u[i, j], dt)
+
+ u_new[i, j] += dt * (u[i, j]*(1 - u[i, j])*(u[i, j] - (v[i, j] + b)/a))/eap
diff --git a/finitewave/cpuwave2D/model/bueno_orovio_2d.py b/finitewave/cpuwave2D/model/bueno_orovio_2d.py
new file mode 100644
index 0000000..ece6666
--- /dev/null
+++ b/finitewave/cpuwave2D/model/bueno_orovio_2d.py
@@ -0,0 +1,476 @@
+import numpy as np
+from numba import njit, prange
+
+from finitewave.core.model.cardiac_model import CardiacModel
+from finitewave.cpuwave2D.stencil.asymmetric_stencil_2d import (
+ AsymmetricStencil2D
+)
+from finitewave.cpuwave2D.stencil.isotropic_stencil_2d import (
+ IsotropicStencil2D
+)
+
+
+class BuenoOrovio2D(CardiacModel):
+
+ def __init__(self):
+ """
+ Two-dimensional implementation of the Bueno-Orovio–Cherry–Fenton (BOCF) model
+ for simulating human ventricular tissue electrophysiology.
+
+ The BOCF model is a minimal phenomenological model developed to capture
+ key ionic mechanisms and reproduce realistic human ventricular action potential
+ dynamics, including restitution, conduction block, and spiral wave behavior.
+ It consists of four variables: transmembrane potential (u), two gating variables (v, w),
+ and one additional slow variable (s), representing calcium-related dynamics.
+
+ This implementation corresponds to the EPI (epicardial) parameter set described in the paper.
+
+ Attributes
+ ----------
+ u : np.ndarray
+ Transmembrane potential (dimensionless, typically in [0, 1.55]).
+ v : np.ndarray
+ Fast gating variable representing sodium channel inactivation.
+ w : np.ndarray
+ Slow recovery variable representing calcium and potassium gating.
+ s : np.ndarray
+ Slow variable related to calcium inactivation.
+ D_model : float
+ Diffusion coefficient for spatial propagation.
+ state_vars : list of str
+ Names of state variables to be saved or restored.
+ npfloat : str
+ Floating point precision (default: 'float64').
+
+ Model Parameters (EPI set)
+ --------------------------
+ u_o : float
+ Resting membrane potential.
+ u_u : float
+ Peak potential (upper bound).
+ theta_v, theta_w : float
+ Activation thresholds for v and w.
+ theta_v_m, theta_o : float
+ Thresholds for switching time constants.
+ tau_v1_m, tau_v2_m : float
+ Time constants for v below/above threshold.
+ tau_v_p : float
+ Decay constant for v.
+ tau_w1_m, tau_w2_m : float
+ Base and transition time constants for w.
+ k_w_m, u_w_m : float
+ Parameters controlling the shape of τw curve.
+ tau_w_p : float
+ Time constant for decay of w above threshold.
+ tau_fi : float
+ Time constant for fast inward current (J_fi).
+ tau_o1, tau_o2 : float
+ Time constants for outward current below/above threshold.
+ tau_so1, tau_so2 : float
+ Time constants for repolarizing tail current.
+ k_so, u_so : float
+ Parameters controlling nonlinearity in tau_so.
+ tau_s1, tau_s2 : float
+ Time constants for the s-gate below/above threshold.
+ k_s, u_s : float
+ Parameters for tanh activation of the s variable.
+ tau_si : float
+ Time constant for slow inward current (J_si).
+ tau_w_inf : float
+ Slope of w∞ below threshold.
+ w_inf_ : float
+ Asymptotic value of w∞ above threshold.
+
+ Paper
+ -----
+ Bueno-Orovio, A., Cherry, E. M., & Fenton, F. H. (2008).
+ Minimal model for human ventricular action potentials in tissue.
+ J Theor Biol., 253(3), 544-60.
+ https://doi.org/10.1016/j.jtbi.2008.03.029
+
+ """
+ super().__init__()
+ self.v = np.ndarray
+ self.w = np.ndarray
+ self.s = np.ndarray
+
+ self.D_model = 1.
+
+ self.state_vars = ["u", "v", "w", "s"]
+ self.npfloat = 'float64'
+
+ # model parameters (EPI)
+
+ self.u_o = 0.0
+ self.u_u = 1.55
+ self.theta_v = 0.3
+ self.theta_w = 0.13
+ self.theta_v_m = 0.006
+ self.theta_o = 0.006
+ self.tau_v1_m = 60
+ self.tau_v2_m = 1150
+ self.tau_v_p = 1.4506
+ self.tau_w1_m = 60
+ self.tau_w2_m = 15
+ self.k_w_m = 65
+ self.u_w_m = 0.03
+ self.tau_w_p = 200
+ self.tau_fi = 0.11
+ self.tau_o1 = 400
+ self.tau_o2 = 6
+ self.tau_so1 = 30.0181
+ self.tau_so2 = 0.9957
+ self.k_so = 2.0458
+ self.u_so = 0.65
+ self.tau_s1 = 2.7342
+ self.tau_s2 = 16
+ self.k_s = 2.0994
+ self.u_s = 0.9087
+ self.tau_si = 1.8875
+ self.tau_w_inf = 0.07
+ self.w_inf_ = 0.94
+
+ # initial conditions
+ self.init_u = 0.0
+ self.init_v = 1.0
+ self.init_w = 1.0
+ self.init_s = 0.0
+
+ def initialize(self):
+ """
+ Initializes the model for simulation.
+ """
+ super().initialize()
+ self.u = self.init_u * np.ones_like(self.u, dtype=self.npfloat)
+ self.v = self.init_v * np.ones_like(self.u, dtype=self.npfloat)
+ self.w = self.init_w * np.ones_like(self.u, dtype=self.npfloat)
+ self.s = self.init_s * np.ones_like(self.u, dtype=self.npfloat)
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel for the Bueno-Orovio model.
+ """
+ ionic_kernel_2d(self.u_new, self.u, self.v, self.w, self.s, self.cardiac_tissue.myo_indexes,
+ self.dt, self.u_o, self.u_u, self.theta_v, self.theta_w, self.theta_v_m,
+ self.theta_o, self.tau_v1_m, self.tau_v2_m, self.tau_v_p,
+ self.tau_w1_m, self.tau_w2_m, self.k_w_m, self.u_w_m,
+ self.tau_w_p, self.tau_fi, self.tau_o1, self.tau_o2,
+ self.tau_so1, self.tau_so2, self.k_so, self.u_so,
+ self.tau_s1, self.tau_s2, self.k_s, self.u_s,
+ self.tau_si, self.tau_w_inf, self.w_inf_)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue2D
+ A tissue object representing the cardiac tissue.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to use for diffusion computations.
+ """
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil2D()
+
+ return AsymmetricStencil2D()
+
+@njit
+def calc_v(v, u, dt, theta_v, v_inf, tau_v_m, tau_v_p):
+ """
+ Updates the fast inactivation gate variable `v`.
+
+ The variable `v` models the fast sodium channel inactivation.
+ It follows a piecewise ODE with different dynamics depending
+ on whether the membrane potential `u` is above or below `theta_v`.
+
+ Parameters
+ ----------
+ v : float
+ Current value of the v gate.
+ u : float
+ Current membrane potential.
+ dt : float
+ Time step.
+ theta_v : float
+ Threshold for switching recovery behavior.
+ v_inf : float
+ Steady-state value of v.
+ tau_v_m : float
+ Time constant for activation (u < threshold).
+ tau_v_p : float
+ Time constant for decay (u >= threshold).
+
+ Returns
+ -------
+ float
+ Updated value of the v gate.
+ """
+ v_ = (v_inf - v)/tau_v_m if (u - theta_v) < 0 else -v/tau_v_p
+ v += dt*v_
+ return v
+
+@njit
+def calc_w(w, u, dt, theta_w, w_inf, tau_w_m, tau_w_p):
+ """
+ Updates the slow gating variable `w`.
+
+ The variable `w` represents calcium/potassium channel gating.
+ It has different recovery dynamics below and above the threshold `theta_w`.
+
+ Parameters
+ ----------
+ w : float
+ Current value of the w gate.
+ u : float
+ Membrane potential.
+ dt : float
+ Time step.
+ theta_w : float
+ Threshold for switching between time constants.
+ w_inf : float
+ Steady-state value of w.
+ tau_w_m : float
+ Time constant for approach to w_inf (u < threshold).
+ tau_w_p : float
+ Time constant for decay (u >= threshold).
+
+ Returns
+ -------
+ float
+ Updated value of the w gate.
+ """
+ w_ = (w_inf - w)/tau_w_m if (u - theta_w) < 0 else -w/tau_w_p
+ w += dt*w_
+ return w
+
+@njit
+def calc_s(s, u, dt, tau_s, k_s, u_s):
+ """
+ Updates the slow variable `s`, related to calcium dynamics.
+
+ The variable `s` evolves toward a tanh-based steady-state function of `u`.
+
+ Parameters
+ ----------
+ s : float
+ Current value of the s variable.
+ u : float
+ Membrane potential.
+ dt : float
+ Time step.
+ tau_s : float
+ Time constant.
+ k_s : float
+ Slope of the tanh function.
+ u_s : float
+ Midpoint of the tanh function.
+
+ Returns
+ -------
+ float
+ Updated value of the s variable.
+ """
+ s += dt*((1 + np.tanh(k_s*(u - u_s)))/2 - s)/tau_s
+ return s
+
+@njit
+def calc_Jfi(u, v, theta_v, u_u, tau_fi):
+ """
+ Computes the fast inward sodium current (J_fi).
+
+ Active when membrane potential exceeds `theta_v`.
+ Models rapid depolarization due to sodium influx.
+
+ Parameters
+ ----------
+ u : float
+ Membrane potential.
+ v : float
+ Fast gating variable.
+ theta_v : float
+ Activation threshold.
+ u_u : float
+ Upper limit for depolarization.
+ tau_fi : float
+ Time constant of the fast inward current.
+
+ Returns
+ -------
+ float
+ Current value of J_fi.
+ """
+ H = 1.0 if (u - theta_v) >= 0 else 0.0
+ return -v*H*(u - theta_v)*(u_u - u)/tau_fi
+
+@njit
+def calc_Jso(u, u_o, theta_w, tau_o, tau_so):
+ """
+ Computes the slow outward current (J_so).
+
+ Consists of a linear repolarization component below `theta_w`
+ and a constant component above.
+
+ Parameters
+ ----------
+ u : float
+ Membrane potential.
+ u_o : float
+ Resting potential (offset).
+ theta_w : float
+ Threshold for switching between components.
+ tau_o : float
+ Time constant below threshold.
+ tau_so : float
+ Time constant above threshold.
+
+ Returns
+ -------
+ float
+ Current value of J_so.
+ """
+ H = 1.0 if (u - theta_w) >= 0 else 0.0
+ return (u - u_o)*(1 - H)/tau_o + H/tau_so
+
+@njit
+def calc_Jsi(u, w, s, theta_w, tau_si):
+ """
+ Computes the slow inward current (J_si), active during plateau phase.
+
+ Active only when `u > theta_w` and controlled by gating variables `w` and `s`.
+
+ Parameters
+ ----------
+ u : float
+ Membrane potential.
+ w : float
+ Slow gating variable.
+ s : float
+ Calcium-related variable.
+ theta_w : float
+ Threshold for activation.
+ tau_si : float
+ Time constant of slow inward current.
+
+ Returns
+ -------
+ float
+ Current value of J_si.
+ """
+ H = 1.0 if (u - theta_w) >= 0 else 0.0
+ return -H*w*s/tau_si
+
+@njit
+def calc_tau_v_m(u, theta_v_m, tau_v1_m, tau_v2_m):
+ """
+ Selects time constant for v gate depending on membrane potential.
+
+ Returns `tau_v1_m` below `theta_v_m`, and `tau_v2_m` above.
+
+ Returns
+ -------
+ float
+ Time constant for v gate.
+ """
+ return tau_v1_m if (u - theta_v_m) < 0 else tau_v2_m
+
+@njit
+def calc_tau_w_m(u, tau_w1_m, tau_w2_m, k_w_m, u_w_m):
+ """
+ Computes smooth transition time constant for w gate using tanh.
+
+ Returns
+ -------
+ float
+ Blended time constant for w gate.
+ """
+ return tau_w1_m + (tau_w2_m - tau_w1_m)*(1 + np.tanh(k_w_m*(u - u_w_m)))/2
+
+@njit
+def calc_tau_so(u, tau_so1, tau_so2, k_so, u_so):
+ """
+ Computes tau_so using a sigmoidal transition between two values.
+ """
+ return tau_so1 + (tau_so2 - tau_so1)*(1 + np.tanh(k_so*(u - u_so)))/2
+
+@njit
+def calc_tau_s(u, tau_s1, tau_s2, theta_w):
+ """
+ Selects tau_s based on threshold.
+ """
+ return tau_s1 if (u - theta_w) < 0 else tau_s2
+
+@njit
+def calc_tau_o(u, tau_o1, tau_o2, theta_o):
+ """
+ Selects tau_o based on threshold.
+ """
+ return tau_o1 if (u - theta_o) < 0 else tau_o2
+
+@njit
+def calc_v_inf(u, theta_v_m):
+ """
+ Computes the value of v based on membrane potential.
+ """
+ return 1.0 if u < theta_v_m else 0.0
+
+@njit
+def calc_w_inf(u, theta_o, tau_w_inf, w_inf_):
+ """
+ Computes the value of w based on membrane potential.
+ """
+ return 1 - u/tau_w_inf if (u - theta_o) < 0 else w_inf_
+
+
+@njit(parallel=True)
+def ionic_kernel_2d(u_new, u, v, w, s, indexes, dt,
+ u_o, u_u, theta_v, theta_w, theta_v_m,
+ theta_o, tau_v1_m, tau_v2_m, tau_v_p,
+ tau_w1_m, tau_w2_m, k_w_m, u_w_m,
+ tau_w_p, tau_fi, tau_o1, tau_o2,
+ tau_so1, tau_so2, k_so, u_so,
+ tau_s1, tau_s2, k_s, u_s,
+ tau_si, tau_w_inf, w_inf_):
+ """
+ Computes the ionic kernel for the Bueno-Orovio 2D model.
+
+ Parameters
+ ----------
+ u_new : np.ndarray
+ Array to store the updated action potential values.
+ u : np.ndarray
+ Current action potential array.
+ indexes : np.ndarray
+ Array of indices where the kernel should be computed (``mesh == 1``).
+ dt : float
+ Time step for the simulation.
+ """
+
+ n_j = u.shape[1]
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = int(ii / n_j)
+ j = ii % n_j
+
+ v[i, j] = calc_v(v[i, j], u[i, j], dt, theta_v, calc_v_inf(u[i, j], theta_v_m),
+ calc_tau_v_m(u[i, j], theta_v_m, tau_v1_m, tau_v2_m), tau_v_p)
+
+ w[i, j] = calc_w(w[i, j], u[i, j], dt, theta_w, calc_w_inf(u[i, j], theta_o, tau_w_inf, w_inf_),
+ calc_tau_w_m(u[i, j], tau_w1_m, tau_w2_m, k_w_m, u_w_m), tau_w_p)
+
+ s[i, j] = calc_s(s[i, j], u[i, j], dt,
+ calc_tau_s(u[i, j], tau_s1, tau_s2, theta_w), k_s, u_s)
+
+ J_fi = calc_Jfi(u[i, j], v[i, j], theta_v, u_u, tau_fi)
+ J_so = calc_Jso(u[i, j], u_o, theta_w,
+ calc_tau_o(u[i, j], tau_o1, tau_o2, theta_o),
+ calc_tau_so(u[i, j], tau_so1, tau_so2, k_so, u_so))
+ J_si = calc_Jsi(u[i, j], w[i, j], s[i, j], theta_w, tau_si)
+
+ u_new[i, j] += dt * (-J_fi - J_so - J_si)
\ No newline at end of file
diff --git a/finitewave/cpuwave2D/model/courtemanche_2d.py b/finitewave/cpuwave2D/model/courtemanche_2d.py
new file mode 100644
index 0000000..9a04c95
--- /dev/null
+++ b/finitewave/cpuwave2D/model/courtemanche_2d.py
@@ -0,0 +1,641 @@
+import numpy as np
+from numba import njit, prange
+
+from finitewave.core.model.cardiac_model import CardiacModel
+from finitewave.cpuwave2D.stencil.asymmetric_stencil_2d import (
+ AsymmetricStencil2D
+)
+from finitewave.cpuwave2D.stencil.isotropic_stencil_2d import (
+ IsotropicStencil2D
+)
+
+
+class Courtemanche2D(CardiacModel):
+ """
+ A class to represent the Courtemanche cardiac model in 2D.
+
+ Attributes
+ ----------
+ D_model : float
+ Model specific diffusion coefficient.
+ state_vars : list of str
+ List of state variable names.
+ """
+
+ def __init__(self):
+ super().__init__()
+ self.D_model = 0.154
+ self.state_vars = ["u", "nai", "ki", "cai", "caup", "carel", "m", "h", "j_",
+ "d", "f", "oa", "oi", "ua", "ui", "xr", "xs", "fca", "irel", "vrel", "urel", "wrel"]
+
+ self.npfloat = 'float64'
+
+ # Model parameters
+ self.gna = 7.8
+ self.gnab = 0.000674
+ self.gk1 = 0.09
+ self.gkr = 0.0294
+ self.gks = 0.129
+ self.gto = 0.1652
+ self.gcal = 0.1238
+ self.gcab = 0.00113
+
+ self.gkur_coeff = 1
+
+ self.F = 96485.0
+ self.T = 310.0
+ self.R = 8314.0
+
+ self.Vc = 20100
+ self.Vj = self.Vc*0.68 # (uL)
+ self.Vup = self.Vj*0.06*0.92
+ self.Vrel = self.Vj*0.06*0.08
+
+ self.ibk = 0.0
+ self.cao = 1.8 # mM
+ self.nao = 140 # mM
+ self.ko = 5.4 # mM
+
+ self.caupmax = 15 # mM/ms
+ self.kup = 0.00092 # mM
+
+ self.kmnai = 10
+ self.kmko = 1.5
+ self.kmnancx = 87.5
+ self.kmcancx = 1.38
+ self.ksatncx = 0.1
+
+ self.kmcmdn = 0.00238
+ self.kmtrpn = 0.0005
+ self.kmcsqn = 0.8
+
+ self.trpnmax = 0.07 # mM
+ self.cmdnmax = 0.05 # mM
+ self.csqnmax = 10.0 # mM
+ self.inacamax = 1600
+ self.inakmax = 0.6
+ self.ipcamax = 0.275
+ self.krel = 30
+
+ self.iupmax = 0.005
+
+ self.kq10 = 3
+
+ # initial conditions
+ self.init_u = -84.5
+ self.init_nai = 11.2
+ self.init_ki = 139
+ self.init_cai = 0.000102
+ self.init_caup = 1.6
+ self.init_carel = 1.1
+ self.init_m = 0.00291
+ self.init_h = 0.965
+ self.init_j = 0.978
+ self.init_d = 0.000137
+ self.init_f = 0.999837
+ self.init_oa = 0.000592
+ self.init_oi = 0.9992
+ self.init_ua = 0.003519
+ self.init_ui = 0.9987
+ self.init_xs = 0.0187
+ self.init_xr = 0.0000329
+ self.init_fca = 0.775
+ self.init_irel = 0
+ self.init_vrel = 1
+ self.init_urel = 0
+ self.init_wrel = 0.9
+
+ def initialize(self):
+ """
+ Initializes the model's state variables and diffusion/ionic kernels.
+
+ Sets up the initial values for membrane potential, ion concentrations,
+ gating variables, and assigns the appropriate kernel functions.
+ """
+ super().initialize()
+ shape = self.cardiac_tissue.mesh.shape
+
+ self.u = self.init_u * np.ones(shape, dtype=self.npfloat) # (mV)
+ self.u_new = self.u.copy() # (mV)
+ self.nai = self.init_nai * np.ones(shape, dtype=self.npfloat) # (mM)
+ self.ki = self.init_ki * np.ones(shape, dtype=self.npfloat) # (mM)
+ self.cai = self.init_cai * np.ones(shape, dtype=self.npfloat) # (mM)
+ self.caup = self.init_caup * np.ones(shape, dtype=self.npfloat) # (mM)
+ self.carel = self.init_carel * np.ones(shape, dtype=self.npfloat) # (mM)
+ self.m = self.init_m * np.ones(shape, dtype=self.npfloat)
+ self.h = self.init_h * np.ones(shape, dtype=self.npfloat)
+ self.j_ = self.init_j * np.ones(shape, dtype=self.npfloat)
+ self.d = self.init_d * np.ones(shape, dtype=self.npfloat)
+ self.f = self.init_f * np.ones(shape, dtype=self.npfloat)
+ self.oa = self.init_oa * np.ones(shape, dtype=self.npfloat)
+ self.oi = self.init_oi * np.ones(shape, dtype=self.npfloat)
+ self.ua = self.init_ua * np.ones(shape, dtype=self.npfloat)
+ self.ui = self.init_ui * np.ones(shape, dtype=self.npfloat)
+ self.xs = self.init_xs * np.ones(shape, dtype=self.npfloat)
+ self.xr =self.init_xr * np.ones(shape, dtype=self.npfloat)
+ self.fca = self.init_fca * np.ones(shape, dtype=self.npfloat)
+ self.irel = self.init_irel * np.ones(shape, dtype=self.npfloat)
+ self.vrel = self.init_vrel * np.ones(shape, dtype=self.npfloat)
+ self.urel = self.init_urel * np.ones(shape, dtype=self.npfloat)
+ self.wrel = self.init_wrel * np.ones(shape, dtype=self.npfloat)
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel function to update ionic currents and state
+ variables
+ """
+ ionic_kernel_2d(self.u_new, self.u, self.nai, self.ki, self.cai, self.caup, self.carel,
+ self.m, self.h, self.j_, self.d, self.f, self.oa, self.oi, self.ua,
+ self.ui, self.xr, self.xs, self.fca, self.irel, self.vrel, self.urel,
+ self.wrel, self.cardiac_tissue.myo_indexes, self.dt,
+ self.gna, self.gnab, self.gk1, self.gkr, self.gks, self.gto, self.gcal,
+ self.gcab, self.gkur_coeff, self.F, self.T, self.R, self.Vc, self.Vj, self.Vup,
+ self.Vrel, self.ibk, self.cao, self.nao, self.ko, self.caupmax,
+ self.kup, self.kmnai, self.kmko, self.kmnancx, self.kmcancx,
+ self.ksatncx, self.kmcmdn, self.kmtrpn, self.kmcsqn, self.trpnmax,
+ self.cmdnmax, self.csqnmax, self.inacamax, self.inakmax,
+ self.ipcamax, self.krel, self.iupmax, self.kq10)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue2D
+ A tissue object representing the cardiac tissue.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to use for diffusion computations.
+ """
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil2D()
+
+ return AsymmetricStencil2D()
+
+@njit
+def safe_exp(x):
+ """
+ Clamps the value of x between -500 and 500 and computes exp(x).
+ """
+ if x > 500:
+ x = 500
+ elif x < -500:
+ x = -500
+ return np.exp(x)
+
+@njit
+def calc_gating_variable(x, x_inf, tau_x, dt):
+ """
+ Calculates the gating variable using the steady-state value and time constant.
+ """
+ return x_inf - (x_inf - x)*np.exp(-dt/tau_x)
+
+@njit
+def calc_cmdn(cmdnmax, kmcmdn, cai):
+ """
+ Calculates the concentration of calmodulin.
+ """
+ cmdn = cmdnmax*cai/(cai + kmcmdn)
+ return cmdn
+
+@njit
+def calc_trpn(trpnmax, kmtrpn, cai):
+ """
+ Calculates the concentration of troponin.
+ """
+ trpn = trpnmax*cai/(cai + kmtrpn)
+ return trpn
+
+@njit
+def calc_csqn(csqnmax, kmcsqn, carel):
+ """
+ Calculates the concentration of calsequestrin.
+ """
+ csqn = csqnmax*carel/(carel + kmcsqn)
+ return csqn
+
+@njit
+def calc_nai(nai, dt, inak, inaca, ibna, ina, F, Vj):
+ """
+ Calculates the intracellular sodium concentration.
+ """
+ dnai = (-3*inak-3*inaca - ibna - ina)/(F*Vj)
+ nai += dt*dnai
+ return nai
+
+@njit
+def calc_ki(ki, dt, inak, ik1, ito, ikur, ikr, iks, ibk, F, Vj):
+ """
+ Calculates the intracellular potassium concentration.
+ """
+ dki = (2*inak - ik1 - ito - ikur - ikr - iks - ibk)/(F*Vj)
+ ki += dt*dki
+ return ki
+
+@njit
+def calc_cai(cai, dt, inaca, ipca, ical, ibca, iup, iupleak, irel, Vrel, Vup, trpnmax, kmtrpn, cmdnmax, kmcmdn, F, Vj):
+ """
+ Calculates the intracellular calcium concentration.
+ """
+ B1 = (2*inaca - ipca - ical - ibca)/(2*F*Vj) + (Vup*(iupleak - iup) + irel*Vrel)/Vj
+ B2 = 1 + (trpnmax*kmtrpn)/((cai + kmtrpn)**2) + (cmdnmax*kmcmdn)/((cai + kmcmdn)**2)
+ dcai = B1/B2
+ cai += dt*dcai
+ # print ("CAI:", cai)
+ return cai
+
+@njit
+def calc_caup(caup, dt, iup, iupleak, itr, Vrel, Vup):
+ """
+ Calculates the calcium concentration in the up compartment.
+ """
+ dcaup = iup - iupleak - itr*(Vrel/Vup)
+ caup += dt*dcaup
+ return caup
+
+@njit
+def calc_carel(carel, dt, itr, irel, csqnmax, kmcsqn):
+ """
+ Calculates the calcium concentration in the release compartment.
+ """
+ dcarel = (itr - irel)/(1 + (csqnmax*kmcsqn)/((carel + kmcsqn)**2))
+ carel += dt*dcarel
+ return carel
+
+@njit
+def calc_equilibrum_potentials(nai, nao, ki, ko, cai, cao, R, T, F):
+ """
+ Calculates the equilibrum potentials for the cell.
+ """
+ ena = (R*T/F)*np.log(nao/nai)
+
+ ek = (R*T/F)*np.log(ko/ki)
+
+ eca = (R*T/(2*F))*np.log(cao/cai)
+ return ena, ek, eca
+
+@njit
+def calc_ina(u, m, h, j, gna, ena):
+ """
+ Calculates the fast sodium current.
+ """
+ ina = gna*(m**3)*h*j*(u - ena)
+ return ina
+
+@njit
+def calc_gating_m(m, u, dt):
+ """
+ Calculates the gating variable m for the fast sodium current.
+ """
+ am = 0
+ if u == -47.13:
+ am = 3.2
+ else:
+ am = 0.32 * (u + 47.13) / (1 - np.exp(-0.1 * (u + 47.13)))
+
+ bm = 0.08*np.exp(-u/11)
+ m_inf = am/(am + bm)
+ tau_m = 1/(am + bm)
+ m = calc_gating_variable(m, m_inf, tau_m, dt)
+
+ return m
+
+@njit
+def calc_gating_h(h, u, dt):
+ """
+ Calculates the gating variable h for the fast sodium current.
+ """
+ ah = 0.135*np.exp(-(80 + u)/6.8)
+ bh = 3.56*np.exp(0.079*u) + 310000*np.exp(0.35*u)
+ if u >= -40:
+ ah = 0
+ bh = 1/(0.13*(1 + np.exp(-(u + 10.66)/11.1)))
+
+ h_inf = ah/(ah + bh)
+ tau_h = 1/(ah + bh)
+ h = calc_gating_variable(h, h_inf, tau_h, dt)
+ return h
+
+@njit
+def calc_gating_j(j, u, dt):
+ """
+ Calculates the gating variable j for the fast sodium current.
+ """
+
+ aj = (-127140*np.exp(0.2444*u) - 0.00003474*np.exp(-0.04391*u))*(u + 37.78)/(1 + np.exp(0.311*(u + 79.23)))
+ bj = 0.1212*np.exp(-0.01052*u)/(1 + np.exp(-0.1378*(u + 40.14)))
+ if u >= -40:
+ aj = 0
+ bj = 0.3*np.exp(-0.0000002535*u)/(1 + np.exp(-0.1*(u + 32)))
+ j_inf = aj/(aj + bj)
+ tau_j = 1/(aj + bj)
+ j = j_inf - (j_inf - j)*np.exp(-dt/tau_j)
+ return j
+
+@njit
+def calc_ik1(u, gk1, ek):
+ """
+ Calculates the time-independent potassium current.
+ """
+ ik1 = gk1*(u - ek)/(1 + np.exp(0.07*(u + 80)))
+ return ik1
+
+@njit
+def calc_ito(u, dt, kq10, oa, oi, gto, ek):
+ """
+ Calculates the transient outward potassium current.
+ """
+ ao = 0.65/(np.exp(-(u + 10)/8.5) + np.exp(-(u - 30)/59.0))
+ bo = 0.65/(2.5 + np.exp((u + 82)/17.0))
+
+ tau_o = 1/(kq10*(ao + bo))
+ o_inf = 1/(1 + np.exp(-(u + 20.47)/17.54))
+
+ aoi = 1/(18.53 + np.exp((u + 113.7)/10.95))
+ boi = 1/(35.56 + np.exp(-(u + 1.26)/7.44))
+
+ tau_oi = 1/(kq10*(aoi + boi))
+ oi_inf = 1/(1 + np.exp((u + 43.1)/5.3))
+
+ oa = calc_gating_variable(oa, o_inf, tau_o, dt)
+ oi = calc_gating_variable(oi, oi_inf, tau_oi, dt)
+
+ ito = gto*(oa**3)*oi*(u - ek)
+
+ return ito, oa, oi
+
+@njit
+def calc_ikur(u, dt, kq10, ua, ui, ek, gkur_coeff):
+ """
+ Calculates the ultra-rapid delayed rectifier potassium current.
+ """
+ gkur = 0.005 + 0.05/(1 + np.exp(-(u - 15)/13.0))
+
+ aua = 0.65/(np.exp(-(u + 10)/8.5) + np.exp(-(u - 30)/59.0))
+ bua = 0.65/(2.5 + np.exp((u + 82)/17.0))
+ tau_ua = 1/(kq10*(aua + bua))
+ ua_inf = 1/(1 + np.exp(-(u + 30.3)/9.6))
+ aui = 1/(21 + np.exp(-(u - 185)/28.0))
+ bui = np.exp((u - 158)/16.0)
+
+ tau_ui = 1/(kq10*(aui + bui))
+ ui_inf = 1/(1 + np.exp((u - 99.45)/27.48))
+
+ ua = calc_gating_variable(ua, ua_inf, tau_ua, dt)
+ ui = calc_gating_variable(ui, ui_inf, tau_ui, dt)
+
+ ikur = gkur_coeff*gkur*(ua**3)*ui*(u - ek)
+
+ return ikur, ua, ui
+
+@njit
+def calc_ikr(u, dt, xr, gkr, ek):
+ """
+ Calculates the rapid delayed rectifier potassium current.
+ """
+ gkr = 0.0294 # * np.sqrt(ko / 5.4)
+ axr = 0.0003*(u + 14.1)/(1 - np.exp(-(u + 14.1)/5))
+ bxr = 0.000073898*(u - 3.3328)/(np.exp((u - 3.3328)/5.1237) - 1)
+
+ tau_xr = 1/(axr + bxr)
+ xr_inf = 1/(1 + np.exp(-(u + 14.1)/6.5))
+
+ xr = calc_gating_variable(xr, xr_inf, tau_xr, dt)
+
+ ikr = (gkr*xr*(u - ek))/(1 + np.exp((u + 15)/22.4))
+
+ return ikr, xr
+
+@njit
+def calc_iks(u, dt, xs, gks, ek):
+ """
+ Calculates the slow delayed rectifier potassium current.
+ """
+ axs = 0.00004*(u - 19.9)/(1 - np.exp(-(u - 19.9)/17))
+ bxs = 0.000035*(u - 19.9)/(np.exp((u - 19.9)/9) - 1)
+
+ tau_xs = 1/(2*(axs + bxs))
+ xs_inf = 1/np.sqrt(1 + np.exp(-(u - 19.9)/12.7))
+
+ xs = calc_gating_variable(xs, xs_inf, tau_xs, dt)
+
+ iks = gks*(xs**2)*(u - ek)
+
+ return iks, xs
+
+@njit
+def calc_ical(u, dt, d, f, cai, gcal, fca, eca):
+ """
+ Calculates the L-type calcium current.
+ """
+ tau_d = (1 - np.exp(-(u + 10)/6.24))/(0.035*(u + 10)*(1 + np.exp(-(u + 10)/6.24)))
+ d_inf = 1/(1 + np.exp(-(u + 10)/8.0))
+
+ tau_f = 9/(0.0197*np.exp(-(0.0337**2)*((u + 10)**2)) + 0.02)
+ f_inf = 1/(1 + np.exp((u + 28)/6.9))
+
+ tau_fca = 2
+ fca_inf = 1/(1 + cai/0.00035)
+
+ d = calc_gating_variable(d, d_inf, tau_d, dt)
+ f = calc_gating_variable(f, f_inf, tau_f, dt)
+ fca = calc_gating_variable(fca, fca_inf, tau_fca, dt)
+
+ ical = gcal*d*f*fca*(u - 65)
+
+ return ical, d, f, fca
+
+@njit
+def calc_inak(inakmax, nai, nao, ko, kmnai, kmko, F, u, R, T):
+ """
+ Calculates the sodium-potassium pump current.
+ """
+ s = (1/7.0)*(np.exp(nao/67.3) - 1)
+ fnak = 1/(1 + 0.1245*np.exp(-0.1*(F*u)/(R*T)) + 0.0365*s*np.exp(-(F*u)/(R*T)))
+
+ inak = inakmax*fnak*(1/(1 + (kmnai/nai)**1.5))*(ko/(ko + kmko))
+
+ return inak
+
+@njit
+def calc_inaca(inacamax, nai, nao, cai, cao, kmnancx, kmcancx, ksatncx, F, u, R, T):
+ """
+ Calculates the sodium-calcium exchanger current.
+ """
+ gamma = 0.35
+
+ # Exponential terms with clamping
+ exp_term = np.exp(gamma * (F * u) / (R * T))
+ exp_rev_term = np.exp((gamma - 1) * (F * u) / (R * T))
+
+ # Numerator
+ numerator = inacamax * (exp_term * nai**3 * cao - exp_rev_term * nao**3 * cai)
+
+ # Denominator
+ term1 = (kmnancx**3 + nao**3) # (K_m,Na^3 + [Na+]_i^3)
+ term2 = (kmcancx + cao) # (K_m,Ca + [Ca2+]_o)
+ term3 = (1 + ksatncx * exp_rev_term) # (1 + k_sat * exp(...))
+
+ denominator = term1 * term2 * term3
+
+ # Calculate INaCa
+ inaca = numerator / denominator
+
+ return inaca
+
+
+@njit
+def calc_ibca(gcab, eca, u):
+ """
+ Calculates the background calcium current.
+ """
+ ibca = gcab*(u - eca)
+ return ibca
+
+@njit
+def calc_ibna(gnab, ena, u):
+ """
+ Calculates the background sodium current.
+ """
+ ibna = gnab*(u - ena)
+ return ibna
+
+@njit
+def calc_ipca(ipcamax, cai):
+ """
+ Calculates the sarcolemmal calcium pump current.
+ """
+ ipca = ipcamax*cai/(cai + 0.0005)
+ return ipca
+
+@njit
+def calc_irel(dt, urel, vrel, irel, wrel, ical, inaca, krel, carel, cai, u, F, Vrel):
+ """
+ Calculates the calcium release from the JSR.
+ """
+ tau_u = 8
+
+ Fn = 1e-12*Vrel*irel - ((5*1e-13)/F)*(0.5*ical - 0.2*inaca)
+
+ u_inf = 1/(1 + np.exp(-(Fn - 3.4175e-13)/13.67e-16))
+
+ tau_v = 1.91 + 2.09/(1 + np.exp(-(Fn - 3.4175e-13)/13.67e-16))
+ v_inf = 1 - 1/(1 + np.exp(-(Fn - 6.835e-14)/13.67e-16))
+
+ tau_w = 6 * (1 - np.exp(-(u - 7.9) / 5.0)) / ((1 + 0.3 * np.exp(-(u - 7.9) / 5.0)) * (u - 7.9))
+ w_inf = 1 - 1/(1 + np.exp(-(u - 40)/17.0))
+
+ urel = calc_gating_variable(urel, u_inf, tau_u, dt)
+ vrel = calc_gating_variable(vrel, v_inf, tau_v, dt)
+ wrel = calc_gating_variable(wrel, w_inf, tau_w, dt)
+
+ irel = krel*(urel**2)*vrel*wrel*(carel - cai)
+
+ return irel, urel, vrel, wrel
+
+@njit
+def calc_itr(caup, carel):
+ """
+ Calculates the transfer of calcium from the NSR to the JSR.
+ """
+ tautr = 180
+ itr = (caup - carel)/tautr
+ return itr
+
+@njit
+def calc_iup(iupmax, cai, kup):
+ """
+ Calculates the uptake of calcium into the NSR.
+ """
+ iup = iupmax/(1 + (kup/cai))
+ return iup
+
+@njit
+def calc_iupleak(caup, caupmax, iupmax):
+ """
+ Calculates the leak of calcium from the NSR.
+ """
+ iupleak = (caup/caupmax)*iupmax
+ return iupleak
+
+
+
+@njit(parallel=True)
+def ionic_kernel_2d(u_new, u, nai, ki, cai, caup, carel, m, h, j_, d, f, oa, oi, ua, ui, xs, xr, fca, irel, vrel, urel, wrel, indexes, dt,
+ gna, gnab, gk1, gkr, gks, gto, gcal, gcab, gkur_coeff, F, T, R, Vc, Vj, Vup, Vrel, ibk, cao, nao, ko, caupmax, kup,
+ kmnai, kmko, kmnancx, kmcancx, ksatncx, kmcmdn, kmtrpn, kmcsqn, trpnmax, cmdnmax, csqnmax, inacamax,
+ inakmax, ipcamax, krel, iupmax, kq10):
+ """
+ Computes the ionic currents and updates the state variables in the 2D
+ Courtemanche cardiac model.
+
+ Parameters
+ ----------
+ u_new : np.ndarray
+ Updated membrane potential values.
+ u : np.ndarray
+ Current membrane potential values.
+ v : np.ndarray
+ Recovery variable array.
+ indexes : np.ndarray
+ Array of indices where the kernel should be computed (``mesh == 1``).
+ dt : float
+ Time step for the simulation.
+ """
+
+ n_i = u.shape[0]
+ n_j = u.shape[1]
+
+ for ind in prange(indexes.shape[0]):
+ ii = indexes[ind]
+ i = int(ii/n_j)
+ j = ii % n_j
+
+ ena, ek, eca = calc_equilibrum_potentials(nai[i, j], nao, ki[i, j], ko, cai[i, j], cao, R, T, F)
+
+ m[i, j] = calc_gating_m(m[i, j], u[i, j], dt)
+ h[i, j] = calc_gating_h(h[i, j], u[i, j], dt)
+ j_[i, j] = calc_gating_j(j_[i, j], u[i, j], dt)
+
+ ina = calc_ina(u[i, j], m[i, j], h[i, j], j_[i, j], gna, ena)
+
+ ik1 = calc_ik1(u[i, j], gk1, ek)
+
+ ito, oa[i, j], oi[i, j] = calc_ito(u[i, j], dt, kq10, oa[i, j], oi[i, j], gto, ek)
+
+ ikur, ua[i, j], ui[i, j] = calc_ikur(u[i, j], dt, kq10, ua[i, j], ui[i, j], ek, gkur_coeff)
+
+ ikr, xr[i, j] = calc_ikr(u[i, j], dt, xr[i, j], gkr, ek)
+
+ iks, xs[i, j] = calc_iks(u[i, j], dt, xs[i, j], gks, ek)
+
+ ical, d[i, j], f[i, j], fca[i, j] = calc_ical(u[i, j], dt, d[i, j], f[i, j], cai[i, j], gcal, fca[i, j], eca)
+
+ inak = calc_inak(inakmax, nai[i, j], nao, ko, kmnai, kmko, F, u[i, j], R, T)
+ inaca = calc_inaca(inacamax, nai[i, j], nao, cai[i, j], cao, kmnancx, kmcancx, ksatncx, F, u[i, j], R, T)
+
+ ibca = calc_ibca(gcab, eca, u[i, j])
+
+ ibna = calc_ibna(gnab, ena, u[i, j])
+
+ ipca = calc_ipca(ipcamax, cai[i, j])
+
+ irel[i, j], urel[i, j], vrel[i, j], wrel[i, j] = calc_irel(dt, urel[i, j], vrel[i, j], irel[i, j], wrel[i, j], ical, inaca, krel, carel[i, j], cai[i, j], u[i, j], F, Vrel)
+ itr = calc_itr(caup[i, j], carel[i, j])
+ iup = calc_iup(iupmax, cai[i, j], kup)
+ iupleak = calc_iupleak(caup[i, j], caupmax, iupmax)
+
+ caup[i, j] = calc_caup(caup[i, j], dt, iup, iupleak, itr, Vrel, Vup)
+ nai[i, j] = calc_nai(nai[i, j], dt, inak, inaca, ibna, ina, F, Vj)
+
+ ki[i, j] = calc_ki(ki[i, j], dt, inak, ik1, ito, ikur, ikr, iks, ibk, F, Vj)
+ cai[i, j] = calc_cai(cai[i, j], dt, inaca, ipca, ical, ibca, iup, iupleak, irel[i, j], Vrel, Vup, trpnmax, kmtrpn, cmdnmax, kmcmdn, F, Vj)
+
+ carel[i, j] = calc_carel(carel[i, j], dt, itr, irel[i, j], csqnmax, kmcsqn)
+
+ u_new[i, j] -= dt * (ina + ik1 + ito + ikur + ikr + iks + ical + ipca + inak + inaca + ibna + ibca)
diff --git a/finitewave/cpuwave2D/model/diffuse_kernels_2d.py b/finitewave/cpuwave2D/model/diffuse_kernels_2d.py
deleted file mode 100644
index 4e0f198..0000000
--- a/finitewave/cpuwave2D/model/diffuse_kernels_2d.py
+++ /dev/null
@@ -1,90 +0,0 @@
-from numba import njit, prange
-
-_parallel = False
-
-@njit(parallel=_parallel)
-def diffuse_kernel_2d_iso(u_new, u, w, mesh):
- """
- Performs isotropic diffusion on a 2D grid.
-
- This function computes the new values of the potential field `u_new` based on an isotropic
- diffusion model. The computation is performed in parallel using Numba's JIT compilation.
-
- Parameters
- ----------
- u_new : numpy.ndarray
- A 2D array to store the updated potential values after diffusion.
-
- u : numpy.ndarray
- A 2D array representing the current potential values before diffusion.
-
- w : numpy.ndarray
- A 3D array of weights used in the diffusion computation. The shape should match (n_i, n_j, 5),
- where `n_i` and `n_j` are the dimensions of the `u` and `u_new` arrays.
-
- mesh : numpy.ndarray
- A 2D array representing the mesh of the tissue. Each element indicates the type of tissue at
- that position (e.g., cardiomyocyte, empty, or fibrosis). Only positions with a value of 1 are
- considered for diffusion.
-
- Notes
- -----
- The diffusion is applied only to points in the `mesh` with a value of 1. Boundary conditions are
- not explicitly handled and are assumed to be implicitly managed by the provided mesh.
- """
- n_i = u.shape[0]
- n_j = u.shape[1]
- for ii in prange(n_i * n_j):
- i = int(ii / n_j)
- j = ii % n_j
- if mesh[i, j] != 1:
- continue
-
- u_new[i, j] = (u[i-1, j] * w[i, j, 0] + u[i, j-1] * w[i, j, 1] +
- u[i, j] * w[i, j, 2] + u[i, j+1] * w[i, j, 3] +
- u[i+1, j] * w[i, j, 4])
-
-
-@njit(parallel=_parallel)
-def diffuse_kernel_2d_aniso(u_new, u, w, mesh):
- """
- Performs anisotropic diffusion on a 2D grid.
-
- This function computes the new values of the potential field `u_new` based on an anisotropic
- diffusion model. The computation is performed in parallel using Numba's JIT compilation.
-
- Parameters
- ----------
- u_new : numpy.ndarray
- A 2D array to store the updated potential values after diffusion.
-
- u : numpy.ndarray
- A 2D array representing the current potential values before diffusion.
-
- w : numpy.ndarray
- A 3D array of weights used in the diffusion computation. The shape should match (n_i, n_j, 9),
- where `n_i` and `n_j` are the dimensions of the `u` and `u_new` arrays.
-
- mesh : numpy.ndarray
- A 2D array representing the mesh of the tissue. Each element indicates the type of tissue at
- that position (e.g., cardiomyocyte, empty, or fibrosis). Only positions with a value of 1 are
- considered for diffusion.
-
- Notes
- -----
- The diffusion is applied only to points in the `mesh` with a value of 1. Boundary conditions are
- not explicitly handled and are assumed to be implicitly managed by the provided mesh.
- """
- n_i = u.shape[0]
- n_j = u.shape[1]
- for ii in prange(n_i * n_j):
- i = int(ii / n_j)
- j = ii % n_j
- if mesh[i, j] != 1:
- continue
-
- u_new[i, j] = (u[i-1, j-1] * w[i, j, 0] + u[i-1, j] * w[i, j, 1] +
- u[i-1, j+1] * w[i, j, 2] + u[i, j-1] * w[i, j, 3] +
- u[i, j] * w[i, j, 4] + u[i, j+1] * w[i, j, 5] +
- u[i+1, j-1] * w[i, j, 6] + u[i+1, j] * w[i, j, 7] +
- u[i+1, j+1] * w[i, j, 8])
diff --git a/finitewave/cpuwave2D/model/fenton_karma_2d.py b/finitewave/cpuwave2D/model/fenton_karma_2d.py
new file mode 100644
index 0000000..d658be6
--- /dev/null
+++ b/finitewave/cpuwave2D/model/fenton_karma_2d.py
@@ -0,0 +1,329 @@
+import numpy as np
+from numba import njit, prange
+
+from finitewave.core.model.cardiac_model import CardiacModel
+from finitewave.cpuwave2D.stencil.asymmetric_stencil_2d import (
+ AsymmetricStencil2D
+)
+from finitewave.cpuwave2D.stencil.isotropic_stencil_2d import (
+ IsotropicStencil2D
+)
+
+
+class FentonKarma2D(CardiacModel):
+
+ def __init__(self):
+ """
+ Two-dimensional implementation of the Fenton-Karma model of cardiac electrophysiology.
+
+ The Fenton-Karma model is a minimal three-variable model designed to reproduce
+ essential features of human ventricular action potentials, including restitution,
+ conduction velocity dynamics, and spiral wave behavior. It captures the interaction
+ between fast depolarization, slow repolarization, and calcium-mediated effects
+ through simplified phenomenological equations.
+
+ This implementation corresponds to the MLR-I parameter set described in the original paper
+ and supports 2D isotropic and anisotropic tissue simulations with diffusion.
+
+ Attributes
+ ----------
+ u : np.ndarray
+ Transmembrane potential (normalized, dimensionless).
+ v : np.ndarray
+ Fast recovery variable, representing sodium channel inactivation.
+ w : np.ndarray
+ Slow recovery variable, representing calcium channel dynamics.
+ D_model : float
+ Baseline diffusion coefficient used in the diffusion stencil.
+ state_vars : list of str
+ Names of the state variables stored during the simulation.
+ npfloat : str
+ Floating point precision (default is 'float64').
+
+ Model Parameters
+ ----------------
+ tau_r : float
+ Time constant for repolarization (outward current).
+ tau_o : float
+ Time constant for the open-state decay of fast sodium channels.
+ tau_d : float
+ Time constant for depolarization (fast inward current).
+ tau_si : float
+ Time constant for the slow inward (calcium-like) current.
+ tau_v_m : float
+ Time constant for inactivation gate v (membrane below threshold).
+ tau_v_p : float
+ Time constant for recovery gate v (above threshold).
+ tau_w_m : float
+ Time constant for recovery gate w (below threshold).
+ tau_w_p : float
+ Time constant for decay of w (above threshold).
+ k : float
+ Steepness parameter for the slow inward current.
+ u_c : float
+ Activation threshold for recovery dynamics.
+ uc_si : float
+ Activation threshold for the slow inward current.
+
+ Paper
+ -----
+ Fenton, F., & Karma, A. (1998).
+ Vortex dynamics in three-dimensional continuous myocardium
+ with fiber rotation: Filament instability and fibrillation.
+ Chaos, 8(1), 20-47.
+ https://doi.org/10.1063/1.166311
+
+ """
+ super().__init__()
+ self.v = np.ndarray
+ self.w = np.ndarray
+
+ self.D_model = 1.
+
+ self.state_vars = ["u", "v", "w"]
+ self.npfloat = 'float64'
+
+ # model parameters (MLR-I)
+ self.tau_r = 130
+ self.tau_o = 12.5
+ self.tau_d = 0.172
+ self.tau_si = 127
+ self.tau_v_m = 18.2
+ self.tau_v_p = 10
+ self.tau_w_m = 80
+ self.tau_w_p = 1020
+ self.k = 10
+ self.u_c = 0.13
+ self.uc_si = 0.85
+
+ # initial conditions
+ self.init_u = 0.0
+ self.init_v = 1.0
+ self.init_w = 1.0
+
+ def initialize(self):
+ """
+ Initializes the model for simulation.
+ """
+ super().initialize()
+ self.u = self.init_u * np.ones_like(self.u, dtype=self.npfloat)
+ self.v = self.init_v * np.ones_like(self.u, dtype=self.npfloat)
+ self.w = self.init_w * np.ones_like(self.u, dtype=self.npfloat)
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel for the Fenton-Karma model.
+ """
+ ionic_kernel_2d(self.u_new, self.u, self.v, self.w, self.cardiac_tissue.myo_indexes,
+ self.dt, self.tau_d, self.tau_o, self.tau_r, self.tau_si,
+ self.tau_v_m, self.tau_v_p, self.tau_w_m, self.tau_w_p,
+ self.k, self.u_c, self.uc_si)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue2D
+ A tissue object representing the cardiac tissue.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to use for diffusion computations.
+ """
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil2D()
+
+ return AsymmetricStencil2D()
+
+@njit
+def calc_Jfi(u, v, u_c, tau_d):
+ """
+ Computes the fast inward current (J_fi) for the Fenton-Karma model.
+
+ This current is responsible for the rapid depolarization of the membrane
+ potential. It is active only when the membrane potential exceeds a threshold `u_c`.
+
+ Parameters
+ ----------
+ u : float
+ Current membrane potential (dimensionless).
+ v : float
+ Fast recovery gate (sodium channel inactivation).
+ u_c : float
+ Activation threshold for the inward current.
+ tau_d : float
+ Time constant for depolarization.
+
+ Returns
+ -------
+ float
+ Value of the fast inward current at this point.
+ """
+ H = 1.0 if (u - u_c) >= 0 else 0.0
+ return -(v*H*(1-u)*(u - u_c))/tau_d
+
+@njit
+def calc_Jso(u, u_c, tau_o, tau_r):
+ """
+ Computes the slow outward current (J_so) for repolarization.
+
+ This current contains two parts:
+ - a linear repolarizing component active below threshold `u_c`
+ - a constant repolarizing component above threshold
+
+ Parameters
+ ----------
+ u : float
+ Membrane potential.
+ u_c : float
+ Activation threshold.
+ tau_o : float
+ Time constant for subthreshold repolarization.
+ tau_r : float
+ Time constant for suprathreshold repolarization.
+
+ Returns
+ -------
+ float
+ Value of the outward repolarizing current.
+ """
+ H1 = 1.0 if (u_c - u) >= 0 else 0.0
+ H2 = 1.0 if (u - u_c) >= 0 else 0.0
+
+ return u*H1/tau_o + H2/tau_r
+
+@njit
+def calc_Jsi(u, w, k, uc_si, tau_si):
+ """
+ Computes the slow inward (calcium-like) current (J_si).
+
+ This current is responsible for the plateau phase of the action potential
+ and depends on the gating variable `w` and a smoothed activation threshold.
+
+ Parameters
+ ----------
+ u : float
+ Membrane potential.
+ w : float
+ Slow recovery gate.
+ k : float
+ Steepness of the tanh activation curve.
+ uc_si : float
+ Activation threshold for the slow inward current.
+ tau_si : float
+ Time constant for the slow inward current.
+
+ Returns
+ -------
+ float
+ Value of the slow inward current.
+ """
+ return -w*(1 + np.tanh(k*(u - uc_si)))/(2*tau_si)
+
+@njit
+def calc_v(v, u, dt, u_c, tau_v_m, tau_v_p):
+ """
+ Updates the fast recovery gate `v` over time.
+
+ This gate controls sodium channel availability and changes depending on
+ whether the membrane potential is below or above a critical threshold.
+
+ Parameters
+ ----------
+ v : float
+ Current value of the recovery variable.
+ u : float
+ Membrane potential.
+ dt : float
+ Time step.
+ u_c : float
+ Activation threshold.
+ tau_v_m : float
+ Time constant below threshold.
+ tau_v_p : float
+ Time constant above threshold.
+
+ Returns
+ -------
+ float
+ Updated value of `v`.
+ """
+ H1 = 1.0 if (u_c - u) >= 0 else 0.0
+ H2 = 1.0 if (u - u_c) >= 0 else 0.0
+ v += dt*(H1*(1 - v)/tau_v_m - H2*v/tau_v_p)
+ return v
+
+@njit
+def calc_w(w, u, dt, u_c, tau_w_m, tau_w_p):
+ """
+ Updates the slow recovery gate `w` over time.
+
+ This gate represents the calcium channel recovery and decays similarly to `v`,
+ depending on whether the membrane potential is above or below threshold `u_c`.
+
+ Parameters
+ ----------
+ w : float
+ Current value of the recovery variable.
+ u : float
+ Membrane potential.
+ dt : float
+ Time step.
+ u_c : float
+ Activation threshold.
+ tau_w_m : float
+ Time constant below threshold.
+ tau_w_p : float
+ Time constant above threshold.
+
+ Returns
+ -------
+ float
+ Updated value of `w`.
+ """
+ H1 = 1.0 if (u_c - u) >= 0 else 0.0
+ H2 = 1.0 if (u - u_c) >= 0 else 0.0
+ w += dt*(H1*(1 - w)/tau_w_m - H2*w/tau_w_p)
+ return w
+
+@njit(parallel=True)
+def ionic_kernel_2d(u_new, u, v, w, indexes, dt,
+ tau_d, tau_o, tau_r, tau_si,
+ tau_v_m, tau_v_p, tau_w_m, tau_w_p,
+ k, u_c, uc_si):
+ """
+ Computes the ionic kernel for the Fenton-Karma 2D model.
+
+ Parameters
+ ----------
+ u_new : np.ndarray
+ Array to store the updated action potential values.
+ u : np.ndarray
+ Current action potential array.
+ indexes : np.ndarray
+ Array of indices where the kernel should be computed (``mesh == 1``).
+ dt : float
+ Time step for the simulation.
+ """
+
+ n_j = u.shape[1]
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = int(ii / n_j)
+ j = ii % n_j
+
+ v[i, j] = calc_v(v[i, j], u[i, j], dt, u_c, tau_v_m, tau_v_p)
+ w[i, j] = calc_w(w[i, j], u[i, j], dt, u_c, tau_w_m, tau_w_p)
+
+ J_fi = calc_Jfi(u[i, j], v[i, j], u_c, tau_d)
+ J_so = calc_Jso(u[i, j], u_c, tau_o, tau_r)
+ J_si = calc_Jsi(u[i, j], v[i, j], k, uc_si, tau_si)
+
+ u_new[i, j] += dt * (-J_fi - J_so - J_si)
+
diff --git a/finitewave/cpuwave2D/model/luo_rudy91_2d.py b/finitewave/cpuwave2D/model/luo_rudy91_2d.py
new file mode 100755
index 0000000..a094725
--- /dev/null
+++ b/finitewave/cpuwave2D/model/luo_rudy91_2d.py
@@ -0,0 +1,514 @@
+import numpy as np
+from numba import njit, prange
+from finitewave.core.model.cardiac_model import CardiacModel
+from finitewave.cpuwave2D.stencil.asymmetric_stencil_2d import (
+ AsymmetricStencil2D
+)
+from finitewave.cpuwave2D.stencil.isotropic_stencil_2d import (
+ IsotropicStencil2D
+)
+
+
+class LuoRudy912D(CardiacModel):
+ """
+ Implements the Luo-Rudy 1991 ventricular action potential model.
+
+ This biophysically detailed model simulates the ionic currents and membrane potential
+ of a ventricular cardiac cell based on Hodgkin-Huxley-type formalism. It was one of
+ the first to incorporate realistic ionic channel kinetics, calcium dynamics, and
+ multiple potassium currents to reproduce key phases of the action potential.
+
+ The model includes:
+ - Fast Na⁺ current (I_Na)
+ - Slow inward Ca²⁺ current (I_Si)
+ - Time-dependent K⁺ current (I_K)
+ - Time-independent K⁺ current (I_K1)
+ - Plateau K⁺ current (I_Kp)
+ - Background/leak current (I_b)
+
+ Attributes
+ ----------
+ state_vars : list of str
+ List of state variable names to save and restore (`u`, `m`, `h`, `j`, `d`, `f`, `x`, `cai`).
+ D_model : float
+ Diffusion coefficient representing electrical conductivity in the medium (typically set to 0.1).
+ gna, gsi, gk, gk1, gkp, gb : float
+ Maximum conductances for Na⁺, Ca²⁺, K⁺, and background channels [mS/μF].
+ ko, ki, nao, nai, cao : float
+ Ion concentrations in mM (extracellular and intracellular for Na⁺, K⁺, Ca²⁺).
+ R, T, F : float
+ Physical constants: gas constant, temperature in Kelvin, and Faraday constant.
+ PR_NaK : float
+ Sodium/potassium permeability ratio (used in reversal potential calculation for I_K).
+
+ Paper
+ -----
+ Luo CH, Rudy Y.
+ A model of the ventricular cardiac action potential. Depolarization, repolarization, and their interaction.
+ Circ Res. 1991 Jun;68(6):1501-26.
+ doi: 10.1161/01.res.68.6.1501.
+ PMID: 1709839.
+
+ """
+
+ def __init__(self):
+ """
+ Initializes the LuoRudy912D instance, setting up the state variables and parameters.
+ """
+ CardiacModel.__init__(self)
+ self.D_model = 0.1
+
+ self.m = np.ndarray
+ self.h = np.ndarray
+ self.j = np.ndarray
+ self.d = np.ndarray
+ self.f = np.ndarray
+ self.x = np.ndarray
+ self.cai = np.ndarray
+
+ self.state_vars = ["u", "m", "h", "j", "d", "f", "x", "cai"]
+ self.npfloat = 'float64'
+
+ # Ion Channel Conductances (mS/µF)
+ self.gna = 23.0 # Fast sodium (Na+) conductance
+ self.gsi = 0.09 # Slow inward calcium (Ca2+) conductance
+ self.gk = 0.282 # Time-dependent potassium (K+) conductance
+ self.gk1 = 0.6047 # Inward rectifier potassium (K1) conductance
+ self.gkp = 0.0183 # Plateau potassium (Kp) conductance
+ self.gb = 0.03921 # Background conductance (leak current)
+
+ # Extracellular and Intracellular Ion Concentrations (mM)
+ self.ko = 5.4 # Extracellular potassium concentration
+ self.ki = 145.0 # Intracellular potassium concentration
+ self.nai = 18.0 # Intracellular sodium concentration
+ self.nao = 140.0 # Extracellular sodium concentration
+ self.cao = 1.8 # Extracellular calcium concentration
+
+ # Physical Constants
+ self.R = 8.314 # Universal gas constant (J/(mol·K))
+ self.T = 310.0 # Temperature (Kelvin, 37°C)
+ self.F = 96.5 # Faraday constant (C/mmol)
+
+ # Ion Permeability Ratios
+ self.PR_NaK = 0.01833 # Na+/K+ permeability ratio
+
+ # initial conditions
+ self.init_u = -84.5
+ self.init_m = 0.0017
+ self.init_h = 0.9832
+ self.init_j = 0.995484
+ self.init_d = 0.000003
+ self.init_f = 1.0
+ self.init_x = 0.0057
+ self.init_cai = 0.0002
+
+ def initialize(self):
+ """
+ Initializes the state variables.
+
+ This method sets the initial values for the membrane potential ``u``,
+ gating variables ``m``, ``h``, ``j``, ``d``, ``f``, ``x``,
+ and intracellular calcium concentration ``cai``.
+ """
+ super().initialize()
+ shape = self.cardiac_tissue.mesh.shape
+
+ self.u = self.init_u * np.ones(shape, dtype=self.npfloat)
+ self.u_new = self.u.copy()
+ self.m = self.init_m * np.ones(shape, dtype=self.npfloat)
+ self.h = self.init_h * np.ones(shape, dtype=self.npfloat)
+ self.j = self.init_j * np.ones(shape, dtype=self.npfloat)
+ self.d = self.init_d * np.ones(shape, dtype=self.npfloat)
+ self.f = self.init_f * np.ones(shape, dtype=self.npfloat)
+ self.x = self.init_x * np.ones(shape, dtype=self.npfloat)
+ self.cai = self.init_cai * np.ones(shape, dtype=self.npfloat)
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel to update the state variables and membrane
+ potential.
+ """
+ ionic_kernel_2d(self.u_new, self.u,
+ self.m, self.h, self.j, self.d,self.f, self.x, self.cai,
+ self.cardiac_tissue.myo_indexes, self.dt,
+ self.gna, self.gsi, self.gk, self.gk1, self.gkp, self.gb,
+ self.ko, self.ki, self.nai, self.nao, self.cao, self.R, self.T, self.F, self.PR_NaK)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue2D
+ A tissue object representing the cardiac tissue.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to use for diffusion computations.
+ """
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil2D()
+
+ return AsymmetricStencil2D()
+
+@njit
+def calc_gating_var(var, dt, alpha, beta):
+ """
+ Computes the gating variable dynamics based on the Hodgkin-Huxley formalism.
+
+ Parameters
+ ----------
+ var : float
+ Current value of the gating variable.
+ dt : float
+ Time step [ms].
+ alpha : float
+ Rate constant for activation.
+ beta : float
+ Rate constant for inactivation.
+
+ Returns
+ -------
+ var_new : float
+ Updated gating variable.
+ """
+ tau = 1. / (alpha + beta)
+ inf = alpha / (alpha + beta)
+ var += dt * (inf - var) / tau
+ return var
+
+@njit
+def calc_ina(u, dt, m, h, j, E_Na, gna):
+ """
+ Computes the fast inward sodium current (I_Na) and updates gating variables m, h, j.
+
+ I_Na is responsible for the rapid depolarization (phase 0) of the action potential.
+ It depends on three gates:
+ - m: activation gate (opens quickly),
+ - h: fast inactivation gate,
+ - j: slow inactivation gate.
+
+ Gating dynamics follow Hodgkin-Huxley kinetics with voltage-dependent time constants
+ and steady-state values. I_Na = g_Na * m^3 * h * j * (u - E_Na).
+
+ Parameters
+ ----------
+ u : float
+ Membrane potential [mV].
+ dt : float
+ Time step [ms].
+ m, h, j : float
+ Gating variables for the sodium channel.
+ E_Na : float
+ Reversal potential for Na⁺ [mV].
+ gna : float
+ Maximal sodium conductance [mS/μF].
+
+ Returns
+ -------
+ ina : float
+ Fast sodium current [μA/μF].
+ m, h, j : float
+ Updated gating variables.
+ """
+ alpha_h, beta_h, beta_J, alpha_J = 0, 0, 0, 0
+ if u >= -40.:
+ beta_h = 1. / (0.13 * (1 + np.exp((u + 10.66) / -11.1)))
+ beta_J = 0.3 * np.exp(-2.535 * 1e-07 *
+ u) / (1 + np.exp(-0.1 * (u + 32)))
+ else:
+ alpha_h = 0.135 * np.exp((80 + u) / -6.8)
+ beta_h = 3.56 * \
+ np.exp(0.079 * u) + 3.1 * 1e5 * np.exp(0.35 * u)
+ beta_J = 0.1212 * \
+ np.exp(-0.01052 * u) / \
+ (1 + np.exp(-0.1378 * (u + 40.14)))
+ alpha_J = (-1.2714 * 1e5 * np.exp(0.2444 * u) - 3.474 * 1e-5 * np.exp(-0.04391 * u)) * \
+ (u + 37.78) / (1 + np.exp(0.311 * (u + 79.23)))
+
+ alpha_m = 0.32 * (u + 47.13) / \
+ (1 - np.exp(-0.1 * (u + 47.13)))
+ beta_m = 0.08 * np.exp(-u / 11)
+
+ m = calc_gating_var(m, dt, alpha_m, beta_m)
+ h = calc_gating_var(h, dt, alpha_h, beta_h)
+ j = calc_gating_var(j, dt, alpha_J, beta_J)
+
+ return gna * m * m * m * h * j * (u - E_Na), m, h, j
+
+@njit
+def calc_isk(u, dt, d, f, cai, gsi):
+ """
+ Computes the slow inward calcium current (I_Si) and updates d, f, and intracellular calcium.
+
+ I_Si is primarily carried by L-type Ca²⁺ channels and governs the plateau (phase 2).
+ The reversal potential E_Si is dynamically calculated based on intracellular Ca²⁺ levels.
+
+ Calcium handling is simplified: part of I_Si is subtracted from intracellular Ca²⁺,
+ while a constant leak term restores it toward a baseline.
+
+ Parameters
+ ----------
+ u : float
+ Membrane potential [mV].
+ dt : float
+ Time step [ms].
+ d, f : float
+ Activation and inactivation gates of the calcium channel.
+ cai : float
+ Intracellular calcium concentration [mM].
+ gsi : float
+ Maximal calcium conductance [mS/μF].
+
+ Returns
+ -------
+ I_Si : float
+ Slow inward calcium current [μA/μF].
+ d, f, cai : float
+ Updated gating variables and intracellular Ca²⁺.
+ """
+ E_Si = 7.7 - 13.0287 * np.log(cai)
+ I_Si = gsi * d * f * (u - E_Si)
+ alpha_d = 0.095 * \
+ np.exp(-0.01 * (u - 5)) / \
+ (1 + np.exp(-0.072 * (u - 5)))
+ beta_d = 0.07 * \
+ np.exp(-0.017 * (u + 44)) / \
+ (1 + np.exp(0.05 * (u + 44)))
+ alpha_f = 0.012 * \
+ np.exp(-0.008 * (u + 28)) / \
+ (1 + np.exp(0.15 * (u + 28)))
+ beta_f = 0.0065 * \
+ np.exp(-0.02 * (u + 30)) / \
+ (1 + np.exp(-0.2 * (u + 30)))
+
+ d = calc_gating_var(d, dt, alpha_d, beta_d)
+ f = calc_gating_var(f, dt, alpha_f, beta_f)
+
+ cai += dt * (-0.0001 * I_Si + 0.07 * (0.0001 - cai))
+
+ return I_Si, d, f, cai
+
+@njit
+def calc_ik(u, dt, x, ko, ki, nao, nai, PR_NaK, R, T, F, gk):
+ """
+ Computes the time-dependent outward potassium current (I_K) and updates gate x.
+
+ This current drives late repolarization (phase 3) and is voltage- and time-dependent.
+ Reversal potential is calculated via the Goldman-Hodgkin-Katz equation
+ (with sodium/potassium permeability ratio).
+
+ An auxiliary factor Xi introduces voltage-sensitive activation near -100 mV.
+
+ Parameters
+ ----------
+ u : float
+ Membrane potential [mV].
+ dt : float
+ Time step [ms].
+ x : float
+ Activation gate of the delayed rectifier K⁺ channel.
+ ko, ki : float
+ Extra-/intracellular potassium concentrations [mM].
+ nao, nai : float
+ Extra-/intracellular sodium concentrations [mM].
+ PR_NaK : float
+ Na⁺/K⁺ permeability ratio.
+ R, T, F : float
+ Gas constant, temperature [K], and Faraday constant.
+ gk : float
+ Maximum potassium conductance [mS/μF].
+
+ Returns
+ -------
+ I_K : float
+ Time-dependent potassium current [μA/μF].
+ x : float
+ Updated activation gate.
+ """
+ E_K = (R * T / F) * \
+ np.log((ko + PR_NaK * nao) / (ki + PR_NaK * nai))
+
+ G_K = gk * np.sqrt(ko / 5.4)
+
+ Xi = 0
+ if u > -100:
+ Xi = 2.837 * (np.exp(0.04 * (u + 77)) - 1) / \
+ ((u + 77) * np.exp(0.04 * (u + 35)))
+ else:
+ Xi = 1
+
+ I_K = G_K * x * Xi * (u - E_K)
+
+ alpha_x = 0.0005 * \
+ np.exp(0.083 * (u + 50)) / \
+ (1 + np.exp(0.057 * (u + 50)))
+ beta_x = 0.0013 * \
+ np.exp(-0.06 * (u + 20)) / \
+ (1 + np.exp(-0.04 * (u + 20)))
+
+ x = calc_gating_var(x, dt, alpha_x, beta_x)
+
+ return I_K, x
+
+@njit
+def calc_ik1(u, ko, E_K1, gk1):
+ """
+ Computes the time-independent inward rectifier potassium current (I_K1).
+
+ I_K1 stabilizes the resting membrane potential and contributes to
+ late repolarization. It is primarily active at negative voltages and
+ follows a voltage-dependent gating-like term (K1_x).
+
+ Parameters
+ ----------
+ u : float
+ Membrane potential [mV].
+ ko : float
+ Extracellular potassium [mM].
+ E_K1 : float
+ Equilibrium potential for K1 current [mV].
+ gk1 : float
+ Maximum K1 conductance [mS/μF].
+
+ Returns
+ -------
+ I_K1 : float
+ Time-independent K⁺ current [μA/μF].
+ """
+ alpha_K1 = 1.02 / (1 + np.exp(0.2385 * (u - E_K1 - 59.215)))
+ beta_K1 = (0.49124 * np.exp(0.08032 * (u - E_K1 + 5.476)) + np.exp(0.06175 * (u - E_K1 - 594.31))) / \
+ (1 + np.exp(-0.5143 * (u - E_K1 + 4.753)))
+
+ K_1x = alpha_K1 / (alpha_K1 + beta_K1)
+
+ G_K1 = gk1 * np.sqrt(ko / 5.4)
+ I_K1 = G_K1 * K_1x * (u - E_K1)
+
+ return I_K1
+
+@njit
+def calc_ikp(u, E_K1, gkp):
+ """
+ Computes the plateau potassium current (I_Kp).
+
+ I_Kp is a small, quasi-steady outward current that operates in the
+ plateau phase. Its activation is a sigmoid function of voltage.
+
+ Parameters
+ ----------
+ u : float
+ Membrane potential [mV].
+ ko : float
+ Extracellular potassium [mM].
+ E_K1 : float
+ Equilibrium potential (same as I_K1).
+ gkp : float
+ Plateau potassium conductance [mS/μF].
+
+ Returns
+ -------
+ I_Kp : float
+ Plateau potassium current [μA/μF].
+ """
+ E_Kp = E_K1
+ K_p = 1. / (1 + np.exp((7.488 - u) / 5.98))
+ I_Kp = gkp * K_p * (u - E_Kp)
+
+ return I_Kp
+
+@njit
+def calc_ib(u, gb):
+ """
+ Computes the non-specific background (leak) current.
+
+ This is a linear leak current contributing to resting potential maintenance.
+
+ Parameters
+ ----------
+ u : float
+ Membrane potential [mV].
+ gb : float
+ Background conductance [mS/μF].
+
+ Returns
+ -------
+ I_b : float
+ Background current [μA/μF].
+ """
+ return gb * (u + 59.87)
+
+
+@njit(parallel=True)
+def ionic_kernel_2d(u_new, u, m, h, j_, d, f, x, cai, indexes, dt, gna, gsi, gk, gk1, gkp, gb, ko, ki, nai, nao, cao, R, T, F, PR_NaK):
+ """
+ Computes the ionic currents and updates the state variables in the 2D
+ Luo-Rudy 1991 cardiac model.
+
+ Parameters
+ ----------
+ u_new : np.ndarray
+ Array to store the updated membrane potential.
+ u : np.ndarray
+ Array of the current membrane potential values.
+ m : np.ndarray
+ Array for the gating variable `m`.
+ h : np.ndarray
+ Array for the gating variable `h`.
+ j_ : np.ndarray
+ Array for the gating variable `j_`.
+ d : np.ndarray
+ Array for the gating variable `d`.
+ f : np.ndarray
+ Array for the gating variable `f`.
+ x : np.ndarray
+ Array for the gating variable `x`.
+ cai : np.ndarray
+ Array for the intracellular calcium concentration.
+ indexes : np.ndarray
+ Array of indexes where the kernel should be computed (``mesh == 1``).
+ dt : float
+ Time step for the simulation.
+ """
+
+ E_Na = (R*T/F)*np.log(nao/nai)
+
+ n_j = u.shape[1]
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = int(ii / n_j)
+ j = ii % n_j
+
+ # Fast sodium current:
+ ina, m[i, j], h[i, j], j_[i, j] = calc_ina(u[i, j], dt, m[i, j], h[i, j], j_[i, j], E_Na, gna)
+
+ # Slow inward current:
+ isi, d[i, j], f[i, j], cai[i, j] = calc_isk(u[i, j], dt, d[i, j], f[i, j], cai[i, j], gsi)
+
+ # Time-dependent potassium current:
+ ik, x[i, j] = calc_ik(u[i, j], dt, x[i, j], ko, ki, nao, nai, PR_NaK, R, T, F, gk)
+
+ E_K1 = (R * T / F) * np.log(ko / ki)
+
+ # Time-independent potassium current:
+ ik1 = calc_ik1(u[i, j], ko, E_K1, gk1)
+
+ # Plateau potassium current:
+ ikp = calc_ikp(u[i, j], E_K1, gkp)
+
+ # Background current:
+ ib = calc_ib(u[i, j], gb)
+
+ # Total time-independent potassium current:
+ ik1t = ik1 + ikp + ib
+
+ u_new[i, j] -= dt * (ina + isi + ik1t + ik)
+
+
+
+
diff --git a/finitewave/cpuwave2D/model/luo_rudy91_2d/__init__.py b/finitewave/cpuwave2D/model/luo_rudy91_2d/__init__.py
deleted file mode 100644
index 535715e..0000000
--- a/finitewave/cpuwave2D/model/luo_rudy91_2d/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from finitewave.cpuwave2D.model.luo_rudy91_2d.luo_rudy91_2d import LuoRudy912D
diff --git a/finitewave/cpuwave2D/model/luo_rudy91_2d/luo_rudy91_2d.py b/finitewave/cpuwave2D/model/luo_rudy91_2d/luo_rudy91_2d.py
deleted file mode 100755
index 9fdff0a..0000000
--- a/finitewave/cpuwave2D/model/luo_rudy91_2d/luo_rudy91_2d.py
+++ /dev/null
@@ -1,108 +0,0 @@
-import numpy as np
-from finitewave.core.model.cardiac_model import CardiacModel
-from finitewave.cpuwave2D.model.luo_rudy91_2d.luo_rudy91_kernels_2d import LuoRudy91Kernels2D
-
-_npfloat = "float64"
-
-class LuoRudy912D(CardiacModel):
- """
- Implements the 2D Luo-Rudy 1991 cardiac model for simulating cardiac electrical activity.
-
- This class initializes the state variables and provides methods for running simulations with the Luo-Rudy 1991 model.
-
- Attributes
- ----------
- m : np.ndarray
- Gating variable m.
- h : np.ndarray
- Gating variable h.
- j_ : np.ndarray
- Gating variable j_.
- d : np.ndarray
- Gating variable d.
- f : np.ndarray
- Gating variable f.
- x : np.ndarray
- Gating variable x.
- Cai_c : np.ndarray
- Intracellular calcium concentration.
- model_parameters : dict
- Dictionary to hold model-specific parameters.
- state_vars : list
- List of state variable names.
- npfloat : str
- NumPy data type used for floating point calculations ('float64').
-
- Methods
- -------
- initialize():
- Initializes the state variables and sets up the diffusion and ionic kernels.
- run_ionic_kernel():
- Executes the ionic kernel to update the state variables and membrane potential.
- """
-
- def __init__(self):
- """
- Initializes the LuoRudy912D instance, setting up the state variables and parameters.
- """
- CardiacModel.__init__(self)
- self.m = np.ndarray
- self.h = np.ndarray
- self.j_ = np.ndarray
- self.d = np.ndarray
- self.f = np.ndarray
- self.x = np.ndarray
- self.Cai_c = np.ndarray
- self.model_parameters = {}
- self.state_vars = ["u", "m", "h", "j_", "d", "f", "x", "Cai_c"]
- self.npfloat = 'float64'
-
- def initialize(self):
- """
- Initializes the state variables and sets up the diffusion and ionic kernels.
-
- This method sets the initial values for the membrane potential `u`, gating variables `m`, `h`, `j_`, `d`, `f`, `x`,
- and intracellular calcium concentration `Cai_c`. It also retrieves and sets the diffusion and ionic kernel functions
- based on the shape of the weights in the cardiac tissue.
- """
- super().initialize()
- weights_shape = self.cardiac_tissue.weights.shape
- shape = self.cardiac_tissue.mesh.shape
-
- self.diffuse_kernel = LuoRudy91Kernels2D().get_diffuse_kernel(weights_shape)
- self.ionic_kernel = LuoRudy91Kernels2D().get_ionic_kernel()
-
- self.u = -84.5 * np.ones(shape, dtype=_npfloat)
- self.u_new = self.u.copy()
- self.m = 0.0017 * np.ones(shape, dtype=_npfloat)
- self.h = 0.9832 * np.ones(shape, dtype=_npfloat)
- self.j_ = 0.995484 * np.ones(shape, dtype=_npfloat)
- self.d = 0.000003 * np.ones(shape, dtype=_npfloat)
- self.f = np.ones(shape, dtype=_npfloat)
- self.x = 0.0057 * np.ones(shape, dtype=_npfloat)
- self.Cai_c = 0.0002 * np.ones(shape, dtype=_npfloat)
-
- def run_ionic_kernel(self):
- """
- Executes the ionic kernel to update the state variables and membrane potential.
-
- This method calls the ionic kernel function provided by the `LuoRudy91Kernels2D` class to compute the updates for
- the membrane potential `u_new` and the gating variables `m`, `h`, `j_`, `d`, `f`, `x`, and `Cai_c` based on the
- current state and the time step `dt`.
-
- The ionic kernel function takes the following parameters:
- - `u_new`: Array to store updated membrane potential values.
- - `u`: Array of current membrane potential values.
- - `m`: Array of gating variable m.
- - `h`: Array of gating variable h.
- - `j_`: Array of gating variable j_.
- - `d`: Array of gating variable d.
- - `f`: Array of gating variable f.
- - `x`: Array of gating variable x.
- - `Cai_c`: Array of intracellular calcium concentration.
- - `mesh`: Array indicating tissue types.
- - `dt`: Time step for the simulation.
- """
- self.ionic_kernel(self.u_new, self.u, self.m, self.h, self.j_, self.d,
- self.f, self.x, self.Cai_c, self.cardiac_tissue.mesh,
- self.dt)
diff --git a/finitewave/cpuwave2D/model/luo_rudy91_2d/luo_rudy91_kernels_2d.py b/finitewave/cpuwave2D/model/luo_rudy91_2d/luo_rudy91_kernels_2d.py
deleted file mode 100644
index 0833217..0000000
--- a/finitewave/cpuwave2D/model/luo_rudy91_2d/luo_rudy91_kernels_2d.py
+++ /dev/null
@@ -1,219 +0,0 @@
-import numpy as np
-from math import log, sqrt, exp
-from numba import njit, prange
-
-from finitewave.core.exception.exceptions import IncorrectWeightsShapeError
-from finitewave.cpuwave2D.model.diffuse_kernels_2d import diffuse_kernel_2d_iso, diffuse_kernel_2d_aniso, _parallel
-
-
-@njit(parallel=_parallel)
-def ionic_kernel_2d(u_new, u, m, h, j_, d, f, x, Cai_c, mesh, dt):
- """
- Computes the ionic currents and updates the state variables in the 2D Luo-Rudy 1991 cardiac model.
-
- This function updates the membrane potential `u` and the gating variables `m`, `h`, `j_`, `d`, `f`, `x` based on
- the Luo-Rudy 1991 equations. It also updates the calcium concentration `Cai_c`.
-
- Parameters
- ----------
- u_new : np.ndarray
- Array to store the updated membrane potential.
- u : np.ndarray
- Array of the current membrane potential values.
- m : np.ndarray
- Array for the gating variable `m`.
- h : np.ndarray
- Array for the gating variable `h`.
- j_ : np.ndarray
- Array for the gating variable `j_`.
- d : np.ndarray
- Array for the gating variable `d`.
- f : np.ndarray
- Array for the gating variable `f`.
- x : np.ndarray
- Array for the gating variable `x`.
- Cai_c : np.ndarray
- Array for the intracellular calcium concentration.
- mesh : np.ndarray
- Mesh array indicating the tissue types.
- dt : float
- Time step for the simulation.
-
- Notes
- -----
- The function uses various constants and equations specific to the Luo-Rudy 1991 model to compute ionic currents and
- update the state variables. The results are stored in `u_new`, which represents the membrane potential at the next
- time step.
- """
- Ko_c = 5.4
- Ki_c = 145
- Nai_c = 18
- Nao_c = 140
- Cao_c = 1.8
-
- R = 8.314
- T = 310 # Temperature in Kelvin (37°C)
- F = 96.5
-
- PR_NaK = 0.01833
- E_Na = (R*T/F)*log(Nao_c/Nai_c)
-
- n_i = u.shape[0]
- n_j = u.shape[1]
-
- for ii in prange(n_i*n_j):
- i = int(ii / n_j)
- j = ii % n_j
- if mesh[i, j] != 1:
- continue
-
- I_Na = 23 * pow(m[i, j], 3) * h[i, j] * j_[i, j] * (u[i, j] - E_Na)
-
- alpha_h, beta_h, beta_J, alpha_J = 0, 0, 0, 0
- if u[i, j] >= -40.:
- beta_h = 1. / (0.13 * (1 + exp((u[i, j] + 10.66) / -11.1)))
- beta_J = 0.3 * exp(-2.535 * 1e-07 * u[i, j]) / (1 + exp(-0.1 * (u[i, j] + 32)))
- else:
- alpha_h = 0.135 * exp((80 + u[i, j]) / -6.8)
- beta_h = 3.56 * exp(0.079 * u[i, j]) + 3.1 * 1e5 * exp(0.35 * u[i, j])
- beta_J = 0.1212 * exp(-0.01052 * u[i, j]) / (1 + exp(-0.1378 * (u[i, j] + 40.14)))
- alpha_J = (-1.2714 * 1e5 * exp(0.2444 * u[i, j]) - 3.474 * 1e-5 * exp(-0.04391 * u[i, j])) * \
- (u[i, j] + 37.78) / (1 + exp(0.311 * (u[i, j] + 79.23)))
-
- alpha_m = 0.32 * (u[i, j] + 47.13) / (1 - exp(-0.1 * (u[i, j] + 47.13)))
- beta_m = 0.08 * exp(-u[i, j] / 11)
-
- tau_m = 1. / (alpha_m + beta_m)
- inf_m = alpha_m / (alpha_m + beta_m)
- m[i, j] += dt * (inf_m - m[i, j]) / tau_m
-
- tau_h = 1. / (alpha_h + beta_h)
- inf_h = alpha_h / (alpha_h + beta_h)
- h[i, j] += dt * (inf_h - h[i, j]) / tau_h
-
- tau_J = 1. / (alpha_J + beta_J)
- inf_J = alpha_J / (alpha_J + beta_J)
- j_[i, j] += dt * (inf_J - j_[i, j]) / tau_J
-
- # Slow inward current:
- E_Si = 7.7 - 13.0287 * log(Cai_c[i, j])
- I_Si = 0.045 * d[i, j] * f[i, j] * (u[i, j] - E_Si)
- alpha_d = 0.095 * exp(-0.01 * (u[i, j] - 5)) / (1 + exp(-0.072 * (u[i, j] - 5)))
- beta_d = 0.07 * exp(-0.017 * (u[i, j] + 44)) / (1 + exp(0.05 * (u[i, j] + 44)))
- alpha_f = 0.012 * exp(-0.008 * (u[i, j] + 28)) / (1 + exp(0.15 * (u[i, j] + 28)))
- beta_f = 0.0065 * exp(-0.02 * (u[i, j] + 30)) / (1 + exp(-0.2 * (u[i, j] + 30)))
- Cai_c[i, j] += dt * (-0.0001 * I_Si + 0.07 * (0.0001 - Cai_c[i, j]))
-
- tau_d = 1. / (alpha_d + beta_d)
- inf_d = alpha_d / (alpha_d + beta_d)
- d[i, j] += dt * (inf_d - d[i, j]) / tau_d
-
- tau_f = 1. / (alpha_f + beta_f)
- inf_f = alpha_f / (alpha_f + beta_f)
- f[i, j] += dt * (inf_f - f[i, j]) / tau_f
-
- # Time-dependent potassium current
- E_K = (R * T / F) * log((Ko_c + PR_NaK * Nao_c) / (Ki_c + PR_NaK * Nai_c))
-
- G_K = 0.705 * sqrt(Ko_c / 5.4)
-
- Xi = 0
- if u[i, j] > -100:
- Xi = 2.837 * (exp(0.04 * (u[i, j] + 77)) - 1) / ((u[i, j] + 77) * exp(0.04 * (u[i, j] + 35)))
- else:
- Xi = 1
-
- I_K = G_K * x[i, j] * Xi * (u[i, j] - E_K)
-
- alpha_x = 0.0005 * exp(0.083 * (u[i, j] + 50)) / (1 + exp(0.057 * (u[i, j] + 50)))
- beta_x = 0.0013 * exp(-0.06 * (u[i, j] + 20)) / (1 + exp(-0.04 * (u[i, j] + 20)))
-
- tau_x = 1. / (alpha_x + beta_x)
- inf_x = alpha_x / (alpha_x + beta_x)
- x[i, j] += dt * (inf_x - x[i, j]) / tau_x
-
- # Time-independent potassium current:
- E_K1 = (R * T / F) * log(Ko_c / Ki_c)
-
- alpha_K1 = 1.02 / (1 + exp(0.2385 * (u[i, j] - E_K1 - 59.215)))
- beta_K1 = (0.49124 * exp(0.08032 * (u[i, j] - E_K1 + 5.476)) + exp(0.06175 * (u[i, j] - E_K1 - 594.31))) / \
- (1 + exp(-0.5143 * (u[i, j] - E_K1 + 4.753)))
-
- K_1x = alpha_K1 / (alpha_K1 + beta_K1)
-
- G_K1 = 0.6047 * sqrt(Ko_c / 5.4)
- I_K1 = G_K1 * K_1x * (u[i, j] - E_K1)
-
- # Plateau potassium current:
- E_Kp = E_K1
- K_p = 1. / (1 + exp((7.488 - u[i, j]) / 5.98))
- I_Kp = 0.0183 * K_p * (u[i, j] - E_Kp)
-
- # Background current:
- I_b = 0.03921 * (u[i, j] + 59.87)
-
- # Total time-independent potassium current:
- I_K1_T = I_K1 + I_Kp + I_b
-
- u_new[i, j] -= dt * (I_Na + I_Si + I_K1_T + I_K)
-
-
-class LuoRudy91Kernels2D:
- """
- Class to handle kernel functions for the Luo-Rudy 1991 cardiac model in 2D.
-
- This class provides methods to obtain the appropriate diffusion and ionic kernels based on the shape of the weight array.
-
- Methods
- -------
- get_diffuse_kernel(shape):
- Returns the diffusion kernel function based on the weight array shape.
- get_ionic_kernel():
- Returns the ionic kernel function used for updating membrane potentials and gating variables.
- """
-
- def __init__(self):
- """
- Initializes the LuoRudy91Kernels2D instance.
- """
- pass
-
- @staticmethod
- def get_diffuse_kernel(shape):
- """
- Retrieves the diffusion kernel function based on the weight shape.
-
- Parameters
- ----------
- shape : tuple
- The shape of the weight array used in the diffusion process.
-
- Returns
- -------
- function
- The diffusion kernel function appropriate for the given weight shape.
-
- Raises
- ------
- IncorrectWeightsShapeError
- If the shape of the weights array does not match expected values (5 or 9).
- """
- if shape[-1] == 5:
- return diffuse_kernel_2d_iso
- if shape[-1] == 9:
- return diffuse_kernel_2d_aniso
- else:
- raise IncorrectWeightsShapeError(shape, 5, 9)
-
- @staticmethod
- def get_ionic_kernel():
- """
- Retrieves the ionic kernel function for updating membrane potentials and gating variables.
-
- Returns
- -------
- function
- The ionic kernel function used in the Luo-Rudy 1991 model.
- """
- return ionic_kernel_2d
-
diff --git a/finitewave/cpuwave2D/model/mitchell_schaeffer_2d.py b/finitewave/cpuwave2D/model/mitchell_schaeffer_2d.py
new file mode 100644
index 0000000..eb42138
--- /dev/null
+++ b/finitewave/cpuwave2D/model/mitchell_schaeffer_2d.py
@@ -0,0 +1,218 @@
+import numpy as np
+from numba import njit, prange
+
+from finitewave.core.model.cardiac_model import CardiacModel
+from finitewave.cpuwave2D.stencil.asymmetric_stencil_2d import (
+ AsymmetricStencil2D
+)
+from finitewave.cpuwave2D.stencil.isotropic_stencil_2d import (
+ IsotropicStencil2D
+)
+
+
+class MitchellSchaeffer2D(CardiacModel):
+
+ def __init__(self):
+ """
+ Implements the 2D Mitchell-Schaeffer model of cardiac excitation.
+
+ This is a phenomenological two-variable model capturing the essence of cardiac
+ action potential dynamics using a simplified formulation. It separates inward and
+ outward currents and uses a single gating variable to regulate excitability.
+
+ It reproduces key features like:
+ - Excitability and recovery
+ - Action potential duration (APD)
+ - Restitution and wave propagation
+
+ Attributes
+ ----------
+ h : np.ndarray
+ Gating variable controlling the availability of inward current.
+ D_model : float
+ Diffusion coefficient for spatial propagation.
+ state_vars : list
+ Names of the dynamic variables for saving/restoring state.
+ npfloat : str
+ Floating-point type used (default: float64).
+
+ Paper
+ -----
+ Mitchell, C. C., & Schaeffer, D. G. (2003).
+ A two-current model for the dynamics of cardiac membrane
+ potential. Bulletin of Mathematical Biology, 65, 767–793.
+ https://doi.org/10.1016/S0092-8240(03)00041-7
+
+ """
+ super().__init__()
+ self.h = np.ndarray
+
+ self.D_model = 1.
+
+ self.state_vars = ["u", "h"]
+ self.npfloat = 'float64'
+
+ # model parameters
+ self.tau_close = 150
+ self.tau_open = 120
+ self.tau_out = 6
+ self.tau_in = 0.3
+ self.u_gate = 0.13
+
+ # initial conditions
+ self.init_u = 0.0
+ self.init_h = 1.0
+
+ def initialize(self):
+ """
+ Initializes the model for simulation.
+ """
+ super().initialize()
+ self.u = self.init_u * np.ones_like(self.u, dtype=self.npfloat)
+ self.h = self.init_h * np.ones_like(self.u, dtype=self.npfloat)
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel for the Mitchell-Schaeffer model.
+ """
+ ionic_kernel_2d(self.u_new, self.u, self.h, self.cardiac_tissue.myo_indexes, self.dt,
+ self.tau_close, self.tau_open, self.tau_in, self.tau_out, self.u_gate)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue2D
+ A tissue object representing the cardiac tissue.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to use for diffusion computations.
+ """
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil2D()
+
+ return AsymmetricStencil2D()
+
+@njit
+def calc_h(h, u, dt, tau_close, tau_open, u_gate):
+ """
+ Updates the gating variable h for the inward current.
+
+ The gating variable h plays the role of a generic recovery mechanism.
+ - It increases toward 1 with time constant tau_open when the membrane is at rest.
+ - It decreases toward 0 with time constant tau_close when the membrane is excited.
+
+ This mimics Na⁺ channel inactivation in a simplified way.
+
+ Parameters
+ ----------
+ h : float
+ Current value of the gating variable.
+ u : float
+ Membrane potential (dimensionless, in [0,1]).
+ dt : float
+ Time step [ms].
+ tau_close : float
+ Inactivation time constant (closing).
+ tau_open : float
+ Recovery time constant (opening).
+ u_gate : float
+ Threshold potential for switching gate dynamics.
+
+ Returns
+ -------
+ float
+ Updated value of h.
+ """
+ h += dt * (1.0 - h) / tau_open if u < u_gate else dt * (-h) / tau_close
+ return h
+
+@njit
+def calc_J_in(h, u, tau_in):
+ """
+ Computes the inward current responsible for depolarization.
+
+ This is a regenerative current:
+ J_in = h * u² * (1 - u) / tau_in
+
+ It activates when h is high (available) and u is sufficiently depolarized.
+ The form ensures that the current grows with u but shuts off when u ~ 1.
+
+ Parameters
+ ----------
+ h : float
+ Gating variable controlling channel availability.
+ u : float
+ Membrane potential (dimensionless).
+ tau_in : float
+ Time constant for inward flow.
+
+ Returns
+ -------
+ float
+ Value of the inward current.
+ """
+ C = (u**2)*(1-u)
+ return h*C/tau_in
+
+@njit
+def calc_J_out(u, tau_out):
+ """
+ Computes the outward current responsible for repolarization.
+
+ This linear term simulates the slow repolarizing current that restores
+ the membrane potential back to rest.
+
+ J_out = -u / tau_out
+
+ Parameters
+ ----------
+ u : float
+ Membrane potential.
+ tau_out : float
+ Time constant for outward current (repolarization).
+
+ Returns
+ -------
+ float
+ Value of the outward current.
+ """
+ return -u/tau_out
+
+@njit(parallel=True)
+def ionic_kernel_2d(u_new, u, h, indexes, dt, tau_close, tau_open, tau_in, tau_out, u_gate):
+ """
+ Ionic kernel for the Mitchell-Schaeffer model in 2D.
+
+ Parameters
+ ----------
+ u_new : ndarray
+ The new state of the u variable.
+ u : ndarray
+ The current state of the u variable.
+ h : ndarray
+ The gating variable h.
+ myo_indexes : list
+ List of indexes representing myocardial cells.
+ dt : float
+ The time step for the simulation.
+ """
+ n_j = u.shape[1]
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = int(ii / n_j)
+ j = ii % n_j
+
+ h[i, j] = calc_h(h[i, j], u[i, j], dt, tau_close, tau_open, u_gate)
+
+ J_in = calc_J_in(h[i, j], u[i, j], tau_in)
+ J_out = calc_J_out(u[i, j], tau_out)
+ u_new[i, j] += dt * (J_in + J_out)
+
diff --git a/finitewave/cpuwave2D/model/tp06_2d.py b/finitewave/cpuwave2D/model/tp06_2d.py
new file mode 100644
index 0000000..207b9e8
--- /dev/null
+++ b/finitewave/cpuwave2D/model/tp06_2d.py
@@ -0,0 +1,1104 @@
+import numpy as np
+from numba import njit, prange
+
+from finitewave.core.model.cardiac_model import CardiacModel
+from finitewave.cpuwave2D.stencil.asymmetric_stencil_2d import (
+ AsymmetricStencil2D
+)
+from finitewave.cpuwave2D.stencil.isotropic_stencil_2d import (
+ IsotropicStencil2D
+)
+
+
+class TP062D(CardiacModel):
+ """
+ Implements the ten Tusscher–Panfilov 2006 (TP06) human ventricular ionic model in 2D.
+
+ The TP06 model is a detailed biophysical model of the human ventricular
+ action potential, designed to simulate realistic electrical behavior in
+ tissue including alternans, reentrant waves, and spiral wave breakup.
+
+ This model includes:
+ - 18 dynamic state variables (voltage, ion concentrations, channel gates, buffers)
+ - Full calcium handling with subspace (cass) and sarcoplasmic reticulum (casr)
+ - Sodium, potassium, and calcium currents including background, exchanger, and pumps
+ - Buffering effects and intracellular transport
+
+ Finitewave provides this model in 2D form for efficient simulation and
+ reproducible experimentation with custom spatial setups.
+
+ Attributes
+ ----------
+ D_model : float
+ Diffusion coefficient specific to this model (cm²/ms).
+ state_vars : list of str
+ List of all state variable names, used for checkpointing and logging.
+ ko : float
+ Extracellular potassium concentration (mM).
+ cao : float
+ Extracellular calcium concentration (mM).
+ nao : float
+ Extracellular sodium concentration (mM).
+ Vc : float
+ Cytoplasmic volume (μL).
+ Vsr : float
+ Sarcoplasmic reticulum volume (μL).
+ Vss : float
+ Subsarcolemmal space volume (μL).
+ R, T, F : float
+ Universal gas constant, absolute temperature, and Faraday constant.
+ RTONF : float
+ Precomputed RT/F value for Nernst equation.
+ CAPACITANCE : float
+ Membrane capacitance per unit area (μF/cm²).
+ gna, gcal, gkr, gks, gk1, gto : float
+ Conductances for major ionic channels.
+ gbna, gbca : float
+ Background sodium and calcium conductances.
+ gpca, gpk : float
+ Pump-related conductances.
+ knak, knaca : float
+ Maximal Na⁺/K⁺ pump and Na⁺/Ca²⁺ exchanger rates.
+ Km*, Kbuf*, Vmaxup, Vrel, etc.
+ Numerous kinetic constants for buffering, pump activity, and calcium handling.
+
+ Paper
+ -----
+ ten Tusscher KH, Panfilov AV.
+ Alternans and spiral breakup in a human ventricular tissue model.
+ Am J Physiol Heart Circ Physiol. 2006 Sep;291(3):H1088–H1100.
+ https://doi.org/10.1152/ajpheart.00109.2006
+
+ """
+
+ def __init__(self):
+ super().__init__()
+ self.D_model = 0.154
+
+ self.state_vars = ["u", "cai", "casr", "cass", "nai", "Ki",
+ "m", "h", "j", "xr1", "xr2", "xs", "r",
+ "s", "d", "f", "f2", "fcass", "rr", "oo"]
+ self.npfloat = 'float64'
+
+ # Extracellular Ion Concentrations (mM)
+ self.ko = 5.4 # Potassium extracellular concentration
+ self.cao = 2.0 # Calcium extracellular concentration
+ self.nao = 140.0 # Sodium extracellular concentration
+
+ # Cell Volume (in uL)
+ self.Vc = 0.016404 # Cytoplasmic volume
+ self.Vsr = 0.001094 # Sarcoplasmic reticulum volume
+ self.Vss = 0.00005468 # Subsarcolemmal space volume
+
+ # Buffering Parameters
+ self.Bufc = 0.2 # Cytoplasmic buffer concentration
+ self.Kbufc = 0.001 # Cytoplasmic buffer affinity
+ self.Bufsr = 10.0 # SR buffer concentration
+ self.Kbufsr = 0.3 # SR buffer affinity
+ self.Bufss = 0.4 # Subsarcolemmal buffer concentration
+ self.Kbufss = 0.00025 # Subsarcolemmal buffer affinity
+
+ # Calcium Handling Parameters
+ self.Vmaxup = 0.006375 # Maximal calcium uptake rate
+ self.Kup = 0.00025 # Calcium uptake affinity
+ self.Vrel = 0.102 # Calcium release rate from SR
+ self.k1_ = 0.15 # Transition rate for SR calcium release
+ self.k2_ = 0.045
+ self.k3 = 0.060
+ self.k4 = 0.005 # Alternative transition rate
+ self.EC = 1.5 # Calcium-induced calcium release sensitivity
+ self.maxsr = 2.5 # Maximum SR calcium release permeability
+ self.minsr = 1.0 # Minimum SR calcium release permeability
+ self.Vleak = 0.00036 # SR calcium leak rate
+ self.Vxfer = 0.0038 # Calcium transfer rate from subspace to cytosol
+
+ # Physical Constants
+ self.R = 8314.472 # Universal gas constant (J/(kmol·K))
+ self.F = 96485.3415 # Faraday constant (C/mol)
+ self.T = 310.0 # Temperature (Kelvin, 37°C)
+ self.RTONF = 26.71376 # RT/F constant for Nernst equation
+
+ # Membrane Capacitance
+ self.CAPACITANCE = 0.185 # Membrane capacitance (μF/cm²)
+
+ # Ion Channel Conductances
+ self.gkr = 0.153 # Rapid delayed rectifier K+ conductance
+ self.gks = 0.392 # Slow delayed rectifier K+ conductance
+ self.gk1 = 5.405 # Inward rectifier K+ conductance
+ self.gto = 0.294 # Transient outward K+ conductance
+ self.gna = 14.838 # Fast Na+ conductance
+ self.gbna = 0.00029 # Background Na+ conductance
+ self.gcal = 0.00003980 # L-type Ca2+ channel conductance
+ self.gbca = 0.000592 # Background Ca2+ conductance
+ self.gpca = 0.1238 # Sarcolemmal Ca2+ pump current conductance
+ self.KpCa = 0.0005 # Sarcolemmal Ca2+ pump affinity
+ self.gpk = 0.0146 # Na+/K+ pump current conductance
+
+ # Na+/K+ Pump Parameters
+ self.pKNa = 0.03 # Na+/K+ permeability ratio
+ self.KmK = 1.0 # Half-saturation for K+ activation
+ self.KmNa = 40.0 # Half-saturation for Na+ activation
+ self.knak = 2.724 # Maximal Na+/K+ pump rate
+
+ # Na+/Ca2+ Exchanger Parameters
+ self.knaca = 1000 # Maximal Na+/Ca2+ exchanger current
+ self.KmNai = 87.5 # Half-saturation for Na+ binding
+ self.KmCa = 1.38 # Half-saturation for Ca2+ binding
+ self.ksat = 0.1 # Saturation factor
+ self.n_ = 0.35 # Exponent for Na+ dependence
+
+ # initial conditions
+ self.init_u = -84.5
+ self.init_cai = 0.00007
+ self.init_casr = 1.3
+ self.init_cass = 0.00007
+ self.init_nai = 7.67
+ self.init_Ki = 138.3
+ self.init_m = 0.0
+ self.init_h = 0.75
+ self.init_j = 0.75
+ self.init_xr1 = 0.0
+ self.init_xr2 = 1.0
+ self.init_xs = 0.0
+ self.init_r = 0.0
+ self.init_s = 1.0
+ self.init_d = 0.0
+ self.init_f = 1.0
+ self.init_f2 = 1.0
+ self.init_fcass = 1.0
+ self.init_rr = 1.0
+ self.init_oo = 0.0
+
+ def initialize(self):
+ """
+ Initializes the model's state variables and diffusion/ionic kernels.
+
+ Sets up the initial values for membrane potential, ion concentrations,
+ gating variables, and assigns the appropriate kernel functions.
+ """
+ super().initialize()
+ shape = self.cardiac_tissue.mesh.shape
+
+ self.u = self.init_u * np.ones(shape, dtype=self.npfloat)
+ self.u_new = self.u.copy()
+ self.cai = self.init_cai * np.ones(shape, dtype=self.npfloat)
+ self.casr = self.init_casr * np.ones(shape, dtype=self.npfloat)
+ self.cass = self.init_cass * np.ones(shape, dtype=self.npfloat)
+ self.nai = self.init_nai * np.ones(shape, dtype=self.npfloat)
+ self.Ki = self.init_Ki * np.ones(shape, dtype=self.npfloat)
+ self.m = self.init_m * np.ones(shape, dtype=self.npfloat)
+ self.h = self.init_h * np.ones(shape, dtype=self.npfloat)
+ self.j = self.init_j * np.ones(shape, dtype=self.npfloat)
+ self.xr1 = self.init_xr1 * np.ones(shape, dtype=self.npfloat)
+ self.xr2 = self.init_xr2 * np.ones(shape, dtype=self.npfloat)
+ self.xs = self.init_xs * np.ones(shape, dtype=self.npfloat)
+ self.r = self.init_r * np.ones(shape, dtype=self.npfloat)
+ self.s = self.init_s * np.ones(shape, dtype=self.npfloat)
+ self.d = self.init_d * np.ones(shape, dtype=self.npfloat)
+ self.f = self.init_f * np.ones(shape, dtype=self.npfloat)
+ self.f2 = self.init_f2 * np.ones(shape, dtype=self.npfloat)
+ self.fcass = self.init_fcass * np.ones(shape, dtype=self.npfloat)
+ self.rr = self.init_rr * np.ones(shape, dtype=self.npfloat)
+ self.oo = self.init_oo * np.ones(shape, dtype=self.npfloat)
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel function to update ionic currents and state
+ variables
+ """
+ ionic_kernel_2d(self.u_new, self.u, self.cai, self.casr, self.cass,
+ self.nai, self.Ki, self.m, self.h, self.j, self.xr1,
+ self.xr2, self.xs, self.r, self.s, self.d, self.f,
+ self.f2, self.fcass, self.rr, self.oo,
+ self.cardiac_tissue.myo_indexes, self.dt,
+ self.ko, self.cao, self.nao, self.Vc, self.Vsr, self.Vss, self.Bufc, self.Kbufc, self.Bufsr, self.Kbufsr,
+ self.Bufss, self.Kbufss, self.Vmaxup, self.Kup, self.Vrel, self.k1_, self.k2_, self.k3, self.k4, self.EC,
+ self.maxsr, self.minsr, self.Vleak, self.Vxfer, self.R, self.F, self.T, self.RTONF, self.CAPACITANCE,
+ self.gkr, self.pKNa, self.gk1, self.gna, self.gbna, self.KmK, self.KmNa, self.knak, self.gcal, self.gbca,
+ self.knaca, self.KmNai, self.KmCa, self.ksat, self.n_, self.gpca, self.KpCa, self.gpk, self.gto, self.gks)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue2D
+ A tissue object representing the cardiac tissue.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to use for diffusion computations.
+ """
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil2D()
+
+ return AsymmetricStencil2D()
+
+
+@njit
+def calc_ina(u, dt, m, h, j, gna, Ena):
+ """
+ Calculates the fast sodium current.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ Membrane potential array.
+ dt : float
+ Time step for the simulation.
+ m : np.ndarray
+ Gating variable for sodium channels (activation).
+ h : np.ndarray
+ Gating variable for sodium channels (inactivation).
+ j : np.ndarray
+ Gating variable for sodium channels (inactivation).
+ gna : float
+ Sodium conductance.
+ Ena : float
+ Sodium reversal potential.
+
+ Returns
+ -------
+ np.ndarray
+ Updated fast sodium current array.
+ """
+
+ alpha_m = 1./(1.+np.exp((-60.-u)/5.))
+ beta_m = 0.1/(1.+np.exp((u+35.)/5.)) + \
+ 0.10/(1.+np.exp((u-50.)/200.))
+ tau_m = alpha_m*beta_m
+ m_inf = 1./((1.+np.exp((-56.86-u)/9.03))
+ * (1.+np.exp((-56.86-u)/9.03)))
+
+ alpha_h = 0.
+ beta_h = 0.
+ if u >= -40.:
+ alpha_h = 0.
+ beta_h = 0.77/(0.13*(1.+np.exp(-(u+10.66)/11.1)))
+ else:
+ alpha_h = 0.057*np.exp(-(u+80.)/6.8)
+ beta_h = 2.7*np.exp(0.079*u)+(3.1e5)*np.exp(0.3485*u)
+
+ tau_h = 1.0/(alpha_h + beta_h)
+
+ h_inf = 1./((1.+np.exp((u+71.55)/7.43))
+ * (1.+np.exp((u+71.55)/7.43)))
+
+ alpha_j = 0.
+ beta_j = 0.
+ if u >= -40.:
+ alpha_j = 0.
+ beta_j = 0.6*np.exp((0.057)*u)/(1.+np.exp(-0.1*(u+32.)))
+ else:
+ alpha_j = ((-2.5428e4)*np.exp(0.2444*u)-(6.948e-6) *
+ np.exp(-0.04391*u))*(u+37.78) /\
+ (1.+np.exp(0.311*(u+79.23)))
+ beta_j = 0.02424*np.exp(-0.01052*u) / \
+ (1.+np.exp(-0.1378*(u+40.14)))
+
+ tau_j = 1.0/(alpha_j + beta_j)
+
+ j_inf = h_inf
+
+ m = m_inf-(m_inf-m)*np.exp(-dt/tau_m)
+ h = h_inf-(h_inf-h)*np.exp(-dt/tau_h)
+ j = j_inf-(j_inf-j)*np.exp(-dt/tau_j)
+
+ return gna*m*m*m*h*j*(u-Ena), m, h, j
+
+@njit
+def calc_ical(u, dt, d, f, f2, fcass, cao, cass, gcal, F, R, T):
+ """
+ Calculates the L-type calcium current.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ Membrane potential array.
+ dt : float
+ Time step for the simulation.
+ d : np.ndarray
+ Gating variable for L-type calcium channels.
+ f : np.ndarray
+ Gating variable for calcium-dependent calcium channels.
+ f2 : np.ndarray
+ Secondary gating variable for calcium-dependent calcium channels.
+ fcass : np.ndarray
+ Gating variable for calcium-sensitive current.
+ cao : float
+ Extracellular calcium concentration.
+ cass : np.ndarray
+ Calcium concentration in the submembrane space.
+ gcal : float
+ Calcium conductance.
+ F : float
+ Faraday's constant.
+ R : float
+ Ideal gas constant.
+ T : float
+
+ Returns
+ -------
+ np.ndarray
+ Updated L-type calcium current array.
+ """
+
+ d_inf = 1./(1.+np.exp((-8-u)/7.5))
+ Ad = 1.4/(1.+np.exp((-35-u)/13))+0.25
+ Bd = 1.4/(1.+np.exp((u+5)/5))
+ Cd = 1./(1.+np.exp((50-u)/20))
+ tau_d = Ad*Bd+Cd
+ f_inf = 1./(1.+np.exp((u+20)/7))
+ Af = 1102.5*np.exp(-(u+27)*(u+27)/225)
+ Bf = 200./(1+np.exp((13-u)/10.))
+ Cf = (180./(1+np.exp((u+30)/10)))+20
+ tau_f = Af+Bf+Cf
+ f2_inf = 0.67/(1.+np.exp((u+35)/7))+0.33
+ Af2 = 600*np.exp(-(u+25)*(u+25)/170)
+ Bf2 = 31/(1.+np.exp((25-u)/10))
+ Cf2 = 16/(1.+np.exp((u+30)/10))
+ tau_f2 = Af2+Bf2+Cf2
+ fcass_inf = 0.6/(1+(cass/0.05)*(cass/0.05))+0.4
+ tau_fcass = 80./(1+(cass/0.05)*(cass/0.05))+2.
+
+ d = d_inf-(d_inf-d)*np.exp(-dt/tau_d)
+ f = f_inf-(f_inf-f)*np.exp(-dt/tau_f)
+ f2 = f2_inf-(f2_inf-f2)*np.exp(-dt/tau_f2)
+ fcass = fcass_inf-(fcass_inf-fcass)*np.exp(-dt/tau_fcass)
+
+ return gcal*d*f*f2*fcass*4*(u-15)*(F*F/(R*T)) *\
+ (0.25*np.exp(2*(u-15)*F/(R*T))*cass-cao) / \
+ (np.exp(2*(u-15)*F/(R*T))-1.), d, f, f2, fcass
+
+@njit
+def calc_ito(u, dt, r, s, Ek, gto):
+ """
+ Calculates the transient outward current.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ Membrane potential array.
+ dt : float
+ Time step for the simulation.
+ r : np.ndarray
+ Gating variable for ryanodine receptors.
+ s : np.ndarray
+ Gating variable for calcium-sensitive current.
+ ek : float
+ Potassium reversal potential.
+
+ Returns
+ -------
+ np.ndarray
+ Updated transient outward current array.
+ """
+
+ r_inf = 1./(1.+np.exp((20-u)/6.))
+ s_inf = 1./(1.+np.exp((u+20)/5.))
+ tau_r = 9.5*np.exp(-(u+40.)*(u+40.)/1800.)+0.8
+ tau_s = 85.*np.exp(-(u+45.)*(u+45.)/320.) + \
+ 5./(1.+np.exp((u-20.)/5.))+3.
+
+ s = s_inf-(s_inf-s)*np.exp(-dt/tau_s)
+ r = r_inf-(r_inf-r)*np.exp(-dt/tau_r)
+
+ return gto*r*s*(u-Ek), r, s
+
+@njit
+def calc_ikr(u, dt, xr1, xr2, Ek, gkr, ko):
+ """
+ Calculates the rapid delayed rectifier potassium current.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ Membrane potential array.
+ dt : float
+ Time step for the simulation.
+ xr1 : np.ndarray
+ Gating variable for rapid delayed rectifier potassium channels.
+ xr2 : np.ndarray
+ Gating variable for rapid delayed rectifier potassium channels.
+ Ek : float
+ Potassium reversal potential.
+ gkr : float
+ Potassium conductance.
+
+ Returns
+ -------
+ np.ndarray
+ Updated rapid delayed rectifier potassium current array.
+ """
+
+ xr1_inf = 1./(1.+np.exp((-26.-u)/7.))
+ axr1 = 450./(1.+np.exp((-45.-u)/10.))
+ bxr1 = 6./(1.+np.exp((u-(-30.))/11.5))
+ tau_xr1 = axr1*bxr1
+ xr2_inf = 1./(1.+np.exp((u-(-88.))/24.))
+ axr2 = 3./(1.+np.exp((-60.-u)/20.))
+ bxr2 = 1.12/(1.+np.exp((u-60.)/20.))
+ tau_xr2 = axr2*bxr2
+
+ xr1 = xr1_inf-(xr1_inf-xr1)*np.exp(-dt/tau_xr1)
+ xr2 = xr2_inf-(xr2_inf-xr2)*np.exp(-dt/tau_xr2)
+
+ return gkr*np.sqrt(ko/5.4)*xr1*xr2*(u-Ek), xr1, xr2
+
+@njit
+def calc_iks(u, dt, xs, Eks, gks):
+ """
+ Calculates the slow delayed rectifier potassium current.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ Membrane potential array.
+ dt : float
+ Time step for the simulation.
+ xs : np.ndarray
+ Gating variable for slow delayed rectifier potassium channels.
+ Eks : float
+ Potassium reversal potential.
+ gks : float
+ Potassium conductance.
+
+ Returns
+ -------
+ np.ndarray
+ Updated slow delayed rectifier potassium current array.
+ """
+ xs_inf = 1./(1.+np.exp((-5.-u)/14.))
+ Axs = (1400./(np.sqrt(1.+np.exp((5.-u)/6))))
+ Bxs = (1./(1.+np.exp((u-35.)/15.)))
+ tau_xs = Axs*Bxs+80
+ xs_inf = 1./(1.+np.exp((-5.-u)/14.))
+
+ xs = xs_inf-(xs_inf-xs)*np.exp(-dt/tau_xs)
+
+ return gks*xs*xs*(u-Eks), xs
+
+@njit
+def calc_ik1(u, Ek, gk1):
+ """
+ Calculates the inward rectifier potassium current.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ Membrane potential array.
+ Ek : float
+ Potassium reversal potential.
+ gk1 : float
+ Inward rectifier potassium conductance.
+
+ Returns
+ -------
+ np.ndarray
+ Updated inward rectifier potassium current array.
+ """
+
+ ak1 = 0.1/(1.+np.exp(0.06*(u-Ek-200)))
+ bk1 = (3.*np.exp(0.0002*(u-Ek+100)) +
+ np.exp(0.1*(u-Ek-10)))/(1.+np.exp(-0.5*(u-Ek)))
+ rec_iK1 = ak1/(ak1+bk1)
+
+ return gk1*rec_iK1*(u-Ek)
+
+@njit
+def calc_inaca(u, nao, nai, cao, cai, KmNai, KmCa, knaca, ksat, n_, F, R, T):
+ """
+ Calculates the sodium-calcium exchanger current.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ Membrane potential array.
+ nao : float
+ Sodium ion concentration in the extracellular space.
+ nai : np.ndarray
+ Sodium ion concentration in the intracellular space.
+ cao : float
+ Calcium ion concentration in the extracellular space.
+ cai : np.ndarray
+ Calcium ion concentration in the submembrane space.
+ KmNai : float
+ Michaelis constant for sodium.
+ KmCa : float
+ Michaelis constant for calcium.
+ knaca : float
+ Sodium-calcium exchanger conductance.
+ ksat : float
+ Saturation factor.
+ n_ : float
+ Exponent for sodium dependence.
+ F : float
+ Faraday's constant.
+ R : float
+ Ideal gas constant.
+ T : float
+ Temperature.
+
+ Returns
+ -------
+ np.ndarray
+ Updated sodium-calcium exchanger current array.
+ """
+
+ return knaca*(1./(KmNai*KmNai*KmNai+nao*nao*nao))*(1./(KmCa+cao)) *\
+ (1./(1+ksat*np.exp((n_-1)*u*F/(R*T)))) *\
+ (np.exp(n_*u*F/(R*T))*nai*nai*nai*cao -
+ np.exp((n_-1)*u*F/(R*T))*nao*nao*nao*cai*2.5)
+
+@njit
+def calc_inak(u, nai, ko, KmK, KmNa, knak, F, R, T):
+ """
+ Calculates the sodium-potassium pump current.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ Membrane potential array.
+ nai : np.ndarray
+ Sodium ion concentration in the intracellular space.
+ ko : float
+ Potassium ion concentration in the extracellular space.
+ KmK : float
+ Michaelis constant for potassium.
+ KmNa : float
+ Michaelis constant for sodium.
+ knak : float
+ Sodium-potassium pump conductance.
+ F : float
+ Faraday's constant.
+ R : float
+ Ideal gas constant.
+ T : float
+ Temperature.
+
+ Returns
+ -------
+ np.ndarray
+ Updated sodium-potassium pump current array.
+ """
+
+ rec_iNaK = (
+ 1./(1.+0.1245*np.exp(-0.1*u*F/(R*T))+0.0353*np.exp(-u*F/(R*T))))
+
+ return knak*(ko/(ko+KmK))*(nai/(nai+KmNa))*rec_iNaK
+
+@njit
+def calc_ipca(cai, KpCa, gpca):
+ """
+ Calculates the calcium pump current.
+
+ Parameters
+ ----------
+ cai : np.ndarray
+ Calcium concentration in the submembrane space.
+ KpCa : float
+ Michaelis constant for calcium pump.
+ gpca : float
+ Calcium pump conductance.
+
+ Returns
+ -------
+ np.ndarray
+ Updated calcium pump current array.
+ """
+
+ return gpca*cai/(KpCa+cai)
+
+@njit
+def calc_ipk(u, Ek, gpk):
+ """
+ Calculates the potassium pump current.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ Membrane potential array.
+ Ek : float
+ Potassium reversal potential.
+ gpk : float
+ Potassium pump conductance.
+
+ Returns
+ -------
+ np.ndarray
+ Updated potassium pump current array.
+ """
+ rec_ipK = 1./(1.+np.exp((25-u)/5.98))
+
+ return gpk*rec_ipK*(u-Ek)
+
+@njit
+def calc_ibna(u, Ena, gbna):
+ """
+ Calculates the background sodium current.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ Membrane potential array.
+ Ena : float
+ Sodium reversal potential.
+ gbna : float
+ Background sodium conductance.
+
+ Returns
+ -------
+ np.ndarray
+ Updated background sodium current array.
+ """
+
+ return gbna*(u-Ena)
+
+@njit
+def calc_ibca(u, Eca, gbca):
+ """
+ Calculates the background calcium current.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ Membrane potential array.
+ Eca : float
+ Calcium reversal potential.
+ gbca : float
+ Background calcium conductance.
+
+ Returns
+ -------
+ np.ndarray
+ Updated background calcium current array.
+ """
+
+ return gbca*(u-Eca)
+
+@njit
+def calc_irel(dt, rr, oo, casr, cass, vrel, k1, k2, k3, k4, maxsr, minsr, EC):
+ """
+ Calculates the ryanodine receptor current.
+
+ Parameters
+ ----------
+ dt : float
+ Time step for the simulation.
+ rr : np.ndarray
+ Ryanodine receptor gating variable for calcium release.
+ oo : np.ndarray
+ Ryanodine receptor gating variable for calcium release.
+ casr : np.ndarray
+ Calcium concentration in the sarcoplasmic reticulum.
+ cass : np.ndarray
+ Calcium concentration in the submembrane space.
+ vrel : float
+ Release rate of calcium from the sarcoplasmic reticulum.
+ k1 : float
+ Transition rate for SR calcium release.
+ k2 : float
+ Transition rate for SR calcium release.
+ k3 : float
+ Transition rate for SR calcium release.
+ k4 : float
+ Alternative transition rate.
+ maxsr : float
+ Maximum SR calcium release permeability.
+ minsr : float
+ Minimum SR calcium release permeability.
+ EC : float
+ Calcium-induced calcium release sensitivity.
+
+ Returns
+ -------
+ np.ndarray
+ Updated ryanodine receptor current array.
+ """
+
+ kCaSR = maxsr-((maxsr-minsr)/(1+(EC/casr)*(EC/casr)))
+ k1_ = k1/kCaSR
+ k2_ = k2*kCaSR
+ drr = k4*(1-rr)-k2_*cass*rr
+ rr += dt*drr
+ oo = k1_*cass*cass * rr/(k3+k1_*cass*cass)
+
+ return vrel*oo*(casr-cass), rr, oo
+
+@njit
+def calc_ileak(casr, cai, vleak):
+ """
+ Calculates the calcium leak current.
+
+ Parameters
+ ----------
+ casr : np.ndarray
+ Calcium concentration in the sarcoplasmic reticulum.
+ cai : np.ndarray
+ Calcium concentration in the submembrane space.
+ vleak : float
+ Leak rate of calcium from the sarcoplasmic reticulum.
+
+ Returns
+ -------
+ np.ndarray
+ Updated calcium leak current array.
+ """
+
+ return vleak*(casr-cai)
+
+@njit
+def calc_iup(cai, vmaxup, Kup):
+ """
+ Calculates the calcium uptake current.
+
+ Parameters
+ ----------
+ cai : np.ndarray
+ Calcium concentration in the submembrane space.
+ vmaxup : float
+ Uptake rate of calcium into the sarcoplasmic reticulum.
+ Kup : float
+ Michaelis constant for calcium uptake.
+
+ Returns
+ -------
+ np.ndarray
+ Updated calcium uptake current array.
+ """
+
+ return vmaxup/(1.+((Kup*Kup)/(cai*cai)))
+
+@njit
+def calc_ixfer(cass, cai, vxfer):
+ """
+ Calculates the calcium transfer current.
+
+ Parameters
+ ----------
+ cass : np.ndarray
+ Calcium concentration in the submembrane space.
+ cai : np.ndarray
+ Calcium concentration in the submembrane space.
+ vxfer : float
+ Transfer rate of calcium between the submembrane space and cytosol.
+
+ Returns
+ -------
+ np.ndarray
+ Updated calcium transfer current array.
+ """
+
+ return vxfer*(cass-cai)
+
+@njit
+def calc_casr(dt, caSR, bufsr, Kbufsr, iup, irel, ileak):
+ """
+ Calculates the calcium concentration in the sarcoplasmic reticulum.
+
+ Parameters
+ ----------
+ casr : np.ndarray
+ Calcium concentration in the sarcoplasmic reticulum.
+ bufsr : float
+ Buffering capacity of the sarcoplasmic reticulum.
+ Kbufsr : float
+ Buffering constant of the sarcoplasmic reticulum.
+ iup : float
+ Calcium uptake current.
+ irel : float
+ Calcium release current.
+ ileak : float
+ Leak rate of calcium from the sarcoplasmic reticulum.
+
+ Returns
+ -------
+ np.ndarray
+ Updated calcium concentration in the sarcoplasmic reticulum.
+ """
+
+ CaCSQN = bufsr*caSR/(caSR+Kbufsr)
+ dCaSR = dt*(iup-irel-ileak)
+ bjsr = bufsr-CaCSQN-dCaSR-caSR+Kbufsr
+ cjsr = Kbufsr*(CaCSQN+dCaSR+caSR)
+ return (np.sqrt(bjsr*bjsr+4*cjsr)-bjsr)/2
+
+@njit
+def calc_cass(dt, caSS, bufss, Kbufss, ixfer, irel, ical, capacitance, Vc, Vss, Vsr, inversevssF2):
+ """
+ Calculates the calcium concentration in the submembrane space.
+
+ Parameters
+ ----------
+ cass : np.ndarray
+ Calcium concentration in the submembrane space.
+ bufss : float
+ Buffering capacity of the submembrane space.
+ Kbufss : float
+ Buffering constant of the submembrane space.
+ ixfer : float
+ Calcium transfer current.
+ irel : float
+ Calcium release current.
+ ical : float
+ L-type calcium current.
+ capacitance : float
+ Membrane capacitance.
+ Vc : float
+ Volume of the cytosol.
+ Vss : float
+ Volume of the submembrane space.
+ Vsr : float
+ Volume of the sarcoplasmic reticulum.
+ inversevssF2 : float
+ Inverse of the product of 2
+ times the volume of the submembrane space and Faraday's constant.
+
+ Returns
+ -------
+ np.ndarray
+ Updated calcium concentration in the submembrane space.
+ """
+
+ CaSSBuf = bufss*caSS/(caSS+Kbufss)
+ dCaSS = dt*(-ixfer*(Vc/Vss)+irel*(Vsr/Vss) +
+ (-ical*inversevssF2*capacitance))
+ bcss = bufss-CaSSBuf-dCaSS-caSS+Kbufss
+ ccss = Kbufss*(CaSSBuf+dCaSS+caSS)
+ return (np.sqrt(bcss*bcss+4*ccss)-bcss)/2
+
+@njit
+def calc_cai(dt, cai, bufc, Kbufc, ibca, ipca, inaca, iup, ileak, ixfer, capacitance, vsr, vc, inverseVcF2):
+ """
+ Calculates the calcium concentration in the cytosol.
+
+ Parameters
+ ----------
+ cai : np.ndarray
+ Calcium concentration in the cytosol.
+ bufc : float
+ Buffering capacity of the cytosol.
+ Kbufc : float
+ Buffering constant of the cytosol.
+ ibca : float
+ Background calcium current.
+ ipca : float
+ Calcium pump current.
+ inaca : float
+ Sodium-calcium exchanger current.
+ iup : float
+ Calcium uptake current.
+ ileak : float
+ Calcium leak current.
+ ixfer : float
+ Calcium transfer current.
+ capacitance : float
+ Membrane capacitance.
+ vsr : float
+ Volume of the sarcoplasmic reticulum.
+ vc : float
+ Volume of the cytosol.
+ inverseVcF2 : float
+ Inverse of the product of 2
+ times the volume of the cytosol and Faraday's constant.
+
+ Returns
+ -------
+ np.ndarray
+ Updated calcium concentration in the cytosol.
+ """
+
+ CaCBuf = bufc*cai/(cai+Kbufc)
+ dCai = dt*((-(ibca+ipca-2*inaca)*inverseVcF2*capacitance) -
+ (iup-ileak)*(vsr/vc)+ixfer)
+ bc = bufc-CaCBuf-dCai-cai+Kbufc
+ cc = Kbufc*(CaCBuf+dCai+cai)
+ return (np.sqrt(bc*bc+4*cc)-bc)/2, cai
+
+@njit
+def calc_nai(dt, ina, ibna, inak, inaca, capacitance, inverseVcF):
+ """
+ Calculates the sodium concentration in the cytosol.
+
+ Parameters
+ ----------
+ dt : float
+ Time step for the simulation.
+ ina : float
+ Fast sodium current.
+ ibna : float
+ Background sodium current.
+ inak : float
+ Sodium-potassium pump current.
+ inaca : float
+ Sodium-calcium exchanger current.
+ capacitance : float
+ Membrane capacitance.
+ inverseVcF : float
+ Inverse of the product of the volume of the cytosol and Faraday's constant.
+
+ Returns
+ -------
+ np.ndarray
+ Updated sodium concentration in the cytosol.
+ """
+
+ dNai = -(ina+ibna+3*inak+3*inaca)*inverseVcF*capacitance
+ return dt*dNai
+
+@njit
+def calc_ki(dt, ik1, ito, ikr, iks, inak, ipk, inverseVcF, capacitance):
+ """
+ Calculates the potassium concentration in the cytosol.
+
+ Parameters
+ ----------
+ ik1 : float
+ Inward rectifier potassium current.
+ ito : float
+ Transient outward current.
+ ikr : float
+ Rapid delayed rectifier potassium current.
+ iks : float
+ Slow delayed rectifier potassium current.
+ inak : float
+ Sodium-potassium pump current.
+ ipk : float
+ Potassium pump current.
+ capacitance : float
+ Membrane capacitance.
+ inverseVcF : float
+ Inverse of the product of the volume of the cytosol and Faraday's constant.
+
+ Returns
+ -------
+ np.ndarray
+ Updated potassium concentration in the cytosol.
+ """
+
+ dKi = -(ik1+ito+ikr+iks-2*inak+ipk)*inverseVcF*capacitance
+ return dt*dKi
+
+# tp06 epi kernel
+@njit(parallel=True)
+def ionic_kernel_2d(u_new, u, cai, casr, cass, nai, Ki, m, h, j_, xr1, xr2,
+ xs, r, s, d, f, f2, fcass, rr, oo, indexes, dt,
+ ko, cao, nao, Vc, Vsr, Vss, Bufc, Kbufc, Bufsr, Kbufsr,
+ Bufss, Kbufss, Vmaxup, Kup, Vrel, k1_, k2_, k3, k4, EC,
+ maxsr, minsr, Vleak, Vxfer, R, F, T, RTONF, CAPACITANCE,
+ gkr, pKNa, gk1, gna, gbna, KmK, KmNa, knak, gcal, gbca,
+ knaca, KmNai, KmCa, ksat, n_, gpca, KpCa, gpk, gto, gks):
+ """
+ Compute the ionic currents and update the state variables for the 2D TP06
+ cardiac model.
+
+ This function calculates the ionic currents based on the TP06 cardiac
+ model, updates ion concentrations, and modifies gating variables in the
+ 2D grid. The calculations are performed in parallel to enhance performance.
+
+ Parameters
+ ----------
+ u_new : numpy.ndarray
+ Array to store the updated membrane potential values.
+ u : numpy.ndarray
+ Array of current membrane potential values.
+ cai : numpy.ndarray
+ Array of calcium concentration in the cytosol.
+ casr : numpy.ndarray
+ Array of calcium concentration in the sarcoplasmic reticulum.
+ cass : numpy.ndarray
+ Array of calcium concentration in the submembrane space.
+ nai : numpy.ndarray
+ Array of sodium ion concentration in the intracellular space.
+ Ki : numpy.ndarray
+ Array of potassium ion concentration in the intracellular space.
+ m : numpy.ndarray
+ Array of gating variable for sodium channels (activation).
+ h : numpy.ndarray
+ Array of gating variable for sodium channels (inactivation).
+ j_ : numpy.ndarray
+ Array of gating variable for sodium channels (inactivation).
+ xr1 : numpy.ndarray
+ Array of gating variable for rapid delayed rectifier potassium
+ channels.
+ xr2 : numpy.ndarray
+ Array of gating variable for rapid delayed rectifier potassium
+ channels.
+ xs : numpy.ndarray
+ Array of gating variable for slow delayed rectifier potassium channels.
+ r : numpy.ndarray
+ Array of gating variable for ryanodine receptors.
+ s : numpy.ndarray
+ Array of gating variable for calcium-sensitive current.
+ d : numpy.ndarray
+ Array of gating variable for L-type calcium channels.
+ f : numpy.ndarray
+ Array of gating variable for calcium-dependent calcium channels.
+ f2 : numpy.ndarray
+ Array of secondary gating variable for calcium-dependent calcium
+ channels.
+ fcass : numpy.ndarray
+ Array of gating variable for calcium-sensitive current.
+ rr : numpy.ndarray
+ Array of ryanodine receptor gating variable for calcium release.
+ oo : numpy.ndarray
+ Array of ryanodine receptor gating variable for calcium release.
+ indexes: numpy.ndarray
+ Array of indexes where the kernel should be computed (``mesh == 1``).
+ dt : float
+ Time step for the simulation.
+
+ Returns
+ -------
+ None
+ The function updates the state variables in place. No return value is
+ produced.
+ """
+ n_j = u.shape[1]
+
+ inverseVcF2 = 1./(2*Vc*F)
+ inverseVcF = 1./(Vc*F)
+ inversevssF2 = 1./(2*Vss*F)
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = int(ii/n_j)
+ j = ii % n_j
+
+ Ek = RTONF*(np.log((ko/Ki[i, j])))
+ Ena = RTONF*(np.log((nao/nai[i, j])))
+ Eks = RTONF*(np.log((ko+pKNa*nao)/(Ki[i, j]+pKNa*nai[i, j])))
+ Eca = 0.5*RTONF*(np.log((cao/cai[i, j])))
+
+ # Compute currents
+ ina, m[i, j], h[i, j], j_[i, j] = calc_ina(u[i, j], dt, m[i, j], h[i, j], j_[i, j], gna, Ena)
+ ical, d[i, j], f[i, j], f2[i, j], fcass[i, j] = calc_ical(u[i, j], dt, d[i, j], f[i, j], f2[i, j], fcass[i, j], cao, cass[i, j], gcal, F, R, T)
+ ito, r[i, j], s[i, j] = calc_ito(u[i, j], dt, r[i, j], s[i, j], Ek, gto)
+ ikr, xr1[i, j], xr2[i, j] = calc_ikr(u[i, j], dt, xr1[i, j], xr2[i, j], Ek, gkr, ko)
+ iks, xs[i, j] = calc_iks(u[i, j], dt, xs[i, j], Eks, gks)
+ ik1 = calc_ik1(u[i, j], Ek, gk1)
+ inaca = calc_inaca(u[i, j], nao, nai[i, j], cao, cai[i, j], KmNai, KmCa, knaca, ksat, n_, F, R, T)
+ inak = calc_inak(u[i, j], nai[i, j], ko, KmK, KmNa, knak, F, R, T)
+ ipca = calc_ipca(cai[i, j], KpCa, gpca)
+ ipk = calc_ipk(u[i, j], Ek, gpk)
+ ibna = calc_ibna(u[i, j], Ena, gbna)
+ ibca = calc_ibca(u[i, j], Eca, gbca)
+ irel, rr[i, j], oo[i, j] = calc_irel(dt, rr[i, j], oo[i, j], casr[i, j], cass[i, j], Vrel, k1_, k2_, k3, k4, maxsr, minsr, EC)
+ ileak = calc_ileak(casr[i, j], cai[i, j], Vleak)
+ iup = calc_iup(cai[i, j], Vmaxup, Kup)
+ ixfer = calc_ixfer(cass[i, j], cai[i, j], Vxfer)
+
+ # Compute concentrations
+ casr[i, j] = calc_casr(dt, casr[i, j], Bufsr, Kbufsr, iup, irel, ileak)
+ cass[i, j] = calc_cass(dt, cass[i, j], Bufss, Kbufss, ixfer, irel, ical, CAPACITANCE, Vc, Vss, Vsr, inversevssF2)
+ cai[i, j], cai[i, j] = calc_cai(dt, cai[i, j], Bufc, Kbufc, ibca, ipca, inaca, iup, ileak, ixfer, CAPACITANCE, Vsr, Vc, inverseVcF2)
+ nai[i, j] += calc_nai(dt, ina, ibna, inak, inaca, CAPACITANCE, inverseVcF)
+ Ki[i, j] += calc_ki(dt, ik1, ito, ikr, iks, inak, ipk, inverseVcF, CAPACITANCE)
+
+ # Update membrane potential
+ u_new[i, j] -= dt * (ikr + iks + ik1 + ito + ina + ibna + ical + ibca + inak + inaca + ipca + ipk)
+
diff --git a/finitewave/cpuwave2D/model/tp06_2d/__init__.py b/finitewave/cpuwave2D/model/tp06_2d/__init__.py
deleted file mode 100644
index c20e5a2..0000000
--- a/finitewave/cpuwave2D/model/tp06_2d/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from finitewave.cpuwave2D.model.tp06_2d.tp06_2d import TP062D
diff --git a/finitewave/cpuwave2D/model/tp06_2d/tp06_2d.py b/finitewave/cpuwave2D/model/tp06_2d/tp06_2d.py
deleted file mode 100644
index ad858ba..0000000
--- a/finitewave/cpuwave2D/model/tp06_2d/tp06_2d.py
+++ /dev/null
@@ -1,161 +0,0 @@
-import numpy as np
-
-from finitewave.core.model.cardiac_model import CardiacModel
-from finitewave.cpuwave2D.model.tp06_2d.tp06_kernels_2d import TP06Kernels2D
-
-_npfloat = "float64"
-
-
-class TP062D(CardiacModel):
- """
- A class to represent the TP06 cardiac model in 2D.
-
- Inherits from:
- -----------
- CardiacModel
- Base class for cardiac models.
-
- Attributes
- ----------
- m : np.ndarray
- Array for the gating variable m.
- h : np.ndarray
- Array for the gating variable h.
- j_ : np.ndarray
- Array for the gating variable j_.
- d : np.ndarray
- Array for the gating variable d.
- f : np.ndarray
- Array for the gating variable f.
- x : np.ndarray
- Array for the gating variable x.
- Cai_c : np.ndarray
- Array for the concentration of calcium in the intracellular space.
- model_parameters : dict
- Dictionary to hold model parameters.
- state_vars : list of str
- List of state variable names.
- npfloat : str
- Data type used for floating point operations.
- diffuse_kernel : function
- Function to handle diffusion in the model.
- ionic_kernel : function
- Function to handle ionic currents in the model.
- u : np.ndarray
- Array for membrane potential.
- u_new : np.ndarray
- Array for updated membrane potential.
- Cai : np.ndarray
- Array for calcium concentration in the intracellular space.
- CaSR : np.ndarray
- Array for calcium concentration in the sarcoplasmic reticulum.
- CaSS : np.ndarray
- Array for calcium concentration in the subsarcolemmal space.
- Nai : np.ndarray
- Array for sodium concentration in the intracellular space.
- Ki : np.ndarray
- Array for potassium concentration in the intracellular space.
- M_ : np.ndarray
- Array for gating variable M_.
- H_ : np.ndarray
- Array for gating variable H_.
- J_ : np.ndarray
- Array for gating variable J_.
- Xr1 : np.ndarray
- Array for gating variable Xr1.
- Xr2 : np.ndarray
- Array for gating variable Xr2.
- Xs : np.ndarray
- Array for gating variable Xs.
- R_ : np.ndarray
- Array for gating variable R_.
- S_ : np.ndarray
- Array for gating variable S_.
- D_ : np.ndarray
- Array for gating variable D_.
- F_ : np.ndarray
- Array for gating variable F_.
- F2_ : np.ndarray
- Array for gating variable F2_.
- FCass : np.ndarray
- Array for calcium concentration in the sarcoplasmic reticulum.
- RR : np.ndarray
- Array for calcium release from the sarcoplasmic reticulum.
- OO : np.ndarray
- Array for open states of ryanodine receptors.
-
- Methods
- -------
- initialize():
- Initializes the model's state variables and kernels.
- run_ionic_kernel():
- Executes the ionic kernel function to update ionic currents and state variables.
- """
-
- def __init__(self):
- """
- Initializes the TP062D cardiac model.
-
- Sets up the arrays for state variables and model parameters.
- """
- CardiacModel.__init__(self)
- self.m = np.ndarray
- self.h = np.ndarray
- self.j_ = np.ndarray
- self.d = np.ndarray
- self.f = np.ndarray
- self.x = np.ndarray
- self.Cai_c = np.ndarray
- self.model_parameters = {}
- self.state_vars = ["u", "Cai", "CaSR", "CaSS", "Nai", "Ki",
- "M_", "H_", "J_", "Xr1", "Xr2", "Xs", "R_",
- "S_", "D_", "F_", "F2_", "FCass", "RR", "OO"]
- self.npfloat = 'float64'
-
- def initialize(self):
- """
- Initializes the model's state variables and diffusion/ionic kernels.
-
- Sets up the initial values for membrane potential, ion concentrations,
- gating variables, and assigns the appropriate kernel functions.
- """
- super().initialize()
- weights_shape = self.cardiac_tissue.weights.shape
- shape = self.cardiac_tissue.mesh.shape
- self.diffuse_kernel = TP06Kernels2D().get_diffuse_kernel(weights_shape)
- self.ionic_kernel = TP06Kernels2D().get_ionic_kernel()
-
- self.u = -84.5*np.ones(shape, dtype=_npfloat)
- self.u_new = self.u.copy()
- self.Cai = 0.00007*np.ones(shape, dtype=_npfloat)
- self.CaSR = 1.3*np.ones(shape, dtype=_npfloat)
- self.CaSS = 0.00007*np.ones(shape, dtype=_npfloat)
- self.Nai = 7.67*np.ones(shape, dtype=_npfloat)
- self.Ki = 138.3*np.ones(shape, dtype=_npfloat)
- self.M_ = np.zeros(shape, dtype=_npfloat)
- self.H_ = 0.75*np.ones(shape, dtype=_npfloat)
- self.J_ = 0.75*np.ones(shape, dtype=_npfloat)
- self.Xr1 = np.zeros(shape, dtype=_npfloat)
- self.Xr2 = np.ones(shape, dtype=_npfloat)
- self.Xs = np.zeros(shape, dtype=_npfloat)
- self.R_ = np.zeros(shape, dtype=_npfloat)
- self.S_ = np.ones(shape, dtype=_npfloat)
- self.D_ = np.zeros(shape, dtype=_npfloat)
- self.F_ = np.ones(shape, dtype=_npfloat)
- self.F2_ = np.ones(shape, dtype=_npfloat)
- self.FCass = np.ones(shape, dtype=_npfloat)
- self.RR = np.ones(shape, dtype=_npfloat)
- self.OO = np.zeros(shape, dtype=_npfloat)
-
- def run_ionic_kernel(self):
- """
- Executes the ionic kernel function to update ionic currents and state variables.
-
- This method calls the `ionic_kernel` function from the TP06Kernels2D class,
- passing in the current state of the model and the time step.
- """
- self.ionic_kernel(self.u_new, self.u, self.Cai, self.CaSR, self.CaSS,
- self.Nai, self.Ki, self.M_, self.H_, self.J_, self.Xr1,
- self.Xr2, self.Xs, self.R_, self.S_, self.D_, self.F_,
- self.F2_, self.FCass, self.RR, self.OO,
- self.cardiac_tissue.mesh, self.dt)
diff --git a/finitewave/cpuwave2D/model/tp06_2d/tp06_kernels_2d.py b/finitewave/cpuwave2D/model/tp06_2d/tp06_kernels_2d.py
deleted file mode 100644
index 25140bb..0000000
--- a/finitewave/cpuwave2D/model/tp06_2d/tp06_kernels_2d.py
+++ /dev/null
@@ -1,384 +0,0 @@
-from math import log, sqrt, exp
-from numba import njit, prange
-
-from finitewave.core.exception.exceptions import IncorrectWeightsShapeError
-from finitewave.cpuwave2D.model.diffuse_kernels_2d \
- import diffuse_kernel_2d_iso, diffuse_kernel_2d_aniso, _parallel
-
-
-# tp06 epi kernel
-@njit(parallel=_parallel)
-def ionic_kernel_2d(u_new, u, Cai, CaSR, CaSS, Nai, Ki, M_, H_, J_, Xr1, Xr2, Xs,
- R_, S_, D_, F_, F2_, FCass, RR, OO, mesh, dt):
- """
- Compute the ionic currents and update the state variables for the 2D TP06 cardiac model.
-
- This function calculates the ionic currents based on the TP06 cardiac model, updates ion
- concentrations, and modifies gating variables in the 2D grid. The calculations are performed
- in parallel to enhance performance.
-
- Parameters
- ----------
- u_new : numpy.ndarray
- Array to store the updated membrane potential values.
- u : numpy.ndarray
- Array of current membrane potential values.
- Cai : numpy.ndarray
- Array of calcium concentration in the cytosol.
- CaSR : numpy.ndarray
- Array of calcium concentration in the sarcoplasmic reticulum.
- CaSS : numpy.ndarray
- Array of calcium concentration in the submembrane space.
- Nai : numpy.ndarray
- Array of sodium ion concentration in the intracellular space.
- Ki : numpy.ndarray
- Array of potassium ion concentration in the intracellular space.
- M_ : numpy.ndarray
- Array of gating variable for sodium channels (activation).
- H_ : numpy.ndarray
- Array of gating variable for sodium channels (inactivation).
- J_ : numpy.ndarray
- Array of gating variable for sodium channels (inactivation).
- Xr1 : numpy.ndarray
- Array of gating variable for rapid delayed rectifier potassium channels.
- Xr2 : numpy.ndarray
- Array of gating variable for rapid delayed rectifier potassium channels.
- Xs : numpy.ndarray
- Array of gating variable for slow delayed rectifier potassium channels.
- R_ : numpy.ndarray
- Array of gating variable for ryanodine receptors.
- S_ : numpy.ndarray
- Array of gating variable for calcium-sensitive current.
- D_ : numpy.ndarray
- Array of gating variable for L-type calcium channels.
- F_ : numpy.ndarray
- Array of gating variable for calcium-dependent calcium channels.
- F2_ : numpy.ndarray
- Array of secondary gating variable for calcium-dependent calcium channels.
- FCass : numpy.ndarray
- Array of gating variable for calcium-sensitive current.
- RR : numpy.ndarray
- Array of ryanodine receptor gating variable for calcium release.
- OO : numpy.ndarray
- Array of ryanodine receptor gating variable for calcium release.
- mesh : numpy.ndarray
- Mesh grid indicating tissue areas.
- dt : float
- Time step for the simulation.
-
- Returns
- -------
- None
- The function updates the state variables in place. No return value is produced.
- """
- n_i = u.shape[0]
- n_j = u.shape[1]
- for ii in prange(n_i*n_j):
- i = int(ii/n_j)
- j = ii % n_j
- if mesh[i, j] != 1:
- continue
-
- # Needed to compute currents
- Ko = 5.4
- Cao = 2.0
- Nao = 140.0
-
- Vc = 0.016404
- Vsr = 0.001094
- Vss = 0.00005468
-
- Bufc = 0.2
- Kbufc = 0.001
- Bufsr = 10.
- Kbufsr = 0.3
- Bufss = 0.4
- Kbufss = 0.00025
-
- Vmaxup = 0.006375
- Kup = 0.00025
- Vrel = 0.102 # 40.8
- k1_ = 0.15
- k2_ = 0.045
- k3 = 0.060
- k4 = 0.005 # 0.000015
- EC = 1.5
- maxsr = 2.5
- minsr = 1.
- Vleak = 0.00036
- Vxfer = 0.0038
-
- R = 8314.472
- F = 96485.3415
- T = 310.0
- RTONF = 26.713760659695648
-
- CAPACITANCE = 0.185
-
- Gkr = 0.153
-
- pKNa = 0.03
-
- GK1 = 5.405
-
- GNa = 14.838
-
- GbNa = 0.00029
-
- KmK = 1.0
- KmNa = 40.0
- knak = 2.724
-
- GCaL = 0.00003980
-
- GbCa = 0.000592
-
- knaca = 1000
- KmNai = 87.5
- KmCa = 1.38
- ksat = 0.1
- n_ = 0.35
-
- GpCa = 0.1238
- KpCa = 0.0005
-
- GpK = 0.0146
-
- Gto = 0.294
- Gks = 0.392
-
- inverseVcF2 = 1./(2*Vc*F)
- inverseVcF = 1./(Vc*F)
- inversevssF2 = 1./(2*Vss*F)
-
- Ek = RTONF*(log((Ko/Ki[i, j])))
- Ena = RTONF*(log((Nao/Nai[i, j])))
- Eks = RTONF*(log((Ko+pKNa*Nao)/(Ki[i, j]+pKNa*Nai[i, j])))
- Eca = 0.5*RTONF*(log((Cao/Cai[i, j])))
- Ak1 = 0.1/(1.+exp(0.06*(u[i, j]-Ek-200)))
- Bk1 = (3.*exp(0.0002*(u[i, j]-Ek+100)) +
- exp(0.1*(u[i, j]-Ek-10)))/(1.+exp(-0.5*(u[i, j]-Ek)))
- rec_iK1 = Ak1/(Ak1+Bk1)
- rec_iNaK = (
- 1./(1.+0.1245*exp(-0.1*u[i, j]*F/(R*T))+0.0353*exp(-u[i, j]*F/(R*T))))
- rec_ipK = 1./(1.+exp((25-u[i, j])/5.98))
-
- # Compute currents
- INa = GNa*M_[i, j]*M_[i, j]*M_[i, j]*H_[i, j]*J_[i, j]*(u[i, j]-Ena)
- ICaL = GCaL*D_[i, j]*F_[i, j]*F2_[i, j]*FCass[i, j]*4*(u[i, j]-15)*(F*F/(R*T)) *\
- (0.25*exp(2*(u[i, j]-15)*F/(R*T))*CaSS[i, j]-Cao) / \
- (exp(2*(u[i, j]-15)*F/(R*T))-1.)
- Ito = Gto*R_[i, j]*S_[i, j]*(u[i, j]-Ek)
- IKr = Gkr*sqrt(Ko/5.4)*Xr1[i, j]*Xr2[i, j]*(u[i, j]-Ek)
- IKs = Gks*Xs[i, j]*Xs[i, j]*(u[i, j]-Eks)
- IK1 = GK1*rec_iK1*(u[i, j]-Ek)
- INaCa = knaca*(1./(KmNai*KmNai*KmNai+Nao*Nao*Nao))*(1./(KmCa+Cao)) *\
- (1./(1+ksat*exp((n_-1)*u[i, j]*F/(R*T)))) *\
- (exp(n_*u[i, j]*F/(R*T))*Nai[i, j]*Nai[i, j]*Nai[i, j]*Cao -
- exp((n_-1)*u[i, j]*F/(R*T))*Nao*Nao*Nao*Cai[i, j]*2.5)
- INaK = knak*(Ko/(Ko+KmK))*(Nai[i, j]/(Nai[i, j]+KmNa))*rec_iNaK
- IpCa = GpCa*Cai[i, j]/(KpCa+Cai[i, j])
- IpK = GpK*rec_ipK*(u[i, j]-Ek)
- IbNa = GbNa*(u[i, j]-Ena)
- IbCa = GbCa*(u[i, j]-Eca)
-
- # Determine total current
- u_new[i, j] -= dt * (IKr + IKs + IK1 + Ito + INa +
- IbNa + ICaL + IbCa + INaK + INaCa + IpCa + IpK)
-
- # update concentrations
- kCaSR = maxsr-((maxsr-minsr)/(1+(EC/CaSR[i, j])*(EC/CaSR[i, j])))
- k1 = k1_/kCaSR
- k2 = k2_*kCaSR
- dRR = k4*(1-RR[i, j])-k2*CaSS[i, j]*RR[i, j]
- RR[i, j] += dt*dRR
- OO[i, j] = k1*CaSS[i, j]*CaSS[i, j] * \
- RR[i, j]/(k3+k1*CaSS[i, j]*CaSS[i, j])
-
- Irel = Vrel*OO[i, j]*(CaSR[i, j]-CaSS[i, j])
- Ileak = Vleak*(CaSR[i, j]-Cai[i, j])
- Iup = Vmaxup/(1.+((Kup*Kup)/(Cai[i, j]*Cai[i, j])))
- Ixfer = Vxfer*(CaSS[i, j]-Cai[i, j])
-
- CaCSQN = Bufsr*CaSR[i, j]/(CaSR[i, j]+Kbufsr)
- dCaSR = dt*(Iup-Irel-Ileak)
- bjsr = Bufsr-CaCSQN-dCaSR-CaSR[i, j]+Kbufsr
- cjsr = Kbufsr*(CaCSQN+dCaSR+CaSR[i, j])
- CaSR[i, j] = (sqrt(bjsr*bjsr+4*cjsr)-bjsr)/2
-
- CaSSBuf = Bufss*CaSS[i, j]/(CaSS[i, j]+Kbufss)
- dCaSS = dt*(-Ixfer*(Vc/Vss)+Irel*(Vsr/Vss) +
- (-ICaL*inversevssF2*CAPACITANCE))
- bcss = Bufss-CaSSBuf-dCaSS-CaSS[i, j]+Kbufss
- ccss = Kbufss*(CaSSBuf+dCaSS+CaSS[i, j])
- CaSS[i, j] = (sqrt(bcss*bcss+4*ccss)-bcss)/2
-
- CaBuf = Bufc*Cai[i, j]/(Cai[i, j]+Kbufc)
- dCai = dt*((-(IbCa+IpCa-2*INaCa)*inverseVcF2*CAPACITANCE) -
- (Iup-Ileak)*(Vsr/Vc)+Ixfer)
- bc = Bufc-CaBuf-dCai-Cai[i, j]+Kbufc
- cc = Kbufc*(CaBuf+dCai+Cai[i, j])
- Cai[i, j] = (sqrt(bc*bc+4*cc)-bc)/2
-
- dNai = -(INa+IbNa+3*INaK+3*INaCa)*inverseVcF*CAPACITANCE
- Nai[i, j] += dt*dNai
-
- dKi = -(IK1+Ito+IKr+IKs-2*INaK+IpK)*inverseVcF*CAPACITANCE
- Ki[i, j] += dt*dKi
-
- # compute steady state values and time constants
- AM = 1./(1.+exp((-60.-u[i, j])/5.))
- BM = 0.1/(1.+exp((u[i, j]+35.)/5.))+0.10/(1.+exp((u[i, j]-50.)/200.))
- TAU_M = AM*BM
- M_INF = 1./((1.+exp((-56.86-u[i, j])/9.03))
- * (1.+exp((-56.86-u[i, j])/9.03)))
-
- AH_ = 0.
- BH_ = 0.
- if u[i, j] >= -40.:
- AH_ = 0.
- BH_ = 0.77/(0.13*(1.+exp(-(u[i, j]+10.66)/11.1)))
- else:
- AH_ = 0.057*exp(-(u[i, j]+80.)/6.8)
- BH_ = 2.7*exp(0.079*u[i, j])+(3.1e5)*exp(0.3485*u[i, j])
-
- TAU_H = 1.0/(AH_ + BH_)
-
- H_INF = 1./((1.+exp((u[i, j]+71.55)/7.43))
- * (1.+exp((u[i, j]+71.55)/7.43)))
-
- AJ_ = 0.
- BJ_ = 0.
- if u[i, j] >= -40.:
- AJ_ = 0.
- BJ_ = 0.6*exp((0.057)*u[i, j])/(1.+exp(-0.1*(u[i, j]+32.)))
- else:
- AJ_ = ((-2.5428e4)*exp(0.2444*u[i, j])-(6.948e-6) *
- exp(-0.04391*u[i, j]))*(u[i, j]+37.78) /\
- (1.+exp(0.311*(u[i, j]+79.23)))
- BJ_ = 0.02424*exp(-0.01052*u[i, j]) / \
- (1.+exp(-0.1378*(u[i, j]+40.14)))
-
- TAU_J = 1.0/(AJ_ + BJ_)
-
- J_INF = H_INF
-
- Xr1_INF = 1./(1.+exp((-26.-u[i, j])/7.))
- axr1 = 450./(1.+exp((-45.-u[i, j])/10.))
- bxr1 = 6./(1.+exp((u[i, j]-(-30.))/11.5))
- TAU_Xr1 = axr1*bxr1
- Xr2_INF = 1./(1.+exp((u[i, j]-(-88.))/24.))
- axr2 = 3./(1.+exp((-60.-u[i, j])/20.))
- bxr2 = 1.12/(1.+exp((u[i, j]-60.)/20.))
- TAU_Xr2 = axr2*bxr2
-
- Xs_INF = 1./(1.+exp((-5.-u[i, j])/14.))
- Axs = (1400./(sqrt(1.+exp((5.-u[i, j])/6))))
- Bxs = (1./(1.+exp((u[i, j]-35.)/15.)))
- TAU_Xs = Axs*Bxs+80
-
- R_INF = 0
- S_INF = 0
- TAU_R = 0
- TAU_S = 0
-
- R_INF = 1./(1.+exp((20-u[i, j])/6.))
- S_INF = 1./(1.+exp((u[i, j]+20)/5.))
- TAU_R = 9.5*exp(-(u[i, j]+40.)*(u[i, j]+40.)/1800.)+0.8
- TAU_S = 85.*exp(-(u[i, j]+45.)*(u[i, j]+45.)/320.) + \
- 5./(1.+exp((u[i, j]-20.)/5.))+3.
-
- D_INF = 1./(1.+exp((-8-u[i, j])/7.5))
- Ad = 1.4/(1.+exp((-35-u[i, j])/13))+0.25
- Bd = 1.4/(1.+exp((u[i, j]+5)/5))
- Cd = 1./(1.+exp((50-u[i, j])/20))
- TAU_D = Ad*Bd+Cd
- F_INF = 1./(1.+exp((u[i, j]+20)/7))
- Af = 1102.5*exp(-(u[i, j]+27)*(u[i, j]+27)/225)
- Bf = 200./(1+exp((13-u[i, j])/10.))
- Cf = (180./(1+exp((u[i, j]+30)/10)))+20
- TAU_F = Af+Bf+Cf
- F2_INF = 0.67/(1.+exp((u[i, j]+35)/7))+0.33
- Af2 = 600*exp(-(u[i, j]+25)*(u[i, j]+25)/170)
- Bf2 = 31/(1.+exp((25-u[i, j])/10))
- Cf2 = 16/(1.+exp((u[i, j]+30)/10))
- TAU_F2 = Af2+Bf2+Cf2
- FCaSS_INF = 0.6/(1+(CaSS[i, j]/0.05)*(CaSS[i, j]/0.05))+0.4
- TAU_FCaSS = 80./(1+(CaSS[i, j]/0.05)*(CaSS[i, j]/0.05))+2.
-
- # Update gates
- M_[i, j] = M_INF-(M_INF-M_[i, j])*exp(-dt/TAU_M)
- H_[i, j] = H_INF-(H_INF-H_[i, j])*exp(-dt/TAU_H)
- J_[i, j] = J_INF-(J_INF-J_[i, j])*exp(-dt/TAU_J)
- Xr1[i, j] = Xr1_INF-(Xr1_INF-Xr1[i, j])*exp(-dt/TAU_Xr1)
- Xr2[i, j] = Xr2_INF-(Xr2_INF-Xr2[i, j])*exp(-dt/TAU_Xr2)
- Xs[i, j] = Xs_INF-(Xs_INF-Xs[i, j])*exp(-dt/TAU_Xs)
- S_[i, j] = S_INF-(S_INF-S_[i, j])*exp(-dt/TAU_S)
- R_[i, j] = R_INF-(R_INF-R_[i, j])*exp(-dt/TAU_R)
- D_[i, j] = D_INF-(D_INF-D_[i, j])*exp(-dt/TAU_D)
- F_[i, j] = F_INF-(F_INF-F_[i, j])*exp(-dt/TAU_F)
- F2_[i, j] = F2_INF-(F2_INF-F2_[i, j])*exp(-dt/TAU_F2)
- FCass[i, j] = FCaSS_INF-(FCaSS_INF-FCass[i, j])*exp(-dt/TAU_FCaSS)
-
-
-class TP06Kernels2D:
- """
- A class to manage the kernel functions for the TP06 cardiac model in 2D.
-
- Attributes
- ----------
- None
-
- Methods
- -------
- get_diffuse_kernel(shape):
- Returns the appropriate diffusion kernel function based on the shape of the weights.
- get_ionic_kernel():
- Returns the ionic kernel function for the TP06 model.
- """
-
- def __init__(self):
- """
- Initializes the TP06Kernels2D class.
- """
- pass
-
- @staticmethod
- def get_diffuse_kernel(shape):
- """
- Returns the diffusion kernel function based on the shape of the weights.
-
- Parameters
- ----------
- shape : tuple
- The shape of the weights array.
-
- Returns
- -------
- function
- The diffusion kernel function suitable for the given weight shape.
-
- Raises
- ------
- IncorrectWeightsShapeError
- If the shape of the weights does not match expected values (5 or 9).
- """
- if shape[-1] == 5:
- return diffuse_kernel_2d_iso
- if shape[-1] == 9:
- return diffuse_kernel_2d_aniso
- else:
- raise IncorrectWeightsShapeError(shape, 5, 9)
-
- @staticmethod
- def get_ionic_kernel():
- """
- Returns the ionic kernel function for the TP06 cardiac model.
-
- Returns
- -------
- function
- The ionic kernel function for the TP06 model.
- """
- return ionic_kernel_2d
-
diff --git a/finitewave/cpuwave2D/stencil/__init__.py b/finitewave/cpuwave2D/stencil/__init__.py
index 7d52004..10e85f0 100644
--- a/finitewave/cpuwave2D/stencil/__init__.py
+++ b/finitewave/cpuwave2D/stencil/__init__.py
@@ -1,2 +1,3 @@
from finitewave.cpuwave2D.stencil.asymmetric_stencil_2d import AsymmetricStencil2D
-from finitewave.cpuwave2D.stencil.isotropic_stencil_2d import IsotropicStencil2D
\ No newline at end of file
+from finitewave.cpuwave2D.stencil.isotropic_stencil_2d import IsotropicStencil2D
+from finitewave.cpuwave2D.stencil.symmetric_stencil_2d import SymmetricStencil2D
\ No newline at end of file
diff --git a/finitewave/cpuwave2D/stencil/asymmetric_stencil_2d.py b/finitewave/cpuwave2D/stencil/asymmetric_stencil_2d.py
index 26abb0e..2d934d6 100644
--- a/finitewave/cpuwave2D/stencil/asymmetric_stencil_2d.py
+++ b/finitewave/cpuwave2D/stencil/asymmetric_stencil_2d.py
@@ -4,49 +4,331 @@
from finitewave.core.stencil.stencil import Stencil
+class AsymmetricStencil2D(Stencil):
+ """
+ This class computes the weights for diffusion on a 2D using an asymmetric
+ stencil. The weights are calculated based on diffusion coefficients and
+ fiber orientations. The stencil includes 9 points: the central point and
+ 8 surrounding points. The boundary conditions are Neumann with first-order
+ approximation.
+
+ Attributes
+ ----------
+ D_al : float
+ Longitudinal diffusion coefficient.
+ D_ac : float
+ Cross-sectional diffusion coefficient.
+
+ Notes
+ -----
+ The diffusion coefficients are general and should be adjusted according to
+ the specific model. These parameters only set the ratios between
+ longitudinal and cross-sectional diffusion.
+
+ The method assumes weights being used in the following order:
+
+ - ``w[i, j, 0] : (i-1, j-1)``,
+ - ``w[i, j, 1] : (i-1, j)``,
+ - ``w[i, j, 2] : (i-1, j+1)``,
+ - ``w[i, j, 3] : (i, j-1)``,
+ - ``w[i, j, 4] : (i, j)``,
+ - ``w[i, j, 5] : (i, j+1)``,
+ - ``w[i, j, 6] : (i+1, j-1)``,
+ - ``w[i, j, 7] : (i+1, j)``,
+ - ``w[i, j, 8] : (i+1, j+1)``.
+ """
+
+ def __init__(self):
+ super().__init__()
+ self.D_al = 1
+ self.D_ac = 1/9
+
+ def compute_weights(self, model, cardiac_tissue):
+ """
+ Computes the weights for diffusion on a 2D mesh using an asymmetric
+ stencil.
+
+ Parameters
+ ----------
+ model : CardiacModel2D
+ A model object containing the simulation parameters.
+ cardiac_tissue : CardiacTissue2D
+ A 2D cardiac tissue object.
+
+ Returns
+ -------
+ np.ndarray
+ Array of weights for diffusion with the shape of (*mesh.shape, 9).
+ """
+ # convert fibrotic areas to non-tissue
+ mesh = cardiac_tissue.mesh.copy()
+ mesh[mesh != 1] = 0
+ conductivity = cardiac_tissue.conductivity
+ conductivity = conductivity * np.ones_like(mesh, dtype=model.npfloat)
+
+ fibers = cardiac_tissue.fibers
+
+ if fibers is None:
+ message = "Fibers must be provided for anisotropic diffusion."
+ raise ValueError(message)
+
+ weights = np.zeros((*mesh.shape, 9))
+ d_xx, d_xy = self.compute_half_step_diffusion(mesh, conductivity,
+ fibers, 0)
+ d_yx, d_yy = self.compute_half_step_diffusion(mesh, conductivity,
+ fibers, 1)
+ weights = compute_weights(weights, mesh, d_xx, d_xy, d_yx, d_yy)
+ weights = weights * model.D_model * model.dt / model.dr**2
+ weights[:, :, 4] += 1
+
+ return weights
+
+ def select_diffusion_kernel(self):
+ """
+ Returns the diffusion kernel function for anisotropic diffusion in 2D.
+
+ Returns
+ -------
+ function
+ The diffusion kernel function for anisotropic diffusion in 2D.
+ """
+ return diffusion_kernel_2d_aniso
+
+ def compute_half_step_diffusion(self, mesh, conductivity, fibers, axis,
+ num_axes=2):
+ """
+ Computes the diffusion components for half-steps based on fiber
+ orientations.
+
+ Parameters
+ ----------
+ mesh : np.ndarray
+ Array representing the mesh grid of the tissue.
+ conductivity : np.ndarray
+ Array representing the conductivity of the tissue.
+ fibers : np.ndarray
+ Array representing fiber orientations with shape
+ ``(2, *mesh.shape)``.
+ axis : int
+ Axis index (0 for x, 1 for y).
+ num_axes : int
+ Number of axes.
+
+ Returns
+ -------
+ np.ndarray
+ Array of diffusion components for half-steps along the specified
+ axis.
+
+ Notes
+ -----
+ The index ``i`` in the returned array corresponds to ``i+1/2`` and
+ ``i-1`` corresponds to ``i-1/2``.
+ """
+ D = np.zeros((num_axes, *mesh.shape))
+ for i in range(num_axes):
+ D[i] = self.compute_diffusion_components(fibers, axis, i,
+ self.D_al, self.D_ac)
+ D[i] = 0.5 * (D[i] * conductivity +
+ np.roll(D[i], -1, axis=axis) *
+ np.roll(conductivity, -1, axis=axis))
+
+ return D
+
+ def compute_diffusion_components(self, fibers, ind0, ind1, D_al, D_ac):
+ """
+ Computes the diffusion components based on fiber orientations.
+
+ Parameters
+ ----------
+ fibers : np.ndarray
+ Array representing fiber orientations.
+ ind0 : int
+ First axis index (0 for x, 1 for y).
+ ind1 : int
+ Second axis index (0 for x, 1 for y).
+ D_al : float
+ Longitudinal diffusion coefficient.
+ D_ac : float
+ Cross-sectional diffusion coefficient.
+
+ Returns
+ -------
+ np.ndarray
+ Array of diffusion components based on fiber orientations
+ """
+ return (D_ac * (ind0 == ind1) +
+ (D_al - D_ac) * fibers[..., ind0] * fibers[..., ind1])
+
+
+@njit(parallel=True)
+def diffusion_kernel_2d_aniso(u_new, u, w, indexes):
+ """
+ Performs anisotropic diffusion on a 2D grid.
+
+ Parameters
+ ----------
+ u_new : np.ndarray
+ Array to store the updated potential values after diffusion.
+ u : np.ndarray
+ Array representing the current potential values before diffusion.
+ w : np.ndarray
+ Array of weights used in the diffusion computation.
+ mesh : np.ndarray
+ Array representing the mesh of the tissue.
+
+ Returns
+ -------
+ np.ndarray
+ The updated potential values after diffusion.
+ """
+ n_i = u.shape[0]
+ n_j = u.shape[1]
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = int(ii / n_j)
+ j = ii % n_j
+
+ u_new[i, j] = (u[i-1, j-1] * w[i, j, 0] +
+ u[i-1, j] * w[i, j, 1] +
+ u[i-1, j+1] * w[i, j, 2] +
+ u[i, j-1] * w[i, j, 3] +
+ u[i, j] * w[i, j, 4] +
+ u[i, j+1] * w[i, j, 5] +
+ u[i+1, j-1] * w[i, j, 6] +
+ u[i+1, j] * w[i, j, 7] +
+ u[i+1, j+1] * w[i, j, 8])
+ return u_new
+
+
@njit
-def coeffs(m0, m1, m2, m3):
+def minor_component(d, m0, m1, m2, m3, m4, m5):
"""
- Computes the coefficients used in the weight calculations.
+ Calculates the minor component for the diffusion current.
+
+ .. code-block:: text
+ m4 ----- m5
+ | |
+ | |
+ | |
+ m2 - d - m3
+ | |
+ | |
+ | |
+ m0 ----- m1
Parameters
----------
- m0 : float
- Mesh value at position (i-1, j-1).
- m1 : float
- Mesh value at position (i-1, j+1).
- m2 : float
- Mesh value at position (i, j-1).
- m3 : float
- Mesh value at position (i, j+1).
+ d : float
+ Minor diffusion at half-steps.
+ m0 : int
+ Mesh point value at (i-1, j-1).
+ m1 : int
+ Mesh point value at (i-1, j).
+ m2 : int
+ Mesh point value at (i, j-1).
+ m3 : int
+ Mesh point value at (i, j).
+ m4 : int
+ Mesh point value at (i+1, j-1).
+ m5 : int
+ Mesh point value at (i+1, j).
Returns
-------
- float
- Computed coefficient based on input values.
+ tuple
+ Tuple of weights for each of the 6 points.
+
+ Notes
+ -----
+ The order of the points assumes m3 is the central point of the stencil.
"""
- return m0 * m1 / (1 + m0 * m1 * m2 * m3)
+ m_higher = m2 + m3 + m4 + m5
+ m_lower = m0 + m1 + m2 + m3
+
+ if m2 == 0 or m3 == 0 or m_higher < 3 or m_lower < 3:
+ return 0, 0, 0, 0, 0, 0
+
+ w0 = - d * m0 / m_lower
+ w1 = - d * m1 / m_lower
+ w2 = d * (m2 / m_higher - m2 / m_lower)
+ w3 = d * (m3 / m_higher - m3 / m_lower)
+ w4 = d * m4 / m_higher
+ w5 = d * m5 / m_higher
+
+ return w0, w1, w2, w3, w4, w5
@njit
-def compute_weights(w, m, d_x, d_xy, d_y, d_yx):
+def major_component(d, m0):
"""
- Computes the weights for diffusion on a 2D mesh based on asymmetric stencil.
+ Computes the major component for the difussion current.
+
+ .. code-block:: text
+ x ------ x
+ | |
+ | |
+ m0 - d - m1
+ | |
+ | |
+ x ------ x
+
+ Parameters
+ ----------
+ d : np.ndarray
+ Major diffusion at half-steps.
+ m0 : np.ndarray
+ Mesh point adjacent to the central point.
+
+ Returns
+ -------
+ np.ndarray
+ Major component for the diffusion.
+ """
+ return d * m0
+
+
+@njit(parallel=True)
+def compute_weights(w, m, d_xx, d_xy, d_yx, d_yy):
+ """
+ Computes the weights for diffusion on a 2D mesh based on the asymmetric
+ stencil.
+
+ .. code-block:: text
+ w2 --------------- w5 ---------------- w8
+ | | |
+ | d_yy_1 |
+ | d_yx_1 |
+ | | |
+ | | |
+ w1 ---- d_xx_0 --- w4 ---- d_xx_1 ---- w7
+ | d_xy_0 | d_xy_1 |
+ | | |
+ | d_yy_0 |
+ | d_yx_0 |
+ | | |
+ w0 --------------- w3 ---------------- w6
Parameters
----------
w : np.ndarray
- 3D array to store the computed weights. Shape is (mesh.shape[0], mesh.shape[1], 9).
+ 3D array to store the weights for diffusion. Shape is (*mesh.shape, 9).
m : np.ndarray
- 2D array representing the mesh grid of the tissue.
- d_x : np.ndarray
- 2D array with diffusion coefficients along the x-direction.
+ 2D array representing the mesh grid of the tissue. Non-tissue areas
+ are set to 0.
+ d_xx : np.ndarray
+ Diffusion x component for x direction.
d_xy : np.ndarray
- 2D array with diffusion coefficients for cross-terms in x and y directions.
- d_y : np.ndarray
- 2D array with diffusion coefficients along the y-direction.
+ Diffusion y component for x direction.
d_yx : np.ndarray
- 2D array with diffusion coefficients for cross-terms in y and x directions.
+ Diffusion x component for y direction.
+ d_yy : np.ndarray
+ Diffusion y component for y direction.
+
+ Returns
+ -------
+ np.ndarray
+ 3D array of weights for diffusion, with the shape of (*mesh.shape, 9).
"""
n_i = m.shape[0]
n_j = m.shape[1]
@@ -56,178 +338,96 @@ def compute_weights(w, m, d_x, d_xy, d_y, d_yx):
if m[i, j] != 1:
continue
- w[i, j, 0] = 0.5 * (d_xy[i-1, j] * coeffs(m[i-1, j-1], m[i-1, j+1],
- m[i, j-1], m[i, j+1]) +
- d_yx[i, j-1] * coeffs(m[i-1, j-1], m[i+1, j-1],
- m[i-1, j], m[i+1, j]))
- w[i, j, 1] = (d_x[i-1, j] * m[i-1, j] +
- 0.5 * (d_yx[i, j-1] * coeffs(m[i-1, j], m[i+1, j],
- m[i-1, j-1], m[i+1, j-1]) -
- d_yx[i, j] * coeffs(m[i-1, j], m[i+1, j],
- m[i-1, j+1], m[i+1, j+1])))
- w[i, j, 2] = -0.5 * (d_xy[i-1, j] * coeffs(m[i-1, j-1], m[i-1, j+1],
- m[i, j-1], m[i, j+1]) +
- d_yx[i, j] * coeffs(m[i-1, j+1], m[i+1, j+1],
- m[i-1, j], m[i+1, j]))
- w[i, j, 3] = (d_y[i, j-1] * m[i, j-1] +
- 0.5 * (d_xy[i-1, j] * coeffs(m[i, j-1], m[i, j+1],
- m[i-1, j-1], m[i-1, j+1]) -
- d_xy[i, j] * coeffs(m[i, j-1], m[i, j+1],
- m[i+1, j-1], m[i+1, j+1])))
- w[i, j, 4] = - (m[i-1, j] * d_x[i-1, j] + m[i+1, j] * d_x[i, j] +
- m[i, j-1] * d_y[i, j-1] + m[i, j+1] * d_y[i, j])
- w[i, j, 5] = (d_y[i, j] * m[i, j+1] +
- 0.5 * (-d_xy[i-1, j] * coeffs(m[i, j-1], m[i, j+1],
- m[i-1, j-1], m[i-1, j+1]) +
- d_xy[i, j] * coeffs(m[i, j-1], m[i, j+1],
- m[i+1, j-1], m[i+1, j+1])))
- w[i, j, 6] = -0.5 * (d_xy[i, j] * coeffs(m[i+1, j-1], m[i+1, j+1],
- m[i, j-1], m[i, j+1]) +
- d_yx[i, j-1] * coeffs(m[i-1, j-1], m[i+1, j-1],
- m[i-1, j], m[i+1, j]))
- w[i, j, 7] = (d_x[i, j] * m[i+1, j] +
- 0.5 * (-d_yx[i, j-1] * coeffs(m[i-1, j], m[i+1, j],
- m[i-1, j-1], m[i+1, j-1]) +
- d_yx[i, j] * coeffs(m[i-1, j], m[i+1, j],
- m[i-1, j+1], m[i+1, j+1])))
- w[i, j, 8] = 0.5 * (d_xy[i, j] * coeffs(m[i+1, j-1], m[i+1, j+1],
- m[i, j-1], m[i, j+1]) +
- d_yx[i, j] * coeffs(m[i-1, j+1], m[i+1, j+1],
- m[i-1, j], m[i+1, j]))
+ # q (i-1/2, j)
+ qx0_major = major_component(d_xx[i-1, j], m[i-1, j])
+ # (i-1, j)
+ w[i, j, 1] += qx0_major
+ # (i, j)
+ w[i, j, 4] -= qx0_major
+ qx0_minor = minor_component(d_xy[i-1, j],
+ m[i-1, j-1], m[i, j-1],
+ m[i-1, j], m[i, j],
+ m[i-1, j+1], m[i, j+1])
+ # (i-1, j-1)
+ w[i, j, 0] -= qx0_minor[0]
+ # (i, j-1)
+ w[i, j, 3] -= qx0_minor[1]
+ # (i-1, j)
+ w[i, j, 1] -= qx0_minor[2]
+ # (i, j)
+ w[i, j, 4] -= qx0_minor[3]
+ # (i-1, j+1)
+ w[i, j, 2] -= qx0_minor[4]
+ # (i, j+1)
+ w[i, j, 5] -= qx0_minor[5]
-class AsymmetricStencil2D(Stencil):
- """
- A class to represent a 2D asymmetric stencil for diffusion processes.
+ # q (i, j-1/2)
+ qy0_major = major_component(d_yy[i, j-1], m[i, j-1])
+ # (i, j-1)
+ w[i, j, 3] += qy0_major
+ # (i, j)
+ w[i, j, 4] -= qy0_major
- Inherits from:
- -----------
- Stencil
- Base class for different stencils used in diffusion calculations.
+ qy0_minor = minor_component(d_yx[i, j-1], m[i-1, j-1], m[i-1, j],
+ m[i, j-1], m[i, j], m[i+1, j-1], m[i+1, j])
- Methods
- -------
- get_weights(mesh, conductivity, fibers, D_al, D_ac, dt, dr):
- Computes the weights for diffusion based on the asymmetric stencil.
- """
+ # (i-1, j-1)
+ w[i, j, 0] -= qy0_minor[0]
+ # (i-1, j)
+ w[i, j, 1] -= qy0_minor[1]
+ # (i, j-1)
+ w[i, j, 3] -= qy0_minor[2]
+ # (i, j)
+ w[i, j, 4] -= qy0_minor[3]
+ # (i+1, j-1)
+ w[i, j, 6] -= qy0_minor[4]
+ # (i+1, j)
+ w[i, j, 7] -= qy0_minor[5]
- def __init__(self):
- """
- Initializes the AsymmetricStencil2D with default settings.
- """
- Stencil.__init__(self)
+ # q (i, j+1/2)
+ qy1_major = major_component(d_yy[i, j], m[i, j+1])
+ # (i, j+1)
+ w[i, j, 5] += qy1_major
+ # (i, j)
+ w[i, j, 4] -= qy1_major
- def get_weights(self, mesh, conductivity, fibers, D_al, D_ac, dt, dr):
- """
- Computes the weights for diffusion on a 2D mesh using an asymmetric stencil.
+ qy1_minor = minor_component(d_yx[i, j], m[i-1, j+1], m[i-1, j],
+ m[i, j+1], m[i, j], m[i+1, j+1], m[i+1, j])
- Parameters
- ----------
- mesh : np.ndarray
- 2D array representing the mesh grid of the tissue. Non-tissue areas are set to 0.
- conductivity : float
- Conductivity of the tissue, which scales the diffusion coefficient.
- fibers : np.ndarray
- Array representing fiber orientations. Used to compute directional diffusion coefficients.
- D_al : float
- Longitudinal diffusion coefficient.
- D_ac : float
- Cross-sectional diffusion coefficient.
- dt : float
- Temporal resolution.
- dr : float
- Spatial resolution.
+ # (i-1, j+1)
+ w[i, j, 2] += qy1_minor[0]
+ # (i-1, j)
+ w[i, j, 1] += qy1_minor[1]
+ # (i, j+1)
+ w[i, j, 5] += qy1_minor[2]
+ # (i, j)
+ w[i, j, 4] += qy1_minor[3]
+ # (i+1, j+1)
+ w[i, j, 8] += qy1_minor[4]
+ # (i+1, j)
+ w[i, j, 7] += qy1_minor[5]
- Returns
- -------
- np.ndarray
- 3D array of weights for diffusion, with the shape of (mesh.shape[0], mesh.shape[1], 9).
-
- Notes
- -----
- The method assumes asymmetric diffusion where different coefficients are used for different directions.
- The weights are computed for eight surrounding directions and the central weight, based on the asymmetric stencil.
- Heterogeneity in the diffusion coefficients is handled by adjusting the weights based on fiber orientations.
- """
- mesh = mesh.copy()
- mesh[mesh != 1] = 0
- fibers[np.where(mesh != 1)] = 0
- weights = np.zeros((*mesh.shape, 9))
+ # q (i+1/2, j)
+ qx1_major = major_component(d_xx[i, j], m[i+1, j])
+ # (i+1, j)
+ w[i, j, 7] += qx1_major
+ # (i, j)
+ w[i, j, 4] -= qx1_major
- def axis_fibers(fibers, ind):
- """
- Computes fiber directions for a given axis.
-
- Parameters
- ----------
- fibers : np.ndarray
- Array representing fiber orientations.
- ind : int
- Axis index (0 for x, 1 for y).
-
- Returns
- -------
- np.ndarray
- Normalized fiber directions along the specified axis.
- """
- fibr = fibers + np.roll(fibers, 1, axis=ind)
- norm = np.linalg.norm(fibr, axis=2)
- np.divide(fibr, norm[:, :, np.newaxis], out=fibr,
- where=norm[:, :, np.newaxis] != 0)
- return fibr
-
- def major_diffuse(fibers, ind):
- """
- Computes the major diffusion term based on fiber orientations.
-
- Parameters
- ----------
- fibers : np.ndarray
- Array representing fiber orientations.
- ind : int
- Axis index (0 for x, 1 for y).
-
- Returns
- -------
- np.ndarray
- Array of major diffusion coefficients.
- """
- return ((D_ac + (D_al - D_ac) * fibers[:, :, ind]**2) *
- conductivity)
-
- def minor_diffuse(fibers, ind1, ind2):
- """
- Computes the minor diffusion term based on fiber orientations.
-
- Parameters
- ----------
- fibers : np.ndarray
- Array representing fiber orientations.
- ind1 : int
- First axis index (0 for x, 1 for y).
- ind2 : int
- Second axis index (0 for x, 1 for y).
-
- Returns
- -------
- np.ndarray
- Array of minor diffusion coefficients.
- """
- return (0.5 * (D_al - D_ac) * fibers[:, :, ind1] *
- fibers_x[:, :, ind2] * conductivity)
-
- fibers_x = axis_fibers(fibers, 0)
- fibers_y = axis_fibers(fibers, 1)
-
- diffuse_x = major_diffuse(fibers_x, 0)
- diffuse_xy = minor_diffuse(fibers_x, 0, 1)
-
- diffuse_y = major_diffuse(fibers_y, 1)
- diffuse_yx = minor_diffuse(fibers_y, 1, 0)
-
- compute_weights(weights, mesh, diffuse_x, diffuse_xy, diffuse_y,
- diffuse_yx)
- weights *= dt/dr**2
- weights[:, :, 4] += 1
+ qx1_minor = minor_component(d_xy[i, j], m[i+1, j-1], m[i, j-1],
+ m[i+1, j], m[i, j], m[i+1, j+1], m[i, j+1])
+ # (i+1, j-1)
+ w[i, j, 6] += qx1_minor[0]
+ # (i, j-1)
+ w[i, j, 3] += qx1_minor[1]
+ # (i+1, j)
+ w[i, j, 7] += qx1_minor[2]
+ # (i, j)
+ w[i, j, 4] += qx1_minor[3]
+ # (i+1, j+1)
+ w[i, j, 8] += qx1_minor[4]
+ # (i, j+1)
+ w[i, j, 5] += qx1_minor[5]
- return weights
+ return w
diff --git a/finitewave/cpuwave2D/stencil/isotropic_stencil_2d.py b/finitewave/cpuwave2D/stencil/isotropic_stencil_2d.py
index 85eb097..1a3a035 100644
--- a/finitewave/cpuwave2D/stencil/isotropic_stencil_2d.py
+++ b/finitewave/cpuwave2D/stencil/isotropic_stencil_2d.py
@@ -1,90 +1,204 @@
-import numbers
import numpy as np
+from numba import njit, prange
from finitewave.core.stencil.stencil import Stencil
class IsotropicStencil2D(Stencil):
"""
- A class to represent a 2D isotropic stencil for diffusion processes.
+ This class computes the weights for diffusion on a 2D using an isotropic
+ stencil. The stencil includes 5 points: the central point and the
+ four neighbors.
- Inherits from:
- -----------
- Stencil
- Base class for different stencils used in diffusion calculations.
+ The method assumes weights being used in the following order:
- Methods
- -------
- get_weights(mesh, conductivity, fibers, D_al, D_ac, dt, dr):
- Computes the weights for diffusion based on the isotropic stencil.
+ - ``w[i, j, 0] : (i-1, j)``,
+ - ``w[i, j, 1] : (i, j-1)``,
+ - ``w[i, j, 2] : (i, j)``,
+ - ``w[i, j, 3] : (i, j+1)``,
+ - ``w[i, j, 4] : (i-1, j)``.
+
+ Notes
+ -----
+ The method can handle heterogeneity in the diffusion coefficients given
+ by the ``conductivity`` parameter.
"""
def __init__(self):
+ super().__init__()
+
+ def select_diffusion_kernel(self):
"""
- Initializes the IsotropicStencil2D with default settings.
+ Returns the diffusion kernel function for isotropic diffusion in 2D.
+
+ Returns
+ -------
+ function
+ The diffusion kernel function for isotropic diffusion in 2D.
"""
- Stencil.__init__(self)
+ return diffusion_kernel_2d_iso
- def get_weights(self, mesh, conductivity, fibers, D_al, D_ac, dt, dr):
+ def compute_weights(self, model, cardiac_tissue):
"""
- Computes the weights for diffusion on a 2D mesh using an isotropic stencil.
+ Computes the weights for isotropic diffusion in 2D.
Parameters
----------
- mesh : np.ndarray
- 2D array representing the mesh grid of the tissue. Non-tissue areas are set to 0.
- conductivity : float
- Conductivity of the tissue, which scales the diffusion coefficient.
- fibers : np.ndarray
- Array representing fiber orientations. Not used in isotropic stencil but kept for consistency.
- D_al : float
- Longitudinal diffusion coefficient.
- D_ac : float
- Cross-sectional diffusion coefficient. Not used in isotropic stencil but kept for consistency.
- dt : float
- Temporal resolution.
- dr : float
- Spatial resolution.
+ model : CardiacModel2D
+ A model object containing the simulation parameters.
+ cardiac_tissue : CardiacTissue2D
+ A 2D cardiac tissue object.
Returns
-------
- np.ndarray
- 3D array of weights for diffusion, with the shape of (mesh.shape[0], mesh.shape[1], 5).
-
- Notes
- -----
- The method assumes isotropic diffusion where `D_al` is used as the diffusion coefficient.
- The weights are computed for four directions (up, right, down, left) and the central weight.
- Heterogeneity in the diffusion coefficients is handled by adjusting the weights based on
- differences in the diffusion coefficients along the rows and columns.
+ numpy.ndarray
+ The weights for isotropic diffusion in 2D.
"""
- mesh = mesh.copy()
+ mesh = cardiac_tissue.mesh.copy()
mesh[mesh != 1] = 0
- weights = np.zeros((*mesh.shape, 5))
-
- # Compute the diffusion term
- diffuse = D_al * conductivity * np.ones(mesh.shape)
-
- # Assign weights based on diffusion
- weights[:, :, 0] = diffuse * dt / (dr**2) * np.roll(mesh, 1, axis=0)
- weights[:, :, 1] = diffuse * dt / (dr**2) * np.roll(mesh, 1, axis=1)
- weights[:, :, 3] = diffuse * dt / (dr**2) * np.roll(mesh, -1, axis=1)
- weights[:, :, 4] = diffuse * dt / (dr**2) * np.roll(mesh, -1, axis=0)
-
- # Adjust weights for heterogeneity
- diff_i = np.roll(diffuse, 1, axis=0) - np.roll(diffuse, -1, axis=0)
- diff_j = np.roll(diffuse, 1, axis=1) - np.roll(diffuse, -1, axis=1)
-
- weights[:, :, 0] -= dt / (2*dr) * diff_i
- weights[:, :, 1] -= dt / (2*dr) * diff_j
- weights[:, :, 3] += dt / (2*dr) * diff_j
- weights[:, :, 4] += dt / (2*dr) * diff_i
-
- # Finalize the weights
- for i in [0, 1, 3, 4]:
- weights[:, :, i] *= mesh
- weights[:, :, 2] -= weights[:, :, i]
+ # make sure the conductivity is a array
+ conductivity = cardiac_tissue.conductivity
+ conductivity = conductivity * np.ones_like(mesh, dtype=model.npfloat)
+ d_xx, d_yy = self.compute_half_step_diffusion(mesh, conductivity)
+
+ weights = np.zeros((*mesh.shape, 5), dtype=model.npfloat)
+ weights = compute_weights(weights, mesh, d_xx, d_yy)
+ weights = weights * model.D_model * model.dt / model.dr**2
weights[:, :, 2] += 1
- weights[:, :, 2] *= mesh
return weights
+
+ def compute_half_step_diffusion(self, mesh, conductivity, num_axes=2):
+ """
+ Computes the half-step diffusion values for isotropic diffusion.
+
+ Parameters
+ ----------
+ mesh : numpy.ndarray
+ A 2D array representing the mesh of the tissue.
+ conductivity : numpy.ndarray
+ A 2D array representing the conductivity of the tissue.
+ num_axes : int
+ The number of axes to compute the half-step diffusion values.
+
+ Returns
+ -------
+ numpy.ndarray
+ The half-step diffusion values for the specified axis.
+ """
+ D = np.zeros((num_axes, *mesh.shape))
+
+ for i in range(num_axes):
+ D[i] = 0.5 * (conductivity + np.roll(conductivity, -1, axis=i))
+
+ return D
+
+
+@njit(parallel=True)
+def diffusion_kernel_2d_iso(u_new, u, w, indexes):
+ """
+ Performs isotropic diffusion on a 2D grid.
+
+ Parameters
+ ----------
+ u_new : numpy.ndarray
+ A 2D array to store the updated potential values after diffusion.
+ u : numpy.ndarray
+ A 2D array representing the current potential values before diffusion.
+ w : numpy.ndarray
+ A 3D array of weights used in the diffusion computation.
+ The shape should match (*mesh.shape, 5).
+ mesh : numpy.ndarray
+ A 2D array representing the mesh of the tissue.
+
+ Returns
+ -------
+ numpy.ndarray
+ The updated potential values after diffusion.
+ """
+ n_i = u.shape[0]
+ n_j = u.shape[1]
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = int(ii / n_j)
+ j = ii % n_j
+
+ u_new[i, j] = (u[i-1, j] * w[i, j, 0] +
+ u[i, j-1] * w[i, j, 1] +
+ u[i, j] * w[i, j, 2] +
+ u[i, j+1] * w[i, j, 3] +
+ u[i+1, j] * w[i, j, 4])
+
+ return u_new
+
+
+@njit
+def compute_component(d, m0, m1):
+ """
+ Computes the component for isotropic diffusion in 2D.
+
+ .. code-block:: text
+
+ m0 -- d -- x ------ m1
+
+ Parameters
+ ----------
+ d : float
+ The diffusion coefficient.
+ m0 : int
+ The value of the mesh point adjacent to the central point.
+ m1 : int
+ The value of the mesh point opposite to the ``m0`` point.
+
+ Returns
+ -------
+ float
+ The computed component for isotropic diffusion in 2D.
+ """
+ return d * m0 * (m0 + (m1 == 0))
+
+
+@njit(parallel=True)
+def compute_weights(w, m, d_xx, d_yy):
+ """
+ Computes the weights for isotropic diffusion in 2D.
+
+ Parameters
+ ----------
+ w : numpy.ndarray
+ A 3D array to store the computed weights.
+ m : numpy.ndarray
+ A 2D array representing the mesh of the tissue.
+ d_xx : numpy.ndarray
+ A 2D array representing the half-step diffusion values in the x-axis.
+ d_yy : numpy.ndarray
+ A 2D array representing the half-step diffusion values in the y-axis.
+
+ Returns
+ -------
+ numpy.ndarray
+ The computed weights for isotropic diffusion in 2D.
+ """
+ n_i = m.shape[0]
+ n_j = m.shape[1]
+
+ for ii in prange(n_i * n_j):
+
+ i = int(ii / n_j)
+ j = ii % n_j
+
+ if m[i, j] != 1:
+ continue
+
+ # (i-1, j)
+ w[i, j, 0] = compute_component(d_xx[i-1, j], m[i-1, j], m[i+1, j])
+ # (i, j-1)
+ w[i, j, 1] = compute_component(d_yy[i, j-1], m[i, j-1], m[i, j+1])
+ # (i, j+1)
+ w[i, j, 3] = compute_component(d_yy[i, j], m[i, j+1], m[i, j-1])
+ # (i+1, j)
+ w[i, j, 4] = compute_component(d_xx[i, j], m[i+1, j], m[i-1, j])
+ # (i, j)
+ w[i, j, 2] = - (w[i, j, 0] + w[i, j, 1] + w[i, j, 3] + w[i, j, 4])
+
+ return w
diff --git a/finitewave/cpuwave2D/stencil/symmetric_stencil_2d.py b/finitewave/cpuwave2D/stencil/symmetric_stencil_2d.py
new file mode 100644
index 0000000..55288d0
--- /dev/null
+++ b/finitewave/cpuwave2D/stencil/symmetric_stencil_2d.py
@@ -0,0 +1,250 @@
+import numpy as np
+from numba import njit, prange
+
+from .asymmetric_stencil_2d import AsymmetricStencil2D
+
+
+class SymmetricStencil2D(AsymmetricStencil2D):
+ """
+ A class to represent a 2D symmetric stencil for diffusion processes.
+ The asymmetric stencil is used to handle anisotropic diffusion in the
+ tissue.
+
+ Notes
+ -----
+ The method assumes weights being used in the following order:
+
+ - ``w[0] : i-1, j-1``,
+ - ``w[1] : i-1, j``,
+ - ``w[2] : i-1, j+1``,
+ - ``w[3] : i, j-1``,
+ - ``w[4] : i, j``,
+ - ``w[5] : i, j+1``,
+ - ``w[6] : i+1, j-1``,
+ - ``w[7] : i+1, j``,
+ - ``w[8] : i+1, j+1``.
+ """
+
+ def __init__(self):
+ super().__init__()
+
+ def compute_weights(self, model, cardiac_tissue):
+ """
+ Computes the weights for diffusion on a 2D mesh using the symmetric
+ stencil.
+
+ Parameters
+ ----------
+ model : CardiacModel2D
+ A model object containing the simulation parameters.
+ cardiac_tissue : CardiacTissue2D
+ A 2D cardiac tissue object.
+
+ Returns
+ -------
+ np.ndarray
+ 3D array of weights for diffusion, with the shape of
+ ``(*mesh.shape, 9)``.
+ """
+ mesh = cardiac_tissue.mesh.copy()
+ conductivity = cardiac_tissue.conductivity
+ fibers = cardiac_tissue.fibers
+
+ if fibers is None:
+ message = "Fibers must be provided for anisotropic diffusion."
+ raise ValueError(message)
+
+ mesh[mesh != 1] = 0
+ # fibers[np.where(mesh != 1)] = 0
+ weights = np.zeros((*mesh.shape, 9))
+
+ D = self.compute_half_step_diffusion(mesh, conductivity, fibers,
+ self.D_al, self.D_ac)
+ compute_weights(weights, mesh, D[0], D[1], D[2], D[3])
+ weights *= model.D_model * model.dt / model.dr**2
+ weights[:, :, 4] += 1
+
+ return weights
+
+ def compute_half_step_diffusion(self, mesh, conductivity, fibers, D_al,
+ D_ac):
+ """
+ Computes the diffusion components for half-steps based on fiber
+ orientations.
+
+ Parameters
+ ----------
+ mesh : np.ndarray
+ Array representing the mesh grid of the tissue.
+ conductivity : np.ndarray
+ Array representing the conductivity of the tissue.
+ fibers : np.ndarray
+ Array representing fiber orientations with shape
+ ``(2, *mesh.shape)``.
+ D_al : float
+ Longitudinal diffusion coefficient.
+ D_ac : float
+ Cross-sectional diffusion coefficient.
+ axis : int
+ Axis index (0 for x, 1 for y).
+ num_axes : int
+ Number of axes.
+
+ Returns
+ -------
+ np.ndarray
+ Array of diffusion components for half-steps along the specified
+ axis.
+
+ Notes
+ -----
+ The index ``i`` in the returned array corresponds to ``i+1/2`` and
+ ``i-1`` corresponds to ``i-1/2``.
+ """
+
+ D = np.zeros((4, *mesh.shape))
+ for i in range(4):
+ ind0 = i // 2
+ ind1 = i % 2
+ D[i] = self.compute_diffusion_components(fibers, ind0, ind1, D_al,
+ D_ac)
+ D[i] *= conductivity
+ D[i] = 0.25 * (D[i] +
+ np.roll(D[i], -1, axis=0) +
+ np.roll(D[i], -1, axis=1) +
+ np.roll(np.roll(D[i], -1, axis=0), -1, axis=1))
+
+ return D
+
+
+@njit
+def compute_components(d_xx, d_xy, d_yx, d_yy, m0, m1, m2, m3, qx, qy):
+ """
+ .. code-block:: text
+ m1 ---- m3
+ | |
+ | o |
+ | |
+ m0 ---- m2
+
+
+ dx = 0.5 * (u2 + u3) - 0.5 * (u0 + u1)
+ dy = 0.5 * (u1 + u3) - 0.5 * (u0 + u2)
+
+ qx = d_xx * dx + d_xy * dy
+ qy = d_yx * dx + d_yy * dy
+ """
+ m = m0 + m1 + m2 + m3
+
+ if m < 3:
+ return 0, 0, 0, 0
+
+ qdx = qx * d_xx + qy * d_yx
+ qdy = qx * d_xy + qy * d_yy
+
+ w0 = - m0 / (m0 + m1) * qdx - m0 / (m0 + m2) * qdy
+ w1 = - m1 / (m0 + m1) * qdx + m1 / (m1 + m3) * qdy
+ w2 = m2 / (m2 + m3) * qdx - m2 / (m0 + m2) * qdy
+ w3 = m3 / (m2 + m3) * qdx + m3 / (m1 + m3) * qdy
+ return 0.5 * w0, 0.5 * w1, 0.5 * w2, 0.5 * w3
+
+
+@njit
+def compute_component_(m0, m1, m2, m3, d_xx, d_xy, d_yx, d_yy, qx, qy, ux, uy):
+ m = m0 * m1 * m2 * m3
+ w = (qx * (d_xx * ux + d_xy * uy) + qy * (d_yx * ux + d_yy * uy)) * m
+ return 0.25 * w
+
+
+@njit
+def compute_weights(w, m, d_xx, d_xy, d_yx, d_yy):
+ """
+ Computes the weights for diffusion on a 2D mesh based on the asymmetric
+ stencil.
+
+ Parameters
+ ----------
+ w : np.ndarray
+ 3D array to store the weights for diffusion. Shape is (*mesh.shape, 9).
+ m : np.ndarray
+ 2D array representing the mesh grid of the tissue. Non-tissue areas
+ are set to 0.
+ d_xx : np.ndarray
+ Diffusion x component for x direction.
+ d_xy : np.ndarray
+ Diffusion y component for x direction.
+ d_yx : np.ndarray
+ Diffusion x component for y direction.
+ d_yy : np.ndarray
+ Diffusion y component for y direction.
+
+ Returns
+ -------
+ np.ndarray
+ 3D array of weights for diffusion, with the shape of (*mesh.shape, 9).
+ """
+ n_i = m.shape[0]
+ n_j = m.shape[1]
+ for ii in prange(n_i * n_j):
+ i = int(ii / n_j)
+ j = ii % n_j
+ if m[i, j] != 1:
+ continue
+
+ # (i-1/2, j-1/2)
+ w0, w1, w2, w3 = compute_components(d_xx[i-1, j-1], d_xy[i-1, j-1],
+ d_yx[i-1, j-1], d_yy[i-1, j-1],
+ m[i-1, j-1], m[i-1, j], m[i, j-1],
+ m[i, j], -1, -1)
+ # (i-1, j-1)
+ w[i, j, 0] += w0
+ # (i-1, j)
+ w[i, j, 1] += w1
+ # (i, j-1)
+ w[i, j, 3] += w2
+ # (i, j)
+ w[i, j, 4] += w3
+
+ # (i-1/2, j+1/2)
+ w0, w1, w2, w3 = compute_components(d_xx[i-1, j], d_xy[i-1, j],
+ d_yx[i-1, j], d_yy[i-1, j],
+ m[i-1, j], m[i-1, j+1], m[i, j],
+ m[i, j+1], -1, 1)
+ # (i-1, j)
+ w[i, j, 1] += w0
+ # (i-1, j+1)
+ w[i, j, 2] += w1
+ # (i, j)
+ w[i, j, 4] += w2
+ # (i, j+1)
+ w[i, j, 5] += w3
+
+ # (i+1/2, j-1/2)
+ w0, w1, w2, w3 = compute_components(d_xx[i, j-1], d_xy[i, j-1],
+ d_yx[i, j-1], d_yy[i, j-1],
+ m[i, j-1], m[i, j], m[i+1, j-1],
+ m[i+1, j], 1, -1)
+ # (i, j-1)
+ w[i, j, 3] += w0
+ # (i, j)
+ w[i, j, 4] += w1
+ # (i+1, j-1)
+ w[i, j, 6] += w2
+ # (i+1, j)
+ w[i, j, 7] += w3
+
+ # (i+1/2, j+1/2)
+ w0, w1, w2, w3 = compute_components(d_xx[i, j], d_xy[i, j],
+ d_yx[i, j], d_yy[i, j],
+ m[i, j], m[i, j+1], m[i+1, j],
+ m[i+1, j+1], 1, 1)
+ # (i, j)
+ w[i, j, 4] += w0
+ # (i, j+1)
+ w[i, j, 5] += w1
+ # (i+1, j)
+ w[i, j, 7] += w2
+ # (i+1, j+1)
+ w[i, j, 8] += w3
+
+ return w
diff --git a/finitewave/cpuwave2D/stimulation/__init__.py b/finitewave/cpuwave2D/stimulation/__init__.py
index b5c7972..7a11393 100755
--- a/finitewave/cpuwave2D/stimulation/__init__.py
+++ b/finitewave/cpuwave2D/stimulation/__init__.py
@@ -1,4 +1,5 @@
-from finitewave.cpuwave2D.stimulation.stim_current_coord_2d import StimCurrentCoord2D
-from finitewave.cpuwave2D.stimulation.stim_voltage_coord_2d import StimVoltageCoord2D
-from finitewave.cpuwave2D.stimulation.stim_current_matrix_2d import StimCurrentMatrix2D
-from finitewave.cpuwave2D.stimulation.stim_voltage_matrix_2d import StimVoltageMatrix2D
\ No newline at end of file
+from .stim_current_area_2d import StimCurrentArea2D
+from .stim_current_coord_2d import StimCurrentCoord2D
+from .stim_current_matrix_2d import StimCurrentMatrix2D
+from .stim_voltage_coord_2d import StimVoltageCoord2D
+from .stim_voltage_matrix_2d import StimVoltageMatrix2D
\ No newline at end of file
diff --git a/finitewave/cpuwave2D/stimulation/stim_current_area_2d.py b/finitewave/cpuwave2D/stimulation/stim_current_area_2d.py
new file mode 100644
index 0000000..158a57b
--- /dev/null
+++ b/finitewave/cpuwave2D/stimulation/stim_current_area_2d.py
@@ -0,0 +1,94 @@
+import numpy as np
+from finitewave.core.stimulation.stim_current import StimCurrent
+
+
+class StimCurrentArea2D(StimCurrent):
+ """
+ A class that applies a stimulation current to a 2D cardiac tissue model
+ based on a area coords.
+
+ Attributes
+ ----------
+ time : float
+ The time at which the stimulation starts.
+ curr_value : float
+ The value of the stimulation current.
+ duration : float
+ The duration of the stimulation.
+ coords : numpy.ndarray
+ The coordinates of the area to be stimulated.
+ u_max : float
+ The maximum value of the membrane potential.
+ """
+ def __init__(self, time, curr_value, duration, coords=None, u_max=None):
+ """
+ Initializes the StimCurrentArea2D instance.
+
+ Parameters
+ ----------
+ time : float
+ The time at which the stimulation starts.
+ curr_value : float
+ The value of the stimulation current.
+ duration : float
+ The duration of the stimulation.
+ coords : numpy.ndarray
+ The coordinates of the area to be stimulated.
+ u_max : float, optional
+ The maximum value of the membrane potential. Default is None.
+ """
+ super().__init__(time, curr_value, duration)
+ self.coords = coords
+ self.u_max = u_max
+
+ def add_stim_point(self, coord, mesh, size=None):
+ """
+ Adds an stimulation point to the area to be stimulated.
+
+ Parameters
+ ----------
+ coord : numpy.ndarray
+ The coordinates of the stimulation point.
+ mesh : numpy.ndarray
+ The mesh of the cardiac tissue model.
+ size : float, optional
+ The size of the area to be stimulated. Default is None.
+ """
+ self._coord = coord
+
+ if size is None:
+ self.coords = np.atleast_2d(coord)
+ return
+
+ tissue_points = np.argwhere(mesh == 1)
+ dist = np.linalg.norm(tissue_points - coord, axis=1)
+ self.coords = tissue_points[dist < size]
+
+ def initialize(self, model):
+ mask = (model.cardiac_tissue.mesh[tuple(self.coords.T)] == 1)
+
+ if mask.sum() == 0:
+ raise ValueError("The specified area does not have healthy cells.")
+
+ self._coords = self.coords[mask]
+ return super().initialize(model)
+
+ def stimulate(self, model):
+ """
+ Applies the stimulation current to the cardiac tissue model based on
+ the specified binary matrix.
+
+ The stimulation is applied only if the current time is within the
+ stimulation period and the stimulation has not been previously applied.
+
+ Parameters
+ ----------
+ model : CardiacModel
+ The 2D cardiac tissue model.
+ """
+ inds = tuple(self._coords.T)
+ model.u[inds] += model.dt * self.curr_value
+
+ if self.u_max is not None:
+ model.u[inds] = np.where(model.u[inds] > self.u_max, self.u_max,
+ model.u[inds])
diff --git a/finitewave/cpuwave2D/stimulation/stim_current_coord_2d.py b/finitewave/cpuwave2D/stimulation/stim_current_coord_2d.py
index 5dc8825..6a797ed 100755
--- a/finitewave/cpuwave2D/stimulation/stim_current_coord_2d.py
+++ b/finitewave/cpuwave2D/stimulation/stim_current_coord_2d.py
@@ -1,19 +1,19 @@
+import numpy as np
from finitewave.core.stimulation.stim_current import StimCurrent
class StimCurrentCoord2D(StimCurrent):
"""
- A class that applies a stimulation current to a rectangular region of a 2D cardiac tissue model.
+ A class that applies a stimulation current to a rectangular region of a 2D
+ cardiac tissue model.
- Inherits from `StimCurrent`.
-
- Parameters
+ Attributes
----------
time : float
The time at which the stimulation starts.
curr_value : float
The value of the stimulation current.
- curr_time : float
+ duration : float
The duration of the stimulation.
x1 : int
The x-coordinate of the lower-left corner of the rectangular region.
@@ -23,8 +23,11 @@ class StimCurrentCoord2D(StimCurrent):
The y-coordinate of the lower-left corner of the rectangular region.
y2 : int
The y-coordinate of the upper-right corner of the rectangular region.
+ u_max : float, optional
+ The maximum value of the membrane potential. Default is None.
"""
- def __init__(self, time, curr_value, curr_time, x1, x2, y1, y2):
+
+ def __init__(self, time, curr_value, duration, x1, x2, y1, y2, u_max=None):
"""
Initializes the StimCurrentCoord2D instance.
@@ -34,50 +37,49 @@ def __init__(self, time, curr_value, curr_time, x1, x2, y1, y2):
The time at which the stimulation starts.
curr_value : float
The value of the stimulation current.
- curr_time : float
+ duration : float
The duration of the stimulation.
x1 : int
- The x-coordinate of the lower-left corner of the rectangular region.
+ The x-coordinate of the lower-left corner of the rectangular.
x2 : int
- The x-coordinate of the upper-right corner of the rectangular region.
+ The x-coordinate of the upper-right corner of the rectangular.
y1 : int
- The y-coordinate of the lower-left corner of the rectangular region.
+ The y-coordinate of the lower-left corner of the rectangular.
y2 : int
- The y-coordinate of the upper-right corner of the rectangular region.
+ The y-coordinate of the upper-right corner of the rectangular.
+ u_max : float, optional
+ The maximum value of the membrane potential. Default is None.
"""
- StimCurrent.__init__(self, time, curr_value, curr_time)
+ super().__init__(time, curr_value, duration)
self.x1 = x1
self.x2 = x2
self.y1 = y1
self.y2 = y2
+ self.u_max = u_max
def stimulate(self, model):
"""
- Applies the stimulation current to the specified rectangular region of the cardiac tissue model.
+ Applies the stimulation current to the specified rectangular region of
+ the cardiac tissue model.
- The stimulation is applied only if the current time is within the stimulation period and
- the stimulation has not been previously applied.
+ The stimulation is applied only if the current time is within the
+ stimulation period and the stimulation has not been previously applied.
Parameters
----------
- model : object
- The cardiac tissue model to which the stimulation current is applied. The model must have
- an attribute `cardiac_tissue` with a `mesh` property and an attribute `u` representing
- the state of the tissue.
-
- Notes
- -----
- The stimulation is applied to the region of interest (ROI) defined by the coordinates
- (x1, x2) and (y1, y2). The current value is added to the `model.u` attribute, which represents
- the state of the tissue.
+ model : CardiacModel
+ The 2D cardiac tissue model.
"""
- if not self.passed:
- # ROI - region of interest
- roi_x1, roi_x2 = self.x1, self.x2
- roi_y1, roi_y2 = self.y1, self.y2
- roi_mesh = model.cardiac_tissue.mesh[roi_x1:roi_x2, roi_y1:roi_y2]
+ roi_mesh = model.cardiac_tissue.mesh[self.x1:self.x2, self.y1:self.y2]
+ mask = (roi_mesh == 1)
+ model.u[self.x1:self.x2,
+ self.y1:self.y2][mask] += model.dt * self.curr_value
- mask = (roi_mesh == 1)
+ if self.u_max is not None:
+ u = model.u[self.x1: self.x2,
+ self.y1: self.y2][mask]
- model.u[roi_x1:roi_x2, roi_y1:roi_y2][mask] += self._dt * self.curr_value
+ model.u[self.x1: self.x2,
+ self.y1: self.y2][mask] = np.where(u > self.u_max,
+ self.u_max, u)
diff --git a/finitewave/cpuwave2D/stimulation/stim_current_matrix_2d.py b/finitewave/cpuwave2D/stimulation/stim_current_matrix_2d.py
index 74bd4a3..c53c9f4 100755
--- a/finitewave/cpuwave2D/stimulation/stim_current_matrix_2d.py
+++ b/finitewave/cpuwave2D/stimulation/stim_current_matrix_2d.py
@@ -1,25 +1,26 @@
+import numpy as np
from finitewave.core.stimulation.stim_current import StimCurrent
class StimCurrentMatrix2D(StimCurrent):
"""
- A class that applies a stimulation current to a 2D cardiac tissue model based on a binary matrix.
+ A class that applies a stimulation current to a 2D cardiac tissue model
+ based on a binary matrix.
- Inherits from `StimCurrent`.
-
- Parameters
+ Attributes
----------
time : float
The time at which the stimulation starts.
curr_value : float
The value of the stimulation current.
- curr_time : float
+ duration : float
The duration of the stimulation.
matrix : numpy.ndarray
A 2D binary matrix indicating the region of interest for stimulation.
Elements greater than 0 represent regions to be stimulated.
+
"""
- def __init__(self, time, curr_value, curr_time, matrix):
+ def __init__(self, time, curr_value, duration, matrix, u_max=None):
"""
Initializes the StimCurrentMatrix2D instance.
@@ -29,34 +30,34 @@ def __init__(self, time, curr_value, curr_time, matrix):
The time at which the stimulation starts.
curr_value : float
The value of the stimulation current.
- curr_time : float
+ duration : float
The duration of the stimulation.
matrix : numpy.ndarray
- A 2D binary matrix indicating the region of interest for stimulation.
+ A 2D binary matrix indicating the region of interest for
+ stimulation.
+ u_max : float, optional
+ The maximum value of the membrane potential. Default is None.
"""
- StimCurrent.__init__(self, time, curr_value, curr_time)
+ super().__init__(time, curr_value, duration)
self.matrix = matrix
+ self.u_max = u_max
def stimulate(self, model):
"""
- Applies the stimulation current to the cardiac tissue model based on the specified binary matrix.
+ Applies the stimulation current to the cardiac tissue model based on
+ the specified binary matrix.
- The stimulation is applied only if the current time is within the stimulation period and
- the stimulation has not been previously applied.
+ The stimulation is applied only if the current time is within the
+ stimulation period and the stimulation has not been previously applied.
Parameters
----------
- model : object
- The cardiac tissue model to which the stimulation current is applied. The model must have
- an attribute `cardiac_tissue` with a `mesh` property and an attribute `u` representing
- the state of the tissue.
-
- Notes
- -----
- The stimulation is applied to the regions of the cardiac tissue indicated by the matrix.
- For each position where the matrix value is greater than 0 and the corresponding value
- in the `model.cardiac_tissue.mesh` is 1, the current value is added to `model.u`.
+ model : CardiacModel
+ The 2D cardiac tissue model.
"""
- if not self.passed:
- mask = (self.matrix > 0) & (model.cardiac_tissue.mesh == 1)
- model.u[mask] += self._dt * self.curr_value
+ mask = (self.matrix > 0) & (model.cardiac_tissue.mesh == 1)
+ model.u[mask] += model.dt * self.curr_value
+
+ if self.u_max is not None:
+ model.u[mask] = np.where(model.u[mask] > self.u_max, self.u_max,
+ model.u[mask])
diff --git a/finitewave/cpuwave2D/stimulation/stim_voltage_coord_2d.py b/finitewave/cpuwave2D/stimulation/stim_voltage_coord_2d.py
index 22d25d6..edbd244 100755
--- a/finitewave/cpuwave2D/stimulation/stim_voltage_coord_2d.py
+++ b/finitewave/cpuwave2D/stimulation/stim_voltage_coord_2d.py
@@ -3,9 +3,8 @@
class StimVoltageCoord2D(StimVoltage):
"""
- A class that applies a voltage stimulus to a 2D cardiac tissue model within a specified region of interest.
-
- Inherits from `StimVoltage`.
+ A class that applies a voltage stimulus to a 2D cardiac tissue model
+ within a specified region of interest.
Parameters
----------
@@ -41,7 +40,7 @@ def __init__(self, time, volt_value, x1, x2, y1, y2):
y2 : int
The ending y-coordinate of the region of interest.
"""
- StimVoltage.__init__(self, time, volt_value)
+ super().__init__(time, volt_value)
self.x1 = x1
self.x2 = x2
self.y1 = y1
@@ -49,31 +48,20 @@ def __init__(self, time, volt_value, x1, x2, y1, y2):
def stimulate(self, model):
"""
- Applies the voltage stimulus to the cardiac tissue model within the specified region of interest.
+ Applies the voltage stimulus to the cardiac tissue model within the
+ specified region of interest.
- The voltage is applied only if the current time is within the stimulation period and
- the stimulation has not been previously applied.
+ The voltage is applied only if the current time is within the
+ stimulation period and the stimulation has not been previously applied.
Parameters
----------
model : object
- The cardiac tissue model to which the voltage stimulus is applied. The model must have
- an attribute `cardiac_tissue` with a `mesh` property and an attribute `u` representing
- the state of the tissue.
-
- Notes
- -----
- The voltage value is applied to the region of the cardiac tissue specified by the coordinates
- (x1, x2) and (y1, y2). The `model.cardiac_tissue.mesh` is used to mask the regions where the
- voltage should be applied. Only positions where the mesh value is 1 will be updated.
+ The cardiac tissue model to which the voltage stimulus is applied.
"""
- if not self.passed:
- # Region of Interest (ROI) coordinates
- roi_x1, roi_x2 = self.x1, self.x2
- roi_y1, roi_y2 = self.y1, self.y2
-
- roi_mesh = model.cardiac_tissue.mesh[roi_x1:roi_x2, roi_y1:roi_y2]
- mask = (roi_mesh == 1)
+ roi_mesh = model.cardiac_tissue.mesh[self.x1: self.x2,
+ self.y1: self.y2]
+ mask = (roi_mesh == 1)
- model.u[roi_x1:roi_x2, roi_y1:roi_y2][mask] = self.volt_value
+ model.u[self.x1: self.x2, self.y1: self.y2][mask] = self.volt_value
diff --git a/finitewave/cpuwave2D/stimulation/stim_voltage_matrix_2d.py b/finitewave/cpuwave2D/stimulation/stim_voltage_matrix_2d.py
index f2f58de..5ea50b5 100755
--- a/finitewave/cpuwave2D/stimulation/stim_voltage_matrix_2d.py
+++ b/finitewave/cpuwave2D/stimulation/stim_voltage_matrix_2d.py
@@ -3,18 +3,8 @@
class StimVoltageMatrix2D(StimVoltage):
"""
- A class that applies a voltage stimulus to a 2D cardiac tissue model according to a specified matrix.
-
- Inherits from `StimVoltage`.
-
- Parameters
- ----------
- time : float
- The time at which the stimulation starts.
- volt_value : float
- The voltage value to apply.
- matrix : numpy.ndarray
- A 2D array where the voltage stimulus is applied to locations with values greater than 0.
+ A class that applies a voltage stimulus to a 2D cardiac tissue model
+ according to a specified matrix.
"""
def __init__(self, time, volt_value, matrix):
"""
@@ -27,30 +17,30 @@ def __init__(self, time, volt_value, matrix):
volt_value : float
The voltage value to apply.
matrix : numpy.ndarray
- A 2D array where the voltage stimulus is applied to locations with values greater than 0.
+ A 2D array where the voltage stimulus is applied to locations with
+ values greater than 0.
"""
- StimVoltage.__init__(self, time, volt_value)
+ super().__init__(time, volt_value)
self.matrix = matrix
def stimulate(self, model):
"""
- Applies the voltage stimulus to the cardiac tissue model based on the specified matrix.
+ Applies the voltage stimulus to the cardiac tissue model based on the
+ specified matrix.
- The voltage is applied only if the current time is within the stimulation period and
- the stimulation has not been previously applied.
+ The voltage is applied only if the current time is within the
+ stimulation period and the stimulation has not been previously applied.
Parameters
----------
- model : object
- The cardiac tissue model to which the voltage stimulus is applied. The model must have
- an attribute `cardiac_tissue` with a `mesh` property and an attribute `u` representing
- the state of the tissue.
+ model : CardiacModel
+ The 2D cardiac tissue model.
Notes
-----
- The voltage value is applied to the positions in the cardiac tissue where the corresponding
- value in `matrix` is greater than 0, and the `model.cardiac_tissue.mesh` value is 1.
+ The voltage value is applied to the positions in the cardiac tissue
+ where the corresponding value in ``matrix`` is greater than 0,
+ and the ``model.cardiac_tissue.mesh`` value is 1.
"""
- if not self.passed:
- mask = (self.matrix > 0) & (model.cardiac_tissue.mesh == 1)
- model.u[mask] = self.volt_value
+ mask = (self.matrix > 0) & (model.cardiac_tissue.mesh == 1)
+ model.u[mask] = self.volt_value
diff --git a/finitewave/cpuwave2D/tissue/cardiac_tissue_2d.py b/finitewave/cpuwave2D/tissue/cardiac_tissue_2d.py
index f5bc234..bbf8ce2 100755
--- a/finitewave/cpuwave2D/tissue/cardiac_tissue_2d.py
+++ b/finitewave/cpuwave2D/tissue/cardiac_tissue_2d.py
@@ -1,61 +1,35 @@
import numpy as np
from finitewave.core.tissue.cardiac_tissue import CardiacTissue
-from finitewave.cpuwave2D.stencil.isotropic_stencil_2d import IsotropicStencil2D
class CardiacTissue2D(CardiacTissue):
"""
- A class to represent a 2D cardiac tissue model with isotropic or anisotropic properties.
-
- Inherits from:
- -----------
- CardiacTissue
- Base class for cardiac tissue models.
+ This class represents a 2D cardiac tissue.
Attributes
----------
- shape : tuple of int
- Shape of the 2D grid for the cardiac tissue.
- mesh : np.ndarray
- Grid representing the tissue, with boundaries set to zero.
- stencil : IsotropicStencil2D
- Stencil for calculating weights in the 2D grid.
- conductivity : float
- Conductivity value for the tissue.
- fibers : np.ndarray or None
- Array representing fiber orientations. If None, isotropic weights are used.
meta : dict
- Metadata about the tissue, including dimensionality.
- weights : np.ndarray
- Weights used for diffusion calculations.
-
- Methods
- -------
- __init__(shape):
- Initializes the 2D cardiac tissue model with the given shape and mode.
- add_boundaries():
- Sets boundary values in the mesh to zero.
- compute_weights(dr, dt):
- Computes the weights for diffusion based on the stencil and mode.
+ A dictionary containing metadata about the tissue.
+ mesh : np.ndarray
+ A 2D numpy array representing the tissue mesh where each value
+ indicates the type of tissue at that location. Possible values are:
+ ``0`` for non-tissue, ``1`` for healthy tissue, and ``2`` for fibrotic
+ tissue.
+ conductivity : float or np.ndarray
+ The conductivity of the tissue used for reducing the diffusion
+ coefficients. The conductivity should be in the range [0, 1].
+ fibers : np.ndarray
+ Fibers orientation in the tissue. If None, the isotropic stencil is
+ used.
"""
def __init__(self, shape):
- """
- Initializes the CardiacTissue2D model.
-
- Parameters
- ----------
- shape : tuple of int
- Shape of the 2D grid for the cardiac tissue.
- """
- CardiacTissue.__init__(self)
- self.meta["Dim"] = 2
- self.shape = shape
- self.mesh = np.ones(shape)
- self.add_boundaries()
- self.stencil = IsotropicStencil2D()
- self.conductivity = 1
+ super().__init__()
+ self.meta["dim"] = 2
+ self.meta["shape"] = shape
+ self.mesh = np.ones(shape, dtype=np.int8)
+ self.conductivity = 1.0
self.fibers = None
def add_boundaries(self):
@@ -65,22 +39,7 @@ def add_boundaries(self):
The boundaries are defined as the edges of the grid, and this method
updates these edges in the mesh array.
"""
- self.mesh[0, :] = 0
- self.mesh[:, 0] = 0
- self.mesh[-1, :] = 0
- self.mesh[:, -1] = 0
-
- def compute_weights(self, dr, dt):
- """
- Computes the weights for diffusion using the stencil and given parameters.
-
- Parameters
- ----------
- dr : float
- Spatial resolution.
- dt : float
- Temporal resolution.
- """
- self.weights = self.stencil.get_weights(self.mesh, self.conductivity,
- self.fibers, self.D_al,
- self.D_ac, dt, dr)
+ self._mesh[0, :] = 0
+ self._mesh[:, 0] = 0
+ self._mesh[-1, :] = 0
+ self._mesh[:, -1] = 0
diff --git a/finitewave/cpuwave2D/tracker/__init__.py b/finitewave/cpuwave2D/tracker/__init__.py
index a0a5d3a..477e9e0 100755
--- a/finitewave/cpuwave2D/tracker/__init__.py
+++ b/finitewave/cpuwave2D/tracker/__init__.py
@@ -1,11 +1,33 @@
-from finitewave.cpuwave2D.tracker.action_potential_2d_tracker import ActionPotential2DTracker
-from finitewave.cpuwave2D.tracker.activation_time_2d_tracker import ActivationTime2DTracker
-from finitewave.cpuwave2D.tracker.animation_2d_tracker import Animation2DTracker
-from finitewave.cpuwave2D.tracker.ecg_2d_tracker import ECG2DTracker
-from finitewave.cpuwave2D.tracker.multi_activation_time_2d_tracker import MultiActivationTime2DTracker
-from finitewave.cpuwave2D.tracker.multivariable_2d_tracker import MultiVariable2DTracker
-from finitewave.cpuwave2D.tracker.period_2d_tracker import Period2DTracker
-from finitewave.cpuwave2D.tracker.period_map_2d_tracker import PeriodMap2DTracker
-from finitewave.cpuwave2D.tracker.spiral_2d_tracker import Spiral2DTracker
-from finitewave.cpuwave2D.tracker.variable_2d_tracker import Variable2DTracker
-from finitewave.cpuwave2D.tracker.velocity_2d_tracker import Velocity2DTracker
\ No newline at end of file
+"""
+2D Tracker
+----------
+
+This module contains classes for tracking the evolution of the wavefront in 2D.
+
+The tracker classes can be grouped into the following categories:
+
+* Full field trackers that track the entire field and output the results in
+ a single array.
+* Point trackers that track the evolution of a specific point(s) in the field.
+* Animation trackers that track the evolution of the field over time and save
+ the results as frames for creating animations.
+
+Each tracker class has basic attributes such as ``start_time``, ``end_time``,
+``step``, ``path``, and ``file_name``.
+
+.. note::
+
+ Note that the ``start_time`` and ``end_time`` is given in time units,
+ and the ``step`` is the number of time steps between recordings.
+"""
+
+from .action_potential_2d_tracker import ActionPotential2DTracker
+from .activation_time_2d_tracker import ActivationTime2DTracker
+from .animation_2d_tracker import Animation2DTracker
+from .ecg_2d_tracker import ECG2DTracker
+from .local_activation_time_2d_tracker import LocalActivationTime2DTracker
+from .multi_variable_2d_tracker import MultiVariable2DTracker
+from .period_2d_tracker import Period2DTracker
+from .period_animation_2d_tracker import PeriodAnimation2DTracker
+from .spiral_wave_core_2d_tracker import SpiralWaveCore2DTracker
+from .variable_2d_tracker import Variable2DTracker
diff --git a/finitewave/cpuwave2D/tracker/action_potential_2d_tracker.py b/finitewave/cpuwave2D/tracker/action_potential_2d_tracker.py
index 5264648..2731e72 100755
--- a/finitewave/cpuwave2D/tracker/action_potential_2d_tracker.py
+++ b/finitewave/cpuwave2D/tracker/action_potential_2d_tracker.py
@@ -1,4 +1,3 @@
-import os
import numpy as np
from finitewave.core.tracker.tracker import Tracker
@@ -6,30 +5,20 @@
class ActionPotential2DTracker(Tracker):
"""
- A class to track and record the action potential of a specific cell in a 2D cardiac tissue model.
+ A class to track and record the action potential of a specific cell in
+ a 2D cardiac tissue model.
- This tracker monitors the membrane potential of a single cell at each time step and stores the data
- in an array for later analysis or visualization.
+ This tracker monitors the membrane potential of a single cell at each time
+ step and stores the data in an array for later analysis or visualization.
Attributes
----------
act_pot : np.ndarray
Array to store the action potential values at each time step.
- cell_ind : list of int
+ cell_ind : list or list of lists with two indices
Coordinates of the cell to be tracked in the 2D model grid.
file_name : str
Name of the file where the tracked action potential data will be saved.
-
- Methods
- -------
- initialize(model):
- Initializes the tracker with the simulation model, setting up the action potential array.
- track():
- Records the action potential of the specified cell at the current time step.
- output():
- Returns the tracked action potential data.
- write():
- Saves the tracked action potential data to a file.
"""
def __init__(self):
@@ -37,35 +26,31 @@ def __init__(self):
Initializes the ActionPotential2DTracker with default parameters.
"""
Tracker.__init__(self)
- self.act_pot = np.array([]) # Initialize the array to store action potential
+ self.act_pot = [] # Initialize the array to store action potential
self.cell_ind = [1, 1] # Default cell indices to track
self.file_name = "act_pot" # Default file name for saving data
def initialize(self, model):
"""
- Initializes the tracker with the simulation model, setting up the action potential array.
+ Initializes the tracker with the simulation model, setting up
+ the action potential array.
Parameters
----------
model : object
- The cardiac tissue model object that contains simulation parameters like `t_max` (maximum time)
- and `dt` (time step).
+ The cardiac tissue model object that contains simulation parameters
+ like `t_max` (maximum time) and `dt` (time step).
"""
self.model = model
- t_max = self.model.t_max # Maximum simulation time
- dt = self.model.dt # Time step
- self.act_pot = np.zeros(int(t_max / dt) + 1) # Initialize the action potential array
- def track(self):
+ def _track(self):
"""
- Records the action potential of the specified cell at the current time step.
-
- The action potential value is retrieved from the model's `u` matrix at the coordinates specified
- by `cell_ind`.
+ Records the action potential (`u`) of the specified cell at the current
+ time step.
"""
- step = self.model.step # Current simulation step
- # Record the action potential value at the specified cell index
- self.act_pot[step] = self.model.u[self.cell_ind[0], self.cell_ind[1]]
+ # Make possible to track multiple cells
+ cell_ind = tuple(np.atleast_2d(self.cell_ind).T)
+ self.act_pot.append(self.model.u[cell_ind])
@property
def output(self):
@@ -77,12 +62,4 @@ def output(self):
np.ndarray
The array containing the tracked action potential values.
"""
- return self.act_pot
-
- def write(self):
- """
- Saves the tracked action potential data to a file.
-
- The file is saved in the path specified by `self.path` with the name `self.file_name`.
- """
- np.save(os.path.join(self.path, self.file_name), self.act_pot)
+ return np.squeeze(self.act_pot)
diff --git a/finitewave/cpuwave2D/tracker/activation_time_2d_tracker.py b/finitewave/cpuwave2D/tracker/activation_time_2d_tracker.py
index a14bc18..3ffd7b2 100755
--- a/finitewave/cpuwave2D/tracker/activation_time_2d_tracker.py
+++ b/finitewave/cpuwave2D/tracker/activation_time_2d_tracker.py
@@ -1,4 +1,4 @@
-import os
+from pathlib import Path
import numpy as np
from finitewave.core.tracker.tracker import Tracker
@@ -6,10 +6,12 @@
class ActivationTime2DTracker(Tracker):
"""
- A class to track and record the activation time of each cell in a 2D cardiac tissue model.
+ A class to track and record the activation time of each cell in a 2D
+ cardiac tissue model.
- This tracker monitors the membrane potential of each cell and records the time at which the potential
- crosses a certain threshold, indicating cell activation.
+ This tracker monitors the membrane potential of each cell and records
+ the time at which the potential crosses a certain threshold, indicating
+ cell activation.
Attributes
----------
@@ -20,16 +22,6 @@ class ActivationTime2DTracker(Tracker):
file_name : str
Name of the file where the tracked activation time data will be saved.
- Methods
- -------
- initialize(model):
- Initializes the tracker with the simulation model, setting up the activation time array.
- track():
- Records the activation time of each cell based on the threshold crossing.
- output():
- Returns the tracked activation time data.
- write():
- Saves the tracked activation time data to a file.
"""
def __init__(self):
@@ -37,34 +29,38 @@ def __init__(self):
Initializes the ActivationTime2DTracker with default parameters.
"""
Tracker.__init__(self)
- self.act_t = np.array([]) # Initialize the array to store activation times
- self.threshold = -40 # Default threshold for activation (in mV)
+ self.act_t = np.ndarray # Array to store activation times
+ self.threshold = -40 # Threshold for activation (in mV)
self.file_name = "act_time_2d" # Default file name for saving data
def initialize(self, model):
"""
- Initializes the tracker with the simulation model, setting up the activation time array.
+ Initializes the tracker with the simulation model, setting up
+ the activation time array.
Parameters
----------
model : object
- The cardiac tissue model object that contains the grid (`u`) of membrane potentials.
+ The cardiac tissue model object that contains the grid (`u`) of
+ membrane potentials.
"""
self.model = model
# Initialize activation time array with -1 to indicate unactivated cells
- self.act_t = -np.ones(self.model.u.shape)
+ self.act_t = - np.ones_like(self.model.u)
- def track(self):
+ def _track(self):
"""
- Records the activation time of each cell based on the threshold crossing.
+ Records the activation time of each cell based on the threshold
+ crossing.
- The activation time is recorded as the first instance where the membrane potential of a cell
- crosses the threshold value.
+ The activation time is recorded as the first instance where
+ the membrane potential of a cell crosses the threshold value.
"""
- # Update activation times where they are still -1 and the membrane potential exceeds the threshold
- self.act_t = np.where(np.logical_and(self.act_t < 0, self.model.u > self.threshold),
- self.model.t,
- self.act_t)
+ # Update activation times where they are still -1 and the membrane
+ # potential exceeds the threshold
+ self.act_t = np.where((self.act_t < 0)
+ & (self.model.u > self.threshold),
+ self.model.t, self.act_t)
@property
def output(self):
@@ -74,14 +70,6 @@ def output(self):
Returns
-------
np.ndarray
- The array containing the activation time of each cell in the 2D grid.
+ The array containing the activation time of each cell in the grid.
"""
return self.act_t
-
- def write(self):
- """
- Saves the tracked activation time data to a file.
-
- The file is saved in the path specified by `self.path` with the name `self.file_name`.
- """
- np.save(os.path.join(self.path, self.file_name), self.act_t)
diff --git a/finitewave/cpuwave2D/tracker/animation_2d_tracker.py b/finitewave/cpuwave2D/tracker/animation_2d_tracker.py
index a557a10..195664e 100755
--- a/finitewave/cpuwave2D/tracker/animation_2d_tracker.py
+++ b/finitewave/cpuwave2D/tracker/animation_2d_tracker.py
@@ -1,45 +1,32 @@
-import os
+from pathlib import Path
import numpy as np
from finitewave.core.tracker.tracker import Tracker
+from finitewave.tools import Animation2DBuilder
class Animation2DTracker(Tracker):
"""
- A class to track and save frames of a 2D cardiac tissue model simulation for animation purposes.
+ A class to track and save frames of a 2D cardiac tissue model simulation
+ for animation purposes.
- This tracker periodically saves the state of a specified target array from the model to disk as NumPy files,
- which can later be used to create animations.
+ This tracker periodically saves the state of a specified target array from
+ the model to disk as NumPy files, which can later be used to create
+ animations.
Attributes
----------
- step : int
- Interval in time steps at which frames are saved.
- start : float
- The time at which to start recording frames.
- _t : float
- Internal counter for keeping track of the elapsed time since the last frame was saved.
dir_name : str
- Directory name where animation frames are stored.
- _frame_n : int
- Internal counter to keep track of the number of frames saved.
- target_array : str
- The name of the model attribute to be saved as a frame.
- frame_format : dict
- A dictionary defining the format of saved frames. Contains 'type' (data type) and 'mult' (multiplier for scaling).
- _frame_format_type : str
- Internal storage for the data type of the saved frames.
- _frame_format_mult : float
- Internal storage for the multiplier for scaling the saved frames.
-
- Methods
- -------
- initialize(model):
- Initializes the tracker with the simulation model and sets up directories for saving frames.
- track():
- Saves frames based on the specified step interval and target array.
- write():
- No operation. Exists to fulfill the interface requirements.
+ Directory for saving frames.
+ variable_name : str
+ Name of the target array to capture.
+ frame_type : str
+ Default frame format settings.
+ overwrite : bool
+ Overwrite existing frames.
+ file_name : str
+ Name of the animation file.
+
"""
def __init__(self):
@@ -47,28 +34,17 @@ def __init__(self):
Initializes the Animation2DTracker with default parameters.
"""
Tracker.__init__(self)
- self.step = 1 # Interval for frame capture
- self.start = 0 # Start time for capturing frames
- self._t = 0 # Internal time counter
-
- self.dir_name = "animation" # Directory for saving frames
-
- self._frame_n = 0 # Frame counter
-
- self.target_array = "" # Name of the target array to capture
-
- # Frame format: type (data type of saved frames), mult (scaling multiplier)
- self.frame_format = {
- "type": "float64",
- "mult": 1
- }
-
- self._frame_format_type = "" # Internal storage for frame format type
- self._frame_format_mult = 1 # Internal storage for frame format multiplier
+ self.dir_name = "animation" # Directory for saving frames
+ self.variable_name = "u" # Name of the target array to capture
+ self.frame_type = "float64" # Default frame format settings
+ self._frame_counter = 0 # Internal frame counter
+ self.overwrite = True # Overwrite existing frames
+ self.file_name = "animation" # Name of the animation file
def initialize(self, model):
"""
- Initializes the tracker with the simulation model and sets up directories for saving frames.
+ Initializes the tracker with the simulation model and sets up
+ directories for saving frames.
Parameters
----------
@@ -76,43 +52,64 @@ def initialize(self, model):
The cardiac tissue model object containing the data to be tracked.
"""
self.model = model
+ self._frame_counter = 0 # Reset frame counter
- self._t = 0 # Reset internal time counter
- self._frame_n = 0 # Reset frame counter
- self._dt = self.model.dt # Time step size from the model
- self._step = self.step - self._dt # Adjusted step for saving frames
+ if not Path(self.path, self.dir_name).is_dir():
+ Path(self.path, self.dir_name).mkdir(parents=True)
- # Create the directory for saving frames if it doesn't exist
- if not os.path.exists(os.path.join(self.path, self.dir_name)):
- os.makedirs(os.path.join(self.path, self.dir_name))
+ if self.overwrite:
+ for file in Path(self.path, self.dir_name).glob("*.npy"):
+ file.unlink()
- # Store frame format settings
- self._frame_format_type = self.frame_format["type"]
- self._frame_format_mult = self.frame_format["mult"]
-
- def track(self):
+ def _track(self):
"""
Saves frames based on the specified step interval and target array.
The frames are saved in the specified directory as NumPy files.
"""
- # Only start tracking if the current model time is beyond the start time
- if not self.model.t >= self.start:
- return
-
- # Save a frame if enough time has elapsed since the last frame
- if self._t > self._step:
- # Retrieve the target array from the model and scale it
- frame = (self.model.__dict__[self.target_array] * self._frame_format_mult).astype(self._frame_format_type)
- # Save the frame as a NumPy file
- np.save(os.path.join(self.path, self.dir_name, str(self._frame_n)), frame)
- self._frame_n += 1 # Increment frame counter
- self._t = 0 # Reset internal time counter
- else:
- self._t += self._dt # Increment internal time counter by the time step
-
- def write(self):
+ frame = self.model.__dict__[self.variable_name]
+ dir_path = Path(self.path, self.dir_name)
+
+ np.save(dir_path.joinpath(str(self._frame_counter)
+ ).with_suffix(".npy"),
+ frame.astype(self.frame_type))
+
+ self._frame_counter += 1
+
+ def write(self, shape_scale=1, fps=12, cmap="coolwarm", clim=[0, 1],
+ clear=False, prog_bar=True):
"""
- No operation for this tracker. Exists to fulfill the interface requirements.
+ Creates an animation from the saved frames using the Animation2DBuilder
+ class. Fibrosis and boundaries will be shown in black.
+
+ Parameters
+ ----------
+ shape_scale : int, optional
+ Scale factor for the frame size. The default is 5.
+ fps : int, optional
+ Frames per second for the animation. The default is 12.
+ cmap : str, optional
+ Color map for the animation. The default is 'coolwarm'.
+ clim : list, optional
+ Color limits for the animation. The default is [0, 1].
+ clear : bool, optional
+ Clear the snapshot folder after creating the animation.
+ The default is False.
+ prog_bar : bool, optional
+ Show a progress bar during the animation creation.
+ The default is True.
"""
- pass
+ animation_builder = Animation2DBuilder()
+ path = Path(self.path, self.dir_name)
+ mask = self.model.cardiac_tissue.mesh != 1
+
+ animation_builder.write(path,
+ animation_name=self.file_name,
+ mask=mask,
+ shape_scale=shape_scale,
+ fps=fps,
+ clim=clim,
+ shape=mask.shape,
+ cmap=cmap,
+ clear=clear,
+ prog_bar=prog_bar)
diff --git a/finitewave/cpuwave2D/tracker/ecg_2d_tracker.py b/finitewave/cpuwave2D/tracker/ecg_2d_tracker.py
index cd532aa..156da65 100644
--- a/finitewave/cpuwave2D/tracker/ecg_2d_tracker.py
+++ b/finitewave/cpuwave2D/tracker/ecg_2d_tracker.py
@@ -1,4 +1,4 @@
-import os
+from pathlib import Path
import numpy as np
from numba import njit, prange
from scipy.spatial import distance
@@ -8,102 +8,146 @@
class ECG2DTracker(Tracker):
"""
- A class to compute and track electrocardiogram (ECG) signals from a 2D cardiac tissue model simulation.
+ A class to compute and track electrocardiogram (ECG) signals from a 2D
+ cardiac tissue model simulation.
- This tracker calculates ECG signals at specified measurement points by computing the potential differences
- across the cardiac tissue mesh and considering the inverse square of the distance from each measurement point.
+ This tracker calculates ECG signals at specified measurement points by
+ computing the potential differences across the cardiac tissue mesh and
+ considering the inverse square of the distance from each measurement point.
Attributes
----------
- measure_points : np.ndarray
+ measure_coords : np.ndarray
An array of points (x, y, z) where ECG signals are measured.
- ecg : np.ndarray
+ ecg : list
The computed ECG signals.
- step : int
- Interval in time steps at which ECG signals are calculated.
- _index : int
- Internal counter to keep track of the current step index for saving ECG signals.
- tissue_points : tuple
- Indices of the tissue points in the cardiac mesh where the potential is measured.
- distances : np.ndarray
- Precomputed squared distances between measurement points and tissue points.
-
- Methods
- -------
- initialize(model):
- Initializes the tracker with the simulation model and precomputes necessary values.
- calc_ecg():
- Calculates the ECG signal based on the current potential difference in the model.
- track():
- Tracks and stores ECG signals at the specified intervals.
- write():
- Saves the computed ECG signals to disk as a NumPy file.
+ file_name : str
+ The name of the file to save the computed ECG signals.
+ u_tr : np.ndarray
+ The updated potential values after diffusion.
+
"""
- def __init__(self):
+ def __init__(self, measure_coords=None):
"""
Initializes the ECG2DTracker with default parameters.
+
+ Parameters
+ ----------
+ distance_power : int, optional
+ The power to which the distance is raised in the calculation of the
+ ECG signal. The default is 1.
"""
- Tracker.__init__(self)
- self.measure_points = np.array([[0, 0, 1]]) # Default measurement points
- self.ecg = np.ndarray # Placeholder for ECG data array
- self.step = 1 # Interval for ECG calculation
- self._index = 0 # Internal step counter
+ super().__init__()
+ self.measure_coords = measure_coords
+ self.ecg = []
+ self.file_name = "ecg.npy"
+ self.u_tr = None
def initialize(self, model):
"""
- Initializes the tracker with the simulation model and precomputes necessary values.
+ Initialize the ECG tracker with the model object.
Parameters
----------
- model : object
- The cardiac tissue model object containing the data to be tracked.
+ model : CardiacModel3D
+ The model object containing the simulation parameters.
"""
self.model = model
- n = int(np.ceil(model.t_max / (self.step * model.dt))) # Number of steps to save ECG data
- self.ecg = np.zeros((self.measure_points.shape[0], n)) # Initialize ECG array
-
- # Get the cardiac tissue mesh and find tissue points
- mesh = model.cardiac_tissue.mesh
- self.tissue_points = np.where(mesh == 1)
-
- # Calculate distances from measure points to each tissue point
- points = np.argwhere(mesh == 1)
- tissue_points = np.append(points, np.zeros((points.shape[0], 1)), axis=1) # Add zero z-coordinate
- self.distances = distance.cdist(self.measure_points, tissue_points) # Compute distances
- self.distances = self.distances**2 # Square distances for inverse-square law
+ self.measure_coords = np.atleast_2d(self.measure_coords)
+ self.ecg = []
+ self.u_tr = np.zeros_like(model.u)
def calc_ecg(self):
"""
- Calculates the ECG signal based on the current potential difference in the model.
+ Calculate the ECG signal at the measurement points.
Returns
-------
np.ndarray
- The calculated ECG signals for each measurement point.
+ The computed ECG signal.
"""
- # Compute the current potential difference across the tissue points
- current = (self.model.u_new - self.model.u)[self.tissue_points]
- # Calculate the ECG signal by summing the contributions weighted by the inverse squared distances
- return np.sum(current / self.distances, axis=1)
-
- def track(self):
+ self.model.diffusion_kernel(self.u_tr,
+ self.model.u,
+ self.model.weights,
+ self.model.cardiac_tissue.myo_indexes)
+ ecg = compute_ecg(self.u_tr,
+ self.model.u,
+ self.measure_coords,
+ self.model.dr,
+ self.model.cardiac_tissue.myo_indexes)
+ return ecg
+
+ def _track(self):
"""
Tracks and stores ECG signals at the specified intervals.
This method should be called at each time step of the simulation.
"""
- # Only compute ECG if the current step is a multiple of the step interval
- if self.model.step % self.step == 0:
- self.ecg[:, self._index] = self.calc_ecg() # Calculate and store ECG
- self._index += 1 # Increment the step index
+ ecg = self.calc_ecg()
+ self.ecg.append(ecg)
+
+ @property
+ def output(self):
+ """
+ Get the computed ECG signals as a numpy array.
+
+ Returns
+ -------
+ np.ndarray
+ The computed ECG signals.
+ """
+ return np.array(self.ecg)
def write(self):
"""
- Saves the computed ECG signals to disk as a NumPy file.
+ Save the computed ECG signals to a file.
+
+ The ECG signals are saved as a numpy array in the specified path.
"""
- # Create the directory if it doesn't exist
- if not os.path.exists(self.dir_name):
- os.mkdir(self.dir_name)
- # Save ECG data to a file
- np.save(os.path.join(self.dir_name, "ecg.npy"), self.ecg)
+ if not Path(self.path).exists():
+ Path(self.path).mkdir(parents=True)
+
+ np.save(Path(self.path).joinpath(self.file_name).with_suffix('.npy'),
+ self.output)
+
+@njit(parallel=True)
+def compute_ecg(u_tr, u, coords, dr, indexes):
+ """
+ Performs isotropic diffusion on a 2D grid.
+
+ Parameters
+ ----------
+ u_tr : numpy.ndarray
+ A 2D array to store the updated potential values after diffusion.
+ u : numpy.ndarray
+ A 2D array representing the current potential values before diffusion.
+ coord : tuple
+ The coordinates of the measurement point.
+ dr : float
+ The spatial resolution of the grid.
+ indexes : numpy.ndarray
+ A 1D array of indices of the healthy tissue points.
+ """
+ n_j = u.shape[1]
+
+ n_c = len(coords)
+ ecg = np.zeros(n_c)
+
+ for c in range(n_c):
+ x, y, z = coords[c]
+ ecg_ = 0
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = ii // n_j
+ j = ii % n_j
+
+ d = (x - i)**2 + (y - j)**2 + (z)**2
+
+ if d > 0:
+ ecg_ += (u_tr[i, j] - u[i, j]) / (d * dr)
+
+ ecg[c] = ecg_
+
+ return ecg
\ No newline at end of file
diff --git a/finitewave/cpuwave2D/tracker/local_activation_time_2d_tracker.py b/finitewave/cpuwave2D/tracker/local_activation_time_2d_tracker.py
new file mode 100644
index 0000000..1313957
--- /dev/null
+++ b/finitewave/cpuwave2D/tracker/local_activation_time_2d_tracker.py
@@ -0,0 +1,101 @@
+import numpy as np
+
+from finitewave.core.tracker.tracker import Tracker
+
+
+class LocalActivationTime2DTracker(Tracker):
+ """
+ A class to compute and track multiple activation times in a 2D cardiac
+ tissue model simulation.
+
+ This tracker monitors the potential across the cardiac tissue and records
+ the times when cells surpass a specific threshold, supporting multiple
+ activations such as re-entrant waves or multiple excitations.
+
+ The activation times are stored in a array where each element is an array
+ storing the activation times for each cell. Arrays can be not fully filled
+ if faster cells activate before slower ones. In oreder to get the full
+ activation times, the user should select the next closest activation time
+ to the desired time base.
+
+ Attributes
+ ----------
+ act_t : list of np.ndarray
+ A list where each element is an array storing activation times for
+ each cell. Preferably accessed through the output property.
+ threshold : float
+ The potential threshold to determine cell activation.
+ file_name : str
+ The file name for saving the activation times.
+
+ """
+
+ def __init__(self):
+ """
+ Initializes the MultiActivationTime2DTracker with default parameters.
+ """
+ Tracker.__init__(self)
+ self.act_t = [] # Initialize activation times as an empty array
+ self.threshold = -40 # Activation threshold
+ self.file_name = "local_act_time_2d" # Output file name
+ self._activated = np.ndarray # Array to store the activation state
+
+ def initialize(self, model):
+ """
+ Initializes the tracker with the simulation model and
+ precomputes necessary values.
+
+ Parameters
+ ----------
+ model : CardiacModel
+ The cardiac tissue model object containing the data to be tracked.
+ """
+ self.model = model
+ # Initialize with a single layer of -1 (no activation)
+ self.act_t = [-np.ones_like(self.model.u)]
+ self._activated = np.full(self.model.u.shape, 0, dtype=bool)
+
+ def _track(self):
+ """
+ Tracks and stores activation times for each cell in
+ the model at each time step.
+ """
+ cross_mask = self.cross_threshold()
+ # Check if there are already activated cells in the current
+ # activation layer
+ if np.any(self.act_t[-1][cross_mask] > -1):
+ self.act_t.append(-np.ones(self.model.u.shape))
+ # Update activation times where the threshold is crossed
+ self.act_t[-1] = np.where(cross_mask, self.model.t, self.act_t[-1])
+
+ def cross_threshold(self):
+ """
+ Detects the cells that crossed the threshold and are not activated yet.
+
+ Returns
+ -------
+ np.ndarray
+ A binary array where 1 indicates cells that crossed the threshold
+ and are not activated yet.
+ """
+ # Mask for cells that crossed the threshold and are not activated yet
+ cross_mask = ((self.model.u >= self.threshold)
+ & (self._activated == 0))
+ self._activated = np.where(cross_mask, 1, self._activated)
+ # Set inactive cells that backcrossed the threshold after activation
+ backcross_mask = ((self.model.u < self.threshold)
+ & (self._activated == 1))
+ self._activated = np.where(backcross_mask, 0, self._activated)
+ return cross_mask
+
+ @property
+ def output(self):
+ """
+ Returns the activation times.
+
+ Returns
+ -------
+ np.ndarray
+ The array containing the activation times for each cell.
+ """
+ return np.array(self.act_t)
diff --git a/finitewave/cpuwave2D/tracker/multi_activation_time_2d_tracker.py b/finitewave/cpuwave2D/tracker/multi_activation_time_2d_tracker.py
deleted file mode 100755
index d788277..0000000
--- a/finitewave/cpuwave2D/tracker/multi_activation_time_2d_tracker.py
+++ /dev/null
@@ -1,113 +0,0 @@
-import os
-import numpy as np
-
-from finitewave.core.tracker.tracker import Tracker
-
-
-class MultiActivationTime2DTracker(Tracker):
- """
- A class to compute and track multiple activation times in a 2D cardiac tissue model simulation.
-
- This tracker monitors the potential across the cardiac tissue and records the times when cells surpass
- a specific threshold, supporting multiple activations such as re-entrant waves or multiple excitations.
-
- Attributes
- ----------
- act_t : list of np.ndarray
- A list where each element is an array storing activation times for each cell.
- threshold : float
- The potential threshold to determine cell activation.
- file_name : str
- The file name for saving the activation times.
- activated : np.ndarray
- A boolean array indicating whether each cell is currently activated.
- amount : np.ndarray
- An array storing the number of times each cell has been activated.
-
- Methods
- -------
- initialize(model):
- Initializes the tracker with the simulation model and precomputes necessary values.
- track():
- Tracks and stores activation times for each cell in the model at each time step.
- output:
- Returns the activation times.
- write():
- Saves the activation times to disk as a NumPy file.
- """
-
- def __init__(self):
- """
- Initializes the MultiActivationTime2DTracker with default parameters.
- """
- Tracker.__init__(self)
- self.act_t = np.array([]) # Initialize activation times as an empty array
- self.threshold = -40 # Activation threshold
- self.file_name = "multi_act_time_2d" # Output file name
-
- def initialize(self, model):
- """
- Initializes the tracker with the simulation model and precomputes necessary values.
-
- Parameters
- ----------
- model : object
- The cardiac tissue model object containing the data to be tracked.
- """
- self.model = model
- self.act_t = [-np.ones(self.model.u.shape)] # Initialize with a single layer of -1 (no activation)
- self.activated = np.full(self.model.u.shape, True) # Initially mark all boundary cells as activated
- self.activated[1:-1, 1:-1] = False # Set internal cells as not activated
- self.amount = np.ones(self.model.u.shape) # Track the number of activations for each cell
-
- def track(self):
- """
- Tracks and stores activation times for each cell in the model at each time step.
-
- This method should be called at each time step of the simulation.
- """
- # Calculate updated activation times where the threshold is crossed
- updated_array = np.where((self.act_t[-1] < 0) & (self.model.u > self.threshold), self.model.t, -1)
-
- # Update the amount of activations for cells that cross the threshold again
- if np.any((self.activated == False) & (self.act_t[-1] > 0) & (self.model.u > self.threshold)):
- self.amount = np.where(
- (self.activated == False) & (self.act_t[-1] > 0) & (self.model.u > self.threshold),
- self.amount + 1, self.amount
- )
- # If any cell has been activated more times than the current activation list length, append a new array
- if np.any(self.amount > len(self.act_t)):
- self.act_t.append(updated_array)
- else:
- # Update the last recorded activation times with new activations
- self.act_t[-1] = np.where(updated_array > 0, updated_array, self.act_t[-1])
-
- # Update the activation status of cells
- self.activated[1:-1, 1:-1] = np.where(
- (self.model.u[1:-1, 1:-1] > self.threshold) & (self.activated[1:-1, 1:-1] == False),
- True, self.activated[1:-1, 1:-1]
- )
- # Reset the activation status if the potential drops below the threshold
- self.activated[1:-1, 1:-1] = np.where(
- (self.model.u[1:-1, 1:-1] <= self.threshold) & (self.activated[1:-1, 1:-1] == True),
- False, self.activated[1:-1, 1:-1]
- )
-
- @property
- def output(self):
- """
- Returns the activation times.
-
- Returns
- -------
- list of np.ndarray
- A list where each element is an array storing activation times for each cell.
- """
- return self.act_t
-
- def write(self):
- """
- Saves the activation times to disk as a NumPy file.
- """
- # Save the activation times list to a file
- np.save(os.path.join(self.path, self.file_name), self.act_t)
diff --git a/finitewave/cpuwave2D/tracker/multivariable_2d_tracker.py b/finitewave/cpuwave2D/tracker/multi_variable_2d_tracker.py
similarity index 58%
rename from finitewave/cpuwave2D/tracker/multivariable_2d_tracker.py
rename to finitewave/cpuwave2D/tracker/multi_variable_2d_tracker.py
index 5d237d6..f6f07cc 100755
--- a/finitewave/cpuwave2D/tracker/multivariable_2d_tracker.py
+++ b/finitewave/cpuwave2D/tracker/multi_variable_2d_tracker.py
@@ -1,4 +1,4 @@
-import os
+from pathlib import Path
import numpy as np
from finitewave.core.tracker.tracker import Tracker
@@ -6,29 +6,25 @@
class MultiVariable2DTracker(Tracker):
"""
- A class to track multiple variables at a specific cell in a 2D cardiac tissue model simulation.
+ A class to track multiple variables at a specific cell in a 2D cardiac
+ tissue model simulation.
- This tracker monitors user-defined variables at a specified cell index and records their values over time.
+ This tracker monitors user-defined variables at a specified cell index and
+ records their values over time.
Attributes
----------
var_list : list of str
A list of variable names to be tracked.
- cell_ind : list of int
+ cell_ind : list or list of lists with two indices
The indices [i, j] of the cell where the variables are tracked.
+ List of lists can be used to track multiple cells.
dir_name : str
The directory name where tracked variables are saved.
vars : dict
- A dictionary where each key is a variable name, and the value is an array of its tracked values over time.
+ A dictionary where each key is a variable name, and the value is
+ an array of its tracked values over time.
- Methods
- -------
- initialize(model):
- Initializes the tracker with the simulation model and precomputes necessary values for each variable.
- track():
- Tracks and stores the values of each specified variable at each time step.
- write():
- Saves the tracked variables to disk as NumPy files.
"""
def __init__(self):
@@ -43,41 +39,60 @@ def __init__(self):
def initialize(self, model):
"""
- Initializes the tracker with the simulation model and precomputes necessary values for each variable.
+ Initializes the tracker with the simulation model and precomputes
+ necessary values for each variable.
Parameters
----------
model : object
The cardiac tissue model object containing the data to be tracked.
"""
+ self.vars = {}
self.model = model
- t_max = self.model.t_max # Maximum simulation time
- dt = self.model.dt # Time step size
-
# Initialize storage for each variable to be tracked
for var_ in self.var_list:
- self.vars[var_] = np.zeros(int(t_max / dt) + 1)
+ if var_ not in self.model.__dict__:
+ raise ValueError(f"Variable '{var_}' not found in model.")
+ self.vars[var_] = []
- def track(self):
+ def _track(self):
"""
Tracks and stores the values of each specified variable at each time step.
This method should be called at each time step of the simulation.
"""
- step = self.model.step # Current simulation step
-
# Track the value of each variable at the specified cell index
+ # Make possible to track multiple cells
+ cell_ind = tuple(np.atleast_2d(self.cell_ind).T)
+ for var_ in self.var_list:
+ var_values = self.model.__dict__[var_]
+ self.vars[var_].append(var_values[cell_ind])
+
+ @property
+ def output(self):
+ """
+ Returns the tracked variables data.
+
+ Returns
+ -------
+ dict
+ A dictionary where each key is a variable name, and the value is
+ an array of its tracked values over time.
+ """
+ vars = {}
for var_ in self.var_list:
- self.vars[var_][step] = self.model.__dict__[var_][self.cell_ind[0], self.cell_ind[1]]
+ vars[var_] = np.squeeze(self.vars[var_])
+ return vars
def write(self):
"""
Saves the tracked variables to disk as NumPy files.
"""
# Create the output directory if it does not exist
- if not os.path.exists(self.dir_name):
- os.mkdir(self.dir_name)
+ if not Path(self.path, self.dir_name).is_dir():
+ Path(self.path, self.dir_name).mkdir(parents=True)
# Save each tracked variable to a file
for var_ in self.var_list:
- np.save(os.path.join(self.dir_name, var_), self.vars[var_])
+ np.save(Path(self.path, self.dir_name, f"{var_}.npy"),
+ self.output[var_])
diff --git a/finitewave/cpuwave2D/tracker/period_2d_tracker.py b/finitewave/cpuwave2D/tracker/period_2d_tracker.py
index f76993f..b4a7afc 100755
--- a/finitewave/cpuwave2D/tracker/period_2d_tracker.py
+++ b/finitewave/cpuwave2D/tracker/period_2d_tracker.py
@@ -1,182 +1,78 @@
+from pathlib import Path
import numpy as np
-from numba import njit
+import pandas as pd
import json
+from .local_activation_time_2d_tracker import LocalActivationTime2DTracker
-from finitewave.core.tracker.tracker import Tracker
-
-@njit
-def _track_detectors_period(periods, detectors, detectors_state, u, t, threshold, step):
- """
- Numba-optimized function to track the activation periods of cells in a 2D mesh.
-
- Parameters
- ----------
- periods : np.ndarray
- Array to store the activation times of the detectors.
- detectors : np.ndarray
- Binary array indicating the presence of detectors at specific cells.
- detectors_state : np.ndarray
- Binary array indicating the state of detectors (1 if below threshold, 0 if above).
- u : np.ndarray
- The current potential values of the cardiac tissue.
- t : float
- The current simulation time.
- threshold : float
- The threshold value above which an activation is detected.
- step : int
- The current index in the periods array to store new activations.
-
- Returns
- -------
- periods : np.ndarray
- Updated periods array with new activation times.
- detectors_state : np.ndarray
- Updated state of detectors.
- step : int
- Updated step index after adding new activations.
+class Period2DTracker(LocalActivationTime2DTracker):
"""
- n_i, n_j = u.shape
- for i in range(n_i):
- for j in range(n_j):
- if detectors[i, j] and u[i, j] > threshold and detectors_state[i, j]:
- periods[step] = [i, j, t]
- detectors_state[i, j] = 0
- step += 1
- elif detectors[i, j] and u[i, j] <= threshold and not detectors_state[i, j]:
- detectors_state[i, j] = 1
-
- return periods, detectors_state, step
-
-
-class Period2DTracker(Tracker):
- """
- A class to track activation periods of cells in a 2D cardiac tissue model using detectors.
+ A class to track activation periods of cells in a 2D cardiac tissue model
+ using detectors.
Attributes
----------
- detectors : np.ndarray
- Binary array indicating the placement of detectors on the mesh.
- threshold : float
- The threshold potential value for detecting activations.
- _periods : np.ndarray
- Array to store the activation times for each detector.
- _detectors_state : np.ndarray
- Binary array indicating the state of detectors (1 if below threshold, 0 if above).
- _step : int
- The current index for storing activation periods.
+ cell_ind : list or list of lists with two indices
+ The indices [i, j] of the cell where the variables are tracked.
+ List of lists can be used to track multiple cells.
file_name : str
- The file name to save the tracked activation periods.
-
- Methods
- -------
- initialize(model):
- Initializes the tracker with the simulation model and preallocates memory for tracking.
- track():
- Tracks the activation periods at each time step of the simulation.
- compute_periods():
- Computes the time intervals between successive activations for each detector.
- output():
- Property to get the computed activation periods.
- write():
- Saves the computed activation periods to a JSON file.
+ The name of the file to save the computed activation periods.
"""
def __init__(self):
"""
Initializes the Period2DTracker with default parameters.
"""
- Tracker.__init__(self)
-
- self.detectors = np.array([]) # Binary array indicating detector placement
- self.threshold = -40 # Threshold potential value for activation detection
-
- self._periods = np.array([]) # Array to store activation times
- self._detectors_state = np.array([]) # Array to store the state of each detector
- self._step = 0 # Current index in the periods array
+ super().__init__()
+ self.cell_ind = []
self.file_name = "period" # File name for saving tracked data
def initialize(self, model):
"""
- Initializes the tracker with the simulation model and preallocates memory for tracking.
+ Initializes the tracker with the simulation model and preallocates
+ memory for tracking.
Parameters
----------
model : object
The cardiac tissue model object containing the data to be tracked.
"""
- self.model = model
-
- t_max = model.t_max # Maximum simulation time
- dt = model.dt # Time step size
-
- # Initial length of the periods array, scaled by the number of detectors
- n = 20 * len(self.detectors[self.detectors == 1])
- self._periods = -1 * np.ones([n, 3])
- self._detectors_state = np.ones(model.u.shape, dtype="uint8")
+ super().initialize(model)
+ self.act_t = [-np.ones(len(np.atleast_2d(self.cell_ind)))]
- def track(self):
+ def _track(self):
"""
- Tracks the activation periods at each time step of the simulation.
-
- This method dynamically expands the periods array if necessary and updates
- the periods and detectors state arrays.
- """
- # Dynamically increase the size of the array if there is no free space
- if self._step == len(self._periods):
- self._periods = np.tile(self._periods, (2, 1))
- self._periods[len(self._periods) // 2:, :] = -1.
-
- # Update the periods and detectors state using the Numba-optimized function
- self._periods, self._detectors_state, self._step = _track_detectors_period(
- self._periods, self.detectors, self._detectors_state,
- self.model.u, self.model.t, self.threshold, self._step)
-
- def compute_periods(self):
- """
- Computes the time intervals between successive activations for each detector.
-
- Returns
- -------
- periods_dict : dict
- A dictionary where each key is a detector's coordinates and each value is a list of activation times and periods.
+ Tracks and stores activation times for each cell in
+ the model at each time step.
"""
- periods_dict = dict()
- to_str = lambda i, j: str(int(i)) + "," + str(int(j))
-
- # Iterate over the recorded periods and group them by detector coordinates
- for i in range(len(self._periods)):
- if self._periods[i][0] < 0:
- continue
- key = to_str(*self._periods[i][:2])
- if key not in periods_dict:
- periods_dict[key] = []
- periods_dict[key].append(self._periods[i][2])
-
- # Calculate the time intervals between successive activations
- for key in periods_dict:
- time_per_list = []
- for i, t in enumerate(periods_dict[key]):
- if i == 0:
- time_per_list.append([t, 0])
- else:
- time_per_list.append([t, t - time_per_list[i - 1][0]])
- periods_dict[key] = time_per_list
-
- return periods_dict
+ cross_mask = self.cross_threshold()
+ cross_mask = cross_mask[tuple(np.atleast_2d(self.cell_ind).T)]
+ # Check if there are already activated cells in the current
+ # activation layer
+ if np.any(self.act_t[-1][cross_mask] > -1):
+ self.act_t.append(-np.ones(len(np.atleast_2d(self.cell_ind))))
+ # Update activation times where the threshold is crossed
+ self.act_t[-1] = np.where(cross_mask, self.model.t, self.act_t[-1])
@property
def output(self):
"""
Property to get the computed activation periods.
+
+ Returns
+ -------
+ pd.DataFrame
+ A DataFrame containing the computed activation periods.
"""
- return self.compute_periods()
+ lats = np.array(self.act_t)
+ lats = pd.DataFrame(lats.T)
+ periods = lats.apply(lambda row: np.diff(row[row != -1]), axis=1)
+ return periods
def write(self):
"""
- Saves the computed activation periods to a JSON file.
+ Saves the computed activation periods to a CSV file.
"""
- jdata = json.dumps(self.compute_periods())
- with open(os.path.join(self.path, self.file_name), "w") as jf:
- jf.write(jdata)
+ periods = self.output
+ periods.to_csv(Path(self.path, self.file_name).with_suffix(".csv"))
diff --git a/finitewave/cpuwave2D/tracker/period_animation_2d_tracker.py b/finitewave/cpuwave2D/tracker/period_animation_2d_tracker.py
new file mode 100755
index 0000000..35de381
--- /dev/null
+++ b/finitewave/cpuwave2D/tracker/period_animation_2d_tracker.py
@@ -0,0 +1,112 @@
+from pathlib import Path
+import numpy as np
+
+from finitewave.tools.animation_2d_builder import Animation2DBuilder
+from .local_activation_time_2d_tracker import LocalActivationTime2DTracker
+
+
+class PeriodAnimation2DTracker(LocalActivationTime2DTracker):
+ """
+ A class to track the periods of activation for each cell in a 2D cardiac
+ tissue model.
+
+ This class extends Animation2DTracker to create and save a period map that
+ shows the time interval between successive activations of each cell that
+ crosses a given threshold. The period map is saved at each time step.
+
+ Attributes
+ ----------
+ dir_name : str
+ The directory name to save the period maps.
+ file_name : str
+ The file name for saving the period maps.
+ overwrite : bool
+ Whether to overwrite existing period maps.
+ period_map : np.ndarray
+ The array to store activation periods.
+ """
+
+ def __init__(self):
+ """
+ Initializes the PeriodMap2DTracker with default parameters.
+ """
+ super().__init__()
+
+ self.dir_name = "period" # Directory to save the period maps
+ self.file_name = "period" # File name for saving the period maps
+ self.overwrite = False # Overwrite existing period maps
+ self._frame_counter = 0 # Counter to track the current frame number
+
+ self.period_map = np.ndarray # Array to store activation periods
+
+ def initialize(self, model):
+ """
+ Initializes the tracker with the simulation model and preallocates
+ memory for tracking.
+
+ Parameters
+ ----------
+ model : object
+ The cardiac tissue model object containing the data to be tracked.
+ """
+ # Initialize the period map and state arrays
+ self.model = model
+ self._frame_counter = 0
+ self.period_map = - np.ones_like(self.model.u)
+ self._activated = np.full(self.model.u.shape, 0, dtype=bool)
+
+ if not Path(self.path, self.dir_name).is_dir():
+ Path(self.path, self.dir_name).mkdir(parents=True)
+
+ if self.overwrite:
+ for file in Path(self.path, self.dir_name).glob("*.npy"):
+ file.unlink()
+
+ def _track(self):
+ """
+ Tracks the activation periods at each time step of the simulation.
+
+ This method calculates the time interval between successive activations
+ for each cell, updates the period map, and saves it to a file.
+ """
+ cross_mask = self.cross_threshold()
+ self.period_map = np.where(cross_mask, self.model.t, self.period_map)
+
+ np.save(Path(self.path, self.dir_name, str(self._frame_counter)
+ ).with_suffix(".npy"), self.period_map)
+ self._frame_counter += 1
+
+ def write(self, shape_scale=3, fps=10, clim=None, cmap="viridis",
+ clear=True, prog_bar=True):
+ """
+ Creates an animation from the saved period maps.
+
+ Parameters
+ ----------
+ shape_scale : int, optional
+ The scaling factor for the shape of the period map.
+ fps : int, optional
+ The frames per second for the animation.
+ clim : list, optional
+ The color limits for the animation.
+ cmap : str, optional
+ The color map for the animation.
+ clear : bool, optional
+ Whether to clear the directory before saving the animation.
+ prog_bar : bool, optional
+ Whether to show a progress bar during the animation creation.
+ """
+ animation_builder = Animation2DBuilder()
+ path = Path(self.path, self.dir_name)
+ mask = self.model.cardiac_tissue.mesh != 1
+
+ animation_builder.write(path,
+ animation_name=self.file_name,
+ mask=mask,
+ shape_scale=shape_scale,
+ fps=fps,
+ clim=clim,
+ shape=mask.shape,
+ cmap=cmap,
+ clear=clear,
+ prog_bar=prog_bar)
diff --git a/finitewave/cpuwave2D/tracker/period_map_2d_tracker.py b/finitewave/cpuwave2D/tracker/period_map_2d_tracker.py
deleted file mode 100755
index 942f469..0000000
--- a/finitewave/cpuwave2D/tracker/period_map_2d_tracker.py
+++ /dev/null
@@ -1,100 +0,0 @@
-import os
-import numpy as np
-
-from finitewave.cpuwave2D.tracker.animation_2d_tracker import Animation2DTracker
-
-
-class PeriodMap2DTracker(Animation2DTracker):
- """
- A class to track the periods of activation for each cell in a 2D cardiac tissue model.
-
- This class extends Animation2DTracker to create and save a period map that shows the time interval between
- successive activations of each cell that crosses a given threshold. The period map is saved at each time step.
-
- Attributes
- ----------
- threshold : float
- The threshold potential value for detecting activations.
- period_map : np.ndarray
- 2D array to store the time interval between successive activations for each cell.
- _period_map_state : np.ndarray
- 2D array to store the current state of each cell (1 if below threshold, 0 if above).
- _last_time_map : np.ndarray
- 2D array to store the last activation time for each cell.
-
- Methods
- -------
- initialize(model):
- Initializes the tracker with the simulation model and preallocates memory for tracking.
- track():
- Tracks the activation periods at each time step of the simulation and saves them to files.
- write():
- Overridden method to handle file writing, here it's empty.
- """
-
- def __init__(self):
- """
- Initializes the PeriodMap2DTracker with default parameters.
- """
- Animation2DTracker.__init__(self)
-
- self.dir_name = "period" # Directory to save the period maps
-
- self.threshold = -40. # Threshold potential value for activation detection
- self.period_map = np.array([]) # Array to store activation periods
- self._period_map_state = np.array([]) # Array to store state of each cell for activation tracking
-
- def initialize(self, model):
- """
- Initializes the tracker with the simulation model and preallocates memory for tracking.
-
- Parameters
- ----------
- model : object
- The cardiac tissue model object containing the data to be tracked.
- """
- # Call the parent class initialization method
- Animation2DTracker.initialize(self, model)
-
- # Initialize the period map and state arrays
- self.period_map = -1 * np.ones(self.model.u.shape)
- self._last_time_map = -1 * np.ones(self.model.u.shape)
- self._period_map_state = np.ones(self.model.u.shape, dtype="uint8")
-
- def track(self):
- """
- Tracks the activation periods at each time step of the simulation.
-
- This method calculates the time interval between successive activations for each cell,
- updates the period map, and saves it to a file.
- """
- # Check if the time to save a frame has been reached
- if self._t > self.step:
- # Identify active nodes where the state is 1 and the potential exceeds the threshold
- active_nodes = np.logical_and(self._period_map_state == 1, self.model.u > self.threshold)
-
- # Update the period map with the time interval between successive activations
- self.period_map[active_nodes] = self.model.t - self._last_time_map[active_nodes]
-
- # Update the last activation time for active nodes
- self._last_time_map[active_nodes] = self.model.t
-
- # Update the state of the nodes based on their potential values
- self._period_map_state[active_nodes] = 0
- self._period_map_state[np.logical_and(self._period_map_state == 0, self.model.u < self.threshold)] = 1
-
- # Save the current period map to a file
- np.save(os.path.join(self.path, self.dir_name, str(self._frame_n)), self.period_map)
- self._frame_n += 1 # Increment the frame counter
- self._t = 0 # Reset the time counter
- else:
- # Increment the time counter if the frame interval has not been reached
- self._t += self._dt
-
- def write(self):
- """
- Overridden write method.
-
- This method is intentionally left empty because the write functionality is handled in the track method.
- """
- pass
diff --git a/finitewave/cpuwave2D/tracker/spiral_2d_tracker.py b/finitewave/cpuwave2D/tracker/spiral_2d_tracker.py
deleted file mode 100755
index bde38d4..0000000
--- a/finitewave/cpuwave2D/tracker/spiral_2d_tracker.py
+++ /dev/null
@@ -1,307 +0,0 @@
-import os
-from math import sqrt
-import numpy as np
-import warnings
-from numba import njit
-
-from finitewave.core.tracker.tracker import Tracker
-
-
-@njit
-def _calc_tippos(vij, vi1j, vi1j1, vij1, vnewij, vnewi1j, vnewi1j1, vnewij1, V_iso1, V_iso2):
- """
- Calculate the position of the tip of a spiral wave in a 2D grid based on the voltage values.
-
- This function uses bilinear interpolation to determine the precise position of the spiral tip
- by finding the crossing point of voltage levels (`V_iso1` and `V_iso2`).
-
- Parameters
- ----------
- vij, vi1j, vi1j1, vij1 : float
- Old voltage values at the current and neighboring grid points.
- vnewij, vnewi1j, vnewi1j1, vnewij1 : float
- New voltage values at the current and neighboring grid points.
- V_iso1, V_iso2 : float
- Isoline voltage values used for detecting spiral tips.
-
- Returns
- -------
- int
- 1 if a tip is found, 0 otherwise.
- list of float
- The (x, y) position of the tip if found; otherwise, [0, 0].
- """
- xy = [0, 0]
- # Compute various differences for both old and new voltage values
- AC = (vij - vij1 + vi1j1 - vi1j)
- GC = (vij1 - vij)
- BC = (vi1j - vij)
- DC = (vij - V_iso1)
-
- AD = (vnewij - vnewij1 + vnewi1j1 - vnewi1j)
- GD = (vnewij1 - vnewij)
- BD = (vnewi1j - vnewij)
- DD = (vnewij - V_iso2)
-
- # Compute intermediate values for solving the system of equations
- Q = (BC * AD - BD * AC)
- R = (GC * AD - GD * AC)
- S = (DC * AD - DD * AC)
-
- QOnR = Q / R
- SOnR = S / R
-
- T = AC * QOnR
- U = (AC * SOnR - BC + GC * QOnR)
- V = (GC * SOnR) - DC
-
- # Calculate the discriminant for the quadratic formula
- Disc = U * U - 4. * T * V
- if Disc < 0:
- return 0, xy # No solution
- else:
- # Two possible solutions for (x, y) coordinates
- T2 = 2. * T
- sqrtDisc = sqrt(Disc)
-
- if T2 == 0.:
- return 0, [0, 0]
- xn = (-U - sqrtDisc) / T2
- xp = (-U + sqrtDisc) / T2
- yn = -QOnR * xn - SOnR
- yp = -QOnR * xp - SOnR
-
- # Ensure the points lie within the valid grid range
- if 0 <= xn <= 1 and 0 <= yn <= 1:
- xy[0] = xn
- xy[1] = yn
- return 1, xy
- elif 0 <= xp <= 1 and 0 <= yp <= 1:
- xy[0] = xp
- xy[1] = yp
- return 1, xy
- else:
- return 0, xy
-
-
-@njit
-def _track_tipline(size_i, size_j, var1, var2, tipvals, tipdata, tipsfound):
- """
- Track spiral wave tips in a 2D grid by detecting crossings of voltage isolines.
-
- This function searches for spiral tips in XY planes by detecting where the voltage crosses
- specified thresholds in both the old and new voltage values.
-
- Parameters
- ----------
- size_i, size_j : int
- Dimensions of the 2D grid.
- var1, var2 : np.ndarray
- 2D arrays representing the old and new voltage values.
- tipvals : list of float
- Isoline voltage values used for detecting spiral tips.
- tipdata : np.ndarray
- Array to store the coordinates of detected tips.
- tipsfound : int
- Counter for the number of detected tips.
-
- Returns
- -------
- np.ndarray
- Updated array containing detected tip coordinates.
- int
- Updated count of detected tips.
- """
- iso1 = tipvals[0]
- iso2 = tipvals[1]
- delta = 5 # Safety margin to avoid boundary effects
-
- # Iterate through the grid to find spiral tips
- for xpos in range(delta, size_i - delta):
- for ypos in range(delta, size_j - delta):
- if tipsfound >= 100: # Limit the number of tips detected
- break
- counter = 0
- # Check for crossings of the first isoline in the XY plane
- if var1[xpos][ypos] >= iso1 and \
- (var1[xpos + 1][ypos] < iso1 or
- var1[xpos][ypos + 1] < iso1 or
- var1[xpos + 1][ypos + 1] < iso1):
- counter = 1
- elif var1[xpos][ypos] < iso1 and \
- (var1[xpos + 1][ypos] >= iso1 or
- var1[xpos][ypos + 1] >= iso1 or
- var1[xpos + 1][ypos + 1] >= iso1):
- counter = 1
-
- if counter == 1:
- # Check for crossings of the second isoline in the XY plane
- if var2[xpos][ypos] >= iso2 and \
- (var2[xpos + 1][ypos] < iso2 or
- var2[xpos][ypos + 1] < iso2 or
- var2[xpos + 1][ypos + 1] < iso2):
- counter = 2
- elif var2[xpos][ypos] < iso2 and \
- (var2[xpos + 1][ypos] >= iso2 or
- var2[xpos][ypos + 1] >= iso2 or
- var2[xpos + 1][ypos + 1] >= iso2):
- counter = 2
-
- # If both crossings are detected, compute the precise position of the tip
- if counter == 2:
- interp = _calc_tippos(var1[xpos, ypos], var1[xpos + 1, ypos], var1[xpos + 1, ypos + 1], var1[xpos, ypos + 1],
- var2[xpos, ypos], var2[xpos + 1, ypos], var2[xpos + 1, ypos + 1], var2[xpos, ypos + 1], iso1, iso2)
- if interp[0] == 1:
- tipdata[tipsfound][0] = xpos + interp[1][0]
- tipdata[tipsfound][1] = ypos + interp[1][1]
- tipsfound += 1
-
- return tipdata, tipsfound
-
-
-class Spiral2DTracker(Tracker):
- """
- A class to track spiral wave tips in a 2D cardiac tissue model.
-
- This tracker identifies and records the positions of spiral wave tips by analyzing
- voltage isoline crossings in the simulated 2D grid over time.
-
- Attributes
- ----------
- size_i, size_j : int
- Dimensions of the 2D grid.
- dr : float
- Grid spacing in the model.
- threshold : float
- Voltage threshold value for detecting spiral tips.
- file_name : str
- Name of the output file where spiral tip data is saved.
- swcore : list
- List to store detected spiral wave core positions.
- all : bool
- Flag to determine whether all tips or only first few are tracked.
- step : int
- Interval of steps for saving the spiral wave tips.
- _t : float
- Internal timer to track the current simulation time.
- _u_prev_step : np.ndarray
- Array to store the voltage values from the previous time step.
- _tipdata : np.ndarray
- Array to store the detected tip coordinates.
-
- Methods
- -------
- initialize(model):
- Initializes the tracker with the simulation model.
- track_tipline(var1, var2, tipvals, tipdata, tipsfound):
- Wrapper function for the low-level _track_tipline function.
- track():
- Tracks spiral tips at each simulation step.
- write():
- Saves the tracked spiral tip data to a file.
- output:
- Property that returns the tracked spiral core data.
- """
-
- def __init__(self):
- """
- Initializes the Spiral2DTracker with default parameters.
- """
- Tracker.__init__(self)
- self.size_i = 100
- self.size_j = 100
- self.dr = 0.25
- self.threshold = 0.2
- self.file_name = "swcore.txt"
- self.swcore = []
-
- self.all = False
- self.step = 1
- self._t = 0
- self._u_prev_step = np.array([])
-
- def initialize(self, model):
- """
- Initialize the tracker with the given cardiac tissue model.
-
- Parameters
- ----------
- model : object
- The cardiac tissue simulation model containing the grid and voltage data.
- """
- self.model = model
- self.size_i, self.size_j = self.model.cardiac_tissue.shape
- self.dt = self.model.dt
- self.dr = self.model.dr
- self._u_prev_step = np.zeros([self.size_i, self.size_j])
- self._tipdata = np.zeros([102, 2])
-
- def track_tipline(self, var1, var2, tipvals, tipdata, tipsfound):
- """
- High-level function to track spiral tips in the 2D grid.
-
- Parameters
- ----------
- var1, var2 : np.ndarray
- 2D arrays representing the old and new voltage values.
- tipvals : list of float
- Isoline voltage values used for detecting spiral tips.
- tipdata : np.ndarray
- Array to store the coordinates of detected tips.
- tipsfound : int
- Counter for the number of detected tips.
-
- Returns
- -------
- tuple
- Updated array of detected tip coordinates and the count of detected tips.
- """
- return _track_tipline(self.size_i, self.size_j, var1, var2, tipvals, tipdata, tipsfound)
-
- def track(self):
- """
- Track spiral tips at each simulation step by analyzing voltage data.
-
- The tracker is updated at each simulation step, detecting any spiral tips
- based on the voltage data from the previous and current steps.
- """
- if self._t > self.step:
- tipvals = [0, 0]
- tipvals[0] = self.threshold
- tipvals[1] = self.threshold
-
- tipsfound = 0
-
- self._tipdata, tipsfound = self.track_tipline(self._u_prev_step, self.model.u, tipvals, self._tipdata, tipsfound)
-
- if self.all:
- if not tipsfound:
- self.swcore.append([self.model.t, 0, -1, -1])
-
- for i in range(tipsfound):
- self.swcore.append([self.model.t, i])
- for j in range(2):
- self.swcore[-1].append(self._tipdata[i][j] * self.dr)
-
- self._u_prev_step = np.copy(self.model.u)
- self._t = 0
- else:
- self._t += self.dt
-
- def write(self):
- """
- Save the tracked spiral tip data to a file.
- """
- np.savetxt(os.path.join(self.path, self.file_name), np.array(self.swcore))
-
- @property
- def output(self):
- """
- Get the tracked spiral core data.
-
- Returns
- -------
- list
- List of tracked spiral core data.
- """
- return self.swcore
diff --git a/finitewave/cpuwave2D/tracker/spiral_wave_core_2d_tracker.py b/finitewave/cpuwave2D/tracker/spiral_wave_core_2d_tracker.py
new file mode 100755
index 0000000..8c0501a
--- /dev/null
+++ b/finitewave/cpuwave2D/tracker/spiral_wave_core_2d_tracker.py
@@ -0,0 +1,249 @@
+from pathlib import Path
+from math import sqrt
+import pandas as pd
+from numba import njit
+from numba.typed import List
+
+from finitewave.core.tracker.tracker import Tracker
+
+
+class SpiralWaveCore2DTracker(Tracker):
+ """
+ A class to track spiral wave tips in a 2D cardiac tissue model.
+
+ This tracker identifies and records the positions of spiral wave tips by
+ analyzing voltage isoline crossings in the simulated 2D grid over time.
+
+ Attributes
+ ----------
+ threshold : float
+ Voltage threshold value for detecting spiral tips.
+ file_name : str
+ Name of the file to save the tracked spiral tip data.
+ spiral_wave_cores : list of pd.DataFrame
+ List of tracked spiral core data.
+ """
+
+ def __init__(self):
+ """
+ Initializes the Spiral2DTracker with default parameters.
+ """
+ Tracker.__init__(self)
+ self.threshold = 0.5
+ self.file_name = "spiral_wave_core"
+ self.sprial_wave_cores = []
+
+ def initialize(self, model):
+ """
+ Initialize the tracker with the given cardiac tissue model.
+
+ Parameters
+ ----------
+ model : object
+ The cardiac tissue simulation model containing the grid and
+ voltage data.
+ """
+ self.model = model
+ self.u_prev = self.model.u.copy()
+
+ def track_tip_line(self, u, u_new, threshold):
+ """
+ Track spiral wave tips in a 2D grid by detecting crossings of voltage
+ isolines.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ 2D array representing the old voltage values.
+ u_new : np.ndarray
+ 2D array representing the new voltage values.
+ threshold : float
+ Voltage threshold value for detecting spiral tips.
+
+ Returns
+ -------
+ List
+ List of detected spiral tip positions.
+ """
+ return list(_track_tip_line(u, u_new, threshold))
+
+ def _track(self):
+ """
+ Track spiral tips at each simulation step by analyzing voltage data.
+
+ The tracker is updated at each simulation step, detecting any spiral
+ tips based on the voltage data from the previous and current steps.
+ """
+ tips = self.track_tip_line(self.u_prev, self.model.u, self.threshold)
+ tips = pd.DataFrame(tips, columns=["x", "y"])
+ tips["time"] = self.model.t
+ tips["step"] = self.model.step
+ self.sprial_wave_cores.append(tips)
+ self.u_prev = self.model.u.copy()
+
+ def write(self):
+ """
+ Save the tracked spiral tip data to a file.
+ """
+ self.output.to_csv(Path(self.path, self.file_name).with_suffix(".csv"))
+
+ @property
+ def output(self):
+ """
+ Get the tracked spiral core data.
+
+ Returns
+ -------
+ pd.DataFrame
+ A DataFrame containing the tracked spiral core data.
+ """
+ validated = [df for df in self.sprial_wave_cores if not df.empty]
+ if not validated:
+ return pd.DataFrame(columns=["x", "y", "time", "step"])
+
+ return pd.concat(validated, ignore_index=True)
+
+
+@njit
+def _correct_tip_pos(i, j, u, u_new, threshold):
+ """
+ Correct the position of a detected spiral wave tip.
+
+ This function corrects the position of a detected spiral wave tip by
+ solving a system of equations to find the intersection of voltage isolines.
+
+ Parameters
+ ----------
+ i, j : int
+ Grid indices.
+ u, u_new : np.ndarray
+ 2D arrays representing the old and new voltage values.
+ threshold : float
+ Voltage threshold value for detecting spiral tips.
+ """
+ # Compute various differences for both old and new voltage values
+ AC = u[i, j] - u[i, j+1] + u[i+1, j+1] - u[i+1, j]
+ GC = u[i, j+1] - u[i, j]
+ BC = u[i+1, j] - u[i, j]
+ DC = u[i, j] - threshold
+
+ AD = u_new[i, j] - u_new[i, j+1] + u_new[i+1, j+1] - u_new[i+1, j]
+ GD = u_new[i, j+1] - u_new[i, j]
+ BD = u_new[i+1, j] - u_new[i, j]
+ DD = u_new[i, j] - threshold
+
+ # Compute intermediate values for solving the system of equations
+ Q = BC * AD - BD * AC
+ R = GC * AD - GD * AC
+ S = DC * AD - DD * AC
+
+ QOnR = Q / R
+ SOnR = S / R
+
+ T = AC * QOnR
+ U = AC * SOnR - BC + GC * QOnR
+ V = GC * SOnR - DC
+
+ # Calculate the discriminant for the quadratic formula
+ discriminant = U * U - 4. * T * V
+
+ if discriminant < 0:
+ return
+
+ # Two possible solutions for (x, y) coordinates
+ T2 = 2. * T
+
+ if T2 == 0.:
+ return
+
+ xn = (-U - sqrt(discriminant)) / T2
+ xp = (-U + sqrt(discriminant)) / T2
+ yn = -QOnR * xn - SOnR
+ yp = -QOnR * xp - SOnR
+
+ # Ensure the points lie within the valid grid range
+ if 0 <= xn <= 1 and 0 <= yn <= 1:
+ return [xn, yn]
+
+ if 0 <= xp <= 1 and 0 <= yp <= 1:
+ return [xp, yp]
+
+ return
+
+
+@njit
+def _apply_threshold(i, j, u, threshold):
+ """
+ Apply a voltage threshold to a 2D grid to detect spiral wave tips.
+
+ This function applies a voltage threshold to the 2D grid to detect spiral
+ wave tips by identifying grid points where the voltage crosses the
+ specified threshold.
+
+ Parameters
+ ----------
+ i, j : int
+ Grid indices.
+ u : np.ndarray
+ 2D array representing the voltage values.
+ threshold : float
+ Voltage threshold value for detecting spiral tips.
+
+ Returns
+ -------
+ int
+ 1 if the voltage crosses the threshold; otherwise, 0.
+ """
+ if (u[i][j] >= threshold and (u[i + 1][j] < threshold
+ or u[i][j + 1] < threshold
+ or u[i + 1][j + 1] < threshold)):
+ return 1
+
+ if (u[i][j] < threshold and (u[i + 1][j] >= threshold
+ or u[i][j + 1] >= threshold
+ or u[i + 1][j + 1] >= threshold)):
+ return 1
+
+ return 0
+
+
+@njit
+def _track_tip_line(u, u_new, threshold):
+ """
+ Track spiral wave tips in a 2D grid by detecting crossings of voltage
+ isolines.
+
+ This function searches for spiral tips in XY planes by detecting where
+ the voltage crosses specified thresholds in both the old and new voltage
+ values.
+
+ Parameters
+ ----------
+ u, u_new : np.ndarray
+ 2D arrays representing the old and new voltage values.
+ threshold : float
+ Voltage threshold value for detecting spiral tips.
+
+ Returns
+ -------
+ List
+ List of detected spiral tip positions.
+ """
+ out = List()
+ size_i, size_j = u.shape
+ delta = 5 # Safety margin to avoid boundary
+
+ for i in range(delta, size_i - delta):
+ for j in range(delta, size_j - delta):
+ counter = _apply_threshold(i, j, u, threshold)
+
+ if counter == 1:
+ counter += _apply_threshold(i, j, u_new, threshold)
+
+ if counter == 2:
+ correction = _correct_tip_pos(i, j, u, u_new, threshold)
+
+ if correction is not None:
+ out.append([j + correction[1], i + correction[0]])
+
+ return out
diff --git a/finitewave/cpuwave2D/tracker/variable_2d_tracker.py b/finitewave/cpuwave2D/tracker/variable_2d_tracker.py
index e71c0d2..55f867c 100755
--- a/finitewave/cpuwave2D/tracker/variable_2d_tracker.py
+++ b/finitewave/cpuwave2D/tracker/variable_2d_tracker.py
@@ -1,69 +1,52 @@
-import os
+from pathlib import Path
import numpy as np
-from finitewave.core.tracker.tracker import Tracker
+from .multi_variable_2d_tracker import MultiVariable2DTracker
-class Variable2DTracker(Tracker):
+class Variable2DTracker(MultiVariable2DTracker):
"""
A tracker that records the values of specified variables from a 2D model
over time at a given grid point.
- Parameters
- ----------
- var_list : list of str
- List of variable names to be tracked.
- cell_ind : list of int
- Indices of the cell to track. Default is [1, 1].
- dir_name : str
- Directory name where the data will be saved. Default is "multi_vars".
- vars : dict
- Dictionary to store the tracked variables over time.
-
Attributes
----------
- model : object
- The model object from which data is being tracked.
+ cell_ind : list
+ The indices [i, j] of the cell where the variable is tracked.
"""
def __init__(self):
- Tracker.__init__(self)
- self.var_list = []
+ super().__init__()
self.cell_ind = [1, 1]
- self.dir_name = "multi_vars"
- self.vars = {}
- def initialize(self, model):
+ @property
+ def var_name(self):
"""
- Initializes the tracker with the given model.
-
- Parameters
- ----------
- model : object
- The model object from which data is being tracked. It must have attributes
- `t_max` (total simulation time) and `dt` (time step) to determine the length
- of the tracking arrays.
+ The name of the variable to be tracked.
"""
- self.model = model
- t_max = self.model.t_max
- dt = self.model.dt
- for var_ in self.var_list:
- self.vars[var_] = np.zeros(int(t_max/dt)+1)
+ return self.var_list[0]
- def track(self):
+ @var_name.setter
+ def var_name(self, value):
+ self.var_list = [value]
+
+ @property
+ def output(self):
"""
- Updates the tracked variable values at the specified cell index for the current step.
+ Property to get the tracked variable values.
+
+ Returns
+ -------
+ np.ndarray
+ The values of the tracked variable at the specified grid point.
"""
- step = self.model.step
- for var_ in self.var_list:
- self.vars[var_][step] = self.model.__dict__[var_][self.cell_ind[0],
- self.cell_ind[1]]
+ return self.vars[self.var_name]
def write(self):
"""
- Saves the tracked variable data to files in the specified directory.
- Creates the directory if it does not exist.
+ Saves the tracked variables to disk as NumPy files.
"""
- if not os.path.exists(self.dir_name):
- os.mkdir(self.dir_name)
- for var_ in self.var_list:
- np.save(os.path.join(self.dir_name, var_), self.vars[var_])
+ if not Path(self.path, self.dir_name).exists():
+ Path(self.path, self.dir_name).mkdir(parents=True)
+
+ np.save(Path(self.path, self.dir_name,
+ self.var_name).with_suffix('.npy'), self.output)
diff --git a/finitewave/cpuwave2D/tracker/velocity_2d_tracker.py b/finitewave/cpuwave2D/tracker/velocity_2d_tracker.py
deleted file mode 100755
index 981e12d..0000000
--- a/finitewave/cpuwave2D/tracker/velocity_2d_tracker.py
+++ /dev/null
@@ -1,108 +0,0 @@
-import os
-import numpy as np
-from scipy.spatial.distance import euclidean
-import json
-
-from finitewave.cpuwave2D.tracker.activation_time_2d_tracker import ActivationTime2DTracker
-
-
-def _local_velocity(act_t):
- """
- Calculates local velocities based on activation times.
-
- Parameters
- ----------
- act_t : numpy.ndarray
- 2D array of activation times.
-
- Returns
- -------
- numpy.ndarray
- 2D array of local velocities.
- """
- N1, N2 = act_t.shape
- vel = np.zeros(act_t.shape)
- for i in range(1, N1-1):
- for j in range(1, N2-1):
- times = [act_t[i-1, j], act_t[i+1, j],
- act_t[i, j-1], act_t[i, j+1]]
- if times:
- min_t = np.min(times)
- vel[i, j] = act_t[i, j] - min_t
- return vel
-
-
-class Velocity2DTracker(ActivationTime2DTracker):
- """
- A tracker that calculates the front velocity of activation based on activation times
- from a 2D model. Inherits from `ActivationTime2DTracker`.
-
- Parameters
- ----------
- file_name : str
- Name of the file where the velocity data will be saved. Default is "front_velocity".
- """
- def __init__(self):
- ActivationTime2DTracker.__init__(self)
- self.file_name = "front_velocity"
-
- def initialize(self, model):
- """
- Initializes the tracker with the given model.
-
- Parameters
- ----------
- model : object
- The model object from which data is being tracked. It must have attributes
- `dr` (distance resolution) for computing velocities.
- """
- ActivationTime2DTracker.initialize(self, model)
-
- def compute_velocity_front(self):
- """
- Computes the front velocity of activation based on the activation times.
-
- Returns
- -------
- numpy.ndarray
- 2D array of velocities at the front of activation.
- """
- # all empty nodes are -1
- # initial activation nodes are 0
- act_t = self.act_t
- dr = self.model.dr
-
- max_act = np.max(act_t)
- front_vel = np.zeros(act_t[act_t == max_act].shape)
- ind_front = np.argwhere(act_t == max_act)
-
- ind_stim = np.argwhere(act_t == np.min(act_t[act_t >= 0.]))
- for i, ind_f in enumerate(ind_front):
- try:
- near_ind = np.argmin(np.array(list(map(
- lambda sp: (sp[0] - ind_f[0])**2 + (sp[1] - ind_f[1])**2,
- ind_stim))))
- except ValueError:
- continue
- front_vel[i] = euclidean(ind_stim[near_ind], ind_f)*dr/max_act
- return front_vel
-
- @property
- def output(self):
- """
- Computes and returns the front velocity of activation.
-
- Returns
- -------
- numpy.ndarray
- 2D array of velocities at the front of activation.
- """
- return self.compute_velocity_front()
-
- def write(self):
- """
- Writes the computed front velocities to a JSON file.
- """
- jdata = json.dumps(self.compute_velocity_front())
- with open(self.file_name, "w") as jf:
- jf.write(jdata)
diff --git a/finitewave/cpuwave3D/__init__.py b/finitewave/cpuwave3D/__init__.py
index f4507f1..4dc4de5 100755
--- a/finitewave/cpuwave3D/__init__.py
+++ b/finitewave/cpuwave3D/__init__.py
@@ -1,19 +1,13 @@
-
from finitewave.cpuwave3D.fibrosis import Diffuse3DPattern, Structural3DPattern
from finitewave.cpuwave3D.model import (
- diffuse_kernel_3d_iso,
- diffuse_kernel_3d_aniso,
- _parallel,
AlievPanfilov3D,
- AlievPanfilovKernels3D,
- LuoRudy913D,
- LuoRudy91Kernels3D,
- TP063D,
- TP06Kernels3D,
+ Barkley3D,
+ MitchellSchaeffer3D,
+ FentonKarma3D,
+ BuenoOrovio3D,
LuoRudy913D,
- LuoRudy91Kernels3D,
TP063D,
- TP06Kernels3D
+ Courtemanche3D,
)
from finitewave.cpuwave3D.stencil import (
AsymmetricStencil3D,
@@ -23,19 +17,10 @@
StimCurrentCoord3D,
StimVoltageCoord3D,
StimCurrentMatrix3D,
- StimVoltageMatrix3D
+ StimVoltageMatrix3D,
+ StimVoltageListMatrix3D,
+ StimCurrentArea3D,
)
from finitewave.cpuwave3D.tissue import CardiacTissue3D
-from finitewave.cpuwave3D.tracker import (
- ActionPotential3DTracker,
- ActivationTime3DTracker,
- AnimationSlice3DTracker,
- ECG3DTracker,
- Period3DTracker,
- PeriodMap3DTracker,
- Spiral3DTracker,
- Variable3DTracker,
- Velocity3DTracker,
- VTKFrame3DTracker,
- Animation3DTracker
-)
+from .tracker import *
+
diff --git a/finitewave/cpuwave3D/fibers/__init__.py b/finitewave/cpuwave3D/fibers/__init__.py
deleted file mode 100755
index d3edd93..0000000
--- a/finitewave/cpuwave3D/fibers/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from finitewave.cpuwave3D.fibers.rotational_anisotropy import RotationalAnisotropy
\ No newline at end of file
diff --git a/finitewave/cpuwave3D/fibers/rotational_anisotropy.py b/finitewave/cpuwave3D/fibers/rotational_anisotropy.py
deleted file mode 100755
index f320794..0000000
--- a/finitewave/cpuwave3D/fibers/rotational_anisotropy.py
+++ /dev/null
@@ -1,102 +0,0 @@
-import numpy as np
-import math
-
-class RotationalAnisotropy:
- """
- A class to generate fiber orientations in a 3D space based on rotational anisotropy.
-
- Attributes
- ----------
- size : list of int
- A list defining the dimensions of the 3D grid (x, y, z).
- alpha : list of float
- A list with two elements defining the range of rotation angles in degrees.
- axis : int
- The axis along which the rotation will be applied (0 for x, 1 for y, 2 for z).
- init_v : list of float
- The initial vector along which the fibers are oriented.
-
- Methods
- -------
- generate_fibers():
- Generates and returns a 3D array of fibers with rotational anisotropy applied.
- test(fibers):
- Visualizes the generated fibers using a 3D quiver plot.
- """
-
- def __init__(self):
- """
- Initializes the RotationalAnisotropy object with default values.
- """
- self.size = [0, 0, 0]
- self.alpha = [0, 0]
- self.axis = 0
- self.init_v = [1, 0, 0]
-
- def generate_fibers(self):
- """
- Generates a 3D array of fiber orientations based on rotational anisotropy.
-
- The fibers are initially aligned along `init_v` and then rotated according to the
- specified range of angles (`alpha`) along the specified axis (`axis`).
-
- Returns
- -------
- numpy.ndarray
- A 4D NumPy array of shape (size[0], size[1], size[2], 3) containing the fiber vectors.
- """
- fibers = np.zeros(list(self.size) + [3])
- fibers[:,:,:,0] = self.init_v[0]
- fibers[:,:,:,1] = self.init_v[1]
- fibers[:,:,:,2] = self.init_v[2]
- alpha_step = (self.alpha[1] - self.alpha[0])/self.size[self.axis]
-
- c_fibers = np.copy(fibers)
-
- for i in range(self.size[0]):
- for j in range(self.size[1]):
- for k in range(self.size[2]):
- c = i
- v = [1, 2]
- if self.axis == 1:
- c = j
- v = [0, 2]
- elif self.axis == 2:
- c = k
- v = [0, 1]
-
- ang = math.radians(self.alpha[0] + alpha_step*c)
-
- fibers[i, j, k, v[0]] = c_fibers[i, j, k, v[0]]*math.cos(ang) + c_fibers[i, j, k, v[1]]*math.sin(ang)
- fibers[i, j, k, v[1]] = -c_fibers[i, j, k, v[0]]*math.sin(ang) + c_fibers[i, j, k, v[1]]*math.cos(ang)
-
- norm = math.sqrt(fibers[i, j, k, 0]**2 + fibers[i, j, k, 1]**2 + fibers[i, j, k, 2]**2)
-
- fibers[i, j, k, 0] /= norm
- fibers[i, j, k, 1] /= norm
- fibers[i, j, k, 2] /= norm
-
- return fibers
-
- def test(self, fibers):
- """
- Visualizes the generated fibers using a 3D quiver plot.
-
- Parameters
- ----------
- fibers : numpy.ndarray
- A 4D NumPy array of shape (size[0], size[1], size[2], 3) containing the fiber vectors.
- """
- from mpl_toolkits.mplot3d import axes3d
- import matplotlib.pyplot as plt
-
- fig = plt.figure()
- ax = fig.gca(projection='3d')
-
- x, y, z = np.meshgrid(np.arange(0, self.size[1], 1),
- np.arange(0, self.size[0], 1),
- np.arange(0, self.size[2], 1))
-
- ax.quiver(x, y, z, fibers[:,:,:,1], fibers[:,:,:,0], fibers[:,:,:,2], length=1.0)
-
- plt.show()
diff --git a/finitewave/cpuwave3D/fibrosis/diffuse_3d_pattern.py b/finitewave/cpuwave3D/fibrosis/diffuse_3d_pattern.py
index 9123b85..39e358e 100644
--- a/finitewave/cpuwave3D/fibrosis/diffuse_3d_pattern.py
+++ b/finitewave/cpuwave3D/fibrosis/diffuse_3d_pattern.py
@@ -24,7 +24,7 @@ class Diffuse3DPattern(FibrosisPattern):
Generates a 3D mesh with a diffuse fibrosis pattern within the specified region.
"""
- def __init__(self, x1, x2, y1, y2, z1, z2, dens):
+ def __init__(self, x1, x2, y1, y2, z1, z2, density):
"""
Initializes the Diffuse3DPattern object with the given region of interest and density.
@@ -36,7 +36,7 @@ def __init__(self, x1, x2, y1, y2, z1, z2, dens):
The start and end indices for the region of interest along the y-axis.
z1, z2 : int
The start and end indices for the region of interest along the z-axis.
- dens : float
+ dendensitys : float
The density of fibrosis within the specified region.
"""
self.x1 = x1
@@ -45,9 +45,9 @@ def __init__(self, x1, x2, y1, y2, z1, z2, dens):
self.y2 = y2
self.z1 = z1
self.z2 = z2
- self.dens = dens
+ self.density = density
- def generate(self, size, mesh=None):
+ def generate(self, shape, mesh=None):
"""
Generates a 3D mesh with a diffuse fibrosis pattern within the specified region.
@@ -55,7 +55,7 @@ def generate(self, size, mesh=None):
Parameters
----------
- size : tuple of int
+ shape : tuple of int
The size of the 3D mesh grid (x, y, z).
mesh : numpy.ndarray, optional
A 3D NumPy array representing the existing mesh grid to which the fibrosis pattern will be applied.
@@ -64,14 +64,26 @@ def generate(self, size, mesh=None):
Returns
-------
numpy.ndarray
- A 3D NumPy array of the same size as the input, with the diffuse fibrosis pattern applied.
+ A 3D NumPy array of the same shape as the input, with the diffuse fibrosis pattern applied.
"""
- if mesh is None:
- mesh = np.zeros(size)
- msh_area = mesh[self.x1:self.x2, self.y1:self.y2, self.z1:self.z2]
- fib_area = np.random.uniform(size=[self.x2-self.x1, self.y2-self.y1, self.z2-self.z1])
- fib_area = np.where(fib_area < self.dens, 2, msh_area)
- mesh[self.x1:self.x2, self.y1:self.y2, self.z1:self.z2] = fib_area
+ if shape is None and mesh is None:
+ message = "Either shape or mesh must be provided."
+ raise ValueError(message)
+ if shape is not None:
+ mesh = np.ones(shape, dtype=np.int8)
+ fibr = self._generate(mesh.shape)
+ mesh[self.x1: self.x2, self.y1: self.y2, self.z1: self.z2] = fibr[self.x1: self.x2,
+ self.y1: self.y2,
+ self.z1: self.z2]
+ return mesh
+
+ fibr = self._generate(mesh.shape)
+ mesh[self.x1: self.x2, self.y1: self.y2, self.z1, self.z2] = fibr[self.x1: self.x2,
+ self.y1: self.y2,
+ self.z1: self.z2]
return mesh
+
+ def _generate(self, shape):
+ return 1 + (np.random.random(shape) <= self.density).astype(np.int8)
diff --git a/finitewave/cpuwave3D/fibrosis/structural_3d_pattern.py b/finitewave/cpuwave3D/fibrosis/structural_3d_pattern.py
index 9f11d55..d7b26ff 100755
--- a/finitewave/cpuwave3D/fibrosis/structural_3d_pattern.py
+++ b/finitewave/cpuwave3D/fibrosis/structural_3d_pattern.py
@@ -27,7 +27,7 @@ class Structural3DPattern(FibrosisPattern):
Generates a 3D mesh with a structural fibrosis pattern within the specified region.
"""
- def __init__(self, x1, x2, y1, y2, z1, z2, dens, length_i, length_j, length_k):
+ def __init__(self, x1, x2, y1, y2, z1, z2, density, length_i, length_j, length_k):
"""
Initializes the Structural3DPattern object with the given region of interest, density, and block sizes.
@@ -39,7 +39,7 @@ def __init__(self, x1, x2, y1, y2, z1, z2, dens, length_i, length_j, length_k):
The start and end indices for the region of interest along the y-axis.
z1, z2 : int
The start and end indices for the region of interest along the z-axis.
- dens : float
+ density : float
The density of fibrosis within the specified region.
length_i, length_j, length_k : int
The lengths of fibrosis blocks along each axis (x, y, z).
@@ -50,12 +50,50 @@ def __init__(self, x1, x2, y1, y2, z1, z2, dens, length_i, length_j, length_k):
self.y2 = y2
self.z1 = z1
self.z2 = z2
- self.dens = dens
+ self.density = density
self.length_i = length_i
self.length_j = length_j
self.length_k = length_k
- def generate(self, size, mesh=None):
+ def generate(self, shape=None, mesh=None):
+ """
+ Generates and applies a structural fibrosis pattern to the mesh.
+
+ The mesh is divided into blocks of size `length_i` x `length_j` x `length_k`, with each block having
+ a probability `density` of being filled with fibrosis. The function ensures that blocks do not
+ extend beyond the specified region.
+
+ Parameters
+ ----------
+ shape : tuple
+ The shape of the mesh.
+ mesh : numpy.ndarray, optional
+ The existing mesh to base the pattern on. Default is None..
+
+ Returns
+ -------
+ numpy.ndarray
+ A new mesh array with the applied fibrosis pattern.
+ """
+ if shape is None and mesh is None:
+ message = "Either shape or mesh must be provided."
+ raise ValueError(message)
+
+ if shape is not None:
+ mesh = np.ones(shape, dtype=np.int8)
+ fibr = self._generate(mesh.shape)
+ mesh[self.x1: self.x2, self.y1: self.y2, self.z1: self.z2] = fibr[self.x1: self.x2,
+ self.y1: self.y2,
+ self.z1: self.z2]
+ return mesh
+
+ fibr = self._generate(mesh.shape)
+ mesh[self.x1: self.x2, self.y1: self.y2, self.z1: self.z2] = fibr[self.x1: self.x2,
+ self.y1: self.y2,
+ self.z1: self.z2]
+ return mesh
+
+ def _generate(self, shape, mesh=None):
"""
Generates a 3D mesh with a structural fibrosis pattern within the specified region.
@@ -63,8 +101,8 @@ def generate(self, size, mesh=None):
Parameters
----------
- size : tuple of int
- The size of the 3D mesh grid (x, y, z).
+ shape : tuple of int
+ The shape of the 3D mesh grid (x, y, z).
mesh : numpy.ndarray, optional
A 3D NumPy array representing the existing mesh grid to which the fibrosis pattern will be applied.
If None, a new mesh grid of the given size is created.
@@ -72,15 +110,13 @@ def generate(self, size, mesh=None):
Returns
-------
numpy.ndarray
- A 3D NumPy array of the same size as the input, with the structural fibrosis pattern applied.
+ A 3D NumPy array of the same shape as the input, with the structural fibrosis pattern applied.
"""
- if mesh is None:
- mesh = np.zeros(size)
-
+ mesh = np.ones(shape, dtype=np.int8)
for i in range(self.x1, self.x2, self.length_i):
for j in range(self.y1, self.y2, self.length_j):
for k in range(self.z1, self.z2, self.length_k):
- if random.random() <= self.dens:
+ if random.random() <= self.density:
i_s = min(self.length_i, self.x2 - i)
j_s = min(self.length_j, self.y2 - j)
k_s = min(self.length_k, self.z2 - k)
diff --git a/finitewave/cpuwave3D/model/__init__.py b/finitewave/cpuwave3D/model/__init__.py
index 880e61b..254e5b9 100755
--- a/finitewave/cpuwave3D/model/__init__.py
+++ b/finitewave/cpuwave3D/model/__init__.py
@@ -1,10 +1,8 @@
-from finitewave.cpuwave3D.model.diffuse_kernels_3d import diffuse_kernel_3d_iso, diffuse_kernel_3d_aniso, _parallel
-
-from finitewave.cpuwave3D.model.aliev_panfilov_3d.aliev_panfilov_3d import AlievPanfilov3D
-from finitewave.cpuwave3D.model.aliev_panfilov_3d.aliev_panfilov_kernels_3d import AlievPanfilovKernels3D
-
-from finitewave.cpuwave3D.model.luo_rudy91_3d.luo_rudy91_3d import LuoRudy913D
-from finitewave.cpuwave3D.model.luo_rudy91_3d.luo_rudy91_kernels_3d import LuoRudy91Kernels3D
-
-from finitewave.cpuwave3D.model.tp06_3d.tp06_3d import TP063D
-from finitewave.cpuwave3D.model.tp06_3d.tp06_kernels_3d import TP06Kernels3D
+from .aliev_panfilov_3d import AlievPanfilov3D
+from .barkley_3d import Barkley3D
+from .mitchell_schaeffer_3d import MitchellSchaeffer3D
+from .fenton_karma_3d import FentonKarma3D
+from .bueno_orovio_3d import BuenoOrovio3D
+from .luo_rudy91_3d import LuoRudy913D
+from .tp06_3d import TP063D
+from .courtemanche_3d import Courtemanche3D
diff --git a/finitewave/cpuwave3D/model/aliev_panfilov_3d.py b/finitewave/cpuwave3D/model/aliev_panfilov_3d.py
new file mode 100644
index 0000000..7905fbd
--- /dev/null
+++ b/finitewave/cpuwave3D/model/aliev_panfilov_3d.py
@@ -0,0 +1,85 @@
+from numba import njit, prange
+
+from finitewave.cpuwave2D.model.aliev_panfilov_2d import AlievPanfilov2D, calc_v
+from finitewave.cpuwave3D.stencil.isotropic_stencil_3d import (
+ IsotropicStencil3D
+)
+from finitewave.cpuwave3D.stencil.asymmetric_stencil_3d import (
+ AsymmetricStencil3D
+)
+
+
+class AlievPanfilov3D(AlievPanfilov2D):
+ """
+ Implementation of the Aliev-Panfilov 3D cardiac model.
+
+ See AlievPanfilov2D for the 2D model description.
+ """
+
+ def __init__(self):
+ super().__init__()
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel for the Aliev-Panfilov model.
+ """
+ ionic_kernel_3d(self.u_new, self.u, self.v,
+ self.cardiac_tissue.myo_indexes, self.dt,
+ self.a, self.k, self.eap, self.mu_1, self.mu_2)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue3D
+ A 3D cardiac tissue object.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to be used for diffusion computations.
+ """
+
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil3D()
+
+ return AsymmetricStencil3D()
+
+
+@njit(parallel=True)
+def ionic_kernel_3d(u_new, u, v, indexes, dt, a, k, eap, mu_1, mu_2):
+ """
+ Computes the ionic kernel for the Aliev-Panfilov 3D model.
+
+ Parameters
+ ----------
+ u_new : np.ndarray
+ Array to store the updated action potential values.
+ u : np.ndarray
+ Current action potential array.
+ v : np.ndarray
+ Recovery variable array.
+ dt : float
+ Time step for the simulation.
+ indexes : np.ndarray
+ Array of indices where the kernel should be computed (``mesh == 1``).
+ """
+
+ n_j = u.shape[1]
+ n_k = u.shape[2]
+
+ for ni in prange(len(indexes)):
+ ii = indexes[ni]
+ i = ii//(n_j*n_k)
+ j = (ii % (n_j*n_k))//n_k
+ k_ = (ii % (n_j*n_k)) % n_k
+
+ v[i, j, k_] = calc_v(v[i, j, k_], u[i, j, k_], dt, a, k, eap, mu_1, mu_2)
+
+ u_new[i, j, k_] += dt * (- k * u[i, j, k_] * (u[i, j, k_] - a) * (u[i, j, k_] - 1.) -
+ u[i, j, k_] * v[i, j, k_])
+
diff --git a/finitewave/cpuwave3D/model/aliev_panfilov_3d/__init__.py b/finitewave/cpuwave3D/model/aliev_panfilov_3d/__init__.py
deleted file mode 100644
index d4eb3bb..0000000
--- a/finitewave/cpuwave3D/model/aliev_panfilov_3d/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from finitewave.cpuwave3D.model.aliev_panfilov_3d.aliev_panfilov_3d import AlievPanfilov3D
diff --git a/finitewave/cpuwave3D/model/aliev_panfilov_3d/aliev_panfilov_3d.py b/finitewave/cpuwave3D/model/aliev_panfilov_3d/aliev_panfilov_3d.py
deleted file mode 100644
index 0cace1f..0000000
--- a/finitewave/cpuwave3D/model/aliev_panfilov_3d/aliev_panfilov_3d.py
+++ /dev/null
@@ -1,68 +0,0 @@
-import numpy as np
-from tqdm import tqdm
-
-from finitewave.core.model.cardiac_model import CardiacModel
-from finitewave.cpuwave3D.model.aliev_panfilov_3d.aliev_panfilov_kernels_3d import \
- AlievPanfilovKernels3D
-
-_npfloat = "float64"
-
-
-class AlievPanfilov3D(CardiacModel):
- """
- Implementation of the Aliev-Panfilov 3D cardiac model.
-
- This model simulates the electrical activity in cardiac tissue using the
- Aliev-Panfilov equations. It extends the CardiacModel base class and provides
- methods to initialize the model, run the ionic kernel, and handle simulation state.
-
- Attributes
- ----------
- v : np.ndarray
- Array for the recovery variable.
- w : np.ndarray
- Array for diffusion weights.
- state_vars : list
- List of state variables to be saved and restored.
- npfloat : str
- Data type used for floating-point operations, default is 'float64'.
- diffuse_kernel : function
- Function for performing diffusion computations.
- ionic_kernel : function
- Function for performing ionic computations.
- """
- def __init__(self):
- CardiacModel.__init__(self)
- self.v = np.ndarray
- self.w = np.ndarray
- self.state_vars = ["u", "v"]
- self.npfloat = _npfloat
-
- def initialize(self):
- """
- Initializes the model for simulation.
-
- This method sets up the diffusion and ionic kernel functions, initializes
- arrays for the action potential and recovery variable, and prepares the model
- for simulation. It calls the base class initialization method and sets up
- the diffusion and ionic kernels specific to the Aliev-Panfilov model.
- """
- super().initialize()
- weights_shape = self.cardiac_tissue.weights.shape
- shape = self.cardiac_tissue.mesh.shape
- self.diffuse_kernel = AlievPanfilovKernels3D().get_diffuse_kernel(weights_shape)
- self.ionic_kernel = AlievPanfilovKernels3D().get_ionic_kernel()
- self.v = np.zeros(shape, dtype=_npfloat)
-
- def run_ionic_kernel(self):
- """
- Executes the ionic kernel for the Aliev-Panfilov model.
-
- This method updates the action potential and recovery variable arrays using
- the ionic kernel function retrieved during initialization.
-
- It applies the Aliev-Panfilov equations to compute the next state of the
- action potential and recovery variable based on the current state of the model.
- """
- self.ionic_kernel(self.u_new, self.u, self.v, self.cardiac_tissue.mesh,
- self.dt)
diff --git a/finitewave/cpuwave3D/model/aliev_panfilov_3d/aliev_panfilov_kernels_3d.py b/finitewave/cpuwave3D/model/aliev_panfilov_3d/aliev_panfilov_kernels_3d.py
deleted file mode 100644
index 3f06d00..0000000
--- a/finitewave/cpuwave3D/model/aliev_panfilov_3d/aliev_panfilov_kernels_3d.py
+++ /dev/null
@@ -1,109 +0,0 @@
-from numba import njit, prange
-
-from finitewave.core.exception.exceptions import IncorrectWeightsShapeError
-from finitewave.cpuwave3D.model.diffuse_kernels_3d \
- import diffuse_kernel_3d_iso, diffuse_kernel_3d_aniso, _parallel
-
-
-@njit(parallel=_parallel)
-def ionic_kernel_3d(u_new, u, v, mesh, dt):
- """
- Computes the ionic kernel for the Aliev-Panfilov 3D model.
-
- This function updates the action potential (u) and recovery variable (v)
- based on the Aliev-Panfilov model equations.
-
- Parameters
- ----------
- u_new : np.ndarray
- Array to store the updated action potential values.
- u : np.ndarray
- Current action potential array.
- v : np.ndarray
- Recovery variable array.
- mesh : np.ndarray
- Tissue mesh array indicating tissue types.
- dt : float
- Time step for the simulation.
- """
- # constants
- a = 0.1
- k_ = 8.
- eap = 0.01
- mu_1 = 0.2
- mu_2 = 0.3
-
- n_i = u.shape[0]
- n_j = u.shape[1]
- n_k = u.shape[2]
-
- for ii in prange(n_i*n_j*n_k):
- i = ii//(n_j*n_k)
- j = (ii % (n_j*n_k))//n_k
- k = (ii % (n_j*n_k)) % n_k
- if mesh[i, j, k] != 1:
- continue
-
- u_new[i, j, k] += dt * (- k_ * u[i, j, k] * (u[i, j, k] - a) *
- (u[i, j, k] - 1.) - u[i, j, k] * v[i, j, k])
-
- v[i, j, k] += (- dt * (eap + (mu_1 * v[i, j, k]) / (mu_2 + u[i, j, k]))
- * (v[i, j, k] + k_ * u[i, j, k] * (u[i, j, k] - a - 1.)))
-
-
-class AlievPanfilovKernels3D:
- """
- Provides kernel functions for the Aliev-Panfilov 3D model.
-
- This class includes methods for retrieving diffusion and ionic kernels
- specific to the Aliev-Panfilov 3D model.
-
- Methods
- -------
- get_diffuse_kernel(shape)
- Returns the appropriate diffusion kernel function based on the shape of weights.
-
- get_ionic_kernel()
- Returns the ionic kernel function for the Aliev-Panfilov 3D model.
- """
- def __init__(self):
- pass
-
- @staticmethod
- def get_diffuse_kernel(shape):
- """
- Retrieves the diffusion kernel function based on the shape of weights.
-
- Parameters
- ----------
- shape : tuple
- The shape of the weights array used for determining the diffusion kernel.
-
- Returns
- -------
- function
- The appropriate diffusion kernel function.
-
- Raises
- ------
- IncorrectWeightsShapeError
- If the shape of the weights array is not recognized.
- """
- if shape[-1] == 7:
- return diffuse_kernel_3d_iso
- if shape[-1] == 19:
- return diffuse_kernel_3d_aniso
- else:
- raise IncorrectWeightsShapeError(shape, 7, 19)
-
- @staticmethod
- def get_ionic_kernel():
- """
- Retrieves the ionic kernel function for the Aliev-Panfilov 3D model.
-
- Returns
- -------
- function
- The ionic kernel function.
- """
- return ionic_kernel_3d
diff --git a/finitewave/cpuwave3D/model/barkley_3d.py b/finitewave/cpuwave3D/model/barkley_3d.py
new file mode 100644
index 0000000..3c54402
--- /dev/null
+++ b/finitewave/cpuwave3D/model/barkley_3d.py
@@ -0,0 +1,84 @@
+from numba import njit, prange
+
+from finitewave.cpuwave2D.model.barkley_2d import Barkley2D, calc_v
+from finitewave.cpuwave3D.stencil.isotropic_stencil_3d import (
+ IsotropicStencil3D
+)
+from finitewave.cpuwave3D.stencil.asymmetric_stencil_3d import (
+ AsymmetricStencil3D
+)
+
+
+class Barkley3D(Barkley2D):
+ """
+ Implementation of the Barkley 3D cardiac model.
+
+ See Barkley2D for the 2D model description.
+ """
+
+ def __init__(self):
+ super().__init__()
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel for the Barkley model.
+ """
+ ionic_kernel_3d(self.u_new, self.u, self.v,
+ self.cardiac_tissue.myo_indexes, self.dt,
+ self.a, self.b, self.eap)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue3D
+ A 3D cardiac tissue object.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to be used for diffusion computations.
+ """
+
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil3D()
+
+ return AsymmetricStencil3D()
+
+
+@njit(parallel=True)
+def ionic_kernel_3d(u_new, u, v, indexes, dt, a, b, eap):
+ """
+ Computes the ionic kernel for the Barkley 3D model.
+
+ Parameters
+ ----------
+ u_new : np.ndarray
+ Array to store the updated action potential values.
+ u : np.ndarray
+ Current action potential array.
+ v : np.ndarray
+ Recovery variable array.
+ dt : float
+ Time step for the simulation.
+ indexes : np.ndarray
+ Array of indices where the kernel should be computed (``mesh == 1``).
+ """
+
+ n_j = u.shape[1]
+ n_k = u.shape[2]
+
+ for ni in prange(len(indexes)):
+ ii = indexes[ni]
+ i = ii//(n_j*n_k)
+ j = (ii % (n_j*n_k))//n_k
+ k = (ii % (n_j*n_k)) % n_k
+
+ v[i, j, k] = calc_v(v[i, j, k], u[i, j, k], dt)
+
+ u_new[i, j, k] += dt * (u[i, j, k]*(1 - u[i, j, k])*(u[i, j, k] - (v[i, j, k] + b)/a))/eap
+
diff --git a/finitewave/cpuwave3D/model/bueno_orovio_3d.py b/finitewave/cpuwave3D/model/bueno_orovio_3d.py
new file mode 100644
index 0000000..fb73646
--- /dev/null
+++ b/finitewave/cpuwave3D/model/bueno_orovio_3d.py
@@ -0,0 +1,122 @@
+from numba import njit, prange
+
+from finitewave.cpuwave2D.model.bueno_orovio_2d import (
+ BuenoOrovio2D,
+ calc_Jfi,
+ calc_Jsi,
+ calc_Jso,
+ calc_tau_v_m,
+ calc_tau_w_m,
+ calc_tau_so,
+ calc_tau_s,
+ calc_tau_o,
+ calc_v_inf,
+ calc_w_inf,
+ calc_v,
+ calc_w,
+ calc_s
+)
+from finitewave.cpuwave3D.stencil.isotropic_stencil_3d import (
+ IsotropicStencil3D
+)
+from finitewave.cpuwave3D.stencil.asymmetric_stencil_3d import (
+ AsymmetricStencil3D
+)
+
+
+class BuenoOrovio3D(BuenoOrovio2D):
+ """
+ Implementation of the Bueno-Orovio 3D cardiac model.
+
+ See BuenoOrovio2D for the 2D model description.
+ """
+
+ def __init__(self):
+ super().__init__()
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel for the Bueno-Orovio model.
+ """
+ ionic_kernel_3d(self.u_new, self.u, self.v, self.w, self.s, self.cardiac_tissue.myo_indexes,
+ self.dt, self.u_o, self.u_u, self.theta_v, self.theta_w, self.theta_v_m,
+ self.theta_o, self.tau_v1_m, self.tau_v2_m, self.tau_v_p,
+ self.tau_w1_m, self.tau_w2_m, self.k_w_m, self.u_w_m,
+ self.tau_w_p, self.tau_fi, self.tau_o1, self.tau_o2,
+ self.tau_so1, self.tau_so2, self.k_so, self.u_so,
+ self.tau_s1, self.tau_s2, self.k_s, self.u_s,
+ self.tau_si, self.tau_w_inf, self.w_inf_)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue3D
+ A 3D cardiac tissue object.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to be used for diffusion computations.
+ """
+
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil3D()
+
+ return AsymmetricStencil3D()
+
+
+@njit(parallel=True)
+def ionic_kernel_3d(u_new, u, v, w, s, indexes, dt,
+ u_o, u_u, theta_v, theta_w, theta_v_m,
+ theta_o, tau_v1_m, tau_v2_m, tau_v_p,
+ tau_w1_m, tau_w2_m, k_w_m, u_w_m,
+ tau_w_p, tau_fi, tau_o1, tau_o2,
+ tau_so1, tau_so2, k_so, u_so,
+ tau_s1, tau_s2, k_s, u_s,
+ tau_si, tau_w_inf, w_inf_):
+ """
+ Computes the ionic kernel for the Bueno-Orovio 3D model.
+
+ Parameters
+ ----------
+ u_new : ndarray
+ The new state of the u variable.
+ u : ndarray
+ The current state of the u variable.
+ myo_indexes : list
+ List of indexes representing myocardial cells.
+ dt : float
+ The time step for the simulation.
+ """
+
+ n_j = u.shape[1]
+ n_k = u.shape[2]
+
+ for ni in prange(len(indexes)):
+ ii = indexes[ni]
+ i = ii//(n_j*n_k)
+ j = (ii % (n_j*n_k))//n_k
+ k = (ii % (n_j*n_k)) % n_k
+
+ v[i, j, k] = calc_v(v[i, j, k] , u[i, j, k] , dt, theta_v, calc_v_inf(u[i, j, k] , theta_v_m),
+ calc_tau_v_m(u[i, j, k] , theta_v_m, tau_v1_m, tau_v2_m), tau_v_p)
+
+ w[i, j, k] = calc_w(w[i, j, k] , u[i, j, k] , dt, theta_w, calc_w_inf(u[i, j, k] , theta_o, tau_w_inf, w_inf_),
+ calc_tau_w_m(u[i, j, k] , tau_w1_m, tau_w2_m, k_w_m, u_w_m), tau_w_p)
+
+ s[i, j, k] = calc_s(s[i, j, k] , u[i, j, k] , dt,
+ calc_tau_s(u[i, j, k] , tau_s1, tau_s2, theta_w), k_s, u_s)
+
+ J_fi = calc_Jfi(u[i, j, k] , v[i, j, k] , theta_v, u_u, tau_fi)
+ J_so = calc_Jso(u[i, j, k] , u_o, theta_w,
+ calc_tau_o(u[i, j, k] , tau_o1, tau_o2, theta_o),
+ calc_tau_so(u[i, j, k] , tau_so1, tau_so2, k_so, u_so))
+ J_si = calc_Jsi(u[i, j, k] , w[i, j, k] , s[i, j, k] , theta_w, tau_si)
+
+ u_new[i, j, k] += dt * (-J_fi - J_so - J_si)
+
diff --git a/finitewave/cpuwave3D/model/courtemanche_3d.py b/finitewave/cpuwave3D/model/courtemanche_3d.py
new file mode 100644
index 0000000..a170360
--- /dev/null
+++ b/finitewave/cpuwave3D/model/courtemanche_3d.py
@@ -0,0 +1,163 @@
+import numpy as np
+from numba import njit, prange
+
+from finitewave.cpuwave2D.model.courtemanche_2d import (
+ Courtemanche2D,
+ calc_ina,
+ calc_ik1,
+ calc_ito,
+ calc_ikr,
+ calc_iks,
+ calc_ikur,
+ calc_ical,
+ calc_inak,
+ calc_inaca,
+ calc_ibca,
+ calc_ibna,
+ calc_ipca,
+ calc_irel,
+ calc_iupleak,
+ calc_iup,
+ calc_itr,
+ calc_caup,
+ calc_nai,
+ calc_ki,
+ calc_cai,
+ calc_carel,
+ calc_gating_m,
+ calc_gating_h,
+ calc_gating_j,
+ calc_equilibrum_potentials
+)
+from finitewave.cpuwave3D.stencil.isotropic_stencil_3d import (
+ IsotropicStencil3D
+)
+from finitewave.cpuwave3D.stencil.asymmetric_stencil_3d import (
+ AsymmetricStencil3D
+)
+
+
+class Courtemanche3D(Courtemanche2D):
+ """
+ A class to represent the Courtemanche cardiac model in 3D.
+
+ See Courtemanche2D for the 2D model description.
+ """
+
+ def __init__(self):
+ super().__init__()
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel function to update ionic currents and state
+ variables.
+ """
+ ionic_kernel_3d(self.u_new, self.u, self.nai, self.ki, self.cai, self.caup, self.carel,
+ self.m, self.h, self.j_, self.d, self.f, self.oa, self.oi, self.ua,
+ self.ui, self.xr, self.xs, self.fca, self.irel, self.vrel, self.urel,
+ self.wrel, self.cardiac_tissue.myo_indexes, self.dt,
+ self.gna, self.gnab, self.gk1, self.gkr, self.gks, self.gto, self.gcal,
+ self.gcab, self.gkur_coeff, self.F, self.T, self.R, self.Vc, self.Vj, self.Vup,
+ self.Vrel, self.ibk, self.cao, self.nao, self.ko, self.caupmax,
+ self.kup, self.kmnai, self.kmko, self.kmnancx, self.kmcancx,
+ self.ksatncx, self.kmcmdn, self.kmtrpn, self.kmcsqn, self.trpnmax,
+ self.cmdnmax, self.csqnmax, self.inacamax, self.inakmax,
+ self.ipcamax, self.krel, self.iupmax, self.kq10)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue2D
+ A tissue object representing the cardiac tissue.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to use for diffusion computations.
+ """
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil3D()
+
+ return AsymmetricStencil3D()
+
+
+@njit(parallel=True)
+def ionic_kernel_3d(u_new, u, nai, ki, cai, caup, carel, m, h, j_, d, f, oa, oi, ua, ui, xs, xr, fca, irel, vrel, urel, wrel, indexes, dt,
+ gna, gnab, gk1, gkr, gks, gto, gcal, gcab, gkur_coeff, F, T, R, Vc, Vj, Vup, Vrel, ibk, cao, nao, ko, caupmax, kup,
+ kmnai, kmko, kmnancx, kmcancx, ksatncx, kmcmdn, kmtrpn, kmcsqn, trpnmax, cmdnmax, csqnmax, inacamax,
+ inakmax, ipcamax, krel, iupmax, kq10):
+ """
+ Computes the ionic currents and updates the state variables in the 3D
+ Courtemanche cardiac model.
+
+ Parameters
+ ----------
+ u_new : np.ndarray
+ Updated membrane potential values.
+ u : np.ndarray
+ Current membrane potential values.
+ v : np.ndarray
+ Recovery variable array.
+ indexes : np.ndarray
+ Array of indices where the kernel should be computed (``mesh == 1``).
+ dt : float
+ Time step for the simulation.
+ """
+
+ n_j = u.shape[1]
+ n_k = u.shape[2]
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = ii//(n_j*n_k)
+ j = (ii % (n_j*n_k))//n_k
+ k = (ii % (n_j*n_k)) % n_k
+
+ ena, ek, eca = calc_equilibrum_potentials(nai[i, j, k], nao, ki[i, j, k], ko, cai[i, j, k], cao, R, T, F)
+
+ m[i, j, k] = calc_gating_m(m[i, j, k], u[i, j, k], dt)
+ h[i, j, k] = calc_gating_h(h[i, j, k], u[i, j, k], dt)
+ j_[i, j, k] = calc_gating_j(j_[i, j, k], u[i, j, k], dt)
+
+ ina = calc_ina(u[i, j, k], m[i, j, k], h[i, j, k], j_[i, j, k], gna, ena)
+
+ ik1 = calc_ik1(u[i, j, k], gk1, ek)
+
+ ito, oa[i, j, k], oi[i, j, k] = calc_ito(u[i, j, k], dt, kq10, oa[i, j, k], oi[i, j, k], gto, ek)
+
+ ikur, ua[i, j, k], ui[i, j, k] = calc_ikur(u[i, j, k], dt, kq10, ua[i, j, k], ui[i, j, k], ek, gkur_coeff)
+
+ ikr, xr[i, j, k] = calc_ikr(u[i, j, k], dt, xr[i, j, k], gkr, ek)
+
+ iks, xs[i, j, k] = calc_iks(u[i, j, k], dt, xs[i, j, k], gks, ek)
+
+ ical, d[i, j, k], f[i, j, k], fca[i, j, k] = calc_ical(u[i, j, k], dt, d[i, j, k], f[i, j, k], cai[i, j, k], gcal, fca[i, j, k], eca)
+
+ inak = calc_inak(inakmax, nai[i, j, k], nao, ko, kmnai, kmko, F, u[i, j, k], R, T)
+ inaca = calc_inaca(inacamax, nai[i, j, k], nao, cai[i, j, k], cao, kmnancx, kmcancx, ksatncx, F, u[i, j, k], R, T)
+
+ ibca = calc_ibca(gcab, eca, u[i, j, k])
+
+ ibna = calc_ibna(gnab, ena, u[i, j, k])
+
+ ipca = calc_ipca(ipcamax, cai[i, j, k])
+
+ irel[i, j, k], urel[i, j, k], vrel[i, j, k], wrel[i, j, k] = calc_irel(dt, urel[i, j, k], vrel[i, j, k], irel[i, j, k], wrel[i, j, k], ical, inaca, krel, carel[i, j, k], cai[i, j, k], u[i, j, k], F, Vrel)
+ itr = calc_itr(caup[i, j, k], carel[i, j, k])
+ iup = calc_iup(iupmax, cai[i, j, k], kup)
+ iupleak = calc_iupleak(caup[i, j, k], caupmax, iupmax)
+
+ caup[i, j, k] = calc_caup(caup[i, j, k], dt, iup, iupleak, itr, Vrel, Vup)
+ nai[i, j, k] = calc_nai(nai[i, j, k], dt, inak, inaca, ibna, ina, F, Vj)
+
+ ki[i, j, k] = calc_ki(ki[i, j, k], dt, inak, ik1, ito, ikur, ikr, iks, ibk, F, Vj)
+ cai[i, j, k] = calc_cai(cai[i, j, k], dt, inaca, ipca, ical, ibca, iup, iupleak, irel[i, j, k], Vrel, Vup, trpnmax, kmtrpn, cmdnmax, kmcmdn, F, Vj)
+
+ carel[i, j, k] = calc_carel(carel[i, j, k], dt, itr, irel[i, j, k], csqnmax, kmcsqn)
+
+ u_new[i, j, k] -= dt * (ina + ik1 + ito + ikur + ikr + iks + ical + ipca + inak + inaca + ibna + ibca)
diff --git a/finitewave/cpuwave3D/model/diffuse_kernels_3d.py b/finitewave/cpuwave3D/model/diffuse_kernels_3d.py
deleted file mode 100644
index f5fcef3..0000000
--- a/finitewave/cpuwave3D/model/diffuse_kernels_3d.py
+++ /dev/null
@@ -1,113 +0,0 @@
-from numba import njit, prange
-
-_parallel = False
-
-
-@njit(parallel=_parallel)
-def diffuse_kernel_3d_iso(u_new, u, w, mesh):
- """
- Performs isotropic diffusion on a 3D grid.
-
- This function computes the new values of the potential field `u_new` based on an isotropic
- diffusion model. The computation is performed in parallel using Numba's JIT compilation.
-
- Parameters
- ----------
- u_new : numpy.ndarray
- A 3D array to store the updated potential values after diffusion.
-
- u : numpy.ndarray
- A 3D array representing the current potential values before diffusion.
-
- w : numpy.ndarray
- A 4D array of weights used in the diffusion computation. The shape should match (n_i, n_j, n_k, 7),
- where `n_i`, `n_j` and `n_k` are the dimensions of the `u` and `u_new` arrays.
-
- mesh : numpy.ndarray
- A 3D array representing the mesh of the tissue. Each element indicates the type of tissue at
- that position (e.g., cardiomyocyte, empty, or fibrosis). Only positions with a value of 1 are
- considered for diffusion.
-
- Notes
- -----
- The diffusion is applied only to points in the `mesh` with a value of 1. Boundary conditions are
- not explicitly handled and are assumed to be implicitly managed by the provided mesh.
- """
- n_i = u.shape[0]
- n_j = u.shape[1]
- n_k = u.shape[2]
- for ii in prange(n_i*n_j*n_k):
- i = ii//(n_j*n_k)
- j = (ii % (n_j*n_k))//n_k
- k = (ii % (n_j*n_k)) % n_k
- if mesh[i, j, k] != 1:
- continue
-
- u_new[i, j, k] = (u[i-1, j, k] * w[i, j, k, 0] +
- u[i, j-1, k] * w[i, j, k, 1] +
- u[i, j, k-1] * w[i, j, k, 2] +
- u[i, j, k] * w[i, j, k, 3] +
- u[i, j, k+1] * w[i, j, k, 4] +
- u[i, j+1, k] * w[i, j, k, 5] +
- u[i+1, j, k] * w[i, j, k, 6])
-
-
-@njit(parallel=_parallel)
-def diffuse_kernel_3d_aniso(u_new, u, w, mesh):
- """
- Performs anisotropic diffusion on a 3D grid.
-
- This function computes the new values of the potential field `u_new` based on an anisotropic
- diffusion model. The computation is performed in parallel using Numba's JIT compilation.
-
- Parameters
- ----------
- u_new : numpy.ndarray
- A 3D array to store the updated potential values after diffusion.
-
- u : numpy.ndarray
- A 3D array representing the current potential values before diffusion.
-
- w : numpy.ndarray
- A 4D array of weights used in the diffusion computation. The shape should match (n_i, n_j, n_k, 19),
- where `n_i`, `n_j` and `n_k` are the dimensions of the `u` and `u_new` arrays.
-
- mesh : numpy.ndarray
- A 3D array representing the mesh of the tissue. Each element indicates the type of tissue at
- that position (e.g., cardiomyocyte, empty, or fibrosis). Only positions with a value of 1 are
- considered for diffusion.
-
- Notes
- -----
- The diffusion is applied only to points in the `mesh` with a value of 1. Boundary conditions are
- not explicitly handled and are assumed to be implicitly managed by the provided mesh.
- """
- n_i = u.shape[0]
- n_j = u.shape[1]
- n_k = u.shape[2]
- for ii in prange(n_i*n_j*n_k):
- i = ii//(n_j*n_k)
- j = (ii % (n_j*n_k))//n_k
- k = (ii % (n_j*n_k)) % n_k
- if mesh[i, j, k] != 1:
- continue
-
- u_new[i, j, k] = (u[i-1, j-1, k] * w[i, j, k, 0] +
- u[i-1, j, k-1] * w[i, j, k, 1] +
- u[i-1, j, k] * w[i, j, k, 2] +
- u[i-1, j, k+1] * w[i, j, k, 3] +
- u[i-1, j+1, k] * w[i, j, k, 4] +
- u[i, j-1, k-1] * w[i, j, k, 5] +
- u[i, j-1, k] * w[i, j, k, 6] +
- u[i, j-1, k+1] * w[i, j, k, 7] +
- u[i, j, k-1] * w[i, j, k, 8] +
- u[i, j, k] * w[i, j, k, 9] +
- u[i, j, k+1] * w[i, j, k, 10] +
- u[i, j+1, k-1] * w[i, j, k, 11] +
- u[i, j+1, k] * w[i, j, k, 12] +
- u[i, j+1, k+1] * w[i, j, k, 13] +
- u[i+1, j-1, k] * w[i, j, k, 14] +
- u[i+1, j, k-1] * w[i, j, k, 15] +
- u[i+1, j, k] * w[i, j, k, 16] +
- u[i+1, j, k+1] * w[i, j, k, 17] +
- u[i+1, j+1, k] * w[i, j, k, 18])
diff --git a/finitewave/cpuwave3D/model/fenton_karma_3d.py b/finitewave/cpuwave3D/model/fenton_karma_3d.py
new file mode 100644
index 0000000..629c654
--- /dev/null
+++ b/finitewave/cpuwave3D/model/fenton_karma_3d.py
@@ -0,0 +1,98 @@
+from numba import njit, prange
+
+from finitewave.cpuwave2D.model.fenton_karma_2d import (
+ FentonKarma2D,
+ calc_Jfi,
+ calc_Jsi,
+ calc_Jso,
+ calc_v,
+ calc_w,
+)
+from finitewave.cpuwave3D.stencil.isotropic_stencil_3d import (
+ IsotropicStencil3D
+)
+from finitewave.cpuwave3D.stencil.asymmetric_stencil_3d import (
+ AsymmetricStencil3D
+)
+
+
+class FentonKarma3D(FentonKarma2D):
+ """
+ Implementation of the Fenton-Karma 3D cardiac model.
+
+ See FentonKarma2D for the 2D model description.
+ """
+
+ def __init__(self):
+ super().__init__()
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel for the Fenton-Karma model.
+ """
+ ionic_kernel_3d(self.u_new, self.u, self.v, self.w, self.cardiac_tissue.myo_indexes,
+ self.dt, self.tau_d, self.tau_o, self.tau_r, self.tau_si,
+ self.tau_v_m, self.tau_v_p, self.tau_w_m, self.tau_w_p,
+ self.k, self.u_c, self.uc_si)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue3D
+ A 3D cardiac tissue object.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to be used for diffusion computations.
+ """
+
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil3D()
+
+ return AsymmetricStencil3D()
+
+
+@njit(parallel=True)
+def ionic_kernel_3d(u_new, u, v, w, indexes, dt,
+ tau_d, tau_o, tau_r, tau_si,
+ tau_v_m, tau_v_p, tau_w_m, tau_w_p,
+ k, u_c, uc_si):
+ """
+ Computes the ionic kernel for the Fenton-Karma 3D model.
+
+ Parameters
+ ----------
+ u_new : ndarray
+ The new state of the u variable.
+ u : ndarray
+ The current state of the u variable.
+ myo_indexes : list
+ List of indexes representing myocardial cells.
+ dt : float
+ The time step for the simulation.
+ """
+
+ n_j = u.shape[1]
+ n_k = u.shape[2]
+
+ for ni in prange(len(indexes)):
+ ii = indexes[ni]
+ i = ii//(n_j*n_k)
+ j = (ii % (n_j*n_k))//n_k
+ k_ = (ii % (n_j*n_k)) % n_k
+
+ v[i, j, k_] = calc_v(v[i, j, k_], u[i, j, k_], dt, u_c, tau_v_m, tau_v_p)
+ w[i, j, k_] = calc_w(w[i, j, k_], u[i, j, k_], dt, u_c, tau_w_m, tau_w_p)
+
+ J_fi = calc_Jfi(u[i, j, k_], v[i, j, k_], u_c, tau_d)
+ J_so = calc_Jso(u[i, j, k_], u_c, tau_o, tau_r)
+ J_si = calc_Jsi(u[i, j, k_], v[i, j, k_], k, uc_si, tau_si)
+
+ u_new[i, j, k_] += dt * (-J_fi - J_so - J_si)
+
diff --git a/finitewave/cpuwave3D/model/luo_rudy91_3d.py b/finitewave/cpuwave3D/model/luo_rudy91_3d.py
new file mode 100644
index 0000000..0ecd8ed
--- /dev/null
+++ b/finitewave/cpuwave3D/model/luo_rudy91_3d.py
@@ -0,0 +1,132 @@
+import numpy as np
+from numba import njit, prange
+
+from finitewave.cpuwave2D.model.luo_rudy91_2d import (
+ LuoRudy912D,
+ calc_ina,
+ calc_isk,
+ calc_ik,
+ calc_ik1,
+ calc_ikp,
+ calc_ib
+)
+from finitewave.cpuwave3D.stencil.isotropic_stencil_3d import (
+ IsotropicStencil3D
+)
+from finitewave.cpuwave3D.stencil.asymmetric_stencil_3d import (
+ AsymmetricStencil3D
+)
+
+
+class LuoRudy913D(LuoRudy912D):
+ """
+ Implements the 3D Luo-Rudy 1991 cardiac model.
+
+ See LuoRudy912D for the 2D model description.
+ """
+ def __init__(self):
+ super().__init__()
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel to update the state variables and membrane
+ potential.
+ """
+ ionic_kernel_3d(self.u_new, self.u, self.m, self.h, self.j, self.d,
+ self.f, self.x, self.cai,
+ self.cardiac_tissue.myo_indexes, self.dt,
+ self.gna, self.gsi, self.gk, self.gk1, self.gkp, self.gb,
+ self.ko, self.ki, self.nai, self.nao, self.cao, self.R, self.T, self.F, self.PR_NaK)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue2D
+ A tissue object representing the cardiac tissue.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to use for diffusion computations.
+ """
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil3D()
+
+ return AsymmetricStencil3D()
+
+
+@njit(parallel=True)
+def ionic_kernel_3d(u_new, u, m, h, j_, d, f, x, cai, indexes, dt, gna, gsi, gk, gk1, gkp, gb, ko, ki, nai, nao, cao, R, T, F, PR_NaK):
+ """
+ Computes the ionic currents and updates the state variables in the 3D
+ Luo-Rudy 1991 cardiac model.
+
+ Parameters
+ ----------
+ u_new : np.ndarray
+ Array to store the updated membrane potential.
+ u : np.ndarray
+ Array of the current membrane potential values.
+ m : np.ndarray
+ Array for the gating variable `m`.
+ h : np.ndarray
+ Array for the gating variable `h`.
+ j_ : np.ndarray
+ Array for the gating variable `j`.
+ d : np.ndarray
+ Array for the gating variable `d`.
+ f : np.ndarray
+ Array for the gating variable `f`.
+ x : np.ndarray
+ Array for the gating variable `x`.
+ Cai_c : np.ndarray
+ Array for the intracellular calcium concentration.
+ mesh : np.ndarray
+ Mesh array indicating the tissue types.
+ dt : float
+ Time step for the simulation.
+ """
+
+ E_Na = (R*T/F)*np.log(nao/nai)
+
+ n_j = u.shape[1]
+ n_k = u.shape[2]
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = ii//(n_j*n_k)
+ j = (ii % (n_j*n_k))//n_k
+ k = (ii % (n_j*n_k)) % n_k
+
+ # Fast sodium current:
+ ina, m[i, j, k], h[i, j, k], j_[i, j, k] = calc_ina(u[i, j, k], dt, m[i, j, k], h[i, j, k], j_[i, j, k], E_Na, gna)
+
+ # Slow inward current:
+ isi, d[i, j, k], f[i, j, k], cai[i, j, k] = calc_isk(u[i, j, k], dt, d[i, j, k], f[i, j, k], cai[i, j, k], gsi)
+
+ # Time-dependent potassium current:
+ ik, x[i, j, k] = calc_ik(u[i, j, k], dt, x[i, j, k], ko, ki, nao, nai, PR_NaK, R, T, F, gk)
+
+ E_K1 = (R * T / F) * np.log(ko / ki)
+
+ # Time-independent potassium current:
+ ik1 = calc_ik1(u[i, j, k], ko, E_K1, gk1)
+
+ # Plateau potassium current:
+ ikp = calc_ikp(u[i, j, k], E_K1, gkp)
+
+ # Background current:
+ ib = calc_ib(u[i, j, k], gb)
+
+ # Total time-independent potassium current:
+ ik1t = ik1 + ikp + ib
+
+ # if i == 4 and j == 4:
+ # print(cai[i, j], m[i, j])
+
+ u_new[i, j, k] -= dt * (ina + isi + ik1t + ik)
diff --git a/finitewave/cpuwave3D/model/luo_rudy91_3d/__init__.py b/finitewave/cpuwave3D/model/luo_rudy91_3d/__init__.py
deleted file mode 100644
index ab3042e..0000000
--- a/finitewave/cpuwave3D/model/luo_rudy91_3d/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from finitewave.cpuwave3D.model.luo_rudy91_3d.luo_rudy91_3d import LuoRudy913D
diff --git a/finitewave/cpuwave3D/model/luo_rudy91_3d/luo_rudy91_3d.py b/finitewave/cpuwave3D/model/luo_rudy91_3d/luo_rudy91_3d.py
deleted file mode 100644
index 0df757e..0000000
--- a/finitewave/cpuwave3D/model/luo_rudy91_3d/luo_rudy91_3d.py
+++ /dev/null
@@ -1,116 +0,0 @@
-import numpy as np
-from tqdm import tqdm
-
-from finitewave.core.model.cardiac_model import CardiacModel
-from finitewave.cpuwave3D.model.luo_rudy91_3d.luo_rudy91_kernels_3d import \
- LuoRudy91Kernels3D
-
-_parallel = True
-_npfloat = "float64"
-
-
-class LuoRudy913D(CardiacModel):
- """
- Implements the 3D Luo-Rudy 1991 cardiac model for simulating cardiac electrical activity.
-
- This class initializes the state variables and provides methods for running simulations with the Luo-Rudy 1991 model.
-
- Attributes
- ----------
- m : np.ndarray
- Gating variable m.
- h : np.ndarray
- Gating variable h.
- j_ : np.ndarray
- Gating variable j_.
- d : np.ndarray
- Gating variable d.
- f : np.ndarray
- Gating variable f.
- x : np.ndarray
- Gating variable x.
- Cai_c : np.ndarray
- Intracellular calcium concentration.
- model_parameters : dict
- Dictionary to hold model-specific parameters.
- state_vars : list
- List of state variable names.
- npfloat : str
- NumPy data type used for floating point calculations ('float64').
-
- Methods
- -------
- initialize():
- Initializes the state variables and sets up the diffusion and ionic kernels.
- run_ionic_kernel():
- Executes the ionic kernel to update the state variables and membrane potential.
- """
- def __init__(self):
- """
- Initializes the LuoRudy913D instance, setting up the state variables and parameters.
- """
- CardiacModel.__init__(self)
- self.D_al = 0.1
- self.D_ac = 0.1
- self.I_tot = np.ndarray
- self.m = np.ndarray
- self.h = np.ndarray
- self.j_ = np.ndarray
- self.d = np.ndarray
- self.f = np.ndarray
- self.x = np.ndarray
- self.Cai_c = np.ndarray
- self.model_parameters = {}
- self.state_vars = ["u", "m", "h", "j_", "d", "f", "x", "Cai_c"]
- self.npfloat = 'float64'
- self.parallel = 'True'
-
- def initialize(self):
- """
- Initializes the state variables and sets up the diffusion and ionic kernels.
-
- This method sets the initial values for the membrane potential `u`, gating variables `m`, `h`, `j_`, `d`, `f`, `x`,
- and intracellular calcium concentration `Cai_c`. It also retrieves and sets the diffusion and ionic kernel functions
- based on the shape of the weights in the cardiac tissue.
- """
- super().initialize()
- weights_shape = self.cardiac_tissue.weights.shape
- shape = self.cardiac_tissue.mesh.shape
- self.kernel_diffuse = LuoRudy91Kernels3D().get_diffuse_kernel(weights_shape)
- self.kernel_vars = LuoRudy91Kernels3D().get_ionic_kernel()
-
- self.u = -84.5*np.ones(shape, dtype=_npfloat)
- self.u_new = self.u.copy()
- self.m = 0.0017*np.ones(shape, dtype=_npfloat)
- self.h = 0.9832*np.ones(shape, dtype=_npfloat)
- self.j_ = 0.995484*np.ones(shape, dtype=_npfloat)
- self.d = 0.000003*np.ones(shape, dtype=_npfloat)
- self.f = np.ones(shape, dtype=_npfloat)
- self.x = 0.0057*np.ones(shape, dtype=_npfloat)
- self.Cai_c = 0.0002*np.ones(shape, dtype=_npfloat)
- self.I_tot = np.zeros(shape, dtype=_npfloat)
-
- def run_ionic_kernel(self):
- """
- Executes the ionic kernel to update the state variables and membrane potential.
-
- This method calls the ionic kernel function provided by the `LuoRudy91Kernels3D` class to compute the updates for
- the membrane potential `u_new` and the gating variables `m`, `h`, `j_`, `d`, `f`, `x`, and `Cai_c` based on the
- current state and the time step `dt`.
-
- The ionic kernel function takes the following parameters:
- - `u_new`: Array to store updated membrane potential values.
- - `u`: Array of current membrane potential values.
- - `m`: Array of gating variable m.
- - `h`: Array of gating variable h.
- - `j_`: Array of gating variable j_.
- - `d`: Array of gating variable d.
- - `f`: Array of gating variable f.
- - `x`: Array of gating variable x.
- - `Cai_c`: Array of intracellular calcium concentration.
- - `mesh`: Array indicating tissue types.
- - `dt`: Time step for the simulation.
- """
- self.ionic_kernel(self.u_new, self.u, self.m, self.h, self.j_, self.d,
- self.f, self.x, self.Cai_c, self.cardiac_tissue.mesh,
- self.dt)
diff --git a/finitewave/cpuwave3D/model/luo_rudy91_3d/luo_rudy91_kernels_3d.py b/finitewave/cpuwave3D/model/luo_rudy91_3d/luo_rudy91_kernels_3d.py
deleted file mode 100644
index 0e117c1..0000000
--- a/finitewave/cpuwave3D/model/luo_rudy91_3d/luo_rudy91_kernels_3d.py
+++ /dev/null
@@ -1,237 +0,0 @@
-from math import log, sqrt, exp, pow
-from numba import njit, prange
-
-from finitewave.core.exception.exceptions import IncorrectWeightsShapeError
-from finitewave.cpuwave3D.model.diffuse_kernels_3d \
- import diffuse_kernel_3d_iso, diffuse_kernel_3d_aniso, _parallel
-
-
-@njit(parallel=_parallel)
-def ionic_kernel_3d(u_new, u, m, h, j_, d, f, x, Cai_c, mesh, dt):
- """
- Computes the ionic currents and updates the state variables in the 3D Luo-Rudy 1991 cardiac model.
-
- This function updates the membrane potential `u` and the gating variables `m`, `h`, `j_`, `d`, `f`, `x` based on
- the Luo-Rudy 1991 equations. It also updates the calcium concentration `Cai_c`.
-
- Parameters
- ----------
- u_new : np.ndarray
- Array to store the updated membrane potential.
- u : np.ndarray
- Array of the current membrane potential values.
- m : np.ndarray
- Array for the gating variable `m`.
- h : np.ndarray
- Array for the gating variable `h`.
- j_ : np.ndarray
- Array for the gating variable `j_`.
- d : np.ndarray
- Array for the gating variable `d`.
- f : np.ndarray
- Array for the gating variable `f`.
- x : np.ndarray
- Array for the gating variable `x`.
- Cai_c : np.ndarray
- Array for the intracellular calcium concentration.
- mesh : np.ndarray
- Mesh array indicating the tissue types.
- dt : float
- Time step for the simulation.
-
- Notes
- -----
- The function uses various constants and equations specific to the Luo-Rudy 1991 model to compute ionic currents and
- update the state variables. The results are stored in `u_new`, which represents the membrane potential at the next
- time step.
- """
- Ko_c = 5.4
- Ki_c = 145
- Nai_c = 18
- Nao_c = 140
- Cao_c = 1.8
-
- R = 8.314
- T = 310 # 37 cels
- F = 96.5
-
- PR_NaK = 0.01833
- E_Na = (R*T/F)*log(Nao_c/Nai_c)
-
- n_i = u.shape[0]
- n_j = u.shape[1]
- n_k = u.shape[2]
-
- for ii in prange(n_i*n_j*n_k):
- i = ii//(n_j*n_k)
- j = (ii % (n_j*n_k))//n_k
- k = (ii % (n_j*n_k)) % n_k
- if mesh[i, j, k] != 1:
- continue
-
- I_Na = 23*pow(m[i, j, k], 3)*h[i, j, k] * \
- j_[i, j, k]*(u[i, j, k]-E_Na)
-
- alpha_h = 0
- beta_h = 0
- beta_J = 0
- alpha_J = 0
- if u[i, j, k] >= -40.:
- alpha_h = 0
- beta_h = 1./(0.13*(1 + exp((u[i, j, k] + 10.66)/-11.1)))
- beta_J = 0.3 * \
- exp(-2.535*1e-07*u[i, j, k]) / \
- (1 + exp(-0.1*(u[i, j, k]+32)))
- alpha_J = 0.
- else:
- alpha_h = 0.135*exp((80+u[i, j, k])/-6.8)
- beta_h = 3.56*exp(0.079*u[i, j, k]) + \
- 3.1*100000*exp(0.35*u[i, j, k])
- beta_J = 0.1212 * \
- exp(-0.01052*u[i, j, k]) / \
- (1+exp(-0.1378*(u[i, j, k]+40.14)))
- alpha_J = (-1.2714*100000*exp(0.2444*u[i, j, k])-3.474*1e-05*exp(-0.04391*u[i, j, k]))*(
- u[i, j, k]+37.78)/(1+exp(0.311*(u[i, j, k]+79.23)))
-
- alpha_m = 0.32*(u[i, j, k]+47.13)/(1-exp(-0.1*(u[i, j, k]+47.13)))
- beta_m = 0.08*exp(-u[i, j, k]/11)
-
- tau_m = 1./(alpha_m+beta_m)
- inf_m = alpha_m/(alpha_m + beta_m)
- m[i, j, k] += dt*(inf_m - m[i, j, k])/tau_m
-
- tau_h = 1./(alpha_h+beta_h)
- inf_h = alpha_h/(alpha_h + beta_h)
- h[i, j, k] += dt*(inf_h - h[i, j, k])/tau_h
-
- tau_J = 1./(alpha_J+beta_J)
- inf_J = alpha_J/(alpha_J + beta_J)
- j_[i, j, k] += dt*(inf_J - j_[i, j, k])/tau_J
-
- # Slow inward current:
- E_Si = 7.7-13.0287*log(Cai_c[i, j, k])
- I_Si = 0.045*d[i, j, k]*f[i, j, k]*(u[i, j, k]-E_Si)
- alpha_d = 0.095 * \
- exp(-0.01*(u[i, j, k]-5))/(1+exp(-0.072*(u[i, j, k]-5)))
- beta_d = 0.07*exp(-0.017*(u[i, j, k]+44)) / \
- (1+exp(0.05*(u[i, j, k]+44)))
- alpha_f = 0.012 * \
- exp(-0.008*(u[i, j, k]+28))/(1+exp(0.15*(u[i, j, k]+28)))
- beta_f = 0.0065 * \
- exp(-0.02*(u[i, j, k]+30))/(1+exp(-0.2*(u[i, j, k]+30)))
- Cai_c[i, j, k] += dt*(-0.0001*I_Si+0.07*(0.0001-Cai_c[i, j, k]))
-
- tau_d = 1./(alpha_d+beta_d)
- inf_d = alpha_d/(alpha_d + beta_d)
- d[i, j, k] += dt*(inf_d - d[i, j, k])/tau_d
-
- tau_f = 1./(alpha_f+beta_f)
- inf_f = alpha_f/(alpha_f + beta_f)
- f[i, j, k] += dt*(inf_f - f[i, j, k])/tau_f
-
- # Time-dependent potassium current
- E_K = (R*T/F)*log((Ko_c + PR_NaK*Nao_c)/(Ki_c + PR_NaK*Nai_c))
-
- G_K = 0.705*sqrt(Ko_c/5.4)
-
- Xi = 0
- if u[i, j, k] > -100:
- Xi = 2.837*(exp(0.04*(u[i, j, k]+77))-1) / \
- ((u[i, j, k]+77)*exp(0.04*(u[i, j, k]+35)))
- else:
- Xi = 1
-
- I_K = G_K*x[i, j, k]*Xi*(u[i, j, k]-E_K)
-
- alpha_x = 0.0005 * \
- exp(0.083*(u[i, j, k]+50))/(1+exp(0.057*(u[i, j, k]+50)))
- beta_x = 0.0013 * \
- exp(-0.06*(u[i, j, k]+20))/(1+exp(-0.04*(u[i, j, k]+20)))
-
- tau_x = 1./(alpha_x+beta_x)
- inf_x = alpha_x/(alpha_x + beta_x)
- x[i, j, k] += dt*(inf_x - x[i, j, k])/tau_x
-
- # Time-independent potassium current:
- E_K1 = (R*T/F)*log(Ko_c/Ki_c)
-
- alpha_K1 = 1.02/(1+exp(0.2385*(u[i, j, k]-E_K1-59.215)))
- beta_K1 = (0.49124*exp(0.08032*(u[i, j, k]-E_K1+5.476))+exp(
- 0.06175*(u[i, j, k]-E_K1-594.31)))/(1+exp(-0.5143*(u[i, j, k]-E_K1+4.753)))
-
- K_1x = alpha_K1/(alpha_K1+beta_K1)
-
- G_K1 = 0.6047*sqrt(Ko_c/5.4)
- I_K1 = G_K1*K_1x*(u[i, j, k]-E_K1)
-
- # Plateau potassium current:
- E_Kp = E_K1
- K_p = 1./(1+exp((7.488-u[i, j, k])/5.98))
- I_Kp = 0.0183*K_p*(u[i, j, k]-E_Kp)
-
- # Background current:
- I_b = 0.03921*(u[i, j, k]+59.87)
-
- # Total time-independent potassium current:
- I_K1_T = I_K1 + I_Kp + I_b
-
- u_new[i, j, k] += dt * (I_Na + I_Si + I_K1_T + I_K)
-
-
-class LuoRudy91Kernels3D:
- """
- Class to handle kernel functions for the Luo-Rudy 1991 cardiac model in 3D.
-
- This class provides methods to obtain the appropriate diffusion and ionic kernels based on the shape of the weight array.
-
- Methods
- -------
- get_diffuse_kernel(shape):
- Returns the diffusion kernel function based on the weight array shape.
- get_ionic_kernel():
- Returns the ionic kernel function used for updating membrane potentials and gating variables.
- """
- def __init__(self):
- """
- Initializes the LuoRudy91Kernels3D instance.
- """
- pass
-
- @staticmethod
- def get_diffuse_kernel(shape):
- """
- Retrieves the diffusion kernel function based on the weight shape.
-
- Parameters
- ----------
- shape : tuple
- The shape of the weight array used in the diffusion process.
-
- Returns
- -------
- function
- The diffusion kernel function appropriate for the given weight shape.
-
- Raises
- ------
- IncorrectWeightsShapeError
- If the shape of the weights array does not match expected values (7 or 19).
- """
- if shape[-1] == 7:
- return diffuse_kernel_3d_iso
- if shape[-1] == 19:
- return diffuse_kernel_3d_aniso
- else:
- raise IncorrectWeightsShapeError(shape, 7, 19)
-
- @staticmethod
- def get_ionic_kernel():
- """
- Retrieves the ionic kernel function for updating membrane potentials and gating variables.
-
- Returns
- -------
- function
- The ionic kernel function used in the Luo-Rudy 1991 model.
- """
- return ionic_kernel_3d
diff --git a/finitewave/cpuwave3D/model/mitchell_schaeffer_3d.py b/finitewave/cpuwave3D/model/mitchell_schaeffer_3d.py
new file mode 100644
index 0000000..a1437a6
--- /dev/null
+++ b/finitewave/cpuwave3D/model/mitchell_schaeffer_3d.py
@@ -0,0 +1,96 @@
+from numba import njit, prange
+
+from finitewave.cpuwave2D.model.mitchell_schaeffer_2d import (
+ MitchellSchaeffer2D,
+ calc_h,
+ calc_J_in,
+ calc_J_out
+)
+from finitewave.cpuwave3D.stencil.isotropic_stencil_3d import (
+ IsotropicStencil3D
+)
+from finitewave.cpuwave3D.stencil.asymmetric_stencil_3d import (
+ AsymmetricStencil3D
+)
+
+
+class MitchellSchaeffer3D(MitchellSchaeffer2D):
+ """
+ Implementation of the Mitchell-Schaeffer 3D cardiac model.
+
+ See MitchellSchaeffer2D for the 2D model description.
+ """
+
+ def __init__(self):
+ super().__init__()
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel for the Mitchell-Schaeffer model.
+ """
+ ionic_kernel_3d(self.u_new, self.u, self.h, self.cardiac_tissue.myo_indexes, self.dt,
+ self.tau_close, self.tau_open, self.tau_in, self.tau_out, self.u_gate)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue3D
+ A 3D cardiac tissue object.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to be used for diffusion computations.
+ """
+
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil3D()
+
+ return AsymmetricStencil3D()
+
+
+@njit(parallel=True)
+def ionic_kernel_3d(u_new, u, h, indexes, dt, tau_close, tau_open, tau_in, tau_out, u_gate):
+ """
+ Computes the ionic kernel for the Mitchell-Schaeffer 3D model.
+
+ Parameters
+ ----------
+ u_new : ndarray
+ The new state of the u variable.
+ u : ndarray
+ The current state of the u variable.
+ h : ndarray
+ The gating variable h.
+ myo_indexes : list
+ List of indexes representing myocardial cells.
+ dt : float
+ The time step for the simulation.
+ tau_close : float
+ The time constant for the closing of the h gate.
+ tau_open : float
+ The time constant for the opening of the h gate.
+ u_gate : float
+ The threshold value for the gating variable.
+ """
+
+ n_j = u.shape[1]
+ n_k = u.shape[2]
+
+ for ni in prange(len(indexes)):
+ ii = indexes[ni]
+ i = ii//(n_j*n_k)
+ j = (ii % (n_j*n_k))//n_k
+ k = (ii % (n_j*n_k)) % n_k
+
+ h[i, j, k] = calc_h(h[i, j, k], u[i, j, k], dt, tau_close, tau_open, u_gate)
+
+ J_in = calc_J_in(h[i, j, k], u[i, j, k], tau_in)
+ J_out = calc_J_out(u[i, j, k], tau_out)
+ u_new[i, j, k] += dt * (J_in + J_out)
+
diff --git a/finitewave/cpuwave3D/model/tp06_3d.py b/finitewave/cpuwave3D/model/tp06_3d.py
new file mode 100644
index 0000000..0ff97a9
--- /dev/null
+++ b/finitewave/cpuwave3D/model/tp06_3d.py
@@ -0,0 +1,204 @@
+import numpy as np
+from numba import njit, prange
+
+from finitewave.cpuwave2D.model.tp06_2d import (
+ TP062D,
+ calc_ina,
+ calc_ical,
+ calc_ito,
+ calc_ikr,
+ calc_iks,
+ calc_ik1,
+ calc_inaca,
+ calc_inak,
+ calc_ipca,
+ calc_ipk,
+ calc_ibna,
+ calc_ibca,
+ calc_irel,
+ calc_ileak,
+ calc_iup,
+ calc_ixfer,
+ calc_casr,
+ calc_cass,
+ calc_cai,
+ calc_nai,
+ calc_ki
+)
+from finitewave.cpuwave3D.stencil.isotropic_stencil_3d import (
+ IsotropicStencil3D
+)
+from finitewave.cpuwave3D.stencil.asymmetric_stencil_3d import (
+ AsymmetricStencil3D
+)
+
+
+class TP063D(TP062D):
+ """
+ A class to represent the TP06 cardiac model in 3D.
+
+ See TP062D for the 2D model description.
+ """
+
+ def __init__(self):
+ super().__init__()
+
+ def run_ionic_kernel(self):
+ """
+ Executes the ionic kernel function to update ionic currents and state
+ variables.
+ """
+ ionic_kernel_3d(self.u_new, self.u, self.cai, self.casr, self.cass,
+ self.nai, self.Ki, self.m, self.h, self.j, self.xr1,
+ self.xr2, self.xs, self.r, self.s, self.d, self.f,
+ self.f2, self.fcass, self.rr, self.oo,
+ self.cardiac_tissue.myo_indexes, self.dt,
+ self.ko, self.cao, self.nao, self.Vc, self.Vsr, self.Vss, self.Bufc, self.Kbufc, self.Bufsr, self.Kbufsr,
+ self.Bufss, self.Kbufss, self.Vmaxup, self.Kup, self.Vrel, self.k1_, self.k2_, self.k3, self.k4, self.EC,
+ self.maxsr, self.minsr, self.Vleak, self.Vxfer, self.R, self.F, self.T, self.RTONF, self.CAPACITANCE,
+ self.gkr, self.pKNa, self.gk1, self.gna, self.gbna, self.KmK, self.KmNa, self.knak, self.gcal, self.gbca,
+ self.knaca, self.KmNai, self.KmCa, self.ksat, self.n_, self.gpca, self.KpCa, self.gpk, self.gto, self.gks)
+
+ def select_stencil(self, cardiac_tissue):
+ """
+ Selects the appropriate stencil for diffusion based on the tissue
+ properties. If the tissue has fiber directions, an asymmetric stencil
+ is used; otherwise, an isotropic stencil is used.
+
+ Parameters
+ ----------
+ cardiac_tissue : CardiacTissue2D
+ A tissue object representing the cardiac tissue.
+
+ Returns
+ -------
+ Stencil
+ The stencil object to use for diffusion computations.
+ """
+ if cardiac_tissue.fibers is None:
+ return IsotropicStencil3D()
+
+ return AsymmetricStencil3D()
+
+
+# tp06 epi kernel
+@njit(parallel=True)
+def ionic_kernel_3d(u_new, u, cai, casr, cass, nai, Ki, m, h, j_, xr1, xr2,
+ xs, r, s, d, f, f2, fcass, rr, oo, indexes, dt,
+ ko, cao, nao, Vc, Vsr, Vss, Bufc, Kbufc, Bufsr, Kbufsr,
+ Bufss, Kbufss, Vmaxup, Kup, Vrel, k1_, k2_, k3, k4, EC,
+ maxsr, minsr, Vleak, Vxfer, R, F, T, RTONF, CAPACITANCE,
+ gkr, pKNa, gk1, gna, gbna, KmK, KmNa, knak, gcal, gbca,
+ knaca, KmNai, KmCa, ksat, n_, gpca, KpCa, gpk, gto, gks):
+ """
+ Compute the ionic currents and update the state variables for the 3D TP06
+ cardiac model.
+
+ This function calculates the ionic currents based on the TP06 cardiac
+ model, updates ion concentrations, and modifies gating variables in
+ the 3D grid. The calculations are performed in parallel to enhance
+ performance.
+
+ Parameters
+ ----------
+ u_new : numpy.ndarray
+ Array to store the updated membrane potential values.
+ u : numpy.ndarray
+ Array of current membrane potential values.
+ cai : numpy.ndarray
+ Array of calcium concentration in the cytosol.
+ casr : numpy.ndarray
+ Array of calcium concentration in the sarcoplasmic reticulum.
+ cass : numpy.ndarray
+ Array of calcium concentration in the submembrane space.
+ nai : numpy.ndarray
+ Array of sodium ion concentration in the intracellular space.
+ ki : numpy.ndarray
+ Array of potassium ion concentration in the intracellular space.
+ m : numpy.ndarray
+ Array of gating variable for sodium channels (activation).
+ h : numpy.ndarray
+ Array of gating variable for sodium channels (inactivation).
+ j_ : numpy.ndarray
+ Array of gating variable for sodium channels (inactivation).
+ xr1 : numpy.ndarray
+ Array of gating variable for rapid delayed rectifier potassium
+ channels.
+ xr2 : numpy.ndarray
+ Array of gating variable for rapid delayed rectifier potassium
+ channels.
+ xs : numpy.ndarray
+ Array of gating variable for slow delayed rectifier potassium channels.
+ r : numpy.ndarray
+ Array of gating variable for ryanodine receptors.
+ s : numpy.ndarray
+ Array of gating variable for calcium-sensitive current.
+ d : numpy.ndarray
+ Array of gating variable for L-type calcium channels.
+ f : numpy.ndarray
+ Array of gating variable for calcium-dependent calcium channels.
+ f2 : numpy.ndarray
+ Array of secondary gating variable for calcium-dependent calcium
+ channels.
+ fcass : numpy.ndarray
+ Array of gating variable for calcium-sensitive current.
+ rr : numpy.ndarray
+ Array of ryanodine receptor gating variable for calcium release.
+ oo : numpy.ndarray
+ Array of ryanodine receptor gating variable for calcium release.
+ indexes : numpy.ndarray
+ Array of indices where the kernel should be computed (``mesh == 1``).
+ dt : float
+ Time step for the simulation.
+
+ Returns
+ -------
+ None
+ The function updates the state variables in place. No return value is
+ produced.
+ """
+ n_j = u.shape[1]
+ n_k = u.shape[2]
+
+ inverseVcF2 = 1./(2*Vc*F)
+ inverseVcF = 1./(Vc*F)
+ inversevssF2 = 1./(2*Vss*F)
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = ii//(n_j*n_k)
+ j = (ii % (n_j*n_k))//n_k
+ k = (ii % (n_j*n_k)) % n_k
+
+ Ek = RTONF*(np.log((ko/Ki[i, j, k])))
+ Ena = RTONF*(np.log((nao/nai[i, j, k])))
+ Eks = RTONF*(np.log((ko+pKNa*nao)/(Ki[i, j, k]+pKNa*nai[i, j, k])))
+ Eca = 0.5*RTONF*(np.log((cao/cai[i, j, k])))
+
+ # Compute currents
+ ina, m[i, j, k], h[i, j, k], j_[i, j, k] = calc_ina(u[i, j, k], dt, m[i, j, k], h[i, j, k], j_[i, j, k], gna, Ena)
+ ical, d[i, j, k], f[i, j, k], f2[i, j, k], fcass[i, j, k] = calc_ical(u[i, j, k], dt, d[i, j, k], f[i, j, k], f2[i, j, k], fcass[i, j, k], cao, cass[i, j, k], gcal, F, R, T)
+ ito, r[i, j, k], s[i, j, k] = calc_ito(u[i, j, k], dt, r[i, j, k], s[i, j, k], Ek, gto)
+ ikr, xr1[i, j, k], xr2[i, j, k] = calc_ikr(u[i, j, k], dt, xr1[i, j, k], xr2[i, j, k], Ek, gkr, ko)
+ iks, xs[i, j, k] = calc_iks(u[i, j, k], dt, xs[i, j, k], Eks, gks)
+ ik1 = calc_ik1(u[i, j, k], Ek, gk1)
+ inaca = calc_inaca(u[i, j, k], nao, nai[i, j, k], cao, cai[i, j, k], KmNai, KmCa, knaca, ksat, n_, F, R, T)
+ inak = calc_inak(u[i, j, k], nai[i, j, k], ko, KmK, KmNa, knak, F, R, T)
+ ipca = calc_ipca(cai[i, j, k], KpCa, gpca)
+ ipk = calc_ipk(u[i, j, k], Ek, gpk)
+ ibna = calc_ibna(u[i, j, k], Ena, gbna)
+ ibca = calc_ibca(u[i, j, k], Eca, gbca)
+ irel, rr[i, j, k], oo[i, j, k] = calc_irel(dt, rr[i, j, k], oo[i, j, k], casr[i, j, k], cass[i, j, k], Vrel, k1_, k2_, k3, k4, maxsr, minsr, EC)
+ ileak = calc_ileak(casr[i, j, k], cai[i, j, k], Vleak)
+ iup = calc_iup(cai[i, j, k], Vmaxup, Kup)
+ ixfer = calc_ixfer(cass[i, j, k], cai[i, j, k], Vxfer)
+
+ # Compute concentrations
+ casr[i, j, k] = calc_casr(dt, casr[i, j, k], Bufsr, Kbufsr, iup, irel, ileak)
+ cass[i, j, k] = calc_cass(dt, cass[i, j, k], Bufss, Kbufss, ixfer, irel, ical, CAPACITANCE, Vc, Vss, Vsr, inversevssF2)
+ cai[i, j, k], cai[i, j, k] = calc_cai(dt, cai[i, j, k], Bufc, Kbufc, ibca, ipca, inaca, iup, ileak, ixfer, CAPACITANCE, Vsr, Vc, inverseVcF2)
+ nai[i, j, k] += calc_nai(dt, ina, ibna, inak, inaca, CAPACITANCE, inverseVcF)
+ Ki[i, j, k] += calc_ki(dt, ik1, ito, ikr, iks, inak, ipk, inverseVcF, CAPACITANCE)
+
+ # Update membrane potential
+ u_new[i, j, k] -= dt * (ikr + iks + ik1 + ito + ina + ibna + ical + ibca + inak + inaca + ipca + ipk)
diff --git a/finitewave/cpuwave3D/model/tp06_3d/__init__.py b/finitewave/cpuwave3D/model/tp06_3d/__init__.py
deleted file mode 100644
index ee44202..0000000
--- a/finitewave/cpuwave3D/model/tp06_3d/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from finitewave.cpuwave3D.model.tp06_3d.tp06_3d import TP063D
diff --git a/finitewave/cpuwave3D/model/tp06_3d/tp06_3d.py b/finitewave/cpuwave3D/model/tp06_3d/tp06_3d.py
deleted file mode 100644
index 04d2129..0000000
--- a/finitewave/cpuwave3D/model/tp06_3d/tp06_3d.py
+++ /dev/null
@@ -1,164 +0,0 @@
-import numpy as np
-from tqdm import tqdm
-
-from finitewave.core.model.cardiac_model import CardiacModel
-from finitewave.cpuwave3D.model.tp06_3d.tp06_kernels_3d import \
- TP06Kernels3D
-
-_npfloat = "float64"
-
-
-class TP063D(CardiacModel):
- """
- A class to represent the TP06 cardiac model in 3D.
-
- Inherits from:
- -----------
- CardiacModel
- Base class for cardiac models.
-
- Attributes
- ----------
- m : np.ndarray
- Array for the gating variable m.
- h : np.ndarray
- Array for the gating variable h.
- j_ : np.ndarray
- Array for the gating variable j_.
- d : np.ndarray
- Array for the gating variable d.
- f : np.ndarray
- Array for the gating variable f.
- x : np.ndarray
- Array for the gating variable x.
- Cai_c : np.ndarray
- Array for the concentration of calcium in the intracellular space.
- model_parameters : dict
- Dictionary to hold model parameters.
- state_vars : list of str
- List of state variable names.
- npfloat : str
- Data type used for floating point operations.
- diffuse_kernel : function
- Function to handle diffusion in the model.
- ionic_kernel : function
- Function to handle ionic currents in the model.
- u : np.ndarray
- Array for membrane potential.
- u_new : np.ndarray
- Array for updated membrane potential.
- Cai : np.ndarray
- Array for calcium concentration in the intracellular space.
- CaSR : np.ndarray
- Array for calcium concentration in the sarcoplasmic reticulum.
- CaSS : np.ndarray
- Array for calcium concentration in the subsarcolemmal space.
- Nai : np.ndarray
- Array for sodium concentration in the intracellular space.
- Ki : np.ndarray
- Array for potassium concentration in the intracellular space.
- M_ : np.ndarray
- Array for gating variable M_.
- H_ : np.ndarray
- Array for gating variable H_.
- J_ : np.ndarray
- Array for gating variable J_.
- Xr1 : np.ndarray
- Array for gating variable Xr1.
- Xr2 : np.ndarray
- Array for gating variable Xr2.
- Xs : np.ndarray
- Array for gating variable Xs.
- R_ : np.ndarray
- Array for gating variable R_.
- S_ : np.ndarray
- Array for gating variable S_.
- D_ : np.ndarray
- Array for gating variable D_.
- F_ : np.ndarray
- Array for gating variable F_.
- F2_ : np.ndarray
- Array for gating variable F2_.
- FCass : np.ndarray
- Array for calcium concentration in the sarcoplasmic reticulum.
- RR : np.ndarray
- Array for calcium release from the sarcoplasmic reticulum.
- OO : np.ndarray
- Array for open states of ryanodine receptors.
-
- Methods
- -------
- initialize():
- Initializes the model's state variables and kernels.
- run_ionic_kernel():
- Executes the ionic kernel function to update ionic currents and state variables.
- """
- def __init__(self):
- """
- Initializes the TP063D cardiac model.
-
- Sets up the arrays for state variables and model parameters.
- """
- CardiacModel.__init__(self)
- self.D_al = 0.154
- self.D_ac = 0.154
- self.m = np.ndarray
- self.h = np.ndarray
- self.j_ = np.ndarray
- self.d = np.ndarray
- self.f = np.ndarray
- self.x = np.ndarray
- self.Cai_c = np.ndarray
- self.model_parameters = {}
- self.state_vars = ["u", "Cai", "CaSR", "CaSS", "Nai", "Ki",
- "M_", "H_", "J_", "Xr1", "Xr2", "Xs", "R_",
- "S_", "D_", "F_", "F2_", "FCass", "RR", "OO"]
- self.npfloat = 'float64'
-
- def initialize(self):
- """
- Initializes the model's state variables and diffusion/ionic kernels.
-
- Sets up the initial values for membrane potential, ion concentrations,
- gating variables, and assigns the appropriate kernel functions.
- """
- super().initialize()
- weights_shape = self.cardiac_tissue.weights.shape
- shape = self.cardiac_tissue.mesh.shape
- self.kernel_diffuse = TP06Kernels3D().get_diffuse_kernel(weights_shape)
- self.kernel_vars = TP06Kernels3D().get_ionic_kernel()
-
- self.u = -84.5*np.ones(shape, dtype=_npfloat)
- self.u_new = self.u.copy()
- self.Cai = 0.00007*np.ones(shape, dtype=_npfloat)
- self.CaSR = 1.3*np.ones(shape, dtype=_npfloat)
- self.CaSS = 0.00007*np.ones(shape, dtype=_npfloat)
- self.Nai = 7.67*np.ones(shape, dtype=_npfloat)
- self.Ki = 138.3*np.ones(shape, dtype=_npfloat)
- self.M_ = np.zeros(shape, dtype=_npfloat)
- self.H_ = 0.75*np.ones(shape, dtype=_npfloat)
- self.J_ = 0.75*np.ones(shape, dtype=_npfloat)
- self.Xr1 = np.zeros(shape, dtype=_npfloat)
- self.Xr2 = np.ones(shape, dtype=_npfloat)
- self.Xs = np.zeros(shape, dtype=_npfloat)
- self.R_ = np.zeros(shape, dtype=_npfloat)
- self.S_ = np.ones(shape, dtype=_npfloat)
- self.D_ = np.zeros(shape, dtype=_npfloat)
- self.F_ = np.ones(shape, dtype=_npfloat)
- self.F2_ = np.ones(shape, dtype=_npfloat)
- self.FCass = np.ones(shape, dtype=_npfloat)
- self.RR = np.ones(shape, dtype=_npfloat)
- self.OO = np.zeros(shape, dtype=_npfloat)
-
- def run_ionic_kernel(self):
- """
- Executes the ionic kernel function to update ionic currents and state variables.
-
- This method calls the `ionic_kernel` function from the TP06Kernels3D class,
- passing in the current state of the model and the time step.
- """
- self.ionic_kernel(self.u_new, self.u, self.Cai, self.CaSR, self.CaSS,
- self.Nai, self.Ki, self.M_, self.H_, self.J_, self.Xr1,
- self.Xr2, self.Xs, self.R_, self.S_, self.D_, self.F_,
- self.F2_, self.FCass, self.RR, self.OO,
- self.cardiac_tissue.mesh, self.dt)
diff --git a/finitewave/cpuwave3D/model/tp06_3d/tp06_kernels_3d.py b/finitewave/cpuwave3D/model/tp06_3d/tp06_kernels_3d.py
deleted file mode 100644
index 9667ce2..0000000
--- a/finitewave/cpuwave3D/model/tp06_3d/tp06_kernels_3d.py
+++ /dev/null
@@ -1,385 +0,0 @@
-from math import log, sqrt, exp
-from numba import njit, prange
-from finitewave.cpuwave3D.model.diffuse_kernels_3d \
- import diffuse_kernel_3d_iso, diffuse_kernel_3d_aniso, _parallel
-from finitewave.core.exception.exceptions import IncorrectWeightsShapeError
-
-
-# tp06 epi kernel
-@njit(parallel=_parallel)
-def ionic_kernel_3d(u_new, u, Cai, CaSR, CaSS, Nai, Ki, M_, H_, J_, Xr1, Xr2,
- Xs, R_, S_, D_, F_, F2_, FCass, RR, OO, mesh, dt):
- """
- Compute the ionic currents and update the state variables for the 3D TP06 cardiac model.
-
- This function calculates the ionic currents based on the TP06 cardiac model, updates ion
- concentrations, and modifies gating variables in the 3D grid. The calculations are performed
- in parallel to enhance performance.
-
- Parameters
- ----------
- u_new : numpy.ndarray
- Array to store the updated membrane potential values.
- u : numpy.ndarray
- Array of current membrane potential values.
- Cai : numpy.ndarray
- Array of calcium concentration in the cytosol.
- CaSR : numpy.ndarray
- Array of calcium concentration in the sarcoplasmic reticulum.
- CaSS : numpy.ndarray
- Array of calcium concentration in the submembrane space.
- Nai : numpy.ndarray
- Array of sodium ion concentration in the intracellular space.
- Ki : numpy.ndarray
- Array of potassium ion concentration in the intracellular space.
- M_ : numpy.ndarray
- Array of gating variable for sodium channels (activation).
- H_ : numpy.ndarray
- Array of gating variable for sodium channels (inactivation).
- J_ : numpy.ndarray
- Array of gating variable for sodium channels (inactivation).
- Xr1 : numpy.ndarray
- Array of gating variable for rapid delayed rectifier potassium channels.
- Xr2 : numpy.ndarray
- Array of gating variable for rapid delayed rectifier potassium channels.
- Xs : numpy.ndarray
- Array of gating variable for slow delayed rectifier potassium channels.
- R_ : numpy.ndarray
- Array of gating variable for ryanodine receptors.
- S_ : numpy.ndarray
- Array of gating variable for calcium-sensitive current.
- D_ : numpy.ndarray
- Array of gating variable for L-type calcium channels.
- F_ : numpy.ndarray
- Array of gating variable for calcium-dependent calcium channels.
- F2_ : numpy.ndarray
- Array of secondary gating variable for calcium-dependent calcium channels.
- FCass : numpy.ndarray
- Array of gating variable for calcium-sensitive current.
- RR : numpy.ndarray
- Array of ryanodine receptor gating variable for calcium release.
- OO : numpy.ndarray
- Array of ryanodine receptor gating variable for calcium release.
- mesh : numpy.ndarray
- Mesh grid indicating tissue areas.
- dt : float
- Time step for the simulation.
-
- Returns
- -------
- None
- The function updates the state variables in place. No return value is produced.
- """
- n_i = u.shape[0]
- n_j = u.shape[1]
- n_k = u.shape[2]
- for ii in prange(n_i*n_j*n_k):
- i = ii//(n_j*n_k)
- j = (ii % (n_j*n_k))//n_k
- k = (ii % (n_j*n_k)) % n_k
- if mesh[i, j, k] != 1:
- continue
-
- # Needed to compute currents
- Ko = 5.4
- Cao = 2.0
- Nao = 140.0
-
- Vc = 0.016404
- Vsr = 0.001094
- Vss = 0.00005468
-
- Bufc = 0.2
- Kbufc = 0.001
- Bufsr = 10.
- Kbufsr = 0.3
- Bufss = 0.4
- Kbufss = 0.00025
-
- Vmaxup = 0.006375
- Kup = 0.00025
- Vrel = 0.102 # 40.8
- k1_ = 0.15
- k2_ = 0.045
- k3 = 0.060
- k4 = 0.005 # 0.000015
- EC = 1.5
- maxsr = 2.5
- minsr = 1.
- Vleak = 0.00036
- Vxfer = 0.0038
-
- R = 8314.472
- F = 96485.3415
- T = 310.0
- RTONF = 26.713760659695648
-
- CAPACITANCE = 0.185
-
- Gkr = 0.153
-
- pKNa = 0.03
-
- GK1 = 5.405
-
- GNa = 14.838
-
- GbNa = 0.00029
-
- KmK = 1.0
- KmNa = 40.0
- knak = 2.724
-
- GCaL = 0.00003980
-
- GbCa = 0.000592
-
- knaca = 1000
- KmNai = 87.5
- KmCa = 1.38
- ksat = 0.1
- n_ = 0.35
-
- GpCa = 0.1238
- KpCa = 0.0005
-
- GpK = 0.0146
-
- Gto = 0.294
- Gks = 0.392
-
- inverseVcF2 = 1./(2*Vc*F)
- inverseVcF = 1./(Vc*F)
- inversevssF2 = 1./(2*Vss*F)
-
- Ek = RTONF*(log((Ko/Ki[i, j, k])))
- Ena = RTONF*(log((Nao/Nai[i, j, k])))
- Eks = RTONF*(log((Ko+pKNa*Nao)/(Ki[i, j, k]+pKNa*Nai[i, j, k])))
- Eca = 0.5*RTONF*(log((Cao/Cai[i, j, k])))
- Ak1 = 0.1/(1.+exp(0.06*(u[i, j, k]-Ek-200)))
- Bk1 = (3.*exp(0.0002*(u[i, j, k]-Ek+100)) +
- exp(0.1*(u[i, j, k]-Ek-10)))/(1.+exp(-0.5*(u[i, j, k]-Ek)))
- rec_iK1 = Ak1/(Ak1+Bk1)
- rec_iNaK = (
- 1./(1.+0.1245*exp(-0.1*u[i, j, k]*F/(R*T))+0.0353*exp(-u[i, j, k]*F/(R*T))))
- rec_ipK = 1./(1.+exp((25-u[i, j, k])/5.98))
-
- # Compute currents
- INa = GNa*M_[i, j, k]*M_[i, j, k]*M_[i, j, k] * \
- H_[i, j, k]*J_[i, j, k]*(u[i, j, k]-Ena)
- ICaL = GCaL*D_[i, j, k]*F_[i, j, k]*F2_[i, j, k]*FCass[i, j, k]*4*(u[i, j, k]-15)*(F*F/(R*T)) *\
- (0.25*exp(2*(u[i, j, k]-15)*F/(R*T))*CaSS[i, j, k] -
- Cao)/(exp(2*(u[i, j, k]-15)*F/(R*T))-1.)
- Ito = Gto*R_[i, j, k]*S_[i, j, k]*(u[i, j, k]-Ek)
- IKr = Gkr*sqrt(Ko/5.4)*Xr1[i, j, k]*Xr2[i, j, k]*(u[i, j, k]-Ek)
- IKs = Gks*Xs[i, j, k]*Xs[i, j, k]*(u[i, j, k]-Eks)
- IK1 = GK1*rec_iK1*(u[i, j, k]-Ek)
- INaCa = knaca*(1./(KmNai*KmNai*KmNai+Nao*Nao*Nao))*(1./(KmCa+Cao)) *\
- (1./(1+ksat*exp((n_-1)*u[i, j, k]*F/(R*T)))) *\
- (exp(n_*u[i, j, k]*F/(R*T))*Nai[i, j, k]*Nai[i, j, k]*Nai[i, j, k]*Cao -
- exp((n_-1)*u[i, j, k]*F/(R*T))*Nao*Nao*Nao*Cai[i, j, k]*2.5)
- INaK = knak*(Ko/(Ko+KmK))*(Nai[i, j, k]/(Nai[i, j, k]+KmNa))*rec_iNaK
- IpCa = GpCa*Cai[i, j, k]/(KpCa+Cai[i, j, k])
- IpK = GpK*rec_ipK*(u[i, j, k]-Ek)
- IbNa = GbNa*(u[i, j, k]-Ena)
- IbCa = GbCa*(u[i, j, k]-Eca)
-
- # Determine total current
- u_new[i, j, k] -= dt * (IKr + IKs + IK1 + Ito + INa +
- IbNa + ICaL + IbCa + INaK + INaCa + IpCa + IpK)
-
- # update concentrations
- kCaSR = maxsr-((maxsr-minsr)/(1+(EC/CaSR[i, j, k])*(EC/CaSR[i, j, k])))
- k1 = k1_/kCaSR
- k2 = k2_*kCaSR
- dRR = k4*(1-RR[i, j, k])-k2*CaSS[i, j, k]*RR[i, j, k]
- RR[i, j, k] += dt*dRR
- OO[i, j, k] = k1*CaSS[i, j, k]*CaSS[i, j, k] * \
- RR[i, j, k]/(k3+k1*CaSS[i, j, k]*CaSS[i, j, k])
-
- Irel = Vrel*OO[i, j, k]*(CaSR[i, j, k]-CaSS[i, j, k])
- Ileak = Vleak*(CaSR[i, j, k]-Cai[i, j, k])
- Iup = Vmaxup/(1.+((Kup*Kup)/(Cai[i, j, k]*Cai[i, j, k])))
- Ixfer = Vxfer*(CaSS[i, j, k]-Cai[i, j, k])
-
- CaCSQN = Bufsr*CaSR[i, j, k]/(CaSR[i, j, k]+Kbufsr)
- dCaSR = dt*(Iup-Irel-Ileak)
- bjsr = Bufsr-CaCSQN-dCaSR-CaSR[i, j, k]+Kbufsr
- cjsr = Kbufsr*(CaCSQN+dCaSR+CaSR[i, j, k])
- CaSR[i, j, k] = (sqrt(bjsr*bjsr+4*cjsr)-bjsr)/2
-
- CaSSBuf = Bufss*CaSS[i, j, k]/(CaSS[i, j, k]+Kbufss)
- dCaSS = dt*(-Ixfer*(Vc/Vss)+Irel*(Vsr/Vss) +
- (-ICaL*inversevssF2*CAPACITANCE))
- bcss = Bufss-CaSSBuf-dCaSS-CaSS[i, j, k]+Kbufss
- ccss = Kbufss*(CaSSBuf+dCaSS+CaSS[i, j, k])
- CaSS[i, j, k] = (sqrt(bcss*bcss+4*ccss)-bcss)/2
-
- CaBuf = Bufc*Cai[i, j, k]/(Cai[i, j, k]+Kbufc)
- dCai = dt*((-(IbCa+IpCa-2*INaCa)*inverseVcF2*CAPACITANCE) -
- (Iup-Ileak)*(Vsr/Vc)+Ixfer)
- bc = Bufc-CaBuf-dCai-Cai[i, j, k]+Kbufc
- cc = Kbufc*(CaBuf+dCai+Cai[i, j, k])
- Cai[i, j, k] = (sqrt(bc*bc+4*cc)-bc)/2
-
- dNai = -(INa+IbNa+3*INaK+3*INaCa)*inverseVcF*CAPACITANCE
- Nai[i, j, k] += dt*dNai
-
- dKi = -(IK1+Ito+IKr+IKs-2*INaK+IpK)*inverseVcF*CAPACITANCE
- Ki[i, j, k] += dt*dKi
-
- # compute steady state values and time constants
- AM = 1./(1.+exp((-60.-u[i, j, k])/5.))
- BM = 0.1/(1.+exp((u[i, j, k]+35.)/5.)) + \
- 0.10/(1.+exp((u[i, j, k]-50.)/200.))
- TAU_M = AM*BM
- M_INF = 1./((1.+exp((-56.86-u[i, j, k])/9.03))
- * (1.+exp((-56.86-u[i, j, k])/9.03)))
-
- AH_ = 0.
- BH_ = 0.
- if u[i, j, k] >= -40.:
- AH_ = 0.
- BH_ = 0.77/(0.13*(1.+exp(-(u[i, j, k]+10.66)/11.1)))
- else:
- AH_ = 0.057*exp(-(u[i, j, k]+80.)/6.8)
- BH_ = 2.7*exp(0.079*u[i, j, k])+(3.1e5)*exp(0.3485*u[i, j, k])
-
- TAU_H = 1.0/(AH_ + BH_)
-
- H_INF = 1./((1.+exp((u[i, j, k]+71.55)/7.43))
- * (1.+exp((u[i, j, k]+71.55)/7.43)))
-
- AJ_ = 0.
- BJ_ = 0.
- if u[i, j, k] >= -40.:
- AJ_ = 0.
- BJ_ = 0.6*exp((0.057)*u[i, j, k])/(1.+exp(-0.1*(u[i, j, k]+32.)))
- else:
- AJ_ = ((-2.5428e4)*exp(0.2444*u[i, j, k])-(6.948e-6) *
- exp(-0.04391*u[i, j, k]))*(u[i, j, k]+37.78) /\
- (1.+exp(0.311*(u[i, j, k]+79.23)))
- BJ_ = 0.02424*exp(-0.01052*u[i, j, k]) / \
- (1.+exp(-0.1378*(u[i, j, k]+40.14)))
-
- TAU_J = 1.0/(AJ_ + BJ_)
-
- J_INF = H_INF
-
- Xr1_INF = 1./(1.+exp((-26.-u[i, j, k])/7.))
- axr1 = 450./(1.+exp((-45.-u[i, j, k])/10.))
- bxr1 = 6./(1.+exp((u[i, j, k]-(-30.))/11.5))
- TAU_Xr1 = axr1*bxr1
- Xr2_INF = 1./(1.+exp((u[i, j, k]-(-88.))/24.))
- axr2 = 3./(1.+exp((-60.-u[i, j, k])/20.))
- bxr2 = 1.12/(1.+exp((u[i, j, k]-60.)/20.))
- TAU_Xr2 = axr2*bxr2
-
- Xs_INF = 1./(1.+exp((-5.-u[i, j, k])/14.))
- Axs = (1400./(sqrt(1.+exp((5.-u[i, j, k])/6))))
- Bxs = (1./(1.+exp((u[i, j, k]-35.)/15.)))
- TAU_Xs = Axs*Bxs+80
-
- R_INF = 0
- S_INF = 0
- TAU_R = 0
- TAU_S = 0
-
- R_INF = 1./(1.+exp((20-u[i, j, k])/6.))
- S_INF = 1./(1.+exp((u[i, j, k]+20)/5.))
- TAU_R = 9.5*exp(-(u[i, j, k]+40.)*(u[i, j, k]+40.)/1800.)+0.8
- TAU_S = 85.*exp(-(u[i, j, k]+45.)*(u[i, j, k]+45.) /
- 320.)+5./(1.+exp((u[i, j, k]-20.)/5.))+3.
-
- D_INF = 1./(1.+exp((-8-u[i, j, k])/7.5))
- Ad = 1.4/(1.+exp((-35-u[i, j, k])/13))+0.25
- Bd = 1.4/(1.+exp((u[i, j, k]+5)/5))
- Cd = 1./(1.+exp((50-u[i, j, k])/20))
- TAU_D = Ad*Bd+Cd
- F_INF = 1./(1.+exp((u[i, j, k]+20)/7))
- Af = 1102.5*exp(-(u[i, j, k]+27)*(u[i, j, k]+27)/225)
- Bf = 200./(1+exp((13-u[i, j, k])/10.))
- Cf = (180./(1+exp((u[i, j, k]+30)/10)))+20
- TAU_F = Af+Bf+Cf
- F2_INF = 0.67/(1.+exp((u[i, j, k]+35)/7))+0.33
- Af2 = 600*exp(-(u[i, j, k]+25)*(u[i, j, k]+25)/170)
- Bf2 = 31/(1.+exp((25-u[i, j, k])/10))
- Cf2 = 16/(1.+exp((u[i, j, k]+30)/10))
- TAU_F2 = Af2+Bf2+Cf2
- FCaSS_INF = 0.6/(1+(CaSS[i, j, k]/0.05)*(CaSS[i, j, k]/0.05))+0.4
- TAU_FCaSS = 80./(1+(CaSS[i, j, k]/0.05)*(CaSS[i, j, k]/0.05))+2.
-
- # Update gates
- M_[i, j, k] = M_INF-(M_INF-M_[i, j, k])*exp(-dt/TAU_M)
- H_[i, j, k] = H_INF-(H_INF-H_[i, j, k])*exp(-dt/TAU_H)
- J_[i, j, k] = J_INF-(J_INF-J_[i, j, k])*exp(-dt/TAU_J)
- Xr1[i, j, k] = Xr1_INF-(Xr1_INF-Xr1[i, j, k])*exp(-dt/TAU_Xr1)
- Xr2[i, j, k] = Xr2_INF-(Xr2_INF-Xr2[i, j, k])*exp(-dt/TAU_Xr2)
- Xs[i, j, k] = Xs_INF-(Xs_INF-Xs[i, j, k])*exp(-dt/TAU_Xs)
- S_[i, j, k] = S_INF-(S_INF-S_[i, j, k])*exp(-dt/TAU_S)
- R_[i, j, k] = R_INF-(R_INF-R_[i, j, k])*exp(-dt/TAU_R)
- D_[i, j, k] = D_INF-(D_INF-D_[i, j, k])*exp(-dt/TAU_D)
- F_[i, j, k] = F_INF-(F_INF-F_[i, j, k])*exp(-dt/TAU_F)
- F2_[i, j, k] = F2_INF-(F2_INF-F2_[i, j, k])*exp(-dt/TAU_F2)
- FCass[i, j, k] = FCaSS_INF-(FCaSS_INF-FCass[i, j, k])*exp(-dt/TAU_FCaSS)
-
-
-class TP06Kernels3D:
- """
- A class to manage the kernel functions for the TP06 cardiac model in 3D.
-
- Attributes
- ----------
- None
-
- Methods
- -------
- get_diffuse_kernel(shape):
- Returns the appropriate diffusion kernel function based on the shape of the weights.
- get_ionic_kernel():
- Returns the ionic kernel function for the TP06 model.
- """
- def __init__(self):
- """
- Initializes the TP06Kernels3D class.
- """
- pass
-
- @staticmethod
- def get_diffuse_kernel(shape):
- """
- Returns the diffusion kernel function based on the shape of the weights.
-
- Parameters
- ----------
- shape : tuple
- The shape of the weights array.
-
- Returns
- -------
- function
- The diffusion kernel function suitable for the given weight shape.
-
- Raises
- ------
- IncorrectWeightsShapeError
- If the shape of the weights does not match expected values (7 or 19).
- """
- if shape[-1] == 7:
- return diffuse_kernel_3d_iso
- if shape[-1] == 19:
- return diffuse_kernel_3d_aniso
- else:
- raise IncorrectWeightsShapeError(shape, 7, 19)
-
- @staticmethod
- def get_ionic_kernel():
- """
- Returns the ionic kernel function for the TP06 cardiac model.
-
- Returns
- -------
- function
- The ionic kernel function for the TP06 model.
- """
- return ionic_kernel_3d
diff --git a/finitewave/cpuwave3D/stencil/asymmetric_stencil_3d.py b/finitewave/cpuwave3D/stencil/asymmetric_stencil_3d.py
index 2261029..f215703 100644
--- a/finitewave/cpuwave3D/stencil/asymmetric_stencil_3d.py
+++ b/finitewave/cpuwave3D/stencil/asymmetric_stencil_3d.py
@@ -1,52 +1,202 @@
import numpy as np
from numba import njit, prange
-from finitewave.core.stencil.stencil import Stencil
+from finitewave.cpuwave2D.stencil.asymmetric_stencil_2d import (
+ AsymmetricStencil2D,
+ major_component,
+ minor_component
+)
-@njit
-def coeffs(d, m, m0, m1, m2, m3):
+class AsymmetricStencil3D(AsymmetricStencil2D):
+ """
+ This class computes the weights for diffusion on a 3D using an asymmetric
+ stencil. The weights are calculated based on the diffusion coefficients
+ and the fibers orientations. The stencil includes 19 points: the central
+ point and the 18 neighbors. The boundary conditions are Neumann with first-
+ order approximation.
+
+ Notes
+ -----
+ The diffusion coefficients are general and should be adjusted according to
+ the specific model. The parameters ``D_ac``, ``D_al`` only set the ratios
+ between longitudinal and cross-sectional diffusion.
+
+ The method assumes weights being used in the following order:
+ ``w[i, j, k, 0] : (i-1, j-1, k)``,
+ ``w[i, j, k, 1] : (i-1, j, k)``,
+ ``w[i, j, k, 2] : (i-1, j+1, k)``,
+ ``w[i, j, k, 3] : (i, j-1, k)``,
+ ``w[i, j, k, 4] : (i, j, k)``,
+ ``w[i, j, k, 5] : (i, j+1, k)``,
+ ``w[i, j, k, 6] : (i+1, j-1, k)``,
+ ``w[i, j, k, 7] : (i+1, j, k)``,
+ ``w[i, j, k, 8] : (i+1, j+1, k)``,
+ ``w[i, j, k, 9] : (i, j-1, k-1)``,
+ ``w[i, j, k, 10] : (i, j-1, k+1)``,
+ ``w[i, j, k, 11] : (i, j, k-1)``,
+ ``w[i, j, k, 12] : (i, j, k+1)``,
+ ``w[i, j, k, 13] : (i, j+1, k-1)``,
+ ``w[i, j, k, 14] : (i, j+1, k+1)``,
+ ``w[i, j, k, 15] : (i-1, j, k-1)``,
+ ``w[i, j, k, 16] : (i+1, j, k-1)``,
+ ``w[i, j, k, 17] : (i-1, j, k+1)``,
+ ``w[i, j, k, 18] : (i+1, j, k+1)``.
+ """
+
+ def __init__(self):
+ super().__init__()
+
+ def select_diffusion_kernel(self):
+ """
+ Selects the diffusion kernel for 3D diffusion.
+
+ Returns
+ -------
+ function
+ The diffusion kernel for 3D diffusion.
+ """
+ return diffusion_kernel_3d_aniso
+
+ def compute_weights(self, model, cardiac_tissue):
+ """
+ Computes the weights for diffusion on a 3D mesh using an asymmetric
+ stencil.
+
+ Parameters
+ ----------
+ model : CardiacModel3D
+ A model object containing the simulation parameters.
+ cardiac_tissue : CardiacTissue3D
+ A 3D cardiac tissue object.
+
+ Returns
+ -------
+ np.ndarray
+ Array of weights for diffusion, with the shape of (*mesh.shape, 19)
+ """
+ mesh = cardiac_tissue.mesh.copy()
+ mesh[mesh != 1] = 0
+ conductivity = cardiac_tissue.conductivity
+ conductivity = conductivity * np.ones_like(mesh, dtype=model.npfloat)
+
+ fibers = cardiac_tissue.fibers
+
+ if fibers is None:
+ message = "Fibers must be provided for anisotropic diffusion."
+ raise ValueError(message)
+
+ d_xx, d_xy, d_xz = self.compute_half_step_diffusion(mesh, conductivity,
+ fibers, 0,
+ num_axes=3)
+ d_yx, d_yy, d_yz = self.compute_half_step_diffusion(mesh, conductivity,
+ fibers, 1,
+ num_axes=3)
+ d_zx, d_zy, d_zz = self.compute_half_step_diffusion(mesh, conductivity,
+ fibers, 2,
+ num_axes=3)
+
+ weights = np.zeros((*mesh.shape, 19), dtype=model.npfloat)
+ weights = compute_weights(weights, mesh, d_xx, d_xy, d_xz, d_yx, d_yy,
+ d_yz, d_zx, d_zy, d_zz)
+
+ weights = weights * model.D_model * model.dt / model.dr**2
+ weights[:, :, :, 4] += 1
+ return weights
+
+
+@njit(parallel=True)
+def diffusion_kernel_3d_aniso(u_new, u, w, indexes):
"""
- Computes the coefficients used in the weight calculations.
+ Performs anisotropic diffusion on a 3D grid.
Parameters
----------
- m0 : float
- Mesh value at position (i-1, j-1).
- m1 : float
- Mesh value at position (i-1, j+1).
- m2 : float
- Mesh value at position (i, j-1).
- m3 : float
- Mesh value at position (i, j+1).
+ u_new : numpy.ndarray
+ A 3D array to store the updated potential values after diffusion.
+
+ u : numpy.ndarray
+ A 3D array representing the current potential values before diffusion.
+
+ w : numpy.ndarray
+ Array of weights for diffusion, with the shape of (*mesh.shape, 19).
+
+ mesh : numpy.ndarray
+ Array representing the mesh of the tissue.
Returns
-------
- float
- Computed coefficient based on input values.
+ np.ndarray
+ The updated potential values after diffusion.
"""
- return 0.5 * d * m * m0 * m1 / (1 + m0 * m1 * m2 * m3)
+ n_j = u.shape[1]
+ n_k = u.shape[2]
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = ii//(n_j*n_k)
+ j = (ii % (n_j*n_k))//n_k
+ k = (ii % (n_j*n_k)) % n_k
+
+ u_new[i, j, k] = (u[i-1, j-1, k] * w[i, j, k, 0] +
+ u[i-1, j, k] * w[i, j, k, 1] +
+ u[i-1, j+1, k] * w[i, j, k, 2] +
+ u[i, j-1, k] * w[i, j, k, 3] +
+ u[i, j, k] * w[i, j, k, 4] +
+ u[i, j+1, k] * w[i, j, k, 5] +
+ u[i+1, j-1, k] * w[i, j, k, 6] +
+ u[i+1, j, k] * w[i, j, k, 7] +
+ u[i+1, j+1, k] * w[i, j, k, 8] +
+ u[i, j-1, k-1] * w[i, j, k, 9] +
+ u[i, j-1, k+1] * w[i, j, k, 10] +
+ u[i, j, k-1] * w[i, j, k, 11] +
+ u[i, j, k+1] * w[i, j, k, 12] +
+ u[i, j+1, k-1] * w[i, j, k, 13] +
+ u[i, j+1, k+1] * w[i, j, k, 14] +
+ u[i-1, j, k-1] * w[i, j, k, 15] +
+ u[i+1, j, k-1] * w[i, j, k, 16] +
+ u[i-1, j, k+1] * w[i, j, k, 17] +
+ u[i+1, j, k+1] * w[i, j, k, 18])
+ return u_new
@njit
-def compute_weights(w, m, d_x, d_xy, d_xz, d_y, d_yx, d_yz, d_z, d_zx, d_zy):
+def compute_weights(w, m, d_xx, d_xy, d_xz, d_yx, d_yy, d_yz, d_zx, d_zy,
+ d_zz):
"""
- Computes the weights for diffusion on a 3D mesh based on asymmetric stencil.
+ Computes the weights for diffusion on a 3D mesh using an asymmetric
+ stencil.
Parameters
----------
w : np.ndarray
- 4D array to store the computed weights. Shape is (mesh.shape[0], mesh.shape[1], 19).
+ 4D array of weights for diffusion, with the shape of (*mesh.shape, 19).
m : np.ndarray
3D array representing the mesh grid of the tissue.
- d_x : np.ndarray
- 3D array with diffusion coefficients along the x-direction.
+ Non-tissue areas are set to 0.
+ d_xx : np.ndarray
+ 3D array of half-step diffusion x-components in the x-direction.
d_xy : np.ndarray
- 3D array with diffusion coefficients for cross-terms in x and y directions.
- d_y : np.ndarray
- 3D array with diffusion coefficients along the y-direction.
+ 3D array of half-step diffusion y-components in the x-direction.
+ d_xz : np.ndarray
+ 3D array of half-step diffusion z-components in the x-direction.
d_yx : np.ndarray
- 3D array with diffusion coefficients for cross-terms in y and x directions.
+ 3D array of half-step diffusion x-components in the y-direction.
+ d_yy : np.ndarray
+ 3D array of half-step diffusion y-components in the y-direction.
+ d_yz : np.ndarray
+ 3D array of half-step diffusion z-components in the y-direction.
+ d_zx : np.ndarray
+ 3D array of half-step diffusion x-components in the z-direction.
+ d_zy : np.ndarray
+ 3D array of half-step diffusion y-components in the z-direction.
+ d_zz : np.ndarray
+ 3D array of half-step diffusion z-components in the z-direction.
+
+ Returns
+ -------
+ np.ndarray
+ 4D array of weights for diffusion, with the shape of (*mesh.shape, 9).
"""
n_i = m.shape[0]
n_j = m.shape[1]
@@ -55,275 +205,254 @@ def compute_weights(w, m, d_x, d_xy, d_xz, d_y, d_yx, d_yz, d_z, d_zx, d_zy):
i = ii//(n_j*n_k)
j = (ii % (n_j*n_k))//n_k
k = (ii % (n_j*n_k)) % n_k
+
if m[i, j, k] != 1:
continue
- w[i, j, k, 0] = (coeffs(d_xy[i-1, j, k], m[i-1, j, k], m[i-1, j-1, k],
- m[i-1, j+1, k], m[i, j-1, k], m[i, j+1, k]) +
- coeffs(d_yx[i, j-1, k], m[i, j-1, k], m[i-1, j-1, k],
- m[i+1, j-1, k], m[i-1, j, k], m[i+1, j, k]))
-
- w[i, j, k, 1] = (coeffs(d_xz[i-1, j, k], m[i-1, j, k], m[i-1, j, k-1],
- m[i-1, j, k+1], m[i, j, k-1], m[i, j, k+1]) +
- coeffs(d_zx[i, j, k-1], m[i, j, k-1], m[i-1, j, k-1],
- m[i+1, j, k-1], m[i-1, j, k], m[i+1, j, k]))
-
- w[i, j, k, 2] = (d_x[i-1, j, k] * m[i-1, j, k] +
- coeffs(d_yx[i, j-1, k], m[i, j-1, k], m[i-1, j, k],
- m[i+1, j, k], m[i-1, j-1, k], m[i+1, j-1, k]) +
- coeffs(-d_yx[i, j, k], m[i, j+1, k], m[i-1, j, k],
- m[i+1, j, k], m[i-1, j+1, k], m[i+1, j+1, k]) +
- coeffs(d_zx[i, j, k-1], m[i, j, k-1], m[i-1, j, k],
- m[i+1, j, k], m[i-1, j, k-1], m[i+1, j, k-1]) +
- coeffs(-d_zx[i, j, k], m[i, j, k+1], m[i-1, j, k],
- m[i+1, j, k], m[i-1, j, k+1], m[i+1, j, k+1]))
-
- w[i, j, k, 3] = (coeffs(-d_xz[i-1, j, k], m[i-1, j, k], m[i-1, j, k-1],
- m[i-1, j, k+1], m[i, j, k-1], m[i, j, k+1]) +
- coeffs(-d_zx[i, j, k], m[i, j, k+1], m[i-1, j, k+1],
- m[i+1, j, k+1], m[i-1, j, k], m[i+1, j, k]))
-
- w[i, j, k, 4] = (coeffs(-d_xy[i-1, j, k], m[i-1, j, k], m[i-1, j-1, k],
- m[i-1, j+1, k], m[i, j-1, k], m[i, j+1, k]) +
- coeffs(-d_yx[i, j, k], m[i, j+1, k], m[i-1, j+1, k],
- m[i+1, j+1, k], m[i-1, j, k], m[i+1, j, k]))
-
- w[i, j, k, 5] = (coeffs(d_yz[i, j-1, k], m[i, j-1, k], m[i, j-1, k-1],
- m[i, j-1, k+1], m[i, j, k-1], m[i, j, k+1]) +
- coeffs(d_zy[i, j, k-1], m[i, j, k-1], m[i, j-1, k-1],
- m[i, j+1, k-1], m[i, j-1, k], m[i, j+1, k]))
-
- w[i, j, k, 6] = (d_y[i, j-1, k] * m[i, j-1, k] +
- coeffs(d_xy[i-1, j, k], m[i-1, j, k], m[i, j-1, k],
- m[i, j+1, k], m[i-1, j-1, k], m[i-1, j+1, k]) +
- coeffs(-d_xy[i, j, k], m[i+1, j, k], m[i, j-1, k],
- m[i, j+1, k], m[i+1, j-1, k], m[i+1, j+1, k]) +
- coeffs(d_zy[i, j, k-1], m[i, j, k-1], m[i, j-1, k],
- m[i, j+1, k], m[i, j-1, k-1], m[i, j+1, k-1]) +
- coeffs(-d_zy[i, j, k], m[i, j, k+1], m[i, j-1, k],
- m[i, j+1, k], m[i, j-1, k+1], m[i, j+1, k+1]))
-
- w[i, j, k, 7] = (coeffs(-d_yz[i, j-1, k], m[i, j-1, k], m[i, j-1, k-1],
- m[i, j-1, k+1], m[i, j, k-1], m[i, j, k+1]) +
- coeffs(-d_zy[i, j, k], m[i, j, k+1], m[i, j-1, k+1],
- m[i, j+1, k+1], m[i, j-1, k], m[i, j+1, k]))
-
- w[i, j, k, 8] = (d_z[i, j, k-1] * m[i, j, k-1] +
- coeffs(d_yz[i, j-1, k], m[i, j-1, k], m[i, j, k-1],
- m[i, j, k+1], m[i, j-1, k-1], m[i, j-1, k+1]) +
- coeffs(-d_yz[i, j, k], m[i, j+1, k], m[i, j, k-1],
- m[i, j, k+1], m[i, j+1, k-1], m[i, j+1, k+1]) +
- coeffs(d_xz[i-1, j, k], m[i-1, j, k], m[i, j, k-1],
- m[i, j, k+1], m[i-1, j, k-1], m[i-1, j, k+1]) +
- coeffs(-d_xz[i, j, k], m[i+1, j, k], m[i, j, k-1],
- m[i, j, k+1], m[i+1, j, k-1], m[i+1, j, k+1]))
-
- w[i, j, k, 9] = - (m[i-1, j, k] * d_x[i-1, j, k] +
- m[i+1, j, k] * d_x[i, j, k] +
- m[i, j-1, k] * d_y[i, j-1, k] +
- m[i, j+1, k] * d_y[i, j, k] +
- m[i, j, k-1] * d_z[i, j, k-1] +
- m[i, j, k+1] * d_z[i, j, k])
-
- w[i, j, k, 10] = (d_z[i, j, k] * m[i, j, k+1] +
- coeffs(-d_xz[i-1, j, k], m[i-1, j, k], m[i, j, k-1],
- m[i, j, k+1], m[i-1, j, k-1], m[i-1, j, k+1]) +
- coeffs(d_xz[i, j, k], m[i+1, j, k], m[i, j, k-1],
- m[i, j, k+1], m[i+1, j, k-1], m[i+1, j, k+1]) +
- coeffs(-d_yz[i, j-1, k], m[i, j-1, k], m[i, j, k-1],
- m[i, j, k+1], m[i, j-1, k-1], m[i, j-1, k+1]) +
- coeffs(d_yz[i, j, k], m[i, j+1, k], m[i, j, k-1],
- m[i, j, k+1], m[i, j+1, k-1], m[i, j+1, k+1]))
-
- w[i, j, k, 11] = (coeffs(-d_yz[i, j, k], m[i, j+1, k], m[i, j+1, k-1],
- m[i, j+1, k+1], m[i, j, k-1], m[i, j, k+1]) +
- coeffs(-d_zy[i, j, k-1], m[i, j, k-1], m[i, j-1, k-1],
- m[i, j+1, k-1], m[i, j-1, k], m[i, j+1, k]))
-
- w[i, j, k, 12] = (d_y[i, j, k] * m[i, j+1, k] +
- coeffs(-d_xy[i-1, j, k], m[i-1, j, k], m[i, j-1, k],
- m[i, j+1, k], m[i-1, j-1, k], m[i-1, j+1, k]) +
- coeffs(d_xy[i, j, k], m[i+1, j, k], m[i, j-1, k],
- m[i, j+1, k], m[i+1, j-1, k], m[i+1, j+1, k]) +
- coeffs(-d_zy[i, j, k-1], m[i, j, k-1], m[i, j-1, k],
- m[i, j+1, k], m[i, j-1, k-1], m[i, j+1, k-1]) +
- coeffs(d_zy[i, j, k], m[i, j, k+1], m[i, j-1, k],
- m[i, j+1, k], m[i, j-1, k+1], m[i, j+1, k+1]))
-
- w[i, j, k, 13] = (coeffs(d_yz[i, j, k], m[i, j+1, k], m[i, j+1, k-1],
- m[i, j+1, k+1], m[i, j, k-1], m[i, j, k+1]) +
- coeffs(d_zy[i, j, k], m[i, j, k+1], m[i, j-1, k+1],
- m[i, j+1, k+1], m[i, j-1, k], m[i, j+1, k]))
-
- w[i, j, k, 14] = (coeffs(-d_xy[i, j, k], m[i+1, j, k], m[i+1, j-1, k],
- m[i+1, j+1, k], m[i, j-1, k], m[i, j+1, k]) +
- coeffs(-d_yx[i, j-1, k], m[i, j-1, k], m[i-1, j-1, k],
- m[i+1, j-1, k], m[i-1, j, k], m[i+1, j, k]))
-
- w[i, j, k, 15] = (coeffs(-d_xz[i, j, k], m[i+1, j, k], m[i+1, j, k-1],
- m[i+1, j, k+1], m[i, j, k-1], m[i, j, k+1]) +
- coeffs(-d_zx[i, j, k-1], m[i, j, k-1], m[i-1, j, k-1],
- m[i+1, j, k-1], m[i-1, j, k], m[i+1, j, k]))
-
- w[i, j, k, 16] = (d_x[i, j, k] * m[i+1, j, k] +
- coeffs(-d_yx[i, j-1, k], m[i, j-1, k], m[i-1, j, k],
- m[i+1, j, k], m[i-1, j-1, k], m[i+1, j-1, k]) +
- coeffs(d_yx[i, j, k], m[i, j+1, k], m[i-1, j, k],
- m[i+1, j, k], m[i-1, j+1, k], m[i+1, j+1, k]) +
- coeffs(-d_zx[i, j, k-1], m[i, j, k-1], m[i-1, j, k],
- m[i+1, j, k], m[i-1, j, k-1], m[i+1, j, k-1]) +
- coeffs(d_zx[i, j, k], m[i, j, k+1], m[i-1, j, k],
- m[i+1, j, k], m[i-1, j, k+1], m[i+1, j, k+1]))
-
- w[i, j, k, 17] = (coeffs(d_xz[i, j, k], m[i+1, j, k], m[i+1, j, k-1],
- m[i+1, j, k+1], m[i, j, k-1], m[i, j, k+1]) +
- coeffs(d_zx[i, j, k], m[i, j, k+1], m[i-1, j, k+1],
- m[i+1, j, k+1], m[i-1, j, k], m[i+1, j, k]))
-
- w[i, j, k, 18] = (coeffs(d_xy[i, j, k], m[i+1, j, k], m[i+1, j-1, k],
- m[i+1, j+1, k], m[i, j-1, k], m[i, j+1, k]) +
- coeffs(d_yx[i, j, k], m[i, j+1, k], m[i-1, j+1, k],
- m[i+1, j+1, k], m[i-1, j, k], m[i+1, j, k]))
-
-
-class AsymmetricStencil3D(Stencil):
- """
- A class to represent a 3D asymmetric stencil for diffusion processes.
-
- Inherits from:
- -----------
- Stencil
- Base class for different stencils used in diffusion calculations.
-
- Methods
- -------
- get_weights(mesh, conductivity, fibers, D_al, D_ac, dt, dr):
- Computes the weights for diffusion based on the asymmetric stencil.
- """
- def __init__(self):
- """
- Initializes the AsymmetricStencil3D with default settings.
- """
- Stencil.__init__(self)
-
- def get_weights(self, mesh, conductivity, fibers, D_al, D_ac, dt, dr):
- """
- Computes the weights for diffusion on a 3D mesh using an asymmetric stencil.
-
- Parameters
- ----------
- mesh : np.ndarray
- 3D array representing the mesh grid of the tissue. Non-tissue areas are set to 0.
- conductivity : float
- Conductivity of the tissue, which scales the diffusion coefficient.
- fibers : np.ndarray
- Array representing fiber orientations. Used to compute directional diffusion coefficients.
- D_al : float
- Longitudinal diffusion coefficient.
- D_ac : float
- Cross-sectional diffusion coefficient.
- dt : float
- Temporal resolution.
- dr : float
- Spatial resolution.
-
- Returns
- -------
- np.ndarray
- 4D array of weights for diffusion, with the shape of (mesh.shape[0], mesh.shape[1], 9).
-
- Notes
- -----
- The method assumes asymmetric diffusion where different coefficients are used for different directions.
- The weights are computed for eight surrounding directions and the central weight, based on the asymmetric stencil.
- Heterogeneity in the diffusion coefficients is handled by adjusting the weights based on fiber orientations.
- """
- mesh = mesh.copy()
- mesh[mesh != 1] = 0
- fibers[np.where(mesh != 1)] = 0
- weights = np.zeros((*mesh.shape, 19), dtype='float32')
-
- def axis_fibers(fibers, ind):
- """
- Computes fiber directions for a given axis.
-
- Parameters
- ----------
- fibers : np.ndarray
- Array representing fiber orientations.
- ind : int
- Axis index (0 for x, 1 for y).
-
- Returns
- -------
- np.ndarray
- Normalized fiber directions along the specified axis.
- """
- fibr = fibers + np.roll(fibers, 1, axis=ind)
- norm = np.linalg.norm(fibr, axis=3)
- np.divide(fibr, norm[:, :, :, np.newaxis], out=fibr,
- where=norm[:, :, :, np.newaxis] != 0)
- return fibr
-
- def major_diffuse(fibers, ind):
- """
- Computes the major diffusion term based on fiber orientations.
-
- Parameters
- ----------
- fibers : np.ndarray
- Array representing fiber orientations.
- ind : int
- Axis index (0 for x, 1 for y).
-
- Returns
- -------
- np.ndarray
- Array of major diffusion coefficients.
- """
- return ((D_ac + (D_al - D_ac) * fibers[:, :, :, ind]**2) *
- conductivity)
-
- def minor_diffuse(fibers, ind1, ind2):
- """
- Computes the minor diffusion term based on fiber orientations.
-
- Parameters
- ----------
- fibers : np.ndarray
- Array representing fiber orientations.
- ind1 : int
- First axis index (0 for x, 1 for y).
- ind2 : int
- Second axis index (0 for x, 1 for y).
-
- Returns
- -------
- np.ndarray
- Array of minor diffusion coefficients.
- """
- return (0.5 * (D_al - D_ac) * fibers[:, :, :, ind1] *
- fibers[:, :, :, ind2] * conductivity)
-
- fibers_x = axis_fibers(fibers, 0)
- diffuse_x = major_diffuse(fibers_x, 0)
- diffuse_xy = minor_diffuse(fibers_x, 0, 1)
- diffuse_xz = minor_diffuse(fibers_x, 0, 2)
-
- fibers_y = axis_fibers(fibers, 1)
- diffuse_y = major_diffuse(fibers_y, 1)
- diffuse_yx = minor_diffuse(fibers_y, 1, 0)
- diffuse_yz = minor_diffuse(fibers_y, 1, 2)
-
- fibers_z = axis_fibers(fibers, 2)
- diffuse_z = major_diffuse(fibers_z, 2)
- diffuse_zx = minor_diffuse(fibers_z, 2, 0)
- diffuse_zy = minor_diffuse(fibers_z, 2, 1)
-
- compute_weights(weights, mesh, diffuse_x, diffuse_xy, diffuse_xz,
- diffuse_y, diffuse_yx, diffuse_yz, diffuse_z,
- diffuse_zx, diffuse_zy)
- weights *= dt/dr**2
- weights[:, :, :, 9] += 1
-
- return weights.astype('float32')
\ No newline at end of file
+ # q (i-1/2, j, k)
+ qx0_major = major_component(d_xx[i-1, j, k], m[i-1, j, k])
+ # (i-1, j, k)
+ w[i, j, k, 1] += qx0_major
+ # (i, j, k)
+ w[i, j, k, 4] -= qx0_major
+
+ qx0_xy_minor = minor_component(d_xy[i-1, j, k],
+ m[i-1, j-1, k], m[i, j-1, k],
+ m[i-1, j, k], m[i, j, k],
+ m[i-1, j+1, k], m[i, j+1, k])
+ # (i-1, j-1, k)
+ w[i, j, k, 0] -= qx0_xy_minor[0]
+ # (i, j-1, k)
+ w[i, j, k, 3] -= qx0_xy_minor[1]
+ # (i-1, j, k)
+ w[i, j, k, 1] -= qx0_xy_minor[2]
+ # (i, j, k)
+ w[i, j, k, 4] -= qx0_xy_minor[3]
+ # (i-1, j+1, k)
+ w[i, j, k, 2] -= qx0_xy_minor[4]
+ # (i, j+1, k)
+ w[i, j, k, 5] -= qx0_xy_minor[5]
+
+ qx0_xz_minor = minor_component(d_xz[i-1, j, k],
+ m[i-1, j, k-1], m[i, j, k-1],
+ m[i-1, j, k], m[i, j, k],
+ m[i-1, j, k+1], m[i, j, k+1])
+ # (i-1, j, k-1)
+ w[i, j, k, 15] -= qx0_xz_minor[0]
+ # (i, j, k-1)
+ w[i, j, k, 11] -= qx0_xz_minor[1]
+ # (i-1, j, k)
+ w[i, j, k, 1] -= qx0_xz_minor[2]
+ # (i, j, k)
+ w[i, j, k, 4] -= qx0_xz_minor[3]
+ # (i-1, j, k+1)
+ w[i, j, k, 17] -= qx0_xz_minor[4]
+ # (i, j, k+1)
+ w[i, j, k, 12] -= qx0_xz_minor[5]
+
+ # q (i+1/2, j, k)
+ qx1_major = major_component(d_xx[i, j, k], m[i+1, j, k])
+ # (i+1, j, k)
+ w[i, j, k, 7] += qx1_major
+ # (i, j, k)
+ w[i, j, k, 4] -= qx1_major
+
+ qx1_xy_minor = minor_component(d_xy[i, j, k],
+ m[i+1, j-1, k], m[i, j-1, k],
+ m[i+1, j, k], m[i, j, k],
+ m[i+1, j+1, k], m[i, j+1, k])
+ # (i+1, j-1, k)
+ w[i, j, k, 6] += qx1_xy_minor[0]
+ # (i, j-1, k)
+ w[i, j, k, 3] += qx1_xy_minor[1]
+ # (i+1, j, k)
+ w[i, j, k, 7] += qx1_xy_minor[2]
+ # (i, j, k)
+ w[i, j, k, 4] += qx1_xy_minor[3]
+ # (i+1, j+1, k)
+ w[i, j, k, 8] += qx1_xy_minor[4]
+ # (i, j+1, k)
+ w[i, j, k, 5] += qx1_xy_minor[5]
+
+ qx1_xz_minor = minor_component(d_xz[i, j, k],
+ m[i+1, j, k-1], m[i, j, k-1],
+ m[i+1, j, k], m[i, j, k],
+ m[i+1, j, k+1], m[i, j, k+1])
+ # (i+1, j, k-1)
+ w[i, j, k, 16] += qx1_xz_minor[0]
+ # (i, j, k-1)
+ w[i, j, k, 11] += qx1_xz_minor[1]
+ # (i+1, j, k)
+ w[i, j, k, 7] += qx1_xz_minor[2]
+ # (i, j, k)
+ w[i, j, k, 4] += qx1_xz_minor[3]
+ # (i+1, j, k+1)
+ w[i, j, k, 18] += qx1_xz_minor[4]
+ # (i, j, k+1)
+ w[i, j, k, 12] += qx1_xz_minor[5]
+
+ # q (i, j-1/2, k)
+ qy0_major = major_component(d_yy[i, j-1, k], m[i, j-1, k])
+ # (i, j-1, k)
+ w[i, j, k, 3] += qy0_major
+ # (i, j, k)
+ w[i, j, k, 4] -= qy0_major
+
+ qy0_yx_minor = minor_component(d_yx[i, j-1, k],
+ m[i-1, j-1, k], m[i-1, j, k],
+ m[i, j-1, k], m[i, j, k],
+ m[i+1, j-1, k], m[i+1, j, k])
+ # (i-1, j-1, k)
+ w[i, j, k, 0] -= qy0_yx_minor[0]
+ # (i-1, j, k)
+ w[i, j, k, 1] -= qy0_yx_minor[1]
+ # (i, j-1, k)
+ w[i, j, k, 3] -= qy0_yx_minor[2]
+ # (i, j, k)
+ w[i, j, k, 4] -= qy0_yx_minor[3]
+ # (i+1, j-1, k)
+ w[i, j, k, 6] -= qy0_yx_minor[4]
+ # (i+1, j, k)
+ w[i, j, k, 7] -= qy0_yx_minor[5]
+
+ qy0_yz_minor = minor_component(d_yz[i, j-1, k],
+ m[i, j-1, k-1], m[i, j, k-1],
+ m[i, j-1, k], m[i, j, k],
+ m[i, j-1, k+1], m[i, j, k+1])
+ # (i, j-1, k-1)
+ w[i, j, k, 9] -= qy0_yz_minor[0]
+ # (i, j, k-1)
+ w[i, j, k, 11] -= qy0_yz_minor[1]
+ # (i, j-1, k)
+ w[i, j, k, 3] -= qy0_yz_minor[2]
+ # (i, j, k)
+ w[i, j, k, 4] -= qy0_yz_minor[3]
+ # (i, j-1, k+1)
+ w[i, j, k, 10] -= qy0_yz_minor[4]
+ # (i, j, k+1)
+ w[i, j, k, 12] -= qy0_yz_minor[5]
+
+ # q (i, j+1/2, k)
+ qy1_major = major_component(d_yy[i, j, k], m[i, j+1, k])
+ # (i, j+1, k)
+ w[i, j, k, 5] += qy1_major
+ # (i, j, k)
+ w[i, j, k, 4] -= qy1_major
+
+ qy1_yx_minor = minor_component(d_yx[i, j, k],
+ m[i-1, j+1, k], m[i-1, j, k],
+ m[i, j+1, k], m[i, j, k],
+ m[i+1, j+1, k], m[i+1, j, k])
+ # (i-1, j+1, k)
+ w[i, j, k, 2] += qy1_yx_minor[0]
+ # (i-1, j, k)
+ w[i, j, k, 1] += qy1_yx_minor[1]
+ # (i, j+1, k)
+ w[i, j, k, 5] += qy1_yx_minor[2]
+ # (i, j, k)
+ w[i, j, k, 4] += qy1_yx_minor[3]
+ # (i+1, j+1, k)
+ w[i, j, k, 8] += qy1_yx_minor[4]
+ # (i+1, j, k)
+ w[i, j, k, 7] += qy1_yx_minor[5]
+
+ qy1_yz_minor = minor_component(d_yz[i, j, k],
+ m[i, j+1, k-1], m[i, j, k-1],
+ m[i, j+1, k], m[i, j, k],
+ m[i, j+1, k+1], m[i, j, k+1])
+ # (i, j+1, k-1)
+ w[i, j, k, 13] += qy1_yz_minor[0]
+ # (i, j, k-1)
+ w[i, j, k, 11] += qy1_yz_minor[1]
+ # (i, j+1, k)
+ w[i, j, k, 5] += qy1_yz_minor[2]
+ # (i, j, k)
+ w[i, j, k, 4] += qy1_yz_minor[3]
+ # (i, j+1, k+1)
+ w[i, j, k, 14] += qy1_yz_minor[4]
+ # (i, j, k+1)
+ w[i, j, k, 12] += qy1_yz_minor[5]
+
+ # q (i, j, k-1/2)
+ qz0_major = major_component(d_zz[i, j, k-1], m[i, j, k-1])
+ # (i, j, k-1)
+ w[i, j, k, 11] += qz0_major
+ # (i, j, k)
+ w[i, j, k, 4] -= qz0_major
+
+ qz0_zx_minor = minor_component(d_zx[i, j, k-1],
+ m[i-1, j, k-1], m[i-1, j, k],
+ m[i, j, k-1], m[i, j, k],
+ m[i+1, j, k-1], m[i+1, j, k])
+ # (i-1, j, k-1)
+ w[i, j, k, 15] -= qz0_zx_minor[0]
+ # (i-1, j, k)
+ w[i, j, k, 1] -= qz0_zx_minor[1]
+ # (i, j, k-1)
+ w[i, j, k, 11] -= qz0_zx_minor[2]
+ # (i, j, k)
+ w[i, j, k, 4] -= qz0_zx_minor[3]
+ # (i+1, j, k-1)
+ w[i, j, k, 16] -= qz0_zx_minor[4]
+ # (i+1, j, k)
+ w[i, j, k, 7] -= qz0_zx_minor[5]
+
+ qz0_zy_minor = minor_component(d_zy[i, j, k-1],
+ m[i, j-1, k-1], m[i, j-1, k],
+ m[i, j, k-1], m[i, j, k],
+ m[i, j+1, k-1], m[i, j+1, k])
+ # (i, j-1, k-1)
+ w[i, j, k, 9] -= qz0_zy_minor[0]
+ # (i, j-1, k)
+ w[i, j, k, 3] -= qz0_zy_minor[1]
+ # (i, j, k-1)
+ w[i, j, k, 11] -= qz0_zy_minor[2]
+ # (i, j, k)
+ w[i, j, k, 4] -= qz0_zy_minor[3]
+ # (i, j+1, k-1)
+ w[i, j, k, 13] -= qz0_zy_minor[4]
+ # (i, j+1, k)
+ w[i, j, k, 5] -= qz0_zy_minor[5]
+
+ # q (i, j, k+1/2)
+ qz1_major = major_component(d_zz[i, j, k], m[i, j, k+1])
+ # (i, j, k+1)
+ w[i, j, k, 12] += qz1_major
+ # (i, j, k)
+ w[i, j, k, 4] -= qz1_major
+
+ qz1_zx_minor = minor_component(d_zx[i, j, k],
+ m[i-1, j, k+1], m[i-1, j, k],
+ m[i, j, k+1], m[i, j, k],
+ m[i+1, j, k+1], m[i+1, j, k])
+ # (i-1, j, k+1)
+ w[i, j, k, 17] += qz1_zx_minor[0]
+ # (i-1, j, k)
+ w[i, j, k, 1] += qz1_zx_minor[1]
+ # (i, j, k+1)
+ w[i, j, k, 12] += qz1_zx_minor[2]
+ # (i, j, k)
+ w[i, j, k, 4] += qz1_zx_minor[3]
+ # (i+1, j, k+1)
+ w[i, j, k, 18] += qz1_zx_minor[4]
+ # (i+1, j, k)
+ w[i, j, k, 7] += qz1_zx_minor[5]
+
+ qz1_zy_minor = minor_component(d_zy[i, j, k],
+ m[i, j-1, k+1], m[i, j-1, k],
+ m[i, j, k+1], m[i, j, k],
+ m[i, j+1, k+1], m[i, j+1, k])
+ # (i, j-1, k+1)
+ w[i, j, k, 10] += qz1_zy_minor[0]
+ # (i, j-1, k)
+ w[i, j, k, 3] += qz1_zy_minor[1]
+ # (i, j, k+1)
+ w[i, j, k, 12] += qz1_zy_minor[2]
+ # (i, j, k)
+ w[i, j, k, 4] += qz1_zy_minor[3]
+ # (i, j+1, k+1)
+ w[i, j, k, 14] += qz1_zy_minor[4]
+ # (i, j+1, k)
+ w[i, j, k, 5] += qz1_zy_minor[5]
+
+ return w
diff --git a/finitewave/cpuwave3D/stencil/isotropic_stencil_3d.py b/finitewave/cpuwave3D/stencil/isotropic_stencil_3d.py
index f4f90e5..f7e03df 100644
--- a/finitewave/cpuwave3D/stencil/isotropic_stencil_3d.py
+++ b/finitewave/cpuwave3D/stencil/isotropic_stencil_3d.py
@@ -1,93 +1,149 @@
-import numbers
import numpy as np
+from numba import njit, prange
-from finitewave.core.stencil.stencil import Stencil
+from finitewave.cpuwave2D.stencil.isotropic_stencil_2d import (
+ compute_component,
+ IsotropicStencil2D
+)
-class IsotropicStencil3D(Stencil):
+class IsotropicStencil3D(IsotropicStencil2D):
"""
- A class to represent a 3D isotropic stencil for diffusion processes.
+ This class computes the weights for diffusion on a 3D using an isotropic
+ stencil. The stencil includes 7 points: the central point and the six
+ neighbors.
- Inherits from:
- -----------
- Stencil
- Base class for different stencils used in diffusion calculations.
+ The method assumes weights being used in the following order:
+ ``w[i, j, k, 0] : (i-1, j, k)``,
+ ``w[i, j, k, 1] : (i, j-1, k)``,
+ ``w[i, j, k, 2] : (i, j, k-1)``,
+ ``w[i, j, k, 3] : (i, j, k)``,
+ ``w[i, j, k, 4] : (i, j, k+1)``,
+ ``w[i, j, k, 5] : (i, j+1, k)``,
+ ``w[i, j, k, 6] : (i+1, j, k)``.
- Methods
- -------
- get_weights(mesh, conductivity, fibers, D_al, D_ac, dt, dr):
- Computes the weights for diffusion based on the isotropic stencil.
+ Notes
+ -----
+ The method can handle heterogeneity in the diffusion coefficients given
+ by the ``conductivity`` parameter.
"""
+
def __init__(self):
+ super().__init__()
+
+ def select_diffusion_kernel(self):
"""
- Initializes the IsotropicStencil3D with default settings.
+ Returns the diffusion kernel function for isotropic diffusion in 3D.
+
+ Returns
+ -------
+ function
+ The diffusion kernel function for isotropic diffusion in 3D.
"""
- Stencil.__init__(self)
+ return diffusion_kernel_3d_iso
- def get_weights(self, mesh, conductivity, fibers, D_al, D_ac, dt, dr):
+ def compute_weights(self, model, cardiac_tissue):
"""
- Computes the weights for diffusion on a 3D mesh using an isotropic stencil.
+ Computes the weights for isotropic diffusion in 3D.
Parameters
----------
- mesh : np.ndarray
- 3D array representing the mesh grid of the tissue. Non-tissue areas are set to 0.
- conductivity : float
- Conductivity of the tissue, which scales the diffusion coefficient.
- fibers : np.ndarray
- Array representing fiber orientations. Not used in isotropic stencil but kept for consistency.
- D_al : float
- Longitudinal diffusion coefficient.
- D_ac : float
- Cross-sectional diffusion coefficient. Not used in isotropic stencil but kept for consistency.
- dt : float
- Temporal resolution.
- dr : float
- Spatial resolution.
+ model : CardiacModel3D
+ A model object containing the simulation parameters.
+ cardiac_tissue : CardiacTissue3D
+ A 3D cardiac tissue object.
Returns
-------
- np.ndarray
- 4D array of weights for diffusion, with the shape of (mesh.shape[0], mesh.shape[1], 7).
-
- Notes
- -----
- The method assumes isotropic diffusion where `D_al` is used as the diffusion coefficient.
- The weights are computed for four directions (up, right, down, left) and the central weight.
- Heterogeneity in the diffusion coefficients is handled by adjusting the weights based on
- differences in the diffusion coefficients along the rows and columns.
+ numpy.ndarray
+ The weights for isotropic diffusion in 3D.
"""
- mesh = mesh.copy()
+ mesh = cardiac_tissue.mesh.copy()
mesh[mesh != 1] = 0
- weights = np.zeros((*mesh.shape, 7))
-
- diffuse = D_al * conductivity * np.ones(mesh.shape)
-
- weights[:, :, :, 0] = diffuse * dt / (dr**2) * np.roll(mesh, 1, axis=0)
- weights[:, :, :, 1] = diffuse * dt / (dr**2) * np.roll(mesh, 1, axis=1)
- weights[:, :, :, 2] = diffuse * dt / (dr**2) * np.roll(mesh, 1, axis=2)
- weights[:, :, :, 4] = diffuse * dt / (dr**2) * np.roll(mesh, -1,
- axis=2)
- weights[:, :, :, 5] = diffuse * dt / (dr**2) * np.roll(mesh, -1,
- axis=1)
- weights[:, :, :, 6] = diffuse * dt / (dr**2) * np.roll(mesh, -1,
- axis=0)
-
- # heterogeneity
- diff_i = np.roll(diffuse, 1, axis=0) - np.roll(diffuse, -1, axis=0)
- diff_j = np.roll(diffuse, 1, axis=1) - np.roll(diffuse, -1, axis=1)
- diff_k = np.roll(diffuse, 1, axis=2) - np.roll(diffuse, -1, axis=2)
-
- weights[:, :, :, 0] -= dt / (2*dr) * diff_i
- weights[:, :, :, 1] -= dt / (2*dr) * diff_j
- weights[:, :, :, 2] -= dt / (2*dr) * diff_k
- weights[:, :, :, 4] += dt / (2*dr) * diff_k
- weights[:, :, :, 5] += dt / (2*dr) * diff_j
- weights[:, :, :, 6] += dt / (2*dr) * diff_i
-
- for i in [0, 1, 2, 4, 5, 6]:
- weights[:, :, :, i] *= mesh
- weights[:, :, :, 3] -= weights[:, :, :, i]
+
+ conductivity = cardiac_tissue.conductivity
+ conductivity = conductivity * np.ones_like(mesh, dtype=model.npfloat)
+
+ d_xx, d_yy, d_zz = self.compute_half_step_diffusion(mesh, conductivity,
+ num_axes=3)
+
+ weights = np.zeros((*mesh.shape, 7), dtype=model.npfloat)
+ weights = compute_weights(weights, mesh, d_xx, d_yy, d_zz)
+ weights = weights * model.D_model * model.dt / model.dr**2
weights[:, :, :, 3] += 1
- weights[:, :, :, 3] *= mesh
return weights
+
+
+@njit(parallel=True)
+def diffusion_kernel_3d_iso(u_new, u, w, indexes):
+ """
+ Performs isotropic diffusion on a 3D grid.
+
+ Parameters
+ ----------
+ u_new : numpy.ndarray
+ A 3D array to store the updated potential values after diffusion.
+ u : numpy.ndarray
+ A 3D array representing the current potential values before diffusion.
+ w : numpy.ndarray
+ A 4D array of weights used in the diffusion computation.
+ The shape should match (*mesh.shape, 7).
+ indexes : numpy.ndarray
+ A 1D array of indices where the diffusion should be computed.
+ """
+ n_j = u.shape[1]
+ n_k = u.shape[2]
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = ii//(n_j*n_k)
+ j = (ii % (n_j*n_k))//n_k
+ k = (ii % (n_j*n_k)) % n_k
+
+ u_new[i, j, k] = (u[i-1, j, k] * w[i, j, k, 0] +
+ u[i, j-1, k] * w[i, j, k, 1] +
+ u[i, j, k-1] * w[i, j, k, 2] +
+ u[i, j, k] * w[i, j, k, 3] +
+ u[i, j, k+1] * w[i, j, k, 4] +
+ u[i, j+1, k] * w[i, j, k, 5] +
+ u[i+1, j, k] * w[i, j, k, 6])
+
+
+@njit(parallel=True)
+def compute_weights(w, m, d_xx, d_yy, d_zz):
+ n_i = m.shape[0]
+ n_j = m.shape[1]
+ n_k = m.shape[2]
+
+ for ii in prange(n_i * n_j * n_k):
+
+ i = ii // (n_j * n_k)
+ j = (ii % (n_j * n_k)) // n_k
+ k = (ii % (n_j * n_k)) % n_k
+
+ if m[i, j, k] != 1:
+ continue
+
+ # (i-1, j, k)
+ w[i, j, k, 0] = compute_component(d_xx[i-1, j, k],
+ m[i-1, j, k], m[i+1, j, k])
+ # (i, j-1, k)
+ w[i, j, k, 1] = compute_component(d_yy[i, j-1, k],
+ m[i, j-1, k], m[i, j+1, k])
+ # (i, j, k-1)
+ w[i, j, k, 2] = compute_component(d_zz[i, j, k-1],
+ m[i, j, k-1], m[i, j, k+1])
+ # (i, j, k+1)
+ w[i, j, k, 4] = compute_component(d_zz[i, j, k],
+ m[i, j, k+1], m[i, j, k-1])
+ # (i, j+1, k)
+ w[i, j, k, 5] = compute_component(d_yy[i, j, k],
+ m[i, j+1, k], m[i, j-1, k])
+ # (i+1, j, k)
+ w[i, j, k, 6] = compute_component(d_xx[i, j, k],
+ m[i+1, j, k], m[i-1, j, k])
+ # (i, j, k)
+ w[i, j, k, 3] = - (w[i, j, k, 0] + w[i, j, k, 1] + w[i, j, k, 2] +
+ w[i, j, k, 4] + w[i, j, k, 5] + w[i, j, k, 6])
+
+ return w
diff --git a/finitewave/cpuwave3D/stimulation/__init__.py b/finitewave/cpuwave3D/stimulation/__init__.py
index f392bdb..463443c 100755
--- a/finitewave/cpuwave3D/stimulation/__init__.py
+++ b/finitewave/cpuwave3D/stimulation/__init__.py
@@ -1,4 +1,6 @@
-from finitewave.cpuwave3D.stimulation.stim_current_coord_3d import StimCurrentCoord3D
-from finitewave.cpuwave3D.stimulation.stim_voltage_coord_3d import StimVoltageCoord3D
-from finitewave.cpuwave3D.stimulation.stim_current_matrix_3d import StimCurrentMatrix3D
-from finitewave.cpuwave3D.stimulation.stim_voltage_matrix_3d import StimVoltageMatrix3D
\ No newline at end of file
+from .stim_current_coord_3d import StimCurrentCoord3D
+from .stim_voltage_coord_3d import StimVoltageCoord3D
+from .stim_current_matrix_3d import StimCurrentMatrix3D
+from .stim_voltage_matrix_3d import StimVoltageMatrix3D
+from .stim_voltage_list_matrix_3d import StimVoltageListMatrix3D
+from .stim_current_area_3d import StimCurrentArea3D
diff --git a/finitewave/cpuwave3D/stimulation/stim_current_area_3d.py b/finitewave/cpuwave3D/stimulation/stim_current_area_3d.py
new file mode 100644
index 0000000..0da1afa
--- /dev/null
+++ b/finitewave/cpuwave3D/stimulation/stim_current_area_3d.py
@@ -0,0 +1,39 @@
+from finitewave.cpuwave2D.stimulation.stim_current_area_2d import (
+ StimCurrentArea2D
+)
+
+
+class StimCurrentArea3D(StimCurrentArea2D):
+ """
+ A class that applies a stimulation current to a 3D cardiac tissue model
+ based on a area coords.
+
+ Attributes
+ ----------
+ time : float
+ The time at which the stimulation starts.
+ curr_value : float
+ The value of the stimulation current.
+ duration : float
+ The duration of the stimulation.
+ coords : numpy.ndarray
+ The coordinates of the area to be stimulated.
+ """
+ def __init__(self, time, curr_value, duration, coords=None, u_max=None):
+ """
+ Initializes the StimCurrentArea3D instance.
+
+ Parameters
+ ----------
+ time : float
+ The time at which the stimulation starts.
+ curr_value : float
+ The value of the stimulation current.
+ duration : float
+ The duration of the stimulation.
+ coords : numpy.ndarray
+ The coordinates of the area to be stimulated.
+ u_max : float, optional
+ The maximum value of the membrane potential. Default is None.
+ """
+ super().__init__(time, curr_value, duration, coords, u_max)
diff --git a/finitewave/cpuwave3D/stimulation/stim_current_coord_3d.py b/finitewave/cpuwave3D/stimulation/stim_current_coord_3d.py
index 1dfb92b..ee58066 100755
--- a/finitewave/cpuwave3D/stimulation/stim_current_coord_3d.py
+++ b/finitewave/cpuwave3D/stimulation/stim_current_coord_3d.py
@@ -1,11 +1,11 @@
+import numpy as np
from finitewave.core.stimulation.stim_current import StimCurrent
class StimCurrentCoord3D(StimCurrent):
"""
- A class that applies a stimulation current to a rectangular region of a 3D cardiac tissue model.
-
- Inherits from `StimCurrent`.
+ A class that applies a stimulation current to a rectangular region of a 3D
+ cardiac tissue model.
Parameters
----------
@@ -13,7 +13,7 @@ class StimCurrentCoord3D(StimCurrent):
The time at which the stimulation starts.
curr_value : float
The value of the stimulation current.
- curr_time : float
+ duration : float
The duration of the stimulation.
x1 : int
The x-coordinate of the lower-left corner of the rectangular region.
@@ -27,8 +27,12 @@ class StimCurrentCoord3D(StimCurrent):
The z-coordinate of the lower-left corner of the rectangular region.
z2 : int
The z-coordinate of the upper-right corner of the rectangular region.
+ u_max : float, optional
+ The maximum value of the membrane potential. Default is None.
"""
- def __init__(self, time, curr_value, curr_time, x1, x2, y1, y2, z1, z2):
+
+ def __init__(self, time, curr_value, duration, x1, x2, y1, y2, z1, z2,
+ u_max=None):
"""
Initializes the StimCurrentCoord3D instance.
@@ -38,57 +42,49 @@ def __init__(self, time, curr_value, curr_time, x1, x2, y1, y2, z1, z2):
The time at which the stimulation starts.
curr_value : float
The value of the stimulation current.
- curr_time : float
+ duration : float
The duration of the stimulation.
- x1 : int
- The x-coordinate of the lower-left corner of the rectangular region.
- x2 : int
- The x-coordinate of the upper-right corner of the rectangular region.
- y1 : int
- The y-coordinate of the lower-left corner of the rectangular region.
- y2 : int
- The y-coordinate of the upper-right corner of the rectangular region.
- z1 : int
- The z-coordinate of the lower-left corner of the rectangular region.
- z2 : int
- The z-coordinate of the upper-right corner of the rectangular region.
+ x1, x2, y1, y2, z1, z2 : int
+ The coordinates of the rectangular region to which the stimulation
+ current is applied.
+ u_max : float, optional
+ The maximum value of the membrane potential. Default is None.
"""
- StimCurrent.__init__(self, time, curr_value, curr_time)
+ super().__init__(time, curr_value, duration)
self.x1 = x1
self.x2 = x2
self.y1 = y1
self.y2 = y2
self.z1 = z1
self.z2 = z2
+ self.u_max = u_max
def stimulate(self, model):
"""
- Applies the stimulation current to the specified rectangular region of the cardiac tissue model.
-
- The stimulation is applied only if the current time is within the stimulation period and
- the stimulation has not been previously applied.
+ Applies the stimulation current to the specified rectangular region of
+ the cardiac tissue model.
Parameters
----------
model : object
- The cardiac tissue model to which the stimulation current is applied. The model must have
- an attribute `cardiac_tissue` with a `mesh` property and an attribute `u` representing
- the state of the tissue.
-
- Notes
- -----
- The stimulation is applied to the region of interest (ROI) defined by the coordinates
- (x1, x2), (y1, y2) and (z1, z2). The current value is added to the `model.u` attribute, which represents
- the state of the tissue.
+ The cardiac tissue model to which the stimulation current is
+ applied.
"""
- if not self.passed:
- # ROI - region of interest
- roi_x1, roi_x2 = self.x1, self.x2
- roi_y1, roi_y2 = self.y1, self.y2
- roi_z1, roi_z2 = self.z1, self.z2
+ roi_mesh = model.cardiac_tissue.mesh[self.x1: self.x2,
+ self.y1: self.y2,
+ self.z1: self.z2]
+ mask = (roi_mesh == 1)
- roi_mesh = model.cardiac_tissue.mesh[roi_x1:roi_x2, roi_y1:roi_y2 ,roi_z1:roi_z2]
+ model.u[self.x1: self.x2,
+ self.y1: self.y2,
+ self.z1: self.z2][mask] += model.dt * self.curr_value
- mask = (roi_mesh == 1)
+ if self.u_max is not None:
+ u = model.u[self.x1: self.x2,
+ self.y1: self.y2,
+ self.z1: self.z2][mask]
- model.u[roi_x1:roi_x2, roi_y1:roi_y2, roi_z1:roi_z2][mask] += self._dt * self.curr_value
\ No newline at end of file
+ model.u[self.x1: self.x2,
+ self.y1: self.y2,
+ self.z1: self.z2][mask] = np.where(u > self.u_max,
+ self.u_max, u)
diff --git a/finitewave/cpuwave3D/stimulation/stim_current_matrix_3d.py b/finitewave/cpuwave3D/stimulation/stim_current_matrix_3d.py
index 2bf897f..ca0ebea 100755
--- a/finitewave/cpuwave3D/stimulation/stim_current_matrix_3d.py
+++ b/finitewave/cpuwave3D/stimulation/stim_current_matrix_3d.py
@@ -1,11 +1,13 @@
-from finitewave.core.stimulation.stim_current import StimCurrent
+import numpy as np
+from finitewave.cpuwave2D.stimulation.stim_current_matrix_2d import (
+ StimCurrentMatrix2D
+)
-class StimCurrentMatrix3D(StimCurrent):
+class StimCurrentMatrix3D(StimCurrentMatrix2D):
"""
- A class that applies a stimulation current to a 3D cardiac tissue model based on a binary matrix.
-
- Inherits from `StimCurrent`.
+ A class that applies a stimulation current to a 3D cardiac tissue model
+ based on a binary matrix.
Parameters
----------
@@ -13,13 +15,16 @@ class StimCurrentMatrix3D(StimCurrent):
The time at which the stimulation starts.
curr_value : float
The value of the stimulation current.
- curr_time : float
+ duration : float
The duration of the stimulation.
matrix : numpy.ndarray
A 3D binary matrix indicating the region of interest for stimulation.
Elements greater than 0 represent regions to be stimulated.
+ u_max : float, optional
+ The maximum value of the membrane potential. Default is None.
"""
- def __init__(self, time, curr_value, curr_time, matrix):
+
+ def __init__(self, time, curr_value, duration, matrix, u_max=None):
"""
Initializes the StimCurrentMatrix3D instance.
@@ -29,35 +34,12 @@ def __init__(self, time, curr_value, curr_time, matrix):
The time at which the stimulation starts.
curr_value : float
The value of the stimulation current.
- curr_time : float
+ duration : float
The duration of the stimulation.
matrix : numpy.ndarray
- A 3D binary matrix indicating the region of interest for stimulation.
- """
- StimCurrent.__init__(self, time, curr_value, curr_time)
- self.matrix = matrix
-
- def stimulate(self, model):
+ A 3D binary matrix indicating the region of interest for
+ stimulation.
+ u_max : float, optional
+ The maximum value of the membrane potential. Default is None.
"""
- Applies the stimulation current to the cardiac tissue model based on the specified binary matrix.
-
- The stimulation is applied only if the current time is within the stimulation period and
- the stimulation has not been previously applied.
-
- Parameters
- ----------
- model : object
- The cardiac tissue model to which the stimulation current is applied. The model must have
- an attribute `cardiac_tissue` with a `mesh` property and an attribute `u` representing
- the state of the tissue.
-
- Notes
- -----
- The stimulation is applied to the regions of the cardiac tissue indicated by the matrix.
- For each position where the matrix value is greater than 0 and the corresponding value
- in the `model.cardiac_tissue.mesh` is 1, the current value is added to `model.u`.
- """
- if not self.passed:
- mask = (self.matrix > 0) & (model.cardiac_tissue.mesh == 1)
- model.u[mask] += self._dt*self.curr_value
-
+ super().__init__(time, curr_value, duration, matrix, u_max)
diff --git a/finitewave/cpuwave3D/stimulation/stim_voltage_coord_3d.py b/finitewave/cpuwave3D/stimulation/stim_voltage_coord_3d.py
index de9e2dd..12269ea 100755
--- a/finitewave/cpuwave3D/stimulation/stim_voltage_coord_3d.py
+++ b/finitewave/cpuwave3D/stimulation/stim_voltage_coord_3d.py
@@ -3,9 +3,8 @@
class StimVoltageCoord3D(StimVoltage):
"""
- A class that applies a voltage stimulus to a 3D cardiac tissue model within a specified region of interest.
-
- Inherits from `StimVoltage`.
+ A class that applies a voltage stimulus to a 3D cardiac tissue model
+ within a specified region of interest.
Parameters
----------
@@ -26,6 +25,7 @@ class StimVoltageCoord3D(StimVoltage):
z2 : int
The ending z-coordinate of the region of interest.
"""
+
def __init__(self, time, volt_value, x1, x2, y1, y2, z1, z2):
"""
Initializes the StimVoltageCoord2D instance.
@@ -36,20 +36,11 @@ def __init__(self, time, volt_value, x1, x2, y1, y2, z1, z2):
The time at which the stimulation starts.
volt_value : float
The voltage value to apply.
- x1 : int
- The starting x-coordinate of the region of interest.
- x2 : int
- The ending x-coordinate of the region of interest.
- y1 : int
- The starting y-coordinate of the region of interest.
- y2 : int
- The ending y-coordinate of the region of interest.
- z1 : int
- The starting z-coordinate of the region of interest.
- z2 : int
- The ending z-coordinate of the region of interest.
+ x1, x2, y1, y2, z1, z2 : int
+ The coordinates of the region of interest to which the voltage
+ stimulus is applied.
"""
- StimVoltage.__init__(self, time, volt_value)
+ super().__init__(time, volt_value)
self.x1 = x1
self.x2 = x2
self.y1 = y1
@@ -59,32 +50,19 @@ def __init__(self, time, volt_value, x1, x2, y1, y2, z1, z2):
def stimulate(self, model):
"""
- Applies the voltage stimulus to the cardiac tissue model within the specified region of interest.
-
- The voltage is applied only if the current time is within the stimulation period and
- the stimulation has not been previously applied.
+ Applies the voltage stimulus to the cardiac tissue model within the
+ specified region of interest.
Parameters
----------
model : object
- The cardiac tissue model to which the voltage stimulus is applied. The model must have
- an attribute `cardiac_tissue` with a `mesh` property and an attribute `u` representing
- the state of the tissue.
-
- Notes
- -----
- The voltage value is applied to the region of the cardiac tissue specified by the coordinates
- (x1, x2), (y1, y2) and (z1, z2). The `model.cardiac_tissue.mesh` is used to mask the regions where the
- voltage should be applied. Only positions where the mesh value is 1 will be updated.
+ The cardiac tissue model to which the voltage stimulus is applied.
"""
- if not self.passed:
- # ROI - region of interest
- roi_x1, roi_x2 = self.x1, self.x2
- roi_y1, roi_y2 = self.y1, self.y2
- roi_z1, roi_z2 = self.z1, self.z2
-
- roi_mesh = model.cardiac_tissue.mesh[roi_x1:roi_x2, roi_y1:roi_y2 ,roi_z1:roi_z2]
-
- mask = (roi_mesh == 1)
+ roi_mesh = model.cardiac_tissue.mesh[self.x1: self.x2,
+ self.y1: self.y2,
+ self.z1: self.z2]
+ mask = (roi_mesh == 1)
- model.u[roi_x1:roi_x2, roi_y1:roi_y2, roi_z1:roi_z2][mask] = self.volt_value
+ model.u[self.x1: self.x2,
+ self.y1: self.y2,
+ self.z1: self.z2][mask] = self.volt_value
diff --git a/finitewave/cpuwave3D/stimulation/stim_voltage_list_matrix_3d.py b/finitewave/cpuwave3D/stimulation/stim_voltage_list_matrix_3d.py
new file mode 100644
index 0000000..100f81d
--- /dev/null
+++ b/finitewave/cpuwave3D/stimulation/stim_voltage_list_matrix_3d.py
@@ -0,0 +1,72 @@
+from finitewave.core.stimulation.stim_voltage import StimVoltage
+
+
+class StimVoltageListMatrix3D(StimVoltage):
+ """
+ A class that applies a voltage stimulus to a 3D cardiac tissue model
+ according to a specified matrix.
+
+ Parameters
+ ----------
+ time : float
+ The time at which the stimulation starts.
+ volt_values : array-like
+ The voltage values to apply.
+ matrix : numpy.ndarray
+ A 3D array where the voltage stimulus is applied to locations with
+ values greater than 0.
+ step : int
+ The step of the voltage values array.
+ """
+ def __init__(self, time, volt_values, duration, matrix):
+ """
+ Initializes the StimVoltageMatrix3D instance.
+
+ Parameters
+ ----------
+ time : float
+ The time at which the stimulation starts.
+ volt_values : float
+ The voltage value to apply.
+ duration : float
+ The duration of the stimulation.
+ matrix : numpy.ndarray
+ A 3D array where the voltage stimulus is applied to locations with
+ values greater than 0.
+ """
+ super().__init__(time, volt_values, duration)
+ self.matrix = matrix
+ self.step = 0
+
+ def initialize(self, model):
+ """
+ Prepares the stimulation for application.
+
+ Parameters
+ ----------
+ model : object
+ The cardiac tissue model to which the voltage stimulus will be
+ applied.
+ """
+ super().initialize(model)
+
+ total_steps = int(self.duration / model.dt) + 1
+
+ if len(self.volt_value) < total_steps:
+ message = ("The length of the voltage values array should be " +
+ "greater than the total number of steps.")
+ raise ValueError(message)
+
+ def stimulate(self, model):
+ """
+ Applies the voltage stimulus to the cardiac tissue model based on the
+ specified matrix.
+
+ Parameters
+ ----------
+ model : object
+ The cardiac tissue model to which the voltage stimulus is applied.
+ """
+ mask = (self.matrix > 0) & (model.cardiac_tissue.mesh == 1)
+ model.u[mask] = self.volt_value[self.step]
+ self.step += 1
diff --git a/finitewave/cpuwave3D/stimulation/stim_voltage_matrix_3d.py b/finitewave/cpuwave3D/stimulation/stim_voltage_matrix_3d.py
index 2876646..9abb05e 100755
--- a/finitewave/cpuwave3D/stimulation/stim_voltage_matrix_3d.py
+++ b/finitewave/cpuwave3D/stimulation/stim_voltage_matrix_3d.py
@@ -3,9 +3,8 @@
class StimVoltageMatrix3D(StimVoltage):
"""
- A class that applies a voltage stimulus to a 3D cardiac tissue model according to a specified matrix.
-
- Inherits from `StimVoltage`.
+ A class that applies a voltage stimulus to a 3D cardiac tissue model
+ according to a specified matrix.
Parameters
----------
@@ -14,7 +13,8 @@ class StimVoltageMatrix3D(StimVoltage):
volt_value : float
The voltage value to apply.
matrix : numpy.ndarray
- A 3D array where the voltage stimulus is applied to locations with values greater than 0.
+ A 3D array where the voltage stimulus is applied to locations with
+ values greater than 0.
"""
def __init__(self, time, volt_value, matrix):
"""
@@ -27,30 +27,21 @@ def __init__(self, time, volt_value, matrix):
volt_value : float
The voltage value to apply.
matrix : numpy.ndarray
- A 3D array where the voltage stimulus is applied to locations with values greater than 0.
+ A 3D array where the voltage stimulus is applied to locations with
+ values greater than 0.
"""
- StimVoltage.__init__(self, time, volt_value)
+ super().__init__(time, volt_value)
self.matrix = matrix
def stimulate(self, model):
"""
- Applies the voltage stimulus to the cardiac tissue model based on the specified matrix.
-
- The voltage is applied only if the current time is within the stimulation period and
- the stimulation has not been previously applied.
+ Applies the voltage stimulus to the cardiac tissue model based on the
+ specified matrix.
Parameters
----------
model : object
- The cardiac tissue model to which the voltage stimulus is applied. The model must have
- an attribute `cardiac_tissue` with a `mesh` property and an attribute `u` representing
- the state of the tissue.
-
- Notes
- -----
- The voltage value is applied to the positions in the cardiac tissue where the corresponding
- value in `matrix` is greater than 0, and the `model.cardiac_tissue.mesh` value is 1.
+ The cardiac tissue model to which the voltage stimulus is applied.
"""
- if not self.passed:
- mask = (self.matrix > 0) & (model.cardiac_tissue.mesh == 1)
- model.u[mask] = self.volt_value
+ mask = (self.matrix > 0) & (model.cardiac_tissue.mesh == 1)
+ model.u[mask] = self.volt_value
diff --git a/finitewave/cpuwave3D/tissue/cardiac_tissue_3d.py b/finitewave/cpuwave3D/tissue/cardiac_tissue_3d.py
index a3bb882..485da38 100644
--- a/finitewave/cpuwave3D/tissue/cardiac_tissue_3d.py
+++ b/finitewave/cpuwave3D/tissue/cardiac_tissue_3d.py
@@ -1,60 +1,34 @@
import numpy as np
from finitewave.core.tissue.cardiac_tissue import CardiacTissue
-from finitewave.cpuwave3D.stencil.isotropic_stencil_3d import IsotropicStencil3D
class CardiacTissue3D(CardiacTissue):
"""
- A class to represent a 3D cardiac tissue model with isotropic or anisotropic properties.
-
- Inherits from:
- -----------
- CardiacTissue
- Base class for cardiac tissue models.
+ This class represents a 3D cardiac tissue.
Attributes
----------
- shape : tuple of int
- Shape of the 3D grid for the cardiac tissue.
- mesh : np.ndarray
- Grid representing the tissue, with boundaries set to zero.
- stencil : IsotropicStencil3D
- Stencil for calculating weights in the 3D grid.
- conductivity : float
- Conductivity value for the tissue.
- fibers : np.ndarray or None
- Array representing fiber orientations. If None, isotropic weights are used.
meta : dict
- Metadata about the tissue, including dimensionality.
- weights : np.ndarray
- Weights used for diffusion calculations.
-
- Methods
- -------
- __init__(shape):
- Initializes the 3D cardiac tissue model with the given shape and mode.
- add_boundaries():
- Sets boundary values in the mesh to zero.
- compute_weights(dr, dt):
- Computes the weights for diffusion based on the stencil and mode.
+ A dictionary containing metadata about the tissue.
+ mesh : np.ndarray
+ A 3D numpy array representing the tissue mesh where each value
+ indicates the type of tissue at that location. Possible values are:
+ ``0`` for non-tissue, ``1`` for healthy tissue, and ``2`` for fibrotic
+ tissue.
+ conductivity : float or np.ndarray
+ The conductivity of the tissue used for reducing the diffusion
+ coefficients. The conductivity should be in the range [0, 1].
+ fibers : np.ndarray
+ Fibers orientation in the tissue. If None, the isotropic stencil is
+ used.
"""
def __init__(self, shape):
- """
- Initializes the CardiacTissue3D model.
-
- Parameters
- ----------
- shape : tuple of int
- Shape of the 3D grid for the cardiac tissue.
- """
- CardiacTissue.__init__(self)
- self.meta["Dim"] = 3
- self.shape = shape
- self.mesh = np.ones(shape)
- self.add_boundaries()
- self.stencil = IsotropicStencil3D()
- self.conductivity = 1
+ super().__init__()
+ self.meta["dim"] = 3
+ self.meta["shape"] = shape
+ self.mesh = np.ones(shape, dtype=np.int8)
+ self.conductivity = 1.
self.fibers = None
def add_boundaries(self):
@@ -70,18 +44,3 @@ def add_boundaries(self):
self.mesh[-1, :, :] = 0
self.mesh[:, -1, :] = 0
self.mesh[:, :, -1] = 0
-
- def compute_weights(self, dr, dt):
- """
- Computes the weights for diffusion using the stencil and given parameters.
-
- Parameters
- ----------
- dr : float
- Spatial resolution.
- dt : float
- Temporal resolution.
- """
- self.weights = self.stencil.get_weights(self.mesh, self.conductivity,
- self.fibers, self.D_al,
- self.D_ac, dt, dr)
diff --git a/finitewave/cpuwave3D/tracker/__init__.py b/finitewave/cpuwave3D/tracker/__init__.py
index 38ae11c..484270d 100755
--- a/finitewave/cpuwave3D/tracker/__init__.py
+++ b/finitewave/cpuwave3D/tracker/__init__.py
@@ -1,11 +1,38 @@
-from finitewave.cpuwave3D.tracker.action_potential_3d_tracker import ActionPotential3DTracker
-from finitewave.cpuwave3D.tracker.activation_time_3d_tracker import ActivationTime3DTracker
-from finitewave.cpuwave3D.tracker.animation_slice_3d_tracker import AnimationSlice3DTracker
-from finitewave.cpuwave3D.tracker.ecg_3d_tracker import ECG3DTracker
-from finitewave.cpuwave3D.tracker.period_3d_tracker import Period3DTracker
-from finitewave.cpuwave3D.tracker.period_map_3d_tracker import PeriodMap3DTracker
-from finitewave.cpuwave3D.tracker.spiral_3d_tracker import Spiral3DTracker
-from finitewave.cpuwave3D.tracker.variable_3d_tracker import Variable3DTracker
-from finitewave.cpuwave3D.tracker.velocity_3d_tracker import Velocity3DTracker
-from finitewave.cpuwave3D.tracker.vtk_frame_3d_tracker import VTKFrame3DTracker
-from finitewave.cpuwave3D.tracker.animation_3d_tracker import Animation3DTracker
\ No newline at end of file
+"""
+3D Tracker
+==========
+
+This module contains classes for tracking the evolution of the wavefront in 3D.
+Most of the classes in this module are similar to the ones in the 2D tracker
+module. More information can be found in the documentation for the 2D tracker
+module.
+
+The tracker classes can be grouped into the following categories:
+
+* Full field trackers that track the entire field and output the results in
+ a single array.
+* Point trackers that track the evolution of a specific point(s) in the field.
+* Animation trackers that track the evolution of the field over time and save
+ the results as frames for creating animations.
+
+Each tracker class has basic attributes such as ``start_time``, ``end_time``,
+``step``, ``path``, and ``file_name``.
+
+.. note::
+
+ Note that the ``start_time`` and ``end_time`` is given in time units,
+ and the ``step`` is the number of time steps between recordings.
+"""
+
+from .action_potential_3d_tracker import ActionPotential3DTracker
+from .activation_time_3d_tracker import ActivationTime3DTracker
+from .local_activation_time_3d_tracker import LocalActivationTime3DTracker
+from .animation_slice_3d_tracker import AnimationSlice3DTracker
+from .ecg_3d_tracker import ECG3DTracker
+from .period_3d_tracker import Period3DTracker
+from .period_animation_3d_tracker import PeriodAnimation3DTracker
+from .spiral_wave_core_3d_tracker import SpiralWaveCore3DTracker
+from .variable_3d_tracker import Variable3DTracker
+from .multi_variable_3d_tracker import MultiVariable3DTracker
+from .vtk_frame_3d_tracker import VTKFrame3DTracker
+from .animation_3d_tracker import Animation3DTracker
diff --git a/finitewave/cpuwave3D/tracker/action_potential_3d_tracker.py b/finitewave/cpuwave3D/tracker/action_potential_3d_tracker.py
index 44e4620..c4a5f48 100755
--- a/finitewave/cpuwave3D/tracker/action_potential_3d_tracker.py
+++ b/finitewave/cpuwave3D/tracker/action_potential_3d_tracker.py
@@ -1,89 +1,15 @@
-import os
-import numpy as np
-from finitewave.core.tracker.tracker import Tracker
+from finitewave.cpuwave2D.tracker.action_potential_2d_tracker import (
+ ActionPotential2DTracker
+)
-class ActionPotential3DTracker(Tracker):
+class ActionPotential3DTracker(ActionPotential2DTracker):
"""
- A class to track and record the action potential of a specific cell in a 3D cardiac tissue model.
-
- This tracker monitors the membrane potential of a single cell at each time step and stores the data
- in an array for later analysis or visualization.
-
- Attributes
- ----------
- act_pot : np.ndarray
- Array to store the action potential values at each time step.
- cell_ind : list of int
- Coordinates of the cell to be tracked in the 3D model grid.
- file_name : str
- Name of the file where the tracked action potential data will be saved.
-
- Methods
- -------
- initialize(model):
- Initializes the tracker with the simulation model, setting up the action potential array.
- track():
- Records the action potential of the specified cell at the current time step.
- output():
- Returns the tracked action potential data.
- write():
- Saves the tracked action potential data to a file.
+ Class that tracks action potentials in 3D.
"""
def __init__(self):
"""
Initializes the ActionPotential3DTracker with default parameters.
"""
- Tracker.__init__(self)
- self.act_pot = np.array([])
- self.cell_ind = [1, 1, 1]
- self.file_name = "act_pot"
-
- def initialize(self, model):
- """
- Initializes the tracker with the simulation model, setting up the action potential array.
-
- Parameters
- ----------
- model : object
- The cardiac tissue model object that contains simulation parameters like `t_max` (maximum time)
- and `dt` (time step).
- """
- self.model = model
-
- t_max = self.model.t_max
- dt = self.model.dt
- self.act_pot = np.zeros(int(t_max/dt)+1)
-
- def track(self):
- """
- Records the action potential of the specified cell at the current time step.
-
- The action potential value is retrieved from the model's `u` matrix at the coordinates specified
- by `cell_ind`.
- """
- step = self.model.step
- self.act_pot[step] = self.model.u[self.cell_ind[0],
- self.cell_ind[1],
- self.cell_ind[2]]
-
- @property
- def output(self):
- """
- Returns the tracked action potential data.
-
- Returns
- -------
- np.ndarray
- The array containing the tracked action potential values.
- """
- return self.act_pot
-
- def write(self):
- """
- Saves the tracked action potential data to a file.
-
- The file is saved in the path specified by `self.path` with the name `self.file_name`.
- """
- np.save(os.path.join(self.path, self.file_name), self.act_pot)
+ super().__init__()
diff --git a/finitewave/cpuwave3D/tracker/activation_time_3d_tracker.py b/finitewave/cpuwave3D/tracker/activation_time_3d_tracker.py
index 3d54a89..0778d73 100755
--- a/finitewave/cpuwave3D/tracker/activation_time_3d_tracker.py
+++ b/finitewave/cpuwave3D/tracker/activation_time_3d_tracker.py
@@ -1,85 +1,15 @@
-import os
-import numpy as np
-from finitewave.core.tracker.tracker import Tracker
+from finitewave.cpuwave2D.tracker.activation_time_2d_tracker import (
+ ActivationTime2DTracker
+)
-class ActivationTime3DTracker(Tracker):
+class ActivationTime3DTracker(ActivationTime2DTracker):
"""
- A class to track and record the activation time of each cell in a 3D cardiac tissue model.
-
- This tracker monitors the membrane potential of each cell and records the time at which the potential
- crosses a certain threshold, indicating cell activation.
-
- Attributes
- ----------
- act_t : np.ndarray
- Array to store the activation time of each cell in the 3D model grid.
- threshold : float
- The membrane potential threshold value that determines cell activation.
- file_name : str
- Name of the file where the tracked activation time data will be saved.
-
- Methods
- -------
- initialize(model):
- Initializes the tracker with the simulation model, setting up the activation time array.
- track():
- Records the activation time of each cell based on the threshold crossing.
- output():
- Returns the tracked activation time data.
- write():
- Saves the tracked activation time data to a file.
+ Class that tracks activation times in 3D.
"""
def __init__(self):
"""
Initializes the ActivationTime3DTracker with default parameters.
"""
- Tracker.__init__(self)
- self.act_t = np.array([])
- self.threshold = -40
- self.file_name = "act_time_3d"
-
- def initialize(self, model):
- """
- Initializes the tracker with the simulation model, setting up the activation time array.
-
- Parameters
- ----------
- model : object
- The cardiac tissue model object that contains the grid (`u`) of membrane potentials.
- """
- self.model = model
-
- self.act_t = -np.ones(self.model.u.shape)
-
- def track(self):
- """
- Records the activation time of each cell based on the threshold crossing.
-
- The activation time is recorded as the first instance where the membrane potential of a cell
- crosses the threshold value.
- """
- self.act_t = np.where(np.logical_and(self.act_t < 0,
- self.model.u > self.threshold),
- self.model.t,
- self.act_t)
- @property
- def output(self):
- """
- Returns the tracked activation time data.
-
- Returns
- -------
- np.ndarray
- The array containing the activation time of each cell in the 3D grid.
- """
- return self.act_t
-
- def write(self):
- """
- Saves the tracked activation time data to a file.
-
- The file is saved in the path specified by `self.path` with the name `self.file_name`.
- """
- np.save(os.path.join(self.path, self.file_name), self.act_t)
+ super().__init__()
diff --git a/finitewave/cpuwave3D/tracker/animation_3d_tracker.py b/finitewave/cpuwave3D/tracker/animation_3d_tracker.py
index 71e6d1f..d009f42 100644
--- a/finitewave/cpuwave3D/tracker/animation_3d_tracker.py
+++ b/finitewave/cpuwave3D/tracker/animation_3d_tracker.py
@@ -1,128 +1,57 @@
from pathlib import Path
-import numpy as np
-import pyvista as pv
import shutil as shatilib
-from finitewave.core.tracker.tracker import Tracker
-from finitewave.tools.vis_mesh_builder_3d import VisMeshBuilder3D
+from finitewave.cpuwave2D.tracker.animation_2d_tracker import (
+ Animation2DTracker
+)
from finitewave.tools.animation_3d_builder import Animation3DBuilder
-class Animation3DTracker(Tracker):
- """
- A class to track and save frames of a 3D cardiac tissue model simulation for animation purposes.
-
- This tracker periodically saves the state of a specified target array from the model to disk as NumPy files,
- which can later be used to create animations.
-
- Attributes
- ----------
- step : int
- Interval in time steps at which frames are saved.
- start : float
- The time at which to start recording frames.
- _t : float
- Internal counter for keeping track of the elapsed time since the last frame was saved.
- dir_name : str
- Directory name where animation frames are stored.
- _frame_n : int
- Internal counter to keep track of the number of frames saved.
- target_array : str
- The name of the model attribute to be saved as a frame.
- frame_format : dict
- A dictionary defining the format of saved frames. Contains 'type' (data type) and 'mult' (multiplier for scaling).
- _frame_format_type : str
- Internal storage for the data type of the saved frames.
- _frame_format_mult : float
- Internal storage for the multiplier for scaling the saved frames.
-
- Methods
- -------
- initialize(model):
- Initializes the tracker with the simulation model and sets up directories for saving frames.
- track():
- Saves frames based on the specified step interval and target array.
- write():
- No operation. Exists to fulfill the interface requirements.
+class Animation3DTracker(Animation2DTracker):
+ """A class to track and save frames of a 3D cardiac tissue model simulation
+ for animation purposes.
"""
def __init__(self):
"""
Initializes the Animation3DTracker with default parameters.
"""
- Tracker.__init__(self)
- self.step = 1
- self.start = 0
- self.target_array = ""
- self.dir_name = "animation"
-
- self._t = 0
- self._frame_n = 0
+ super().__init__()
- def initialize(self, model):
+ def write(self, path=None, clim=[0, 1], cmap="viridis", scalar_bar=False,
+ format="mp4", clear=False, prog_bar=True, **kwargs):
"""
- Initializes the tracker with the simulation model and sets up directories for saving frames.
+ Write the animation to a file.
Parameters
----------
- model : object
- The cardiac tissue model object containing the data to be tracked.
- """
- self.model = model
-
- self._t = 0
- self._frame_n = 0
- self._dt = self.model.dt
- self._step = self.step - self._dt
-
- if not Path(self.path).joinpath(self.dir_name).exists():
- Path(self.path).joinpath(self.dir_name).mkdir(parents=True)
-
- def track(self):
- """
- Saves frames based on the specified step interval and target array.
-
- The frames are saved in the specified directory as NumPy files.
- """
- path = Path(self.path)
- if not self.model.t >= self.start:
- return
-
- if self._t > self._step:
- frame = self.model.__dict__[self.target_array]
- np.save(path.joinpath(self.dir_name, f"{self._frame_n}.npy"),
- frame)
- self._frame_n += 1
- self._t = 0
- else:
- self._t += self._dt
-
- def write(self, path=None, clim=[0, 1], cmap="viridis", scalar_bar=False,
- format="mp4", clear=False, **kwargs):
- """Write the animation to a file.
-
- Args:
- path (str, optional): Path to save the animation.
- Defaults is path of the tracker.
- clim (list, optional): Color limits. Defaults to [0, 1].
- cmap (str, optional): Color map. Defaults to "viridis".
- scalar_bar (bool, optional): Show scalar bar. Defaults to False.
- format (str, optional): Format of the animation. Defaults to "mp4".
- Other options are "gif".
- clear (bool, optional): Clear the snapshot folder after writing
- the animation. Defaults to False.
- **kwargs: Additional arguments for the animation writer.
+ path : str, optional
+ Path to save the animation. Defaults to path of the tracker.
+ clim : list, optional
+ Color limits. Defaults to [0, 1].
+ cmap : str, optional
+ Color map. Defaults to "viridis".
+ scalar_bar : bool, optional
+ Show scalar bar. Defaults to False.
+ format : str, optional
+ Format of the animation. Defaults to "mp4". Other option is "gif".
+ clear : bool, optional
+ Clear the snapshot folder after writing the animation.
+ Defaults to False.
+ **kwargs : optional
+ Additional arguments for the animation writer.
"""
if path is None:
path = self.path
animation_builder = Animation3DBuilder()
- animation_builder.write(Path(self.path).joinpath(self.dir_name),
+ animation_builder.write(Path(self.path, self.dir_name),
path_save=path,
mask=self.model.cardiac_tissue.mesh,
- scalar_name=self.target_array,
+ scalar_name=self.variable_name,
clim=clim, cmap=cmap,
- scalar_bar=scalar_bar, format=format, **kwargs)
+ scalar_bar=scalar_bar, format=format,
+ prog_bar=prog_bar, **kwargs)
if clear:
- shatilib.rmtree(Path(self.path).joinpath(self.dir_name))
+ shatilib.rmtree(Path(self.path, self.dir_name))
diff --git a/finitewave/cpuwave3D/tracker/animation_slice_3d_tracker.py b/finitewave/cpuwave3D/tracker/animation_slice_3d_tracker.py
index 3221ee0..11f7a7f 100755
--- a/finitewave/cpuwave3D/tracker/animation_slice_3d_tracker.py
+++ b/finitewave/cpuwave3D/tracker/animation_slice_3d_tracker.py
@@ -1,63 +1,120 @@
-import os
+from pathlib import Path
import numpy as np
-from finitewave.core.tracker.tracker import Tracker
+from finitewave.cpuwave2D.tracker.animation_2d_tracker import (
+ Animation2DTracker
+)
+from finitewave.tools.animation_2d_builder import Animation2DBuilder
-class AnimationSlice3DTracker(Tracker):
- def __init__(self):
- Tracker.__init__(self)
- self.step = 1
- self._t = 0
-
- self.dir_name = "animation"
-
- self._frame_n = 0
-
- self.target_array = ""
+class AnimationSlice3DTracker(Animation2DTracker):
+ """
+ A class to track and save 2D frames of a 3D cardiac tissue model simulation
+ for animation purposes.
- self.slice_n = 1
- self.slice_d = 2
+ This tracker periodically saves the state of a specified target array from
+ the model to disk as NumPy files, which can later be used to create
+ animations.
- self._get_slice = None
+ Attributes
+ ----------
+ slice_x : int
+ The x-coordinate of the slice to capture.
+ slice_y : int
+ The y-coordinate of the slice to capture.
+ slice_z : int
+ The z-coordinate of the slice to capture.
+ """
- self.frame_format = {
- "type" : "float64",
- "mult" : 1
- }
-
- self._frame_format_type = ""
- self._frame_format_mult = 1
+ def __init__(self):
+ super().__init__()
+ self.slice_x = None
+ self.slice_y = None
+ self.slice_z = None
def initialize(self, model):
self.model = model
-
- self._t = 0
- self._frame_n = 0
- self._dt = self.model.dt
- self._step = self.step - self._dt
-
- if not os.path.exists(os.path.join(self.path, self.dir_name)):
- os.makedirs(os.path.join(self.path, self.dir_name))
-
- if self.slice_d == 0:
- self._get_slice = lambda a: a[self.slice_n,:,:]
- elif self.slice_d == 1:
- self._get_slice = lambda a: a[:,self.slice_n,:]
- else:
- self._get_slice = lambda a: a[:,:,self.slice_n]
-
- self._frame_format_type = self.frame_format["type"]
- self._frame_format_mult = self.frame_format["mult"]
-
- def track(self):
- if self._t > self._step:
- frame = (self._get_slice(self.model.__dict__[self.target_array])*self._frame_format_mult).astype(self._frame_format_type)
- np.save(os.path.join(self.path, self.dir_name, str(self._frame_n)), frame)
- self._frame_n += 1
- self._t = 0
- else:
- self._t += self._dt
-
- def write(self):
- pass
+ self._frame_counter = 0
+
+ if np.count_nonzero([self.slice_x, self.slice_y, self.slice_z]) != 1:
+ message = "Exactly one slice must be specified."
+ raise ValueError(message)
+
+ super().initialize(model)
+
+ def _track(self):
+ """
+ Saves frames based on the specified step interval and target array.
+
+ The frames are saved in the specified directory as NumPy files.
+ """
+ values = self.model.__dict__[self.variable_name]
+
+ frame = self.select_frame(values)
+
+ np.save(Path(self.path, self.dir_name, str(self._frame_counter)
+ ).with_suffix(".npy"), frame.astype(self.frame_type))
+
+ self._frame_counter += 1
+
+ def select_frame(self, array):
+ """
+ Selects the slice from the 3D array based on the specified slice
+ coordinates.
+
+ Parameters
+ ----------
+ array : ndarray
+ The 3D array to slice.
+
+ Returns
+ -------
+ ndarray
+ The 2D slice of the 3D array.
+ """
+ if self.slice_x is not None:
+ return array[self.slice_x, :, :]
+
+ if self.slice_y is not None:
+ return array[:, self.slice_y, :]
+
+ if self.slice_z is not None:
+ return array[:, :, self.slice_z]
+
+ def write(self, shape_scale=1, fps=12, cmap="coolwarm", clim=[0, 1],
+ clear=False, prog_bar=True):
+ """
+ Creates an animation from the saved frames using the Animation2DBuilder
+ class. Fibrosis and boundaries will be shown in black.
+
+ Parameters
+ ----------
+ shape_scale : int, optional
+ Scale factor for the frame size. The default is 5.
+ fps : int, optional
+ Frames per second for the animation. The default is 12.
+ cmap : str, optional
+ Color map for the animation. The default is 'coolwarm'.
+ clim : list, optional
+ Color limits for the animation. The default is [0, 1].
+ clear : bool, optional
+ Clear the snapshot folder after creating the animation.
+ The default is False.
+ prog_bar : bool, optional
+ Show a progress bar during the animation creation.
+ The default is True.
+ """
+ animation_builder = Animation2DBuilder()
+ path = Path(self.path, self.dir_name)
+ mask = self.select_frame(self.model.cardiac_tissue.mesh) != 1
+
+ animation_builder.write(path,
+ animation_name=self.file_name,
+ mask=mask,
+ shape_scale=shape_scale,
+ fps=fps,
+ clim=clim,
+ shape=mask.shape,
+ cmap=cmap,
+ clear=clear,
+ prog_bar=prog_bar)
diff --git a/finitewave/cpuwave3D/tracker/ecg_3d_tracker.py b/finitewave/cpuwave3D/tracker/ecg_3d_tracker.py
index e89a963..2254f54 100644
--- a/finitewave/cpuwave3D/tracker/ecg_3d_tracker.py
+++ b/finitewave/cpuwave3D/tracker/ecg_3d_tracker.py
@@ -1,4 +1,4 @@
-import os
+from pathlib import Path
import numpy as np
from numba import njit, prange
from scipy import spatial
@@ -6,89 +6,135 @@
from finitewave.core.tracker.tracker import Tracker
-@njit(parallel=True)
-def measure(mesh, curr, coord):
- n0 = coord.shape[0]
- n1 = curr.shape[0]
- n2 = curr.shape[1]
- n3 = curr.shape[2]
-
- ecg = np.zeros(n0)
- for i in prange(n0 * n1 * n2 * n3):
- i0 = i // (n1 * n2 * n3)
- i1 = i % (n1 * n2 * n3) // (n2 * n3)
- i2 = (i % (n1 * n2 * n3)) % (n2 * n3) // n3
- i3 = (i % (n1 * n2 * n3)) % (n2 * n3) % n3
- if mesh[i1, i2, i3] != 1:
- continue
- ecg[i0] += curr[i1, i2, i3] / ((coord[i0, 0] - i1)**2 +
- (coord[i0, 1] - i2)**2 +
- (coord[i0, 2] - i3)**2)
- return ecg
-
-
class ECG3DTracker(Tracker):
- def __init__(self, memory_save=False):
- Tracker.__init__(self)
- # self.radius = radius
- self.measure_coords = np.array([[0, 0, 1]])
- self.ecg = np.ndarray
- self.step = 1
- self._index = 0
- self.memory_save = memory_save
+ """
+ A class to compute and track electrocardiogram (ECG) signals from a 3D
+ cardiac tissue model simulation.
+
+ This tracker calculates ECG signals at specified measurement points by
+ computing the potential differences across the cardiac tissue mesh and
+ considering the inverse of the distance from each measurement point.
+
+ Attributes
+ ----------
+ measure_coords : np.ndarray
+ An array of points (x, y, z) where ECG signals are measured.
+ ecg : list
+ The computed ECG signals.
+ file_name : str
+ The name of the file to save the computed ECG signals.
+ u_tr : np.ndarray
+ The updated potential values after diffusion.
+ """
+
+ def __init__(self, measure_coords=None):
+ super().__init__()
+ self.measure_coords = measure_coords
+ self.ecg = []
+ self.file_name = "ecg.npy"
+ self.u_tr = None
def initialize(self, model):
+ """
+ Initialize the ECG tracker with the model object.
+
+ Parameters
+ ----------
+ model : CardiacModel3D
+ The model object containing the simulation parameters.
+ """
self.model = model
- n = self.measure_coords.shape[0]
- m = int(np.ceil(model.t_max / (self.step * model.dt)))
- self.ecg = np.zeros((n, m), dtype=model.npfloat)
- self.tissue_coords = np.argwhere(model.cardiac_tissue.mesh == 1
- ).astype(np.int32)
-
- if self.memory_save:
- self.uni_voltage = self._uni_voltage_memory_save
- return
-
- self.compute_distance()
-
- def compute_distance(self):
- self.distance = np.ones((self.measure_coords.shape[0],
- self.tissue_coords.shape[0]),
- dtype=np.float16)
-
- for i, point in enumerate(self.measure_coords):
- self.distance[i, :] = np.sum((point - self.tissue_coords)**2,
- axis=1).astype(np.float32)
-
- def uni_voltage(self, current):
- return np.sum(current[tuple(self.tissue_coords.T)] / self.distance,
- axis=1)
-
- def _uni_voltage_memory_save(self, current):
- return self.measure(current, self.measure_coords)
-
- def measure(self, current, coords, batch_size=10):
- ecg = []
- split_inds = np.arange(coords.shape[0])[::batch_size][1:]
- coords = np.split(coords, split_inds)
- for coord in coords:
- distance = spatial.distance.cdist(coord, self.tissue_coords)
- ecg.append(np.sum(current[tuple(self.tissue_coords.T)]
- / distance ** 2, axis=1))
- ecg = np.hstack(ecg)
- return ecg
+ self.measure_coords = np.atleast_2d(self.measure_coords)
+ self.ecg = []
+ self.u_tr = np.zeros_like(model.u)
def calc_ecg(self):
- current = self.model.u_new - self.model.u
- current[self.model.cardiac_tissue.mesh != 1] = 0
- return self.uni_voltage(current) / self.model.dr
+ """
+ Calculate the ECG signal at the measurement points.
+
+ Returns
+ -------
+ np.ndarray
+ The computed ECG signal.
+ """
+ self.model.diffusion_kernel(self.u_tr,
+ self.model.u,
+ self.model.weights,
+ self.model.cardiac_tissue.myo_indexes)
+ ecg = compute_ecg(self.u_tr,
+ self.model.u,
+ self.measure_coords,
+ self.model.dr,
+ self.model.cardiac_tissue.myo_indexes)
+ return ecg
+
+ def _track(self):
+ ecg = self.calc_ecg()
+ self.ecg.append(ecg)
+
+ @property
+ def output(self):
+ """
+ Get the computed ECG signals as a numpy array.
- def track(self):
- if self.model.step % self.step == 0:
- self.ecg[:, self._index] = self.calc_ecg()
- self._index += 1
+ Returns
+ -------
+ np.ndarray
+ The computed ECG signals.
+ """
+ return np.array(self.ecg)
def write(self):
- if not os.path.exists(self.dir_name):
- os.mkdir(self.dir_name)
- np.save(self.ecg)
+ """
+ Save the computed ECG signals to a file.
+
+ The ECG signals are saved as a numpy array in the specified path.
+ """
+ if not Path(self.path).exists():
+ Path(self.path).mkdir(parents=True)
+
+ np.save(Path(self.path, self.file_name), self.output)
+
+
+@njit(parallel=True)
+def compute_ecg(u_tr, u, coords, dr, indexes):
+ """
+ Performs isotropic diffusion on a 3D grid.
+
+ Parameters
+ ----------
+ u_tr : numpy.ndarray
+ A 3D array to store the updated potential values after diffusion.
+ u : numpy.ndarray
+ A 3D array representing the current potential values before diffusion.
+ coord : tuple
+ The coordinates of the measurement point.
+ dr : float
+ The spatial resolution of the grid.
+ indexes : numpy.ndarray
+ A 1D array of indices of the healthy tissue points.
+ """
+ n_j = u.shape[1]
+ n_k = u.shape[2]
+
+ n_c = len(coords)
+ ecg = np.zeros(n_c)
+
+ for c in range(n_c):
+ x, y, z = coords[c]
+ ecg_ = 0
+
+ for ind in prange(len(indexes)):
+ ii = indexes[ind]
+ i = ii // (n_j * n_k)
+ j = (ii % (n_j * n_k)) // n_k
+ k = (ii % (n_j * n_k)) % n_k
+
+ d = (x - i)**2 + (y - j)**2 + (z - k)**2
+
+ if d > 0:
+ ecg_ += (u_tr[i, j, k] - u[i, j, k]) / (d * dr)
+
+ ecg[c] = ecg_
+
+ return ecg
diff --git a/finitewave/cpuwave3D/tracker/local_activation_time_3d_tracker.py b/finitewave/cpuwave3D/tracker/local_activation_time_3d_tracker.py
new file mode 100644
index 0000000..3cf37a3
--- /dev/null
+++ b/finitewave/cpuwave3D/tracker/local_activation_time_3d_tracker.py
@@ -0,0 +1,15 @@
+
+from finitewave.cpuwave2D.tracker.local_activation_time_2d_tracker import (
+ LocalActivationTime2DTracker
+)
+
+
+class LocalActivationTime3DTracker(LocalActivationTime2DTracker):
+ """
+ Class that tracks multiple activation times in 3D.
+ """
+ def __init__(self):
+ """
+ Initializes the LocalActivationTime3DTracker with default parameters.
+ """
+ super().__init__()
diff --git a/finitewave/cpuwave3D/tracker/multi_variable_3d_tracker.py b/finitewave/cpuwave3D/tracker/multi_variable_3d_tracker.py
new file mode 100644
index 0000000..ef89a19
--- /dev/null
+++ b/finitewave/cpuwave3D/tracker/multi_variable_3d_tracker.py
@@ -0,0 +1,11 @@
+from finitewave.cpuwave2D.tracker.multi_variable_2d_tracker import (
+ MultiVariable2DTracker
+)
+
+
+class MultiVariable3DTracker(MultiVariable2DTracker):
+ """
+ Class for tracking 3D variables
+ """
+ def __init__(self):
+ super().__init__()
diff --git a/finitewave/cpuwave3D/tracker/period_3d_tracker.py b/finitewave/cpuwave3D/tracker/period_3d_tracker.py
index 8a5b115..a144af1 100755
--- a/finitewave/cpuwave3D/tracker/period_3d_tracker.py
+++ b/finitewave/cpuwave3D/tracker/period_3d_tracker.py
@@ -1,87 +1,9 @@
-import numpy as np
-from numba import njit
-import json
+from finitewave.cpuwave2D.tracker.period_2d_tracker import Period2DTracker
-from finitewave.core.tracker.tracker import Tracker
-
-@njit
-def _track_detectors_period(periods, detectors, detectors_state, u, t, threshold, step):
- n_i, n_j, n_k = u.shape
- for i in range(n_i):
- for j in range(n_j):
- for k in range(n_k):
- if detectors[i, j, k] and u[i, j, k] > threshold and detectors_state[i, j, k]:
- periods[step] = [i, j, k, t]
- detectors_state[i, j, k] = 0
- step += 1
- elif detectors[i, j, k] and u[i, j, k] <= threshold and not detectors_state[i, j, k]:
- detectors_state[i, j, k] = 1
-
- return periods, detectors_state, step
-
-
-class Period3DTracker(Tracker):
+class Period3DTracker(Period2DTracker):
+ """
+ Class for tracking 3D period. Initializes Period2DTracker.
+ """
def __init__(self):
- Tracker.__init__(self)
-
- self.detectors = np.array([])
- self.threshold = -40
-
- self._periods = np.array([])
- self._detectors_state = np.array([])
- self._step = 0
-
- self.file_name = "period"
-
- def initialize(self, model):
- self.model = model
-
- t_max = self.model.t_max
- dt = self.model.dt
- n = 20*len(self.detectors[self.detectors == 1]) # a start length of the array
- self._periods = -1*np.ones([n, 4])
- self._detectors_state = np.ones(self.model.u.shape, dtype="uint8")
-
- def track(self):
- # dynamically increase the size of the array if there is no free space:
- if self._step == len(self._periods):
- self._periods = np.tile(self._periods, (2, 1))
- self._periods[len(self._periods)//2:, :] = -1.
-
- self.period_detectors, self._detectors_state, self._step = _track_detectors_period(
- self._periods, self.detectors, self._detectors_state,
- self.model.u, self.model.t, self.threshold,
- self._step)
-
- def compute_periods(self):
- periods_dict = dict()
- to_str = lambda i, j, k: str(int(i)) + "," + str(int(j)) + "," + str(int(k))
-
- for i in range(len(self._periods)):
- if self._periods[i][0] < 0:
- continue
- key = to_str(*self._periods[i][:3])
- if not key in periods_dict:
- periods_dict[key] = []
- periods_dict[key].append(self._periods[i][3])
-
- for key in periods_dict:
- time_per_list = []
- for i, t in enumerate(periods_dict[key]):
- if i == 0:
- time_per_list.append([t, 0])
- else:
- time_per_list.append([t, t-time_per_list[i-1][0]])
- periods_dict[key] = time_per_list
-
- return periods_dict
-
- @property
- def output(self):
- return self.compute_periods()
-
- def write(self):
- jdata = json.dumps(self.compute_periods())
- with open(os.path.join(self.path, self.file_name), "w") as jf:
- jf.write(jdata)
+ super().__init__()
diff --git a/finitewave/cpuwave3D/tracker/period_animation_3d_tracker.py b/finitewave/cpuwave3D/tracker/period_animation_3d_tracker.py
new file mode 100755
index 0000000..bc35579
--- /dev/null
+++ b/finitewave/cpuwave3D/tracker/period_animation_3d_tracker.py
@@ -0,0 +1,48 @@
+from pathlib import Path
+import shutil as shatilib
+from finitewave.cpuwave2D.tracker.period_animation_2d_tracker import (
+ PeriodAnimation2DTracker
+)
+from finitewave.tools.animation_3d_builder import Animation3DBuilder
+
+
+class PeriodAnimation3DTracker(PeriodAnimation2DTracker):
+ """
+ Class for tracking 3D period map. Initializes PeriodAnimation2DTracker.
+ """
+ def __init__(self):
+ super().__init__()
+
+ def write(self, clim=[0, 1], cmap="viridis", scalar_bar=False, clear=True,
+ prog_bar=True, **kwargs):
+ """
+ Write the animation to a file.
+
+ Parameters
+ ----------
+ clim : list, optional
+ Color limits. Defaults to [0, 1].
+ cmap : str, optional
+ Color map. Defaults to "viridis".
+ scalar_bar : bool, optional
+ Show scalar bar. Defaults to False.
+ clear : bool, optional
+ Clear the snapshot folder after writing the animation.
+ Defaults to True.
+ prog_bar : bool, optional
+ Show progress bar. Defaults to True.
+ **kwargs : optional
+ Additional arguments for the animation writer.
+ """
+
+ animation_builder = Animation3DBuilder()
+ animation_builder.write(Path(self.path, self.dir_name),
+ path_save=self.path,
+ mask=self.model.cardiac_tissue.mesh,
+ scalar_name='Period',
+ clim=clim, cmap=cmap,
+ scalar_bar=scalar_bar, format='mp4',
+ prog_bar=prog_bar, **kwargs)
+
+ if clear:
+ shatilib.rmtree(Path(self.path, self.dir_name))
diff --git a/finitewave/cpuwave3D/tracker/period_map_3d_tracker.py b/finitewave/cpuwave3D/tracker/period_map_3d_tracker.py
deleted file mode 100755
index 5f6c95d..0000000
--- a/finitewave/cpuwave3D/tracker/period_map_3d_tracker.py
+++ /dev/null
@@ -1,38 +0,0 @@
-import os
-import numpy as np
-
-from finitewave.cpuwave3D.tracker import AnimationSlice3DTracker
-
-class PeriodMap3DTracker(AnimationSlice3DTracker):
- def __init__(self):
- AnimationSlice3DTracker.__init__(self)
-
- self.dir_name = "period"
-
- self.threshold = -40.
- self.period_map = np.array([])
- self._period_map_state = np.array([])
-
- def initialize(self, model):
- AnimationSlice3DTracker.initialize(self, model)
-
- self.period_map = -1*np.ones(self.model.u.shape)
- self._last_time_map = -1*np.ones(self.model.u.shape)
- self._period_map_state = np.ones(self.model.u.shape, dtype="uint8")
-
- def track(self):
- if self._t > self.step:
- active_nodes = np.logical_and(self._period_map_state == 1, self.model.u > self.threshold)
- self.period_map[active_nodes] = self.model.t - self._last_time_map[active_nodes]
- self._last_time_map[active_nodes] = self.model.t
- self._period_map_state[active_nodes] = 0
- self._period_map_state[np.logical_and(self._period_map_state == 0, self.model.u < self.threshold)] = 1
-
- np.save(os.path.join(self.path, self.dir_name, str(self._frame_n)), self.period_map)
- self._frame_n += 1
- self._t = 0
- else:
- self._t += self._dt
-
- def write(self):
- pass
diff --git a/finitewave/cpuwave3D/tracker/spiral_3d_tracker.py b/finitewave/cpuwave3D/tracker/spiral_3d_tracker.py
deleted file mode 100755
index cf96496..0000000
--- a/finitewave/cpuwave3D/tracker/spiral_3d_tracker.py
+++ /dev/null
@@ -1,215 +0,0 @@
-import os
-from math import sqrt
-from numba import njit
-import numpy as np
-import warnings
-from math import sqrt
-
-from finitewave.core.tracker.tracker import Tracker
-
-
-# @njit
-def _calc_tippos(vij, vi1j, vi1j1, vij1, vnewij, vnewi1j,
- vnewi1j1, vnewij1, V_iso1, V_iso2):
- xy = [0, 0]
- # For old voltage values of point and neighbours
- AC=(vij-vij1+vi1j1-vi1j) # upleft-downleft + downright-upright
- GC=(vij1-vij) # downleft-upleft
- BC=(vi1j-vij) # upright-upleft
- DC=(vij-V_iso1) # upleft-iso
-
- # For current voltage values of point and neighbours
- AD=(vnewij-vnewij1+vnewi1j1-vnewi1j)
- GD=(vnewij1-vnewij)
- BD=(vnewi1j-vnewij)
- DD=(vnewij-V_iso2) # adapted here
-
- Q=(BC*AD-BD*AC)
- R=(GC*AD-GD*AC)
- S=(DC*AD-DD*AC)
-
- QOnR=Q/R
- SOnR=S/R
-
- T=AC*QOnR
- U=(AC*SOnR-BC+GC*QOnR)
- V=(GC*SOnR)-DC
-
- # Compute discriminant of the abc formula
- # with a=T, b=U and c=V
- Disc=U*U-4.*T*V
- if Disc<0:
- # If the discriminant is smaller than
- # zero there is no solution and a
- # failure flag should be returned
- return 0, xy
- else:
-
- # Otherwise two solutions for xvalues
- T2=2.*T
- sqrtDisc=sqrt(Disc)
-
- if T2 == 0.:
- return 0, [0,0]
- xn=(-U-sqrtDisc)/T2
- xp=(-U+sqrtDisc)/T2
- # Leading to two solutions for yvalues
- yn=-QOnR*xn-SOnR
- yp=-QOnR*xp-SOnR
-
- # demand that fractions lie in interval [0,1]
- if xn>=0 and xn<=1 and yn>=0 and yn<=1:
- # If the first point fulfills these
- # conditions take that point
- xy[0]=xn
- xy[1]=yn
- return 1, xy
- elif xp>=0 and xp<=1 and yp>=0 and yp<=1:
- # If the second point fulfills these
- # conditions take that point
- xy[0]=xp
- xy[1]=yp
- return 1, xy
- else:
- # If neither point fulfills these
- # conditions return a failure flag.
- return 0, xy
-
-
-# @njit
-def _track_tipline(size_i, size_j, var1, var2, tipvals, tipdata, tipsfound, mesh):
- iso1 = tipvals[0]
- iso2 = tipvals[1]
-
- # each row contains data for a point of the tipline
- # stored in columns: type, posx posy posz, dxu dyu dzu, dxv dyv dzv, tx ty tx
- # possible types: 1 = YZ, 11 = YZ at lower medium boundary, 21 = YZ at upper medium boundary,
- # 31 at lower domain boundary, 41 at upper domain boundary
- # 2 = XZ, 12 = XZ at lower medium boundary, 22 = XZ at upper medium boundary
- # 3 = XY, 13 = XY at lower medium boundary, 23 = XY at upper medium boundary
- # sign of type equals < T , e_i > (i.e. entering or leaving the voxel)
-
- tipsfound = 0
- delta = 5
-
- # check XY-planes
- for xpos in range(delta, size_i-delta):
- for ypos in range(delta, size_j-delta):
- # Just to fix some strange behaviour. Should be deleted.
- if mesh[xpos][ypos] != 1:
- continue
- if mesh[xpos+1][ypos] != 1:
- continue
- if mesh[xpos-1][ypos] != 1:
- continue
- if mesh[xpos][ypos+1] != 1:
- continue
- if mesh[xpos][ypos-1] != 1:
- continue
- if mesh[xpos+1][ypos+1] != 1:
- continue
- if mesh[xpos-1][ypos-1] != 1:
- continue
- if tipsfound >= 100:
- break
- counter = 0
- if var1[xpos][ypos] >= iso1 and \
- (var1[xpos+1][ypos] < iso1 or \
- var1[xpos][ypos+1] < iso1 or \
- var1[xpos+1][ypos+1] < iso1):
- counter = 1
- else:
- if var1[xpos][ypos] < iso1 and \
- (var1[xpos+1][ypos] >= iso1 or \
- var1[xpos][ypos+1] >= iso1 or \
- var1[xpos+1][ypos+1] >= iso1):
- counter = 1
- if counter == 1:
- if var2[xpos][ypos] >= iso2 and \
- (var2[xpos+1][ypos] < iso2 or \
- var2[xpos][ypos+1] < iso2 or \
- var2[xpos+1][ypos+1] < iso2):
- counter = 2
- else:
- if var2[xpos][ypos] < iso2 and \
- (var2[xpos+1][ypos] >= iso2 or \
- var2[xpos][ypos+1] >= iso2 or \
- var2[xpos+1][ypos+1] >= iso2):
- counter = 2
-
- if counter == 2:
- interp = _calc_tippos(var1[xpos, ypos], var1[xpos+1, ypos], var1[xpos+1, ypos+1], var1[xpos, ypos+1],
- var2[xpos, ypos], var2[xpos+1, ypos], var2[xpos+1, ypos+1], var2[xpos, ypos+1], iso1, iso2)
- if interp[0] == 1:
- tipdata[tipsfound][0] = xpos + interp[1][0]
- tipdata[tipsfound][1] = ypos + interp[1][1]
- tipsfound += 1
-
- return tipdata, tipsfound
-
-
-class Spiral3DTracker(Tracker):
- def __init__(self):
- Tracker.__init__(self)
- self.size_i = 100
- self.size_j = 100
- self.size_k = 100
- self.dr = 0.25
- self.threshold = 0.2
- self.file_name = "swcore.txt"
- self.swcore = []
-
- self.all = False
-
- self.step = 1
- self._t = 0
-
- self._u_prev_step = np.array([])
-
- def initialize(self, model):
- self.model = model
-
- self.size_i, self.size_j, self.size_k = self.model.cardiac_tissue.shape
- self.dt = self.model.dt
- self.dr = self.model.dr
- self._u_prev_step = np.zeros([self.size_i, self.size_j, self.size_k])
- self._tipdata = np.zeros([102, 2])
-
- def track_tipline(self, var1, var2, tipvals, tipdata, tipsfound, mesh):
- return _track_tipline(self.size_i, self.size_j, var1, var2, tipvals, tipdata, tipsfound, mesh)
-
- def track(self):
- if self._t > self.step:
-
- tipvals = [0, 0]
- tipvals[0] = self.threshold
- tipvals[1] = self.threshold
-
- tipsfound = 0
- sum = 0
-
- for k in range(self.size_k):
-
- self._tipdata, tipsfound = self.track_tipline(self._u_prev_step[:,:,k], self.model.u[:,:,k], tipvals, self._tipdata, tipsfound, self.model.cardiac_tissue.mesh[:,:,k])
-
- if self.all:
- if not tipsfound:
- self.swcore.append([self.model.t, 0, -1, -1])
- for i in range(tipsfound):
- self.swcore.append([self.model.t, i+sum])
- for j in range(2):
- self.swcore[-1].append(self._tipdata[i][j]*self.dr)
- self.swcore[-1].append(k*self.dr)
-
- sum += tipsfound
- self._u_prev_step = np.copy(self.model.u)
- self._t = 0
- else:
- self._t += self.dt
-
- def write(self):
- np.savetxt(os.path.join(self.path, self.file_name), np.array(self.swcore))
-
- @property
- def output(self):
- return self.swcore
diff --git a/finitewave/cpuwave3D/tracker/spiral_wave_core_3d_tracker.py b/finitewave/cpuwave3D/tracker/spiral_wave_core_3d_tracker.py
new file mode 100755
index 0000000..ac69e6b
--- /dev/null
+++ b/finitewave/cpuwave3D/tracker/spiral_wave_core_3d_tracker.py
@@ -0,0 +1,35 @@
+import pandas as pd
+from finitewave.cpuwave2D.tracker.spiral_wave_core_2d_tracker import (
+ SpiralWaveCore2DTracker
+)
+
+
+class SpiralWaveCore3DTracker(SpiralWaveCore2DTracker):
+ """
+ A class to track spiral wave cores in 3D cardiac tissue simulations.
+
+ The tip tracker detects spiral wave cores by analyzing the voltage data
+ on each slice (z-axis) of the 3D tissue mesh.
+
+ """
+ def __init__(self):
+ super().__init__()
+
+ def _track(self):
+ """
+ Track spiral tips at each simulation step by analyzing voltage data.
+
+ The tracker is updated at each simulation step, detecting any spiral
+ tips based on the voltage data from the previous and current steps.
+ """
+ for k in range(self.model.u.shape[2]):
+ u_prev = self.u_prev[:, :, k]
+ u = self.model.u[:, :, k]
+ tips = self.track_tip_line(u_prev, u, self.threshold)
+ tips = pd.DataFrame(tips, columns=["x", "y"])
+ tips["z"] = k
+ tips["time"] = self.model.t
+ tips["step"] = self.model.step
+ self.sprial_wave_cores.append(tips)
+
+ self.u_prev = self.model.u.copy()
diff --git a/finitewave/cpuwave3D/tracker/variable_3d_tracker.py b/finitewave/cpuwave3D/tracker/variable_3d_tracker.py
index b896937..eddf6a5 100755
--- a/finitewave/cpuwave3D/tracker/variable_3d_tracker.py
+++ b/finitewave/cpuwave3D/tracker/variable_3d_tracker.py
@@ -1,33 +1,9 @@
-import os
-import numpy as np
+from finitewave.cpuwave2D.tracker.variable_2d_tracker import Variable2DTracker
-from finitewave.core.tracker.tracker import Tracker
-
-class Variable3DTracker(Tracker):
+class Variable3DTracker(Variable2DTracker):
+ """
+ Class for tracking 3D variable
+ """
def __init__(self):
- Tracker.__init__(self)
- self.var_list = []
- self.cell_ind = [1, 1, 1]
- self.dir_name = "multi_vars"
- self.vars = {}
-
- def initialize(self, model):
- self.model = model
- t_max = self.model.t_max
- dt = self.model.dt
- for var_ in self.var_list:
- self.vars[var_] = np.zeros(int(t_max/dt)+1)
-
- def track(self):
- step = self.model.step
- for var_ in self.var_list:
- self.vars[var_][step] = self.model.__dict__[var_][self.cell_ind[0],
- self.cell_ind[1],
- self.cell_ind[2]]
-
- def write(self):
- if not os.path.exists(self.dir_name):
- os.mkdir(self.dir_name)
- for var_ in self.var_list:
- np.save(os.path.join(self.dir_name, var_), self.vars[var_])
+ super().__init__()
diff --git a/finitewave/cpuwave3D/tracker/velocity_3d_tracker.py b/finitewave/cpuwave3D/tracker/velocity_3d_tracker.py
deleted file mode 100755
index efac098..0000000
--- a/finitewave/cpuwave3D/tracker/velocity_3d_tracker.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import os
-import numpy as np
-from scipy.spatial.distance import euclidean
-import json
-
-from finitewave.cpuwave3D.tracker.activation_time_3d_tracker import ActivationTime3DTracker
-
-
-class Velocity3DTracker(ActivationTime3DTracker):
- def __init__(self):
- ActivationTime3DTracker.__init__(self)
- self.file_name = "front_velocity"
-
- def initialize(self, model):
- ActivationTime3DTracker.initialize(self, model)
-
- def compute_velocity_front(self):
- # all empty nodes are -1
- # intial activation nodes are 0
- act_t = self.act_t
- dr = self.model.dr
-
- max_act = np.max(act_t)
- # front_vel = np.zeros(act_t[act_t == max_act].shape)
- ind_front = np.argwhere(act_t == max_act)
- ind_front_i = np.mean(ind_front[:, 0])
- ind_front_j = np.mean(ind_front[:, 1])
- ind_front_k = np.mean(ind_front[:, 2])
-
- ind_stim = np.argwhere(act_t == np.min(act_t[act_t >= 0.]))
- ind_stim_i = np.mean(ind_stim[:, 0])
- ind_stim_j = np.mean(ind_stim[:, 1])
- ind_stim_k = np.mean(ind_stim[:, 2])
-
- return euclidean([ind_stim_i, ind_stim_j, ind_stim_k], [ind_front_i, ind_front_j, ind_front_k])*dr/max_act
-
- @property
- def output(self):
- return self.compute_velocity_front()
-
- def write(self):
- jdata = json.dumps(self.compute_velocity_front())
- with open(self.file_name, "w") as jf:
- jf.write(jdata)
diff --git a/finitewave/cpuwave3D/tracker/vtk_frame_3d_tracker.py b/finitewave/cpuwave3D/tracker/vtk_frame_3d_tracker.py
index ff2dfaf..ad75bb4 100755
--- a/finitewave/cpuwave3D/tracker/vtk_frame_3d_tracker.py
+++ b/finitewave/cpuwave3D/tracker/vtk_frame_3d_tracker.py
@@ -8,57 +8,69 @@ class VTKFrame3DTracker(Tracker):
"""
A class for tracking and saving VTK frames in a 3D model.
- Attributes:
- step (int): The step size for tracking frames.
- file_name (str): The name of the file to save the frames
- ".vtk" or ".vtu"
- target_array (str): The name of the target array to be tracked.
- file_type (str): The file type of the saved frames.
+ Attributes
+ ----------
+ file_name (str): The name of the saved frames.
+ dir_name (str): The name of the folder where the frames will be saved.
+ variable_name (str): The name of the target array to be tracked.
+ file_type (str): The file type of the saved frames (".vtk" or ".vtu")
"""
def __init__(self):
- Tracker.__init__(self)
- self.step = 5
- self.file_name = "vtk_frames"
- self.target_array = ""
+ super().__init__()
+ self.file_name = "frame"
+ self.dir_name = "vtk_frames"
+ self.variable_name = ""
self.file_type = ".vtk"
- self._t = 0
- self._frame_n = 0
+ self._frame_counter = 0
def initialize(self, model):
- self.model = model
+ """
+ Initializes the tracker with the model.
- self._t = 0
- self._frame_n = 0
- self._dt = self.model.dt
+ Parameters
+ -----------
+ model (CardiacModel): The model to track.
+ """
+ self.model = model
+ self._frame_counter = 0
self.path = Path(self.path)
- if not self.path.joinpath(self.file_name).exists():
- self.path.joinpath(self.file_name).mkdir(parents=True)
+ if not self.path.joinpath(self.dir_name).exists():
+ self.path.joinpath(self.dir_name).mkdir(parents=True)
- if self.target_array == "":
+ if self.variable_name == "":
raise ValueError("Please specify the target array to be tracked.")
- if self.target_array not in self.model.__dict__:
- raise ValueError(f"Array {self.target_array} not found in model.")
+ if self.variable_name not in self.model.__dict__:
+ raise ValueError(f"Array {self.variable_name} not found in model.")
- def track(self):
- if self._t > self.step:
- frame_name = self.path.joinpath(self.file_name,
- f"frame{self._frame_n}"
- ).with_suffix(self.file_type)
+ def _track(self):
+ frame_name = self.path.joinpath(
+ self.dir_name, f"{self.file_name}{self._frame_counter}"
+ ).with_suffix(self.file_type)
- self.write_frame(frame_name)
- self._frame_n += 1
- self._t = 0
- else:
- self._t += self._dt
+ self.write_frame(frame_name)
+ self._frame_counter += 1
def write_frame(self, frame_name):
- state_var = self.model.__dict__[self.target_array]
+ """
+ Writes a VTK frame to a file.
+
+ Parameters
+ -----------
+ frame_name (str): The name of the frame file.
+ """
+ state_var = self.model.__dict__[self.variable_name]
vtk_mesh_builder = VisMeshBuilder3D()
vtk_mesh = vtk_mesh_builder.build_mesh(self.model.cardiac_tissue.mesh)
- vtk_mesh = vtk_mesh_builder.add_scalar(state_var, self.target_array)
+ vtk_mesh = vtk_mesh_builder.add_scalar(state_var, self.variable_name)
vtk_mesh.save(frame_name)
+
+ def write(self):
+ """
+ For compatibility with the Tracker class.
+ """
+ return super().write()
diff --git a/finitewave/tools/__init__.py b/finitewave/tools/__init__.py
index 3d8b1cd..cec9448 100755
--- a/finitewave/tools/__init__.py
+++ b/finitewave/tools/__init__.py
@@ -1,6 +1,5 @@
-from finitewave.tools.animation_builder import AnimationBuilder
-from finitewave.tools.drift_velocity_calculation import DriftVelocityCalculation
-from finitewave.tools.potential_period_animation_builder import PotentialPeriodAnimationBuilder
-from finitewave.tools.vtk_mesh_builder import VTKMeshBuilder
-from finitewave.tools.vis_mesh_builder_3d import VisMeshBuilder3D
-from finitewave.tools.animation_3d_builder import Animation3DBuilder
+from .animation_2d_builder import Animation2DBuilder
+from .animation_3d_builder import Animation3DBuilder
+from .velocity_2d_calculation import Velocity2DCalculation
+from .velocity_3d_calculation import Velocity3DCalculation
+from .vis_mesh_builder_3d import VisMeshBuilder3D
diff --git a/finitewave/tools/animation_2d_builder.py b/finitewave/tools/animation_2d_builder.py
new file mode 100755
index 0000000..a68e27d
--- /dev/null
+++ b/finitewave/tools/animation_2d_builder.py
@@ -0,0 +1,86 @@
+from pathlib import Path
+import shutil
+from natsort import natsorted
+import ffmpeg
+import numpy as np
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+
+
+class Animation2DBuilder:
+ def __init__(self):
+ pass
+
+ def write(self, path, animation_name='animation', mask=None, shape_scale=1,
+ fps=12, clim=[0, 1], shape=(100, 100), cmap="coolwarm",
+ clear=False, prog_bar=False):
+ """
+ Write an animation from a folder with snapshots.
+
+ Parameters
+ ----------
+ path : str or Path
+ Path to the folder with snapshots.
+ animation_name : str
+ Name of the animation file.
+ mask : ndarray
+ Mask to apply to the frames.
+ shape_scale : int
+ Scale factor for the frames.
+ fps : int
+ Frames per second.
+ clim : list
+ Color limits for the colormap.
+ shape : tuple
+ Shape of the frames.
+ cmap : str
+ Matplotlib colormap to use.
+ clear : bool
+ Clear the snapshot folder after writing the animation.
+ prog_bar : bool
+ Show progress bar.
+ """
+ path = Path(path)
+ path_save = path.parent.joinpath(animation_name).with_suffix(".mp4")
+
+ files = natsorted(path.glob("*.npy"))
+
+ height, width = np.array(shape) * shape_scale
+ cmap = plt.get_cmap(cmap)
+
+ with (
+ ffmpeg
+ .input('pipe:', format='rawvideo', pix_fmt='rgb24',
+ s=f'{width}x{height}', framerate=fps)
+ .output(path_save.as_posix(), pix_fmt='yuv420p')
+ .overwrite_output()
+ .run_async(pipe_stdin=True, quiet=True)
+ ) as process:
+ # Write frames to FFmpeg process
+ for file in tqdm(files, desc='Building animation',
+ disable=not prog_bar):
+ frame = np.load(file.with_suffix(".npy"))
+ # Normalize the frame data to the colormap
+ mask_ = (frame < clim[0]) | (frame > clim[1])
+
+ if mask is not None:
+ mask_ |= mask
+
+ frame = (frame - clim[0]) / (clim[1] - clim[0])
+ frame[mask_] = np.nan
+
+ frame = (cmap(frame, bytes=True)[:, :, :3]).astype("uint8")
+
+ # Upscale the frame if necessary
+ if shape_scale > 1:
+ frame = np.repeat(np.repeat(frame, shape_scale, axis=0),
+ shape_scale, axis=1)
+
+ process.stdin.write(frame.tobytes())
+
+ # Close the FFmpeg process
+ process.stdin.close()
+ process.wait()
+
+ if clear:
+ shutil.rmtree(path)
diff --git a/finitewave/tools/animation_3d_builder.py b/finitewave/tools/animation_3d_builder.py
index 2b7e6a5..aa9dff6 100644
--- a/finitewave/tools/animation_3d_builder.py
+++ b/finitewave/tools/animation_3d_builder.py
@@ -2,6 +2,7 @@
import numpy as np
import pyvista as pv
from natsort import natsorted
+from tqdm import tqdm
from finitewave.tools.vis_mesh_builder_3d import VisMeshBuilder3D
@@ -39,7 +40,8 @@ def load_scalar(self, path, mask=None):
def write(self, path, mask=None, path_save=None, window_size=(800, 800),
clim=[0, 1], scalar_name="Scalar", animation_name="animation",
- cmap="viridis", scalar_bar=False, format="mp4", **kwargs):
+ cmap="viridis", scalar_bar=False, format="mp4", prog_bar=True,
+ **kwargs):
"""Write the animation to a file.
Args:
@@ -95,7 +97,8 @@ def write(self, path, mask=None, path_save=None, window_size=(800, 800),
pl.write_frame()
- for filename in files[1:]:
+ for filename in tqdm(files[1:], disable=not prog_bar,
+ desc="Building animation"):
scalar = self.load_scalar(filename, mask)
mesh_builder.add_scalar(scalar, scalar_name)
pl.write_frame()
diff --git a/finitewave/tools/animation_builder.py b/finitewave/tools/animation_builder.py
deleted file mode 100755
index 205467a..0000000
--- a/finitewave/tools/animation_builder.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-from matplotlib.animation import FFMpegWriter
-import time
-import sys
-import os
-
-
-class AnimationBuilder:
- def __init__(self):
- self.dir_name = ""
- self.skip = 0
- self.vmin = 0
- self.vmax = 1
-
- # take into account the user path:
- self._prefix = os.getcwd()
-
- def write_2d_mp4(self, file_name, title="", fps=5, dpi=100):
- metadata = dict(title=title, artist='finitewave')
- writer = FFMpegWriter(fps=fps, metadata=metadata)
-
- frames_list = os.listdir(self.dir_name)
- frames_list.sort(key=lambda x: int(x.split(".")[0]))
-
- if not len(frames_list):
- return
- fig = plt.figure()
- frame_data = np.load(os.path.join(self._prefix, self.dir_name, frames_list[0]))
- anim = plt.imshow(frame_data, vmax=self.vmax, vmin=self.vmin, animated=True)
- plt.colorbar(anim)
- with writer.saving(fig, os.path.join(self._prefix, file_name), dpi):
- start_time = time.time()
- N = len(frames_list)
- for i in range(1, N):
- frame_data = np.load(os.path.join(self._prefix, self.dir_name, frames_list[i]))
- anim.set_array(frame_data)
- writer.grab_frame()
- sys.stdout.write("Writing frames: %d of %d\r" % (i, N))
- sys.stdout.flush()
- plt.close()
diff --git a/finitewave/tools/drift_velocity_calculation.py b/finitewave/tools/drift_velocity_calculation.py
deleted file mode 100755
index 8a6f1c8..0000000
--- a/finitewave/tools/drift_velocity_calculation.py
+++ /dev/null
@@ -1,34 +0,0 @@
-import math
-import numpy as np
-from scipy.optimize import curve_fit
-
-
-def _line(x, a, b):
- return a*x + b
-
-
-class DriftVelocityCalculation:
- def __init__(self):
- self.swcore = []
- self.time_span = 0.
-
- def compute_drift(self):
- swcore = np.array(self.swcore)
- step = swcore[1, 0] - swcore[0, 0]
-
- indx = int(self.time_span/step)
-
- time = swcore[-indx:, 0]
- comp_x = swcore[-indx:, 2]
- comp_y = swcore[-indx:, 3]
-
- a_x, b_x = curve_fit(_line, time, comp_x)[0]
- a_y, b_y = curve_fit(_line, time, comp_y)[0]
-
- fit_x = _line(time, a_x, b_x)
- fit_y = _line(time, a_y, b_y)
-
- drift_x = (fit_x[-1] - fit_x[0])/(time[-1] - time[0])
- drift_y = (fit_y[-1] - fit_y[0])/(time[-1] - time[0])
-
- return drift_x, drift_y, math.sqrt(drift_x**2 + drift_y**2)
diff --git a/finitewave/tools/potential_period_animation_builder.py b/finitewave/tools/potential_period_animation_builder.py
deleted file mode 100755
index 68a7fd6..0000000
--- a/finitewave/tools/potential_period_animation_builder.py
+++ /dev/null
@@ -1,76 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-from matplotlib.animation import FFMpegWriter
-import time
-import sys
-import os
-
-
-class PotentialPeriodAnimationBuilder:
- def __init__(self):
- self.file_name_pot = ""
- self.file_name_per = ""
- self.skip = 0
- self.vmin_pot = 0
- self.vmax_pot = 1
- self.vmin_per = 0
- self.vmax_per = 1
-
- self.colormap_pot = ""
- self.colormap_per = ""
-
- # take into account the user path:
- self._prefix = os.getcwd()
-
- def write_2d_mp4(self, file_name, title="", fps=5, dpi=100):
- metadata = dict(title=title, artist='finitewave')
- writer = FFMpegWriter(fps=fps, metadata=metadata)
-
- pot_frames_list = os.listdir(self.file_name_pot)
- pot_frames_list.sort(key=lambda x: int(x.split(".")[0]))
-
- per_frames_list = os.listdir(self.file_name_per)
- per_frames_list.sort(key=lambda x: int(x.split(".")[0]))
-
- if not (len(pot_frames_list) and len(per_frames_list)):
- return
-
- fig, ax = plt.subplots(1,2)
-
- fig.subplots_adjust(wspace=0.5)
-
- ax_pot = ax[0]
- ax_per = ax[1]
-
- if not self.colormap_pot:
- self.colormap_pot = "viridis"
-
- if not self.colormap_per:
- self.colormap_per = "viridis"
-
- pot_frame_data = np.load(os.path.join(self._prefix, self.file_name_pot, pot_frames_list[0]))
- per_frame_data = np.load(os.path.join(self._prefix, self.file_name_per, per_frames_list[0]))
-
- anim_pot = ax_pot.imshow(pot_frame_data, vmax=self.vmax_pot, vmin=self.vmin_pot, animated=True, cmap=self.colormap_pot)
- anim_per = ax_per.imshow(per_frame_data, vmax=self.vmax_per, vmin=self.vmin_per, animated=True, cmap=self.colormap_per)
-
- fig.colorbar(anim_pot, ax=ax_pot, fraction=0.046, pad=0.04)
- fig.colorbar(anim_per, ax=ax_per, fraction=0.046, pad=0.04)
-
- fig.set_figheight(10)
- fig.set_figwidth(10)
- plt.tight_layout()
-
-
- with writer.saving(fig, os.path.join(self._prefix, file_name), dpi):
- start_time = time.time()
- N = len(pot_frames_list)
- for i in range(1, N):
- pot_frame_data = np.load(os.path.join(self._prefix, self.file_name_pot, pot_frames_list[i]))
- per_frame_data = np.load(os.path.join(self._prefix, self.file_name_per, per_frames_list[i]))
- anim_pot.set_array(pot_frame_data)
- anim_per.set_array(per_frame_data)
-
- writer.grab_frame()
- sys.stdout.write("Writing frames: %d of %d\r" % (i, N))
- sys.stdout.flush()
diff --git a/finitewave/tools/stim_sequence.py b/finitewave/tools/stim_sequence.py
deleted file mode 100755
index 96f282f..0000000
--- a/finitewave/tools/stim_sequence.py
+++ /dev/null
@@ -1,19 +0,0 @@
-
-
-class StimSequence:
-
- @staticmethod
- def generate_2d(x0, x1, y0, y1, start_time, end_time, period, val, dur=0):
- n = int((end_time - start_time)/period)
- if dur:
- return [[x0, x1, y0, y1, val, dur, start_time + i*period] for i in range(n)]
- else:
- return [[x0, x1, y0, y1, val, start_time + i*period] for i in range(n)]
-
- @staticmethod
- def generate_3d(x0, x1, y0, y1, z0, z1, start_time, end_time, period, val, dur=0):
- n = int((end_time - start_time)/period)
- if dur:
- return [[x0, x1, y0, y1, z0, z1, val, dur, start_time + i*period] for i in range(n)]
- else:
- return [[x0, x1, y0, y1, z0, z1, val, start_time + i*period] for i in range(n)]
diff --git a/finitewave/tools/velocity_2d_calculation.py b/finitewave/tools/velocity_2d_calculation.py
new file mode 100755
index 0000000..3c81ea7
--- /dev/null
+++ b/finitewave/tools/velocity_2d_calculation.py
@@ -0,0 +1,103 @@
+import numpy as np
+from scipy import spatial
+from skimage import measure
+
+
+class Velocity2DCalculation:
+ """
+ Class for calculating the velocity of the wavefront.
+
+ """
+ def __init__(self):
+ pass
+
+ @staticmethod
+ def front_velocity(act_t, dr):
+ """
+ Computes the front velocity of activation based on the activation
+ times.
+
+ Parameters
+ ----------
+ act_t : numpy.ndarray
+ Activation times.
+ dr : float
+ Spatial resolution.
+
+ Returns
+ -------
+ numpy.ndarray
+ Velocity of the wavefront.
+ """
+ min_time = np.min(act_t[act_t >= 0])
+ max_time = np.max(act_t)
+
+ start_coords = np.argwhere(act_t == min_time)
+ current_coords = np.argwhere(act_t == max_time)
+
+ tree = spatial.KDTree(start_coords)
+ dist, _ = tree.query(current_coords)
+
+ front_vel = np.zeros(act_t.shape)
+ front_vel = dist * dr / (max_time - min_time)
+ return front_vel
+
+ @staticmethod
+ def velocity_vector(act_t, dr, orientation=False, t_min=None, t_max=None):
+ """
+ Computes the velocity of the wavefront from a single source based on
+ the elliptical shape of the wavefront.
+
+ Parameters
+ ----------
+ act_t : numpy.ndarray
+ 2D array of activation times.
+ dr : float
+ Spatial resolution.
+ orientation : bool
+ If True, the angle of the major axis of the ellipse is returned.
+
+ Returns
+ -------
+ tuple
+ Tuple of the major and minor components of the velocity.
+ """
+
+ if t_min is None:
+ t_min = np.min(act_t[act_t >= 0])
+
+ if t_max is None:
+ t_max = np.max(act_t)
+
+ mask = (act_t >= t_min) & (act_t <= t_max)
+
+ major, minor, angle = Velocity2DCalculation.calc_ellipse_axes(mask)
+ major_velocity = major * dr / (t_max - t_min)
+ minor_velocity = minor * dr / (t_max - t_min)
+
+ if orientation:
+ return major_velocity, minor_velocity, angle
+
+ return major_velocity, minor_velocity
+
+ @staticmethod
+ def calc_ellipse_axes(mask):
+ """
+ Calculate the major and minor axes of the ellipse that best fits the
+ wavefront.
+
+ Parameters
+ ----------
+ mask : numpy.ndarray
+ 2D array of the wavefront.
+
+ Returns
+ -------
+ tuple
+ Major and minor axes and the angle of the ellipse.
+ """
+ props = measure.regionprops(mask.astype(int))
+ major = 0.5 * props[0].major_axis_length
+ minor = 0.5 * props[0].minor_axis_length
+ orientation = props[0].orientation
+ return major, minor, orientation
diff --git a/finitewave/tools/velocity_3d_calculation.py b/finitewave/tools/velocity_3d_calculation.py
new file mode 100644
index 0000000..1c608b8
--- /dev/null
+++ b/finitewave/tools/velocity_3d_calculation.py
@@ -0,0 +1,86 @@
+import numpy as np
+from scipy import spatial
+from skimage import measure
+
+from finitewave.tools.velocity_2d_calculation import Velocity2DCalculation
+
+
+class Velocity3DCalculation(Velocity2DCalculation):
+ """
+ Class for calculating the velocity of the wavefront.
+
+ """
+ def __init__(self):
+ super().__init__()
+
+ @staticmethod
+ def velocity_vector(act_t, dr, orientation=False, t_max=None, t_min=None):
+ """
+ Computes the velocity of the wavefront from a single source based on
+ the elliptical shape of the wavefront.
+
+ Parameters
+ ----------
+ act_t : numpy.ndarray
+ 2D array of activation times.
+ dr : float
+ Spatial resolution.
+ orientation : bool
+ If True, the angle of the major axis of the ellipse is returned.
+
+ Returns
+ -------
+ tuple
+ Tuple of the major and minor components of the velocity.
+ """
+ if t_min is None:
+ t_min = np.min(act_t[act_t >= 0])
+
+ if t_max is None:
+ t_max = np.max(act_t)
+
+ mask = (act_t >= t_min) & (act_t <= t_max)
+
+ res = Velocity3DCalculation.calc_ellipsoid_axes(mask)
+ major, medium, minor, theta, phi = res
+ major_velocity = major * dr / (t_max - t_min)
+ medium_velocity = medium * dr / (t_max - t_min)
+ minor_velocity = minor * dr / (t_max - t_min)
+
+ if orientation:
+ return major_velocity, medium_velocity, minor_velocity, theta, phi
+
+ return major_velocity, medium_velocity, minor_velocity
+
+ @staticmethod
+ def calc_ellipsoid_axes(mask):
+ """
+ Calculate the major, medium and minor axes of the ellipsoid
+ that best fits the wavefront.
+
+ Parameters
+ ----------
+ mask : numpy.ndarray
+ 3D array of the wavefront.
+
+ Returns
+ -------
+ tuple
+ Major, medium, minor axes and the angles theta and phi.
+ """
+
+ cov_matrix = measure.inertia_tensor(mask.astype(int))
+ eigvals, eigvecs = np.linalg.eig(cov_matrix)
+
+ sorted_ids = np.argsort(eigvals)[::-1]
+ eigvals = eigvals[sorted_ids]
+ eigvecs = eigvecs[:, sorted_ids]
+
+ major = np.sqrt(2.5 * (eigvals[0] + eigvals[1] - eigvals[2]))
+ medium = np.sqrt(2.5 * (eigvals[0] - eigvals[1] + eigvals[2]))
+ minor = np.sqrt(2.5 * (-eigvals[0] + eigvals[1] + eigvals[2]))
+
+ major_vec = eigvecs[:, 2]
+ theta = np.arccos(major_vec[2])
+ phi = np.arctan2(major_vec[1], major_vec[0])
+ return major, medium, minor, theta, phi
diff --git a/finitewave/tools/vis_mesh_builder_3d.py b/finitewave/tools/vis_mesh_builder_3d.py
index b231253..05f90e6 100644
--- a/finitewave/tools/vis_mesh_builder_3d.py
+++ b/finitewave/tools/vis_mesh_builder_3d.py
@@ -4,39 +4,60 @@
class VisMeshBuilder3D:
"""Class to build a 3D mesh for visualization with pyvista.
+
+ Attributes:
+ ------------
+ grid : pv.UnstructuredGrid)
+ Masked grid with cells where mesh > 0.
+
+ full_grid : pv.ImageData
+ Full grid with all cells.
"""
def __init__(self):
- pass
+ self.grid = None
+ self.full_grid = None
def build_mesh(self, mesh):
"""Build a Unstructured Grid from 3D mesh where mesh > 0.
- Args:
- mesh (np.array): 3D mesh with cardiomyocytes (elems = 1),
- empty space (elems = 0), and fibrosis (elems = 2).
+ Parameters:
+ ------------
+ mesh : np.array
+ 3D mesh with cardiomyocytes (elems = 1), empty space (elems = 0),
+ and fibrosis (elems = 2).
Returns:
- grid (pv.UnstructuredGrid): pyvista Unstructured Grid.
+ ------------
+ grid : pv.UnstructuredGrid
+ Masked grid with cells where mesh > 0.
"""
grid = pv.ImageData()
grid.dimensions = np.array(mesh.shape) + 1
grid.spacing = (1, 1, 1)
grid.cell_data['mesh'] = mesh.astype(float).flatten(order='F')
+
+ self.full_grid = grid
# Threshold the mesh to remove empty space
self.grid = grid.threshold(0.5)
self._mesh = mesh
return self.grid
def add_scalar(self, scalars, name='Scalars'):
- """Add a scalar field to the mesh. The scalar field is flattened
+ """
+ Add a scalar field to the mesh. The scalar field is flattened
and only the values of the non-empty space are added to the mesh.
- Args:
- scalar (np.array): 3D scalar field.
- name (str): Name of the scalar.
-
- Returns:
- grid (pv.UnstructuredGrid): pyvista Unstructured Grid.
+ Parameters
+ ----------
+ scalars : np.array
+ 3D scalar field.
+ name : str, optional
+ Name of the scalar. Default is 'Scalars'.
+
+ Returns
+ -------
+ grid : pv.UnstructuredGrid
+ Grid with the scalar field added.
"""
if scalars.shape != self._mesh.shape:
@@ -47,16 +68,31 @@ def add_scalar(self, scalars, name='Scalars'):
self.grid.set_active_scalars(name)
return self.grid
+ def flatten_scalars(self, scalars):
+ """
+ """
+ if scalars.shape != self._mesh.shape:
+ raise ValueError("Scalars must have the same shape asthe mesh.")
+
+ scalars_flat = scalars.T[self._mesh.T > 0].flatten(order='F')
+ return scalars_flat
+
def add_vector(self, vectors, name='Vectors'):
- """Add a vector field to the mesh. The vector field is flattened
+ """
+ Add a vector field to the mesh. The vector field is flattened
and only the values of the non-empty space are added to the mesh.
- Args:
- vectors (np.array): 3D vector field.
- name (str): Name of the vector.
-
- Returns:
- grid (pv.UnstructuredGrid): pyvista Unstructured Grid.
+ Parameters
+ ----------
+ vectors : np.array
+ 3D vector field.
+ name : str, optional
+ Name of the vector. Default is 'Vectors'.
+
+ Returns
+ -------
+ grid : pv.UnstructuredGrid
+ Grid with the vector field added.
"""
if vectors.shape != self._mesh.shape + (3,):
@@ -68,7 +104,7 @@ def add_vector(self, vectors, name='Vectors'):
x_flat = x[self._mesh.T > 0].flatten(order='F')
vectors_list.append(x_flat)
- vectors_flat = np.vstack(vectors_list).T
+ vectors_flat = np.column_stack(vectors_list)
self.grid.cell_data[name] = vectors_flat
self.grid.set_active_vectors(name)
diff --git a/finitewave/tools/vtk_mesh_builder.py b/finitewave/tools/vtk_mesh_builder.py
deleted file mode 100755
index a76189b..0000000
--- a/finitewave/tools/vtk_mesh_builder.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import vtk
-
-
-class VTKMeshBuilder:
- def __init__(self):
- pass
-
- @staticmethod
- def create_vtk_mesh_3D(np_mesh, np_fibers=None):
- unstructured_grid = vtk.vtkUnstructuredGrid()
-
- points= vtk.vtkPoints()
- number = np_mesh[np_mesh == 1].size
- points.SetNumberOfPoints(number)
-
- if np_fibers is not None:
- fibers_array = vtk.vtkDoubleArray()
- fibers_array.SetNumberOfComponents(3)
- fibers_array.SetName("Fibers")
-
- n, m, s = np_mesh.shape
- idx = 0
- for i in range(n):
- for j in range(m):
- for k in range(s):
- if np_mesh[i, j, k] == 1:
- points.InsertPoint(idx, i, j, k)
- vertex = vtk.vtkVertex()
- vertex.GetPointIds().SetId(0, idx)
- unstructured_grid.InsertNextCell(vertex.GetCellType(),
- vertex.GetPointIds())
- idx += 1
- if np_fibers is not None:
- fibers_array.InsertNextTuple3(np_fibers[i, j, k, 0], np_fibers[i, j, k, 1], np_fibers[i, j, k, 2])
-
- unstructured_grid.SetPoints(points)
-
- if np_fibers is not None:
- unstructured_grid.GetPointData().SetVectors(fibers_array)
-
- return unstructured_grid
-
- @staticmethod
- def write_vtk_unstructured_grid(file_name, unstructured_grid):
- writer = vtk.vtkUnstructuredGridWriter()
- writer.SetFileName(file_name)
- writer.SetInputData(unstructured_grid)
- writer.Write()
diff --git a/docs/wave_2d.gif b/images/spiral_wave_fib.gif
similarity index 100%
rename from docs/wave_2d.gif
rename to images/spiral_wave_fib.gif
diff --git a/docs/spiral_wave_3d.gif b/images/spiral_wave_lv.gif
similarity index 100%
rename from docs/spiral_wave_3d.gif
rename to images/spiral_wave_lv.gif
diff --git a/docs/spiral_wave_2d.gif b/images/spiral_wave_slab.gif
similarity index 100%
rename from docs/spiral_wave_2d.gif
rename to images/spiral_wave_slab.gif
diff --git a/pyproject.toml b/pyproject.toml
index f7dfb74..68d5c17 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,19 +1,53 @@
[build-system]
-requires = ["hatchling", "numpy", "numba", "scipy", "matplotlib", "tables", "tqdm", "natsort", "pyvista"]
+requires = ["hatchling"]
build-backend = "hatchling.build"
[project]
name = "finitewave"
-version = "0.8"
+version = "0.8.5"
+requires-python = ">=3.7"
authors = [
{ name="Timur Nezlobinsky", email="nezlobinsky@gmail.com" },
{ name="Arstanbek Okenov", email="arstanbek.okenov@ugent.be" }
]
description = "Simple package for a wide range of tasks in modeling cardiac electrophysiology using finite-difference methods."
-readme = "README.md"
-requires-python = ">=3.7"
-classifiers = [
- "Programming Language :: Python :: 3",
- "License :: Other/Proprietary License",
- "Operating System :: OS Independent",
+readme = "README.rst"
+license = "MIT"
+
+dependencies = [
+ "numpy>=1.26.4",
+ "numba>=0.60.0",
+ "scipy>=1.14.1",
+ "matplotlib>=3.9.2",
+ "tqdm>=4.66.5",
+ "natsort>=8.4.0",
+ "pyvista>=0.44.1",
+ "ffmpeg-python>=0.2.0",
+ "pandas>=2.2.3",
+ "scikit-image>=0.24.0",
]
+
+[project.optional-dependencies]
+test = [
+ "pytest",
+ "pytest-cov"
+]
+docs = [
+ "sphinx",
+ "sphinx-rtd-theme",
+ "pydata-sphinx-theme",
+ "sphinx-gallery",
+ "sphinx-copybutton",
+ "numpydoc",
+]
+
+# [tool.setuptools]
+# zip-safe = false
+# include-package-data = false
+# packages = [
+# 'finitewave',
+# 'finitewave.core',
+# 'finitewave.cpuwave2D',
+# 'finitewave.cpuwave3D',
+# 'finitewave.tools',
+# ]
diff --git a/pytest.ini b/pytest.ini
new file mode 100644
index 0000000..d98b876
--- /dev/null
+++ b/pytest.ini
@@ -0,0 +1,45 @@
+# pytest.ini
+
+[pytest]
+addopts = -ra
+testpaths =
+ tests
+markers =
+ aliev_panfilov_2d: Test for the Aliev-Panfilov 2D model
+ barkley_2d: Test for the Barkley 2D model
+ mitchell_schaeffer_2d: Test for the Mitchell-Schaeffer 2D model
+ fenton_karma_2d: Test for the Fenton-Karma 2D model
+ bueno_orovio_2d: Test for the Bueno-Orovio 2D model
+ luo_rudy91_2d: Test for the Luo-Rudy 1991 2D model
+ tp06_2d: Test for the ten Tusscher-Panfilov 2006 model
+ courtemanche_2d: Test for the Courtemanche atrial 2D model
+
+ aliev_panfilov_3d: Test for the Aliev-Panfilov 3D model
+ barkley_3d: Test for the Barkley 3D model
+ mitchell_schaeffer_3d: Test for the Mitchell-Schaeffer 3D model
+ fenton_karma_3d: Test for the Fenton-Karma 3D model
+ bueno_orovio_3d: Test for the Bueno-Orovio 3D model
+ luo_rudy91_3d: Test for the Luo-Rudy 1991 3D model
+ tp06_3d: Test for the ten Tusscher-Panfilov 2006 model
+ courtemanche_3d: Test for the Courtemanche atrial 3D model
+
+ action_potential_2d_tracker: Test for the action potential tracking in 2D
+ animation_2d_tracker: Test for the animation tracking in 2D
+ activation_time_2d_tracker: Test for the activation time tracking in 2D
+ local_activation_time_2d_tracker: Test for the local activation time tracking in 2D
+ test_multi_variable_2d_tracker: Test for the multi-variable tracking in 2D
+ spiral_wave_core_2d_tracker: Test for the spiral wave core tracking in 2D
+ spiral_wave_period_2d_tracker: Test for the spiral wave period tracking in 2D
+ ecg_2d_tracker: Test for the ECG tracking in 2D
+
+ action_potential_3d_tracker: Test for the action potential tracking in 3D
+ animation_3d_tracker: Test for the animation tracking in 3D
+ activation_time_3d_tracker: Test for the activation time tracking in 3D
+ local_activation_time_3d_tracker: Test for the local activation time tracking in 3D
+ test_multi_variable_3d_tracker: Test for the multi-variable tracking in 3D
+ spiral_wave_core_3d_tracker: Test for the spiral wave core tracking in 3D
+ spiral_wave_period_3d_tracker: Test for the spiral wave period tracking in 3D
+ ecg_3d_tracker: Test for the ECG tracking in 3D
+
+
+
diff --git a/setup.py b/setup.py
deleted file mode 100755
index bcac18b..0000000
--- a/setup.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
- name="finitewave",
- description=("Simple finite-difference package for electrical cardiac"
- " modeling tasks solution"),
- version="0.8",
- packages=find_packages(exclude=["examples", "tests"]),
- install_requires=["numpy", "scipy", "numba", "matplotlib",
- "tables", "tqdm", "vtk"]
-)
diff --git a/tests/test_aliev_panfilov_2d.py b/tests/test_aliev_panfilov_2d.py
deleted file mode 100755
index df53d6d..0000000
--- a/tests/test_aliev_panfilov_2d.py
+++ /dev/null
@@ -1,95 +0,0 @@
-import sys
-import unittest
-import numpy as np
-import matplotlib.pyplot as plt
-
-import finitewave as fw
-
-
-class TestAlievPanfilov2D(unittest.TestCase):
- def setUp(self):
-
- n = 200
- self.tissue = fw.CardiacTissue2D([n, n])
- self.tissue.mesh = np.ones([n, n], dtype="uint8")
- self.tissue.add_boundaries()
- self.tissue.fibers = np.zeros([n, n, 2])
- self.tissue.stencil = fw.AsymmetricStencil2D()
-
- self.aliev_panfilov = fw.AlievPanfilov2D()
- self.aliev_panfilov.dt = 0.01
- self.aliev_panfilov.dr = 0.25
- self.aliev_panfilov.t_max = 25
-
- stim_sequence = fw.StimSequence()
- stim_sequence.add_stim(fw.StimCurrentCoord2D(0, 3, 0.18, 0, 200, 0, 5))
-
- tracker_sequence = fw.TrackerSequence()
- self.velocity_tracker = fw.Velocity2DTracker()
- self.velocity_tracker.threshold = 0.2
- tracker_sequence.add_tracker(self.velocity_tracker)
-
- self.aliev_panfilov.cardiac_tissue = self.tissue
- self.aliev_panfilov.stim_sequence = stim_sequence
- self.aliev_panfilov.tracker_sequence = tracker_sequence
-
- def test_wave_along_the_fibers(self):
- sys.stdout.write("---> Check the wave speed along the fibers\n")
- self.tissue.fibers[:,:,0] = 0.
- self.tissue.fibers[:,:,1] = 1.
-
- self.aliev_panfilov.run()
-
- front_vel = np.mean(self.velocity_tracker.compute_velocity_front())
- self.assertAlmostEqual(front_vel, 1.6,
- msg="Wave velocity along the fibers direction is incorrect! (AlievPanfilov 2D)",
- delta=0.05)
-
- def test_wave_across_the_fibers(self):
- sys.stdout.write("---> Check the wave speed across the fibers\n")
- self.tissue.fibers[:,:,0] = 1.
- self.tissue.fibers[:,:,1] = 0.
- self.tissue.D_al = 1
- self.tissue.D_ac = 0.111
-
- self.aliev_panfilov.run()
-
- front_vel = np.mean(self.velocity_tracker.compute_velocity_front())
- self.assertAlmostEqual(front_vel, 0.55,
- msg="Wave velocity across the fibers direction is incorrect! (AlievPanfilov 2D)",
- delta=0.05)
-
- def test_spiral_wave_period(self):
- sys.stdout.write("---> Check the spiral wave period\n")
- self.tissue.fibers[:,:,0] = 0.
- self.tissue.fibers[:,:,1] = 1.
- self.tissue.D_al = 1.
- self.tissue.D_ac = 1.
- self.aliev_panfilov.t_max = 200
-
- stim_sequence = fw.StimSequence()
- stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 200, 0, 100))
- stim_sequence.add_stim(fw.StimVoltageCoord2D(31, 1, 0, 100, 0, 200))
-
- tracker_sequence = fw.TrackerSequence()
- period_tracker = fw.Period2DTracker()
- detectors = np.zeros([200, 200], dtype="uint8")
- positions = np.array([[100, 100]])
- detectors[positions[:, 0], positions[:, 1]] = 1
- period_tracker.detectors = detectors
- period_tracker.threshold = 0.2
- tracker_sequence.add_tracker(period_tracker)
-
- spiral_tracker = fw.Spiral2DTracker()
- tracker_sequence.add_tracker(spiral_tracker)
-
- self.aliev_panfilov.stim_sequence = stim_sequence
- self.aliev_panfilov.tracker_sequence = tracker_sequence
-
- self.aliev_panfilov.run()
-
- self.assertAlmostEqual(period_tracker.output["100,100"][-1][1], 25.8,
- msg="Spiral wave period is incorrect! (AlievPanfilov 2D)",
- delta=0.3)
-
- spiral_tracker.write()
diff --git a/tests/test_aliev_panfilov_2d_rectangle.py b/tests/test_aliev_panfilov_2d_rectangle.py
deleted file mode 100755
index 90b54bf..0000000
--- a/tests/test_aliev_panfilov_2d_rectangle.py
+++ /dev/null
@@ -1,61 +0,0 @@
-import sys
-import unittest
-import numpy as np
-import matplotlib.pyplot as plt
-
-import finitewave as fw
-
-
-class TestAlievPanfilov2DRectangle(unittest.TestCase):
- def setUp(self):
-
- n_i = 100
- n_j = 300
- self.tissue = fw.CardiacTissue2D([n_i, n_j])
- self.tissue.mesh = np.ones([n_i, n_j], dtype="uint8")
- self.tissue.add_boundaries()
- self.tissue.fibers = np.zeros([n_i, n_j, 2])
- self.tissue.stencil = fw.AsymmetricStencil2D()
-
- self.aliev_panfilov = fw.AlievPanfilov2D()
- self.aliev_panfilov.dt = 0.01
- self.aliev_panfilov.dr = 0.25
- self.aliev_panfilov.t_max = 25
-
- stim_sequence = fw.StimSequence()
- stim_sequence.add_stim(fw.StimCurrentCoord2D(0, 3, 0.18, 0, 100, 0, 5))
-
- tracker_sequence = fw.TrackerSequence()
- self.velocity_tracker = fw.Velocity2DTracker()
- self.velocity_tracker.threshold = 0.2
- tracker_sequence.add_tracker(self.velocity_tracker)
-
- self.aliev_panfilov.cardiac_tissue = self.tissue
- self.aliev_panfilov.stim_sequence = stim_sequence
- self.aliev_panfilov.tracker_sequence = tracker_sequence
-
- def test_wave_along_the_fibers(self):
- sys.stdout.write("---> Check the wave speed along the fibers\n")
- self.tissue.fibers[:,:,0] = 0.
- self.tissue.fibers[:,:,1] = 1.
-
- self.aliev_panfilov.run()
-
- front_vel = np.mean(self.velocity_tracker.compute_velocity_front())
- self.assertAlmostEqual(front_vel, 1.6,
- msg="Wave velocity along the fibers direction is incorrect! (AlievPanfilov 2D)",
- delta=0.05)
-
- def test_wave_across_the_fibers(self):
- sys.stdout.write("---> Check the wave speed across the fibers\n")
- self.tissue.fibers[:,:,0] = 1.
- self.tissue.fibers[:,:,1] = 0.
- self.tissue.D_al = 1
- self.tissue.D_ac = 0.111
-
- self.aliev_panfilov.run()
-
- front_vel = np.mean(self.velocity_tracker.compute_velocity_front())
- self.assertAlmostEqual(front_vel, 0.55,
- msg="Wave velocity across the fibers direction is incorrect! (AlievPanfilov 2D)",
- delta=0.05)
diff --git a/tests/test_aliev_panfilov_3d.py b/tests/test_aliev_panfilov_3d.py
deleted file mode 100755
index 18b88b5..0000000
--- a/tests/test_aliev_panfilov_3d.py
+++ /dev/null
@@ -1,68 +0,0 @@
-import sys
-import unittest
-import numpy as np
-import matplotlib.pyplot as plt
-
-import finitewave as fw
-
-class TestAlievPanfilov3D(unittest.TestCase):
- def setUp(self):
-
- n = 100
- self.tissue = fw.CardiacTissue3D([n, n, n])
- self.tissue.mesh = np.ones([n, n, n], dtype="uint8")
- self.tissue.add_boundaries()
- self.tissue.fibers = np.zeros([n, n, n, 3])
- self.tissue.stencil = fw.AsymmetricStencil3D()
-
- self.aliev_panfilov = fw.AlievPanfilov3D()
- self.aliev_panfilov.dt = 0.01
- self.aliev_panfilov.dr = 0.25
- self.aliev_panfilov.t_max = 40
-
- stim_sequence = fw.StimSequence()
- stim_sequence.add_stim(fw.StimCurrentCoord3D(0, 3, 0.18, 0, 100, 0, 5, 0, 5))
-
- tracker_sequence = fw.TrackerSequence()
- self.velocity_tracker = fw.Velocity3DTracker()
- self.velocity_tracker.threshold = 0.2
- tracker_sequence.add_tracker(self.velocity_tracker)
-
- self.aliev_panfilov.cardiac_tissue = self.tissue
- self.aliev_panfilov.stim_sequence = stim_sequence
- self.aliev_panfilov.tracker_sequence = tracker_sequence
-
- def test_wave_along_the_fibers(self):
- sys.stdout.write("---> Check the wave speed along the fibers\n")
- self.tissue.fibers[:,:,:,0] = 0.
- self.tissue.fibers[:,:,:,1] = 1.
- self.tissue.fibers[:,:,:,2] = 0.
- self.tissue.D_al = 1.
- self.tissue.D_ac = 0.111
-
- stim_sequence = fw.StimSequence()
- stim_sequence.add_stim(fw.StimCurrentCoord3D(0, 3, 0.18, 0, 100, 0, 5, 0, 100))
-
- self.aliev_panfilov.stim_sequence = stim_sequence
-
- self.aliev_panfilov.run()
-
- front_vel = np.mean(self.velocity_tracker.compute_velocity_front())
- self.assertAlmostEqual(front_vel, 1.6,
- msg="Wave velocity along the fibers direction is incorrect! (AlievPanfilov 3D)",
- delta=0.05)
-
- def test_wave_across_the_fibers(self):
- sys.stdout.write("---> Check the wave speed across the fibers\n")
- self.tissue.fibers[:,:,:,0] = 1.
- self.tissue.fibers[:,:,:,1] = 0.
- self.tissue.fibers[:,:,:,2] = 0.
- self.tissue.D_al = 1.
- self.tissue.D_ac = 0.111
-
- self.aliev_panfilov.run()
-
- front_vel = np.mean(self.velocity_tracker.compute_velocity_front())
- self.assertAlmostEqual(front_vel, 0.5,
- msg="Wave velocity across the fibers direction is incorrect! (AlievPanfilov 3D)",
- delta=0.05)
diff --git a/tests/test_basics.py b/tests/test_basics.py
new file mode 100644
index 0000000..c15e085
--- /dev/null
+++ b/tests/test_basics.py
@@ -0,0 +1,76 @@
+import os
+import shutil
+import numpy as np
+import pytest
+import finitewave as fw
+
+
+def test_state_loading():
+ n = 5
+ tissue = fw.CardiacTissue2D([n, n])
+
+ stim_sequence = fw.StimSequence()
+ stim_sequence.add_stim(fw.StimCurrentCoord2D(0, 10, 0.5, 1, n//2, n//2 + 1,
+ n//2, n//2 + 1))
+
+ state_saver = fw.StateSaverCollection()
+ state_saver.savers.append(fw.StateSaver("state_0", time=3))
+
+ model = fw.FentonKarma2D()
+ model.dt = 0.01
+ model.dr = 0.25
+ model.t_max = 5
+
+ model.cardiac_tissue = tissue
+ model.stim_sequence = stim_sequence
+ model.state_saver = state_saver
+
+ model.run()
+
+ u_before = model.u.copy()
+ v_before = model.v.copy()
+ w_before = model.w.copy()
+
+ # recreate the model
+ model = fw.FentonKarma2D()
+ model.dt = 0.01
+ model.dr = 0.25
+ model.t_max = 5
+
+ model.cardiac_tissue = tissue
+ model.state_loader = fw.StateLoader("state_0")
+
+ model.run()
+ u_after = model.u.copy()
+ v_after = model.v.copy()
+ w_after = model.w.copy()
+
+ assert np.allclose(u_before, u_after, atol=1e-5), "u states are not equal"
+ assert np.allclose(v_before, v_after, atol=1e-5), "v states are not equal"
+ assert np.allclose(w_before, w_after, atol=1e-5), "w states are not equal"
+
+def test_commands():
+ n = 5
+ tissue = fw.CardiacTissue2D([n, n])
+
+ stim_sequence = fw.StimSequence()
+
+ model = fw.FentonKarma2D()
+ model.dt = 0.01
+ model.dr = 0.25
+ model.t_max = 10
+
+ class ExcitationCommand(fw.Command):
+ def execute(self, model):
+ model.u[1:-1, 1:-1] = 1
+
+ command_sequence = fw.CommandSequence()
+ command_sequence.add_command(ExcitationCommand(5))
+
+ model.cardiac_tissue = tissue
+ model.stim_sequence = stim_sequence
+ model.command_sequence = command_sequence
+
+ model.run()
+
+ assert np.mean(model.u[1:-1, 1:-1]) > 0.5, "Command did not work"
\ No newline at end of file
diff --git a/tests/test_fibrosis_2d.py b/tests/test_fibrosis_2d.py
new file mode 100644
index 0000000..9e166aa
--- /dev/null
+++ b/tests/test_fibrosis_2d.py
@@ -0,0 +1,48 @@
+import random
+import numpy as np
+from finitewave.cpuwave2D.fibrosis.diffuse_2d_pattern import Diffuse2DPattern
+from finitewave.cpuwave2D.fibrosis.structural_2d_pattern import Structural2DPattern
+
+def test_diffuse_fibrosis_2d():
+ shape = (1000, 1000)
+ x1, x2 = 100, 900
+ y1, y2 = 200, 800
+ density = 0.3
+
+ random.seed(0)
+
+ pattern = Diffuse2DPattern(density=density, x1=x1, x2=x2, y1=y1, y2=y2)
+ result = pattern.generate(shape=shape)
+
+ assert result.shape == shape, "Diffuse: shape mismatch"
+
+ assert np.all(np.isin(result, [1, 2])), "Diffuse: invalid values in result"
+
+ subregion = result[x1:x2, y1:y2]
+ fibrosis_ratio = np.sum(subregion == 2) / subregion.size
+
+ assert abs(fibrosis_ratio - density) < 0.01, "Diffuse: fibrosis density mismatch"
+
+def test_structural_fibrosis_2d():
+ shape = (1000, 1000)
+ x1, x2 = 100, 900
+ y1, y2 = 200, 800
+ density = 0.4
+ length_i = 5
+ length_j = 4
+
+ random.seed(0)
+
+ pattern = Structural2DPattern(
+ density=density, length_i=length_i, length_j=length_j,
+ x1=x1, x2=x2, y1=y1, y2=y2
+ )
+ result = pattern.generate(shape=shape)
+
+ assert result.shape == shape, "Structural: shape mismatch"
+ assert np.all(np.isin(result, [1, 2])), "Structural: invalid values in result"
+
+ subregion = result[x1:x2, y1:y2]
+ fibrosis_ratio = np.sum(subregion == 2) / subregion.size
+
+ assert abs(fibrosis_ratio - density) < 0.05, "Structural: fibrosis density mismatch"
\ No newline at end of file
diff --git a/tests/test_fibrosis_3d.py b/tests/test_fibrosis_3d.py
new file mode 100644
index 0000000..fa3822c
--- /dev/null
+++ b/tests/test_fibrosis_3d.py
@@ -0,0 +1,51 @@
+import random
+import numpy as np
+from finitewave.cpuwave3D.fibrosis.diffuse_3d_pattern import Diffuse3DPattern
+from finitewave.cpuwave3D.fibrosis.structural_3d_pattern import Structural3DPattern
+
+def test_diffuse_fibrosis_3d():
+ shape = (100, 100, 100)
+ x1, x2 = 10, 90
+ y1, y2 = 20, 80
+ z1, z2 = 30, 70
+ density = 0.3
+
+ random.seed(0)
+
+ pattern = Diffuse3DPattern(density=density, x1=x1, x2=x2, y1=y1, y2=y2, z1=z1, z2=z2)
+ result = pattern.generate(shape=shape)
+
+ assert result.shape == shape, "Diffuse: shape mismatch"
+
+ assert np.all(np.isin(result, [1, 2])), "Diffuse: invalid values in result"
+
+ subregion = result[x1:x2, y1:y2, z1:z2]
+ fibrosis_ratio = np.sum(subregion == 2) / subregion.size
+
+ assert abs(fibrosis_ratio - density) < 0.01, "Diffuse: fibrosis density mismatch"
+
+def test_structural_fibrosis_3d():
+ shape = (100, 100, 100)
+ x1, x2 = 10, 90
+ y1, y2 = 20, 80
+ z1, z2 = 30, 70
+ density = 0.4
+ length_i = 5
+ length_j = 4
+ length_k = 3
+
+ random.seed(0)
+
+ pattern = Structural3DPattern(
+ density=density, length_i=length_i, length_j=length_j, length_k=length_k,
+ x1=x1, x2=x2, y1=y1, y2=y2, z1=z1, z2=z2
+ )
+ result = pattern.generate(shape=shape)
+
+ assert result.shape == shape, "Structural: shape mismatch"
+ assert np.all(np.isin(result, [1, 2])), "Structural: invalid values in result"
+
+ subregion = result[x1:x2, y1:y2, z1:z2]
+ fibrosis_ratio = np.sum(subregion == 2) / subregion.size
+
+ assert abs(fibrosis_ratio - density) < 0.05, "Structural: fibrosis density mismatch"
\ No newline at end of file
diff --git a/tests/test_fibrosis_generation_2d.py b/tests/test_fibrosis_generation_2d.py
deleted file mode 100755
index a1bb9f2..0000000
--- a/tests/test_fibrosis_generation_2d.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import unittest
-import numpy as np
-import matplotlib.pyplot as plt
-import sys
-
-import finitewave as fw
-
-
-class TestFibrosisGeneration2D(unittest.TestCase):
- def setUp(self):
-
- self.n = 500
- self.tissue = fw.CardiacTissue2D([self.n, self.n])
- self.tissue.mesh = np.ones([self.n, self.n], dtype="uint8")
- self.tissue.add_boundaries()
-
- def test_diffuse_pattern(self):
- sys.stdout.write("---> Check the diffuse fibrosis pattern\n")
- diffuse = fw.Diffuse2DPattern(0, self.n, 0, self.n, 0.37)
- matrix = diffuse.generate([self.n, self.n])
- percentage = len(matrix[matrix == 2])/self.n**2
- self.assertAlmostEqual(percentage, 0.37,
- msg="Diffuse fibrosis percentage is incorrect! (matrix getter)",
- delta=0.01)
-
- diffuse.apply(self.tissue)
- matrix = self.tissue.mesh[1:499, 1:499]
- percentage = len(matrix[matrix == 2])/(self.n-2)**2
- self.assertAlmostEqual(percentage, 0.37,
- msg="Diffuse fibrosis percentage is incorrect! (apply method)",
- delta=0.01)
-
-
diff --git a/tests/test_luo_rudy91_2d.py b/tests/test_luo_rudy91_2d.py
deleted file mode 100755
index e80f10f..0000000
--- a/tests/test_luo_rudy91_2d.py
+++ /dev/null
@@ -1,163 +0,0 @@
-import unittest
-import numpy as np
-import matplotlib.pyplot as plt
-import sys
-
-import finitewave as fw
-
-
-class TestLR912D(unittest.TestCase):
- def setUp(self):
-
- n = 200
- self.tissue = fw.CardiacTissue2D([n, n])
- self.tissue.mesh = np.ones([n, n], dtype="uint8")
- self.tissue.add_boundaries()
- self.tissue.fibers = np.zeros([n, n, 2])
- self.tissue.stencil = fw.AsymmetricStencil2D()
- self.tissue.D_al = 0.1
- self.tissue.D_ac = 0.1
-
- self.lr91 = fw.LuoRudy912D()
- self.lr91.dt = 0.001
- self.lr91.dr = 0.1
- self.lr91.t_max = 10
-
- stim_sequence = fw.StimSequence()
- stim_sequence.add_stim(fw.StimVoltageCoord2D(0, -20, 0, 200, 0, 5))
-
- tracker_sequence = fw.TrackerSequence()
- self.velocity_tracker = fw.Velocity2DTracker()
- self.velocity_tracker.threshold = -60
- tracker_sequence.add_tracker(self.velocity_tracker)
-
- self.lr91.cardiac_tissue = self.tissue
- self.lr91.stim_sequence = stim_sequence
- self.lr91.tracker_sequence = tracker_sequence
-
- def test_wave_along_the_fibers(self):
- sys.stdout.write("---> Check the wave speed along the fibers\n")
- self.tissue.fibers[:,:,0] = 0.
- self.tissue.fibers[:,:,1] = 1.
-
- self.lr91.run()
-
- front_vel = np.mean(self.velocity_tracker.compute_velocity_front())
-
- self.assertAlmostEqual(front_vel, 0.6,
- msg="Wave velocity along the fibers direction is incorrect! (LR91 2D)",
- delta=0.05)
-
-
- def test_wave_across_the_fibers(self):
- sys.stdout.write("---> Check the wave speed across the fibers\n")
- self.tissue.fibers[:,:,0] = 1.
- self.tissue.fibers[:,:,1] = 0.
- self.tissue.D_al = 0.1
- self.tissue.D_ac = 0.0111
-
- stim_params = [[0, 5, 0, 100, -20, 0.]]
- self.lr91.stim_params = stim_params
-
- self.lr91.run()
-
- front_vel = np.mean(self.velocity_tracker.compute_velocity_front())
-
- self.assertAlmostEqual(front_vel, 0.2,
- msg="Wave velocity across the fibers direction is incorrect! (LR91 2D)",
- delta=0.05)
-
- # def test_fibrosis_velocity(self):
- # sys.stdout.write("---> Check the fibrosis wave speed\n")
- # self.lr91.Di = 0.1
- # self.lr91.Dj = 0.1
- # velocities = []
- #
- # stim_params = [[0, 100, 0, 5, -20, 0.]]
- # self.lr91.stim_params = stim_params
- #
- # self.lr91.run()
- # velocities.append(np.mean(self.velocity_tracker.compute_velocity_front()))
- #
- # self.tissue.add_pattern(Diffuse2DPattern(0, 100, 0, 100, 0.1))
- # self.lr91.run()
- # velocities.append(np.mean(self.velocity_tracker.compute_velocity_front()))
- #
- # self.tissue.clean()
- # self.tissue.add_pattern(Diffuse2DPattern(0, 100, 0, 100, 0.2))
- # self.lr91.run()
- # velocities.append(np.mean(self.velocity_tracker.compute_velocity_front()))
- #
- # self.tissue.clean()
- # self.tissue.add_pattern(Diffuse2DPattern(0, 100, 0, 100, 0.3))
- # self.lr91.run()
- # velocities.append(np.mean(self.velocity_tracker.compute_velocity_front()))
- #
- # self.tissue.clean()
- #
- # self.assertAlmostEqual(velocities[0], 0.7,
- # msg="Wave velocity in the presence of fibrosis is incorrect! (LR91 2D)",
- # delta=0.05)
- # self.assertAlmostEqual(velocities[1], 0.65,
- # msg="Wave velocity in the presence of fibrosis is incorrect! (LR91 2D)",
- # delta=0.05)
- # self.assertAlmostEqual(velocities[2], 0.62,
- # msg="Wave velocity in the presence of fibrosis is incorrect! (LR91 2D)",
- # delta=0.1)
- # self.assertAlmostEqual(velocities[3], 0.52,
- # msg="Wave velocity in the presence of fibrosis is incorrect! (LR91 2D)",
- # delta=0.15)
-
- # def test_spiral_wave_period(self):
- # sys.stdout.write("---> Check the spiral wave period\n")
- # self.lr91.Di = 0.1
- # self.lr91.Dj = 0.1
- # self.lr91.t_max = 350
- #
- # stim_params = [[0, 3, 0, 400, -20, 0.],
- # [0, 400, 0, 200, -20, 210.]]
- # self.lr91.cardiac_tissue = self.tissue
- # self.lr91.stim_params = stim_params
- #
- # period_tracker = Period2DTracker()
- # period_tracker.target_model = self.lr91
- # period_tracker.mode = "Detectors"
- #
- # detectors = np.zeros([400, 400], dtype="uint8")
- # positions = np.array([[100, 100]])
- # detectors[positions[:, 0], positions[:, 1]] = 1
- #
- # period_tracker.detectors = detectors
- # period_tracker.threshold = -60
- #
- # # add tracker to the model
- # self.lr91.add_tracker(period_tracker)
- #
- # self.lr91.run()
- #
- # plt.imshow(self.lr91.u)
- # plt.show()
- #
- # print ("Period: ", period_tracker.output["100,100"][-1][1])
- #
- # self.assertAlmostEqual(period_tracker.output["100,100"][-1][1], 100.,
- # msg="Spiral wave period is incorrect! (LR91 2D)",
- # delta=10.)
-
- # def test_apd(self):
- # sys.stdout.write("---> Show the model apd\n")
- # self.tissue.fibers[:,:,0] = 0.
- # self.tissue.fibers[:,:,1] = 1.
- #
- # stim_params = [[0, 200, 0, 3, -20, 0.]]
- # self.lr91.stim_params = stim_params
- #
- # act_pot_tracker = ActionPotential2DTracker()
- # act_pot_tracker.target_model = self.lr91
- # act_pot_tracker.cell_ind = [30, 30]
- # self.lr91.add_tracker(act_pot_tracker)
- #
- # self.lr91.run()
- #
- # plt.plot(np.arange(len(act_pot_tracker.act_pot))*self.lr91.dt, act_pot_tracker.act_pot )
- # plt.show()
diff --git a/tests/test_models_2d.py b/tests/test_models_2d.py
new file mode 100644
index 0000000..c22b1ec
--- /dev/null
+++ b/tests/test_models_2d.py
@@ -0,0 +1,294 @@
+import os
+import shutil
+import numpy as np
+import pytest
+import finitewave as fw
+
+
+def prepare_model(model_class, curr_value, curr_dur, t_calc, t_prebeats):
+ """
+ Prepares a 2D cardiac model with a stimulation protocol.
+
+ Parameters
+ ----------
+ model_class : Callable
+ The cardiac model class to be instantiated.
+ curr_value : float
+ Amplitude of the stimulus current (μA/cm² or model units).
+ curr_dur : float
+ Duration of each stimulus pulse (ms or model units).
+ t_calc : float
+ Time after the last preconditioning beat to continue recording (ms or model units).
+ t_prebeats : float
+ Interval between preconditioning stimuli (ms or model units).
+
+ Returns
+ -------
+ model : CardiacModel
+ Configured and initialized model ready for simulation.
+ """
+ ni = 5
+ nj = 3
+ tissue = fw.CardiacTissue2D([ni, nj])
+
+ stim_sequence = fw.StimSequence()
+ stim_sequence.add_stim(fw.StimCurrentCoord2D(0, curr_value, curr_dur, 0, 2, 0, nj))
+ stim_sequence.add_stim(fw.StimCurrentCoord2D(t_prebeats, curr_value, curr_dur, 0, 2, 0, nj))
+ stim_sequence.add_stim(fw.StimCurrentCoord2D(2*t_prebeats, curr_value, curr_dur, 0, 2, 0, nj))
+ stim_sequence.add_stim(fw.StimCurrentCoord2D(3*t_prebeats, curr_value, curr_dur, 0, 2, 0, nj))
+
+ model = model_class()
+ model.dt = 0.01
+ model.dr = 0.25
+ model.t_max = 3*t_prebeats + t_calc
+ model.cardiac_tissue = tissue
+ model.stim_sequence = stim_sequence
+
+ return model
+
+def run_model(model):
+ """
+ Runs a cardiac model with a membrane potential tracker.
+
+ Parameters
+ ----------
+ model : CardiacModel
+ A configured model with stimulation and tissue already assigned.
+
+ Returns
+ -------
+ output : np.ndarray
+ Time series of membrane potential for a specific cell.
+ """
+ tracker = fw.ActionPotential2DTracker()
+ tracker.cell_ind = [3, 1]
+ tracker.step = 1
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ model.tracker_sequence = seq
+
+ model.run()
+ return tracker.output
+
+def calculate_apd(u, dt, threshold, beat_index=3):
+ """
+ Calculates the action potential duration (APD) for a single beat.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ Membrane potential time series.
+ dt : float
+ Time step of the simulation (ms).
+ threshold : float
+ Voltage threshold to define APD90 (e.g., -70 mV or 0.1 for normalized models).
+ beat_index : int, optional
+ Index of the beat to analyze (default is 3).
+
+ Returns
+ -------
+ apd : float or None
+ Duration of the action potential (ms or model units), or None if no complete AP was found.
+ """
+ up_idx = np.where((u[:-1] < threshold) & (u[1:] >= threshold))[0]
+ down_idx = np.where((u[:-1] > threshold) & (u[1:] <= threshold))[0]
+
+ if len(up_idx) <= beat_index or len(down_idx) == 0:
+ return None
+
+ ap_start = up_idx[beat_index]
+ ap_end_candidates = down_idx[down_idx > ap_start]
+ if len(ap_end_candidates) == 0:
+ return None
+
+ ap_end = ap_end_candidates[0]
+ return (ap_end - ap_start) * dt
+
+@pytest.mark.aliev_panfilov_2d
+def test_aliev_panfilov_2d():
+ """
+ Test the Aliev-Panfilov 2D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within expected range [21, 23] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 60 ms.
+ - Amplitude: 10
+ - Duration: 0.5 ms
+ """
+ model = prepare_model(fw.AlievPanfilov2D, curr_value=5, curr_dur=0.5, t_calc=80, t_prebeats=60)
+ u = run_model(model)
+
+ assert np.max(u) == pytest.approx(1.0, abs=0.1)
+ assert np.min(u) == pytest.approx(0.0, abs=0.01)
+
+ apd = calculate_apd(u, model.dt, threshold=0.1)
+ assert 20 <= apd <= 25, f"Aliev-Panfilov APD90 is out of expected range {apd}"
+
+@pytest.mark.barkley_2d
+def test_barkley_2d():
+ """
+ Test the Barkley 2D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within expected range [1, 2] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 60 ms.
+ - Amplitude: 1
+ - Duration: 0.5 ms
+ """
+ model = prepare_model(fw.Barkley2D, curr_value=5, curr_dur=0.1, t_calc=80, t_prebeats=60)
+ u = run_model(model)
+
+ assert np.max(u) == pytest.approx(1.0, abs=0.1)
+ assert np.min(u) == pytest.approx(0.0, abs=0.01)
+
+ apd = calculate_apd(u, model.dt, threshold=0.1)
+ assert 1 <= apd <= 4, f"Barkley APD90 is out of expected range {apd}"
+
+@pytest.mark.mitchell_schaeffer_2d
+def test_mitchell_schaeffer_2d():
+ """
+ Test the Mitchell-Schaeffer 2D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within [280, 320] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 1000 ms.
+ - Amplitude: 10
+ - Duration: 0.5 ms
+ """
+ model = prepare_model(fw.MitchellSchaeffer2D, curr_value=5, curr_dur=0.5, t_calc=1000, t_prebeats=1000)
+ u = run_model(model)
+
+ assert np.max(u) == pytest.approx(0.95, abs=0.1)
+ assert np.min(u) == pytest.approx(0.0, abs=0.01)
+
+ apd = calculate_apd(u, model.dt, threshold=0.1)
+
+ assert 250 <= apd <= 350, f"Mitchell-Schaeffer APD90 is out of expected range {apd}"
+
+@pytest.mark.fenton_karma_2d
+def test_fenton_karma_2d():
+ """
+ Test the Fenton-Karma 2D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within [100, 200] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 1000 ms.
+ - Amplitude: 10
+ - Duration: 0.5 ms
+ """
+ model = prepare_model(fw.FentonKarma2D, curr_value=5, curr_dur=0.5, t_calc=1000, t_prebeats=1000)
+ u = run_model(model)
+
+ assert np.max(u) == pytest.approx(1.0, abs=0.1)
+ assert np.min(u) == pytest.approx(0.0, abs=0.01)
+
+ apd = calculate_apd(u, model.dt, threshold=0.1)
+ assert 100 <= apd <= 200, f"Fenton-Karma APD90 is out of expected range {apd}"
+
+@pytest.mark.bueno_orovio_2d
+def test_bueno_orovio_2d():
+ """
+ Test the Bueno-Orovio 2D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within [200, 300] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 1000 ms.
+ - Amplitude: 100
+ - Duration: 1 ms
+ """
+ model = prepare_model(fw.BuenoOrovio2D, curr_value=5, curr_dur=0.5, t_calc=1000, t_prebeats=1000)
+ u = run_model(model)
+
+ assert np.max(u) == pytest.approx(1.4, abs=0.1)
+ assert np.min(u) == pytest.approx(0.0, abs=0.01)
+
+ apd = calculate_apd(u, model.dt, threshold=0.1)
+ assert 200 <= apd <= 300, f"Bueno-Orovio APD90 is out of expected range {apd}"
+
+@pytest.mark.luo_rudy91_2d
+def test_luo_rudy_2d():
+ """
+ Test the Luo-Rudy 1991 2D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - APD90 is within [350, 400] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 1000 ms.
+ - Amplitude: 100
+ - Duration: 1 ms
+ """
+ model = prepare_model(fw.LuoRudy912D, curr_value=100, curr_dur=1, t_calc=1000, t_prebeats=1000)
+ u = run_model(model)
+
+ assert np.max(u) > 20
+ assert np.min(u) < -80
+
+ apd = calculate_apd(u, model.dt, threshold=-70)
+ assert 350 <= apd <= 400, f"Luo-Rudy APD90 is out of expected range {apd}"
+
+@pytest.mark.tp06_2d
+def test_tp06_2d():
+ """
+ Test the Ten Tusscher-Panfilov 2006 (TP06) 2D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within [280, 320] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 1000 ms.
+ - Amplitude: 100
+ - Duration: 1 ms
+ """
+ model = prepare_model(fw.TP062D, curr_value=100, curr_dur=1, t_calc=1000, t_prebeats=1000)
+ u = run_model(model)
+
+ assert np.max(u) > 20
+ assert np.min(u) < -80
+
+ apd = calculate_apd(u, model.dt, threshold=-70)
+ assert 280 <= apd <= 320, f"TP06 APD90 is out of expected range {apd}"
+
+@pytest.mark.courtemanche_2d
+def test_courtemanche_2d():
+ """
+ Test the Courtemanche 2D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within [200, 300] ms.
+
+ Note: Slightly elevated plateau potential is expected in some parameterizations.
+
+ Stimulation:
+ - 4 current pulses at intervals of 1000 ms.
+ - Amplitude: 100
+ - Duration: 1 ms
+ """
+ model = prepare_model(fw.Courtemanche2D, curr_value=100, curr_dur=1, t_calc=1000, t_prebeats=1000)
+ u = run_model(model)
+
+ assert np.max(u) > 10
+ assert np.min(u) < -80
+
+ apd = calculate_apd(u, model.dt, threshold=-70)
+ assert 200 <= apd <= 300, f"Courtemanche APD90 is out of expected range {apd}"
+
diff --git a/tests/test_models_3d.py b/tests/test_models_3d.py
new file mode 100644
index 0000000..0baa52c
--- /dev/null
+++ b/tests/test_models_3d.py
@@ -0,0 +1,296 @@
+import os
+import shutil
+import numpy as np
+import pytest
+import finitewave as fw
+
+
+def prepare_model(model_class, curr_value, curr_dur, t_calc, t_prebeats):
+ """
+ Prepares a 3D cardiac model with a stimulation protocol.
+
+ Parameters
+ ----------
+ model_class : Callable
+ The cardiac model class to be instantiated.
+ curr_value : float
+ Amplitude of the stimulus current (μA/cm² or model units).
+ curr_dur : float
+ Duration of each stimulus pulse (ms or model units).
+ t_calc : float
+ Time after the last preconditioning beat to continue recording (ms or model units).
+ t_prebeats : float
+ Interval between preconditioning stimuli (ms or model units).
+
+ Returns
+ -------
+ model : CardiacModel
+ Configured and initialized model ready for simulation.
+ """
+ ni = 5
+ nj = 3
+ nk = 3
+ tissue = fw.CardiacTissue3D([ni, nj, nk])
+
+ stim_sequence = fw.StimSequence()
+ stim_sequence.add_stim(fw.StimCurrentCoord3D(0, curr_value, curr_dur, 0, 2, 0, nj, 0, nk))
+ stim_sequence.add_stim(fw.StimCurrentCoord3D(t_prebeats, curr_value, curr_dur, 0, 2, 0, nj, 0, nk))
+ stim_sequence.add_stim(fw.StimCurrentCoord3D(2*t_prebeats, curr_value, curr_dur, 0, 2, 0, nj, 0, nk))
+ stim_sequence.add_stim(fw.StimCurrentCoord3D(3*t_prebeats, curr_value, curr_dur, 0, 2, 0, nj, 0, nk))
+
+ model = model_class()
+ model.dt = 0.01
+ model.dr = 0.25
+ model.t_max = 3*t_prebeats + t_calc
+ model.cardiac_tissue = tissue
+ model.stim_sequence = stim_sequence
+
+ return model
+
+def run_model(model):
+ """
+ Runs a cardiac model with a membrane potential tracker.
+
+ Parameters
+ ----------
+ model : CardiacModel
+ A configured model with stimulation and tissue already assigned.
+
+ Returns
+ -------
+ output : np.ndarray
+ Time series of membrane potential for a specific cell.
+ """
+ tracker = fw.ActionPotential3DTracker()
+ tracker.cell_ind = [3, 1, 1]
+ tracker.step = 1
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ model.tracker_sequence = seq
+
+ model.run()
+ return tracker.output
+
+def calculate_apd(u, dt, threshold, beat_index=3):
+ """
+ Calculates the action potential duration (APD) for a single beat.
+
+ Parameters
+ ----------
+ u : np.ndarray
+ Membrane potential time series.
+ dt : float
+ Time step of the simulation (ms).
+ threshold : float
+ Voltage threshold to define APD90 (e.g., -70 mV or 0.1 for normalized models).
+ beat_index : int, optional
+ Index of the beat to analyze (default is 3).
+
+ Returns
+ -------
+ apd : float or None
+ Duration of the action potential (ms or model units), or None if no complete AP was found.
+ """
+ up_idx = np.where((u[:-1] < threshold) & (u[1:] >= threshold))[0]
+ down_idx = np.where((u[:-1] > threshold) & (u[1:] <= threshold))[0]
+
+ if len(up_idx) <= beat_index or len(down_idx) == 0:
+ return None
+
+ ap_start = up_idx[beat_index]
+ ap_end_candidates = down_idx[down_idx > ap_start]
+ if len(ap_end_candidates) == 0:
+ return None
+
+ ap_end = ap_end_candidates[0]
+ return (ap_end - ap_start) * dt
+
+@pytest.mark.aliev_panfilov_3d
+def test_aliev_panfilov():
+ """
+ Test the Aliev-Panfilov 3D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within expected range [21, 23] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 60 ms.
+ - Amplitude: 10
+ - Duration: 0.5 ms
+ """
+ model = prepare_model(fw.AlievPanfilov3D, curr_value=5, curr_dur=0.5, t_calc=80, t_prebeats=60)
+ u = run_model(model)
+
+ assert np.max(u) == pytest.approx(1.0, abs=0.02)
+ assert np.min(u) == pytest.approx(0.0, abs=0.01)
+
+ apd = calculate_apd(u, model.dt, threshold=0.1)
+ assert 20 <= apd <= 25, f"Aliev-Panfilov APD90 is out of expected range {apd}"
+
+@pytest.mark.barkley_3d
+def test_barkley():
+ """
+ Test the Barkley 3D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within expected range [1, 2] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 60 ms.
+ - Amplitude: 1
+ - Duration: 0.5 ms
+ """
+ model = prepare_model(fw.Barkley3D, curr_value=5, curr_dur=0.1, t_calc=80, t_prebeats=60)
+ u = run_model(model)
+
+ assert np.max(u) == pytest.approx(1.0, abs=0.02)
+ assert np.min(u) == pytest.approx(0.0, abs=0.01)
+
+ apd = calculate_apd(u, model.dt, threshold=0.1)
+ assert 1 <= apd <= 4, f"Barkley APD90 is out of expected range {apd}"
+
+@pytest.mark.mitchell_schaeffer_3d
+def test_mitchell_schaeffer():
+ """
+ Test the Mitchell-Schaeffer 3D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within [280, 320] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 1000 ms.
+ - Amplitude: 10
+ - Duration: 0.5 ms
+ """
+ model = prepare_model(fw.MitchellSchaeffer3D, curr_value=5, curr_dur=0.5, t_calc=1000, t_prebeats=1000)
+ u = run_model(model)
+
+ assert np.max(u) == pytest.approx(0.95, abs=0.02)
+ assert np.min(u) == pytest.approx(0.0, abs=0.01)
+
+ apd = calculate_apd(u, model.dt, threshold=0.1)
+
+ assert 250 <= apd <= 350, f"Mitchell-Schaeffer APD90 is out of expected range {apd}"
+
+@pytest.mark.fenton_karma_3d
+def test_fenton_karma():
+ """
+ Test the Fenton-Karma 3D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within [100, 200] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 1000 ms.
+ - Amplitude: 10
+ - Duration: 0.5 ms
+ """
+ model = prepare_model(fw.FentonKarma3D, curr_value=5, curr_dur=0.5, t_calc=1000, t_prebeats=1000)
+ u = run_model(model)
+
+ assert np.max(u) == pytest.approx(1.0, abs=0.02)
+ assert np.min(u) == pytest.approx(0.0, abs=0.01)
+
+ apd = calculate_apd(u, model.dt, threshold=0.1)
+ assert 100 <= apd <= 200, f"Fenton-Karma APD90 is out of expected range {apd}"
+
+@pytest.mark.bueno_orovio_3d
+def test_bueno_orovio_3d():
+ """
+ Test the Bueno-Orovio 3D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within [200, 300] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 1000 ms.
+ - Amplitude: 100
+ - Duration: 1 ms
+ """
+ model = prepare_model(fw.BuenoOrovio3D, curr_value=5, curr_dur=0.5, t_calc=1000, t_prebeats=1000)
+ u = run_model(model)
+
+ assert np.max(u) == pytest.approx(1.4, abs=0.1)
+ assert np.min(u) == pytest.approx(0.0, abs=0.01)
+
+ apd = calculate_apd(u, model.dt, threshold=0.1)
+ assert 200 <= apd <= 300, f"Bueno-Orovio APD90 is out of expected range {apd}"
+
+
+@pytest.mark.luo_rudy91_3d
+def test_luo_rudy():
+ """
+ Test the Luo-Rudy 1991 3D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - APD90 is within [350, 400] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 1000 ms.
+ - Amplitude: 100
+ - Duration: 1 ms
+ """
+ model = prepare_model(fw.LuoRudy913D, curr_value=100, curr_dur=1, t_calc=1000, t_prebeats=1000)
+ u = run_model(model)
+
+ assert np.max(u) > 20
+ assert np.min(u) < -80
+
+ apd = calculate_apd(u, model.dt, threshold=-70)
+ assert 350 <= apd <= 400, f"Luo-Rudy APD90 is out of expected range {apd}"
+
+@pytest.mark.tp06_3d
+def test_tp06():
+ """
+ Test the Ten Tusscher-Panfilov 2006 (TP06) 3D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within [280, 320] ms.
+
+ Stimulation:
+ - 4 current pulses at intervals of 1000 ms.
+ - Amplitude: 100
+ - Duration: 1 ms
+ """
+ model = prepare_model(fw.TP063D, curr_value=100, curr_dur=1, t_calc=1000, t_prebeats=1000)
+ u = run_model(model)
+
+ assert np.max(u) > 20
+ assert np.min(u) < -80
+
+ apd = calculate_apd(u, model.dt, threshold=-70)
+ assert 280 <= apd <= 320, f"TP06 APD90 is out of expected range {apd}"
+
+@pytest.mark.courtemanche_3d
+def test_courtemanche():
+ """
+ Test the Courtemanche 3D model.
+
+ This test checks:
+ - Correct range of membrane potential values after stimulation.
+ - Action potential duration (APD90) within [200, 300] ms.
+
+ Note: Slightly elevated plateau potential is expected in some parameterizations.
+
+ Stimulation:
+ - 4 current pulses at intervals of 1000 ms.
+ - Amplitude: 100
+ - Duration: 1 ms
+ """
+ model = prepare_model(fw.Courtemanche3D, curr_value=100, curr_dur=1, t_calc=1000, t_prebeats=1000)
+ u = run_model(model)
+
+ assert np.max(u) > 10
+ assert np.min(u) < -80
+
+ apd = calculate_apd(u, model.dt, threshold=-70)
+ assert 200 <= apd <= 300, f"Courtemanche APD90 is out of expected range {apd}"
+
diff --git a/tests/test_multi_act_time.py b/tests/test_multi_act_time.py
deleted file mode 100644
index 06d4be2..0000000
--- a/tests/test_multi_act_time.py
+++ /dev/null
@@ -1,72 +0,0 @@
-import unittest
-import numpy as np
-
-import finitewave as fw
-
-
-def extract_activation_times(t, u, thr):
- activation_times = []
- activated = False
- for i in range(len(t)):
- if u[i] > thr and not activated:
- activation_times.append(t[i])
- activated = True
- elif u[i] <= thr and activated:
- activated = False
- return activation_times
-
-
-class TestMultiActTime(unittest.TestCase):
- def setUp(self):
-
- n = 200
- self.tissue = fw.CardiacTissue2D([n, n])
- self.tissue.mesh = np.ones([n, n], dtype="uint8")
- self.tissue.add_boundaries()
- self.tissue.fibers = np.zeros([n, n, 2])
-
- self.aliev_panfilov = fw.AlievPanfilov2D()
- self.aliev_panfilov.dt = 0.01
- self.aliev_panfilov.dr = 0.25
- self.aliev_panfilov.t_max = 25
-
- stim_sequence = fw.StimSequence()
- stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, 3, 0, n))
- stim_sequence.add_stim(fw.StimVoltageCoord2D(100, 1, 0, 3, 0, n))
- stim_sequence.add_stim(fw.StimVoltageCoord2D(200, 1, 0, 3, 0, n))
-
- tracker_sequence = fw.TrackerSequence()
-
- self.act_time_tracker = fw.MultiActivationTime2DTracker()
- self.act_time_tracker.threshold = 0.5
- tracker_sequence.add_tracker(self.act_time_tracker)
-
- self.multivariable_tracker = fw.MultiVariable2DTracker()
- self.multivariable_tracker.cell_ind = [100, 100]
- self.multivariable_tracker.var_list = ["u"]
- tracker_sequence.add_tracker(self.multivariable_tracker)
-
- tracker_sequence.add_tracker(self.act_time_tracker)
- tracker_sequence.add_tracker(self.multivariable_tracker)
-
- self.aliev_panfilov.cardiac_tissue = self.tissue
- self.aliev_panfilov.stim_sequence = stim_sequence
- self.aliev_panfilov.tracker_sequence = tracker_sequence
-
- def test_activation_time_sequence(self):
- self.aliev_panfilov.run()
-
- calculated_times = []
- for i in range(len(self.act_time_tracker.act_t)):
- calculated_times.append(self.act_time_tracker.act_t[i][100][100])
-
- reference_times = extract_activation_times(np.arange(len(self.multivariable_tracker.vars["u"]))*self.aliev_panfilov.dt,
- self.multivariable_tracker.vars["u"],
- 0.5)
- self.assertEqual(len(calculated_times), len(reference_times),
- msg="Activation time sequence has incorrect length (Multi activation time)")
-
- for i in range(len(calculated_times)):
- self.assertAlmostEqual(calculated_times[i], reference_times[i],
- msg="Different activation times sequence (Multi activation time)",
- delta=2*self.aliev_panfilov.dt)
diff --git a/tests/test_tp06_2d.py b/tests/test_tp06_2d.py
deleted file mode 100755
index 632f1dd..0000000
--- a/tests/test_tp06_2d.py
+++ /dev/null
@@ -1,104 +0,0 @@
-import unittest
-import numpy as np
-import matplotlib.pyplot as plt
-import sys
-
-import finitewave as fw
-
-
-class TestTP062D(unittest.TestCase):
- def setUp(self):
-
- n = 200
- self.tissue = fw.CardiacTissue2D([n, n])
- self.tissue.mesh = np.ones([n, n], dtype="uint8")
- self.tissue.add_boundaries()
- self.tissue.fibers = np.zeros([n, n, 2])
- self.tissue.stencil = fw.AsymmetricStencil2D()
- self.tissue.D_al = 0.154
- self.tissue.D_ac = 0.154
-
- self.tp06 = fw.TP062D()
- self.tp06.dt = 0.001
- self.tp06.dr = 0.1
- self.tp06.t_max = 10
-
- stim_sequence = fw.StimSequence()
- stim_sequence.add_stim(fw.StimVoltageCoord2D(0, -20, 0, 200, 0, 5))
-
- tracker_sequence = fw.TrackerSequence()
- self.velocity_tracker = fw.Velocity2DTracker()
- self.velocity_tracker.threshold = -60
- tracker_sequence.add_tracker(self.velocity_tracker)
-
- self.tp06.cardiac_tissue = self.tissue
- self.tp06.stim_sequence = stim_sequence
- self.tp06.tracker_sequence = tracker_sequence
-
- def test_wave_along_the_fibers(self):
- sys.stdout.write("---> Check the wave speed along the fibers\n")
- self.tissue.fibers[:,:,0] = 0.
- self.tissue.fibers[:,:,1] = 1.
-
- stim_sequence = fw.StimSequence()
- stim_sequence.add_stim(fw.StimVoltageCoord2D(0, -20, 0, 200, 0, 5))
- self.tp06.stim_sequence = stim_sequence
-
- self.tp06.run()
-
- front_vel = np.mean(self.velocity_tracker.compute_velocity_front())
-
- self.assertAlmostEqual(front_vel, 0.8,
- msg="Wave velocity along the fibers direction is incorrect! (AlievPanfilov 2D)",
- delta=0.05)
-
-
- def test_wave_across_the_fibers(self):
- sys.stdout.write("---> Check the wave speed across the fibers\n")
- self.tissue.fibers[:,:,0] = 1.
- self.tissue.fibers[:,:,1] = 0.
- self.tissue.D_al = 0.154
- self.tissue.D_ac = 0.0171
-
- stim_sequence = fw.StimSequence()
- stim_sequence.add_stim(fw.StimVoltageCoord2D(0, -20, 0, 200, 0, 5))
- self.tp06.stim_sequence = stim_sequence
-
- self.tp06.run()
-
- front_vel = np.mean(self.velocity_tracker.compute_velocity_front())
- self.assertAlmostEqual(front_vel, 0.23,
- msg="Wave velocity across the fibers direction is incorrect! (AlievPanfilov 2D)",
- delta=0.05)
-
- # def test_spiral_wave_period(self):
- # sys.stdout.write("---> Check the spiral wave period\n")
- # self.tissue.fibers[:,:,0] = 1.
- # self.tissue.fibers[:,:,1] = 0.
- # self.tissue.D_al = 0.154
- # self.tissue.D_ac = 0.154
- #
- # stim_params = [[0, 200, 0, 100, -20, 0.],
- # [0, 100, 0, 200, -20, 31.]]
- # self.tp06.cardiac_tissue = self.tissue
- # self.tp06.stim_params = stim_params
- #
- # period_tracker = Period2DTracker()
- # period_tracker.target_model = self.tp06
- # period_tracker.mode = "Detectors"
- #
- # detectors = np.zeros([200, 200], dtype="uint8")
- # positions = np.array([[100, 100]])
- # detectors[positions[:, 0], positions[:, 1]] = 1
- #
- # period_tracker.detectors = detectors
- # period_tracker.threshold = 0.2
- #
- # # add tracker to the model
- # self.tp06.add_tracker(period_tracker)
- #
- # self.tp06.run()
- #
- # self.assertAlmostEqual(period_tracker.output["100,100"][-1][1], 194.,
- # msg="Spiral wave period is incorrect! (AlievPanfilov 2D)",
- # delta=1.)
diff --git a/tests/test_trackers_2d.py b/tests/test_trackers_2d.py
new file mode 100644
index 0000000..5014230
--- /dev/null
+++ b/tests/test_trackers_2d.py
@@ -0,0 +1,305 @@
+import os
+import shutil
+import numpy as np
+import pytest
+import finitewave as fw
+
+@pytest.fixture
+def cable_model():
+ ni = 12
+ nj = 3
+ tissue = fw.CardiacTissue2D([ni, nj])
+
+ stim_sequence = fw.StimSequence()
+ stim_sequence.add_stim(fw.StimCurrentCoord2D(0, 5, 0.5, 0, 5, 0, nj))
+
+ model = fw.AlievPanfilov2D()
+ model.dt = 0.01
+ model.dr = 0.25
+ model.t_max = 3
+ model.cardiac_tissue = tissue
+ model.stim_sequence = stim_sequence
+ return model
+
+@pytest.fixture
+def spiral_model():
+ ni = 100
+ nj = 100
+ tissue = fw.CardiacTissue2D([ni, nj])
+
+ stim_sequence = fw.StimSequence()
+ stim_sequence.add_stim(fw.StimVoltageCoord2D(0, 1, 0, ni, 0, 3))
+ stim_sequence.add_stim(fw.StimVoltageCoord2D(5, 1, 0, ni//2, 0, nj))
+
+ model = fw.Barkley2D()
+ model.dt = 0.01
+ model.dr = 0.25
+ model.t_max = 20
+ model.cardiac_tissue = tissue
+ model.stim_sequence = stim_sequence
+ return model
+
+@pytest.fixture
+def planar_model():
+ ni = 50
+ nj = 5
+ tissue = fw.CardiacTissue2D([ni, nj])
+
+ stim_sequence = fw.StimSequence()
+ stim_sequence.add_stim(fw.StimCurrentCoord2D(5, 5, 0.5, 0, 5, 0, nj))
+
+ model = fw.AlievPanfilov2D()
+ model.dt = 0.0015
+ model.dr = 0.25
+ model.t_max = 15
+ model.cardiac_tissue = tissue
+ model.stim_sequence = stim_sequence
+ return model
+
+@pytest.mark.action_potential_2d_tracker
+def test_action_potential_tracker(cable_model):
+ tracker = fw.ActionPotential2DTracker()
+ tracker.cell_ind = [10, 1]
+ tracker.step = 1
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ cable_model.tracker_sequence = seq
+
+ cable_model.t_max = 30
+ cable_model.run()
+
+ u = tracker.output
+
+ # Check if the output is not empty
+ assert u is not None
+ assert len(u) > 0
+
+ # Check if the Aliev-Panfilov model maximal amplitude is within expected range
+ assert np.max(u) == pytest.approx(1.0, abs=0.02)
+
+ threshold = 0.1
+ up_idx = np.where((u[:-1] < threshold) & (u[1:] >= threshold))[0]
+ down_idx = np.where((u[:-1] > threshold) & (u[1:] <= threshold))[0]
+
+ assert len(up_idx) > 0, "Action potential upstroke not found"
+ assert len(down_idx) > 0, "Action potential downstroke not found"
+
+ ap_start = up_idx[0]
+ ap_end = down_idx[down_idx > ap_start][0]
+
+ apd = (ap_end - ap_start) * cable_model.dt
+ # without prebeats:
+ assert 20 <= apd <= 30, f"APD90 is out of expected range {apd}"
+
+@pytest.mark.animation_2d_tracker
+def test_animation_2d_tracker(spiral_model):
+ tracker = fw.Animation2DTracker()
+ tracker.variable_name = "u"
+ tracker.dir_name = "test_frames"
+ tracker.step = 100 # write every 100th step
+ tracker.overwrite = True
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ spiral_model.tracker_sequence = seq
+
+ spiral_model.run()
+
+ # Check if the animation files are created
+ assert os.path.exists(tracker.dir_name), "Output directory was not created."
+ files = sorted(os.listdir(tracker.dir_name))
+ expected_frames = (spiral_model.t_max/spiral_model.dt) // tracker.step
+ assert len(files) == expected_frames, f"Expected {expected_frames} frames, got {len(files)}"
+
+ # Check if the frames are not empty
+ for fname in files:
+ frame = np.load(os.path.join(tracker.dir_name, fname))
+ assert np.any(frame > 0), f"Frame {fname} appears to be empty."
+
+ shutil.rmtree(tracker.dir_name)
+
+@pytest.mark.activation_time_2d_tracker
+def test_activation_time_2d_tracker(cable_model):
+ # TODO:
+ # Edge cases: start time - end time, values rewriting (should not work)
+ tracker = fw.ActivationTime2DTracker()
+ tracker.threshold = 0.5
+ tracker.step = 1
+ tracker.start_time = 0
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ cable_model.tracker_sequence = seq
+
+ cable_model.run()
+
+ ats = tracker.output
+
+ # Check if the output is not empty
+ assert ats is not None
+ assert len(ats) > 0
+ assert np.any(~np.isnan(ats)), "AT array is entirely NaN"
+
+ # Check if the wavefront speed (distance/activation time) value is within expected range
+ speed = 5*cable_model.dr/ats[10, 1] # 5 - number of nodes on the way
+ assert 1.5 <= speed <= 2, f"Wavefront speed is out of expected range {speed}"
+
+@pytest.mark.local_activation_time_2d_tracker
+def test_local_activation_time_2d_tracker(cable_model):
+ tracker = fw.LocalActivationTime2DTracker()
+ tracker.threshold = 0.5
+ tracker.step = 1
+ tracker.start_time = 0
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ cable_model.tracker_sequence = seq
+
+ cable_model.stim_sequence.add_stim(fw.StimVoltageCoord2D(45, 1, 0, 5, 0, 10))
+
+ cable_model.t_max = 50
+ cable_model.run()
+
+ lats = tracker.output
+
+ # Check if the output is not empty
+ assert lats is not None
+ assert len(lats) > 0
+ assert np.any(~np.isnan(lats)), "LAT array is entirely NaN"
+
+ # Values at the center cell should have two LAT values
+ assert len(lats) == 2, "Every cell should have two LAT values"
+ LAT1, LAT2 = lats[:, 10, 1]
+
+ # Check if the wavefront speed (distance/activation time) values are within expected range
+ assert LAT1 < LAT2, "LAT values should be in ascending order"
+ speed_1 = 5*cable_model.dr/LAT1 # 5 - number of nodes on the way
+ speed_2 = 5*cable_model.dr/(LAT2 - 45) # 45 - second wave start time
+ assert 1.5 <= speed_1 <= 2, f"Wavefront speed for the first wave is out of expected range {speed_1}"
+ assert 1.5 <= speed_2 <= 2, f"Wavefront speed for the second wave is out of expected range {speed_2}"
+
+@pytest.mark.activation_time_2d_tracker
+def test_multi_variable_2d_tracker(cable_model):
+ tracker = fw.MultiVariable2DTracker()
+ tracker.cell_ind = [10, 1]
+ tracker.var_list = ["v"]
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ cable_model.tracker_sequence = seq
+
+ cable_model.t_max = 30
+ cable_model.run()
+
+ v = tracker.output["v"]
+
+ # Check if the output is not empty
+ assert v is not None
+ assert len(v) > 0
+
+ # Check if the Aliev-Panfilov model 'v' maximal amplitude is within expected range
+ assert np.max(v) == pytest.approx(2, abs=0.1)
+
+@pytest.mark.spiral_wave_core_2d_tracker
+def test_spiral_wave_core_2d_tracker(spiral_model):
+ tracker = fw.SpiralWaveCore2DTracker()
+ tracker.threshold = 0.5
+ tracker.start_time = 12
+ tracker.step = 10 # Record the spiral wave core every 10 step
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ spiral_model.tracker_sequence = seq
+
+ spiral_model.run()
+
+ sw_core = tracker.output
+
+ x, y = sw_core['x'], sw_core['y']
+
+ # Check if the output is not empty
+ assert x is not None
+ assert y is not None
+ assert len(x) > 0
+ assert len(y) > 0
+
+ # Check if the spiral wave core is within expected range
+ assert np.min(x) >= 32
+ assert np.max(x) <= 38
+ assert np.min(y) >= 47
+ assert np.max(y) <= 53
+
+@pytest.mark.spiral_wave_period_2d_tracker
+def test_spiral_wave_period_2d_tracker(spiral_model):
+ tracker = fw.Period2DTracker()
+ # Here we create an int array of detectors as a list of positions in which we want to calculate the period.
+ positions = np.array([[80, 80], [20, 70], [40, 10], [25, 90]])
+ tracker.cell_ind = positions
+ tracker.threshold = 0.5
+ tracker.start_time = 10
+ tracker.step = 10
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ spiral_model.tracker_sequence = seq
+
+ spiral_model.run()
+
+ periods = tracker.output
+
+ period_mean = np.mean(np.array([np.mean(x) if len(x) > 0 else np.nan for x in periods]))
+
+ # Check if the output is not empty
+ assert periods is not None
+ assert len(periods) > 0
+
+ # Check if the spiral wave period is within expected range
+ assert period_mean == pytest.approx(3.5, abs=0.2)
+
+@pytest.mark.ecg_2d_tracker
+def test_ecg_2d_tracker(planar_model):
+ tracker = fw.ECG2DTracker()
+ tracker.start_time = 0
+ tracker.step = 10
+ tracker.measure_coords = np.array([[25, 2, 0]])
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+
+ planar_model.tracker_sequence = seq
+
+ planar_model.run()
+
+ ecg = tracker.output.T[0]
+
+ assert ecg.max() > 0.001
+ assert ecg.min() < -0.001
+ assert np.argmax(ecg) > 100 # Check if the peak occurs not at the beginning
+
+def test_period_animation_2d_tracker(spiral_model):
+ tracker = fw.PeriodAnimation2DTracker()
+ tracker.dir_name = "test_frames"
+ tracker.threshold = 0.5
+ tracker.step = 100 # write every 100th step
+ tracker.overwrite = True
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ spiral_model.tracker_sequence = seq
+
+ spiral_model.run()
+
+ # Check if the animation files are created
+ assert os.path.exists(tracker.dir_name), "Output directory was not created."
+ files = sorted(os.listdir(tracker.dir_name))
+ expected_frames = (spiral_model.t_max/spiral_model.dt) // tracker.step
+ assert len(files) == expected_frames, f"Expected {expected_frames} frames, got {len(files)}"
+
+ # Check if the frames are not empty
+ frame = np.load(os.path.join(tracker.dir_name, files[-1]))
+ assert np.any(frame > 0), f"Frame {frame} appears to be empty."
+
+ shutil.rmtree(tracker.dir_name)
+
+
diff --git a/tests/test_trackers_3d.py b/tests/test_trackers_3d.py
new file mode 100644
index 0000000..81862f6
--- /dev/null
+++ b/tests/test_trackers_3d.py
@@ -0,0 +1,344 @@
+import os
+import shutil
+from pathlib import Path
+from tempfile import TemporaryDirectory
+import numpy as np
+import pytest
+import finitewave as fw
+
+@pytest.fixture
+def cable_model():
+ ni = 12
+ nj = 3
+ nk = 3
+ tissue = fw.CardiacTissue3D([ni, nj, nk])
+
+ stim_sequence = fw.StimSequence()
+ stim_sequence.add_stim(fw.StimCurrentCoord3D(0, 5, 0.5, 0, 5, 0, nj, 0, nk))
+
+ model = fw.AlievPanfilov3D()
+ model.dt = 0.01
+ model.dr = 0.25
+ model.t_max = 3
+ model.cardiac_tissue = tissue
+ model.stim_sequence = stim_sequence
+ return model
+
+@pytest.fixture
+def spiral_model():
+ ni = 100
+ nj = 100
+ nk = 3
+ tissue = fw.CardiacTissue3D([ni, nj, nk])
+
+ stim_sequence = fw.StimSequence()
+ stim_sequence.add_stim(fw.StimVoltageCoord3D(0, 1, 0, ni, 0, 3, 0, nk))
+ stim_sequence.add_stim(fw.StimVoltageCoord3D(5, 1, 0, ni//2, 0, nj, 0, nk))
+
+ model = fw.Barkley3D()
+ model.dt = 0.01
+ model.dr = 0.25
+ model.t_max = 20
+ model.cardiac_tissue = tissue
+ model.stim_sequence = stim_sequence
+ return model
+
+@pytest.fixture
+def planar_model():
+ ni = 50
+ nj = 5
+ nk = 3
+ tissue = fw.CardiacTissue3D([ni, nj, nk])
+
+ stim_sequence = fw.StimSequence()
+ stim_sequence.add_stim(fw.StimCurrentCoord3D(5, 5, 0.5, 0, 5, 0, nj, 0, nk))
+
+ model = fw.AlievPanfilov3D()
+ model.dt = 0.0015
+ model.dr = 0.25
+ model.t_max = 15
+ model.cardiac_tissue = tissue
+ model.stim_sequence = stim_sequence
+ return model
+
+@pytest.mark.action_potential_3d_tracker
+def test_action_potential_tracker(cable_model):
+ tracker = fw.ActionPotential3DTracker()
+ tracker.cell_ind = [10, 1, 1]
+ tracker.step = 1
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ cable_model.tracker_sequence = seq
+
+ cable_model.t_max = 30
+ cable_model.run()
+
+ u = tracker.output
+
+ # Check if the output is not empty
+ assert u is not None
+ assert len(u) > 0
+
+ # Check if the Aliev-Panfilov model maximal amplitude is within expected range
+ assert np.max(u) == pytest.approx(1.0, abs=0.02)
+
+ threshold = 0.1
+ up_idx = np.where((u[:-1] < threshold) & (u[1:] >= threshold))[0]
+ down_idx = np.where((u[:-1] > threshold) & (u[1:] <= threshold))[0]
+
+ assert len(up_idx) > 0, "Action potential upstroke not found"
+ assert len(down_idx) > 0, "Action potential downstroke not found"
+
+ ap_start = up_idx[0]
+ ap_end = down_idx[down_idx > ap_start][0]
+
+ apd = (ap_end - ap_start) * cable_model.dt
+ # without prebeats:
+ assert 20 <= apd <= 30, f"APD90 is out of expected range {apd}"
+
+@pytest.mark.animation_3d_tracker
+def test_animation_3d_tracker(spiral_model):
+ tracker = fw.Animation3DTracker()
+ tracker.variable_name = "u"
+ tracker.dir_name = "test_frames"
+ tracker.step = 100 # write every 100th step
+ tracker.overwrite = True
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ spiral_model.tracker_sequence = seq
+
+ spiral_model.run()
+
+ # Check if the animation files are created
+ assert os.path.exists(tracker.dir_name), "Output directory was not created."
+ files = sorted(os.listdir(tracker.dir_name))
+ expected_frames = (spiral_model.t_max/spiral_model.dt) // tracker.step
+ assert len(files) == expected_frames, f"Expected {expected_frames} frames, got {len(files)}"
+
+ # Check if the frames are not empty
+ for fname in files:
+ frame = np.load(os.path.join(tracker.dir_name, fname))
+ assert np.any(frame > 0), f"Frame {fname} appears to be empty."
+
+ shutil.rmtree(tracker.dir_name)
+
+@pytest.mark.activation_time_3d_tracker
+def test_activation_time_3d_tracker(cable_model):
+ # TODO:
+ # Edge cases: start time - end time, values rewriting (should not work)
+ tracker = fw.ActivationTime3DTracker()
+ tracker.threshold = 0.5
+ tracker.step = 1
+ tracker.start_time = 0
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ cable_model.tracker_sequence = seq
+
+ cable_model.run()
+
+ ats = tracker.output
+
+ # Check if the output is not empty
+ assert ats is not None
+ assert len(ats) > 0
+ assert np.any(~np.isnan(ats)), "AT array is entirely NaN"
+
+ # Check if the wavefront speed (distance/activation time) value is within expected range
+ speed = 5*cable_model.dr/ats[10, 1, 1] # 5 - number of nodes on the way
+ assert 1.5 <= speed <= 2, f"Wavefront speed is out of expected range {speed}"
+
+@pytest.mark.local_activation_time_3d_tracker
+def test_local_activation_time_3d_tracker(cable_model):
+ tracker = fw.LocalActivationTime3DTracker()
+ tracker.threshold = 0.5
+ tracker.step = 1
+ tracker.start_time = 0
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ cable_model.tracker_sequence = seq
+
+ cable_model.stim_sequence.add_stim(fw.StimVoltageCoord3D(45, 1, 0, 5, 0, 10, 0, 3))
+
+ cable_model.t_max = 50
+ cable_model.run()
+
+ lats = tracker.output
+
+ # Check if the output is not empty
+ assert lats is not None
+ assert len(lats) > 0
+ assert np.any(~np.isnan(lats)), "LAT array is entirely NaN"
+
+ # Values at the center cell should have two LAT values
+ assert len(lats) == 2, "Every cell should have two LAT values"
+ LAT1, LAT2 = lats[:, 10, 1, 1]
+
+ # Check if the wavefront speed (distance/activation time) values are within expected range
+ assert LAT1 < LAT2, "LAT values should be in ascending order"
+ speed_1 = 5*cable_model.dr/LAT1 # 5 - number of nodes on the way
+ speed_2 = 5*cable_model.dr/(LAT2 - 45) # 45 - second wave start time
+ assert 1.5 <= speed_1 <= 2, f"Wavefront speed for the first wave is out of expected range {speed_1}"
+ assert 1.5 <= speed_2 <= 2, f"Wavefront speed for the second wave is out of expected range {speed_2}"
+
+@pytest.mark.activation_time_3d_tracker
+def test_multi_variable_3d_tracker(cable_model):
+ tracker = fw.MultiVariable3DTracker()
+ tracker.cell_ind = [10, 1, 1]
+ tracker.var_list = ["v"]
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ cable_model.tracker_sequence = seq
+
+ cable_model.t_max = 30
+ cable_model.run()
+
+ v = tracker.output["v"]
+
+ # Check if the output is not empty
+ assert v is not None
+ assert len(v) > 0
+
+ # Check if the Aliev-Panfilov model 'v' maximal amplitude is within expected range
+ assert np.max(v) == pytest.approx(2, abs=0.1)
+
+@pytest.mark.spiral_wave_core_3d_tracker
+def test_spiral_wave_core_3d_tracker(spiral_model):
+ tracker = fw.SpiralWaveCore3DTracker()
+ tracker.threshold = 0.5
+ tracker.start_time = 12
+ tracker.step = 10 # Record the spiral wave core every 10 step
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ spiral_model.tracker_sequence = seq
+
+ spiral_model.run()
+
+ sw_core = tracker.output
+
+ x, y, z = sw_core['x'], sw_core['y'], sw_core['z']
+
+ # Check if the output is not empty
+ assert x is not None
+ assert y is not None
+ assert z is not None
+ assert len(x) > 0
+ assert len(y) > 0
+ assert len(z) > 0
+
+ # Check if the spiral wave core is within expected range
+ assert np.min(x) >= 32
+ assert np.max(x) <= 38
+ assert np.min(y) >= 47
+ assert np.max(y) <= 53
+ assert np.min(z) >= 0
+ assert np.max(z) <= 2
+
+@pytest.mark.spiral_wave_period_3d_tracker
+def test_spiral_wave_period_3d_tracker(spiral_model):
+ tracker = fw.Period3DTracker()
+ # Here we create an int array of detectors as a list of positions in which we want to calculate the period.
+ positions = np.array([[80, 80, 1], [20, 70, 1], [40, 10, 1], [25, 90, 1]])
+ tracker.cell_ind = positions
+ tracker.threshold = 0.5
+ tracker.start_time = 10
+ tracker.step = 10
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ spiral_model.tracker_sequence = seq
+
+ spiral_model.run()
+
+ periods = tracker.output
+
+ period_mean = np.mean(np.array([np.mean(x) if len(x) > 0 else np.nan for x in periods]))
+
+ # Check if the output is not empty
+ assert periods is not None
+ assert len(periods) > 0
+
+ # Check if the spiral wave period is within expected range
+ assert period_mean == pytest.approx(3.5, abs=0.2)
+
+@pytest.mark.ecg_3d_tracker
+def test_ecg_3d_tracker(planar_model):
+ tracker = fw.ECG3DTracker()
+ tracker.start_time = 0
+ tracker.step = 10
+ tracker.measure_coords = np.array([[25, 2, 1]])
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+
+ planar_model.tracker_sequence = seq
+
+ planar_model.run()
+
+ ecg = tracker.output.T[0]
+
+ assert ecg.max() > 0.001
+ assert ecg.min() < -0.001
+ assert np.argmax(ecg) > 100 # Check if the peak occurs not at the beginning
+
+def test_animation_slice_3d_tracker():
+
+ class MockModel:
+ def __init__(self):
+ self.V = np.random.rand(5, 5, 5)
+ self.cardiac_tissue = type("Tissue", (), {})()
+ self.cardiac_tissue.mesh = np.ones((5, 5, 5), dtype=np.int8)
+
+ tracker = fw.AnimationSlice3DTracker()
+ tracker.variable_name = 'V'
+ tracker.slice_z = 2 # only one of slice_x, slice_y, slice_z must be set
+ tracker.dir_name = "test_frames"
+ tracker.file_name = "test_animation"
+
+ with TemporaryDirectory() as tmpdir:
+ tracker.path = tmpdir
+ model = MockModel()
+ tracker.initialize(model)
+
+ for _ in range(3):
+ tracker._track()
+
+ output_dir = Path(tmpdir) / "test_frames"
+ files = sorted(output_dir.glob("*.npy"))
+ assert len(files) == 3, "Should create exactly 3 frame files"
+
+ for file in files:
+ frame = np.load(file)
+ assert frame.shape == (5, 5), "Each frame should have shape (5, 5)"
+ assert frame.dtype == np.float32 or frame.dtype == np.float64
+
+def test_period_animation_3d_tracker(spiral_model):
+ tracker = fw.PeriodAnimation3DTracker()
+ tracker.dir_name = "test_frames"
+ tracker.threshold = 0.5
+ tracker.step = 100 # write every 100th step
+ tracker.overwrite = True
+
+ seq = fw.TrackerSequence()
+ seq.add_tracker(tracker)
+ spiral_model.tracker_sequence = seq
+
+ spiral_model.run()
+
+ # Check if the animation files are created
+ assert os.path.exists(tracker.dir_name), "Output directory was not created."
+ files = sorted(os.listdir(tracker.dir_name))
+ expected_frames = (spiral_model.t_max/spiral_model.dt) // tracker.step
+ assert len(files) == expected_frames, f"Expected {expected_frames} frames, got {len(files)}"
+
+ # Check if the frames are not empty
+ frame = np.load(os.path.join(tracker.dir_name, files[-1]))
+ assert np.any(frame > 0), f"Frame {frame} appears to be empty."
+
+ shutil.rmtree(tracker.dir_name)
+
- 
- 
-