semvec/pypi-packages huggingface dataset:
finitewave-model-mitchell-schaeffer 0.2.0
Mitchell-Schaeffer model.
License: MIT
Requires Python: >=3.10
Keywords: cardiac, electrophysiology, finitewave, model

## Mitchell-Schaeffer Finitewave model

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.

This model implementation can be used separately from the Finitewave, allowing for standalone simulations and testing of the model dynamics without the need for the entire framework.

### Reference
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.

DOI: https://doi.org/10.1016/S0092-8240(03)00041-7

### How to use (quickstart)
```bash
python -m examples.mitchell_schaeffer_example
```

### How to test
```bash
python -m pytest -q
```

### Repository structure
```text
.
├── mitchell_schaeffer/               # equations package (ops.py)
│   ├── __init__.py
│   └── ops.py                        # fill with the model equations (pure functions)
├── implementation/                   # 0D model implementation
│   ├── __init__.py
│   └── mitchell_schaeffer_0d.py
├── example/
│   └── mitchell_schaeffer_example.py # minimal script to run a short trace
├── tests/
│   └── mitchell_schaeffer_test.py    # smoke test; extend with reproducibility checks
├── .gitignore
├── LICENSE                           # MIT
├── pyproject.toml                    # placeholders to replace
└── README.md                         # this file
```

### Variables
- `u` — Transmembrane potential (dimensionless)
- `h` — Gating variable (dimensionless)

### Parameters
Parameters and their defualt values
- `tau_close = 150.0` - Inactivation time constant (closing).
- `tau_open = 120.0`  - Recovery time constant (opening).
- `tau_out = 6.0`     - Time constant for outward current (repolarization)
- `tau_in = 0.3`      - Time constant for inward flow.
- `u_gate = 0.13`     - Threshold potential for switching gate dynamics.
finitewave-model-fenton-karma 0.2.0
Fenton-Karma model.
License: MIT
Requires Python: >=3.10
Keywords: cardiac, electrophysiology, finitewave, model

## Fenton-Karma Finitewave model

The Fenton-Karma model is a simplified mathematical representation of cardiac action potentials, designed to reproduce the essential excitation–recovery dynamics of cardiac cells. Unlike detailed ionic models, it does not explicitly describe individual ion currents but instead uses a reduced set of variables and parameters to capture the key features of cardiac electrophysiology. This abstraction makes the model computationally efficient while retaining the ability to simulate wave propagation, spiral wave dynamics, and arrhythmia mechanisms in cardiac tissue.

This model implementation can be used separately from the Finitewave, allowing for standalone simulations and testing of the model dynamics without the need for the entire framework.

### Reference
Fenton, F. H., & Karma, A. (1998). Vortex dynamics in three-dimensional 
continuous myocardium with fiber rotation: Filament instability and fibrillation.
Chaos: An Interdisciplinary Journal of Nonlinear Science, 8(1), 20-47.

DOI: https://doi.org/10.1063/1.166311

### How to use (quickstart)
```bash
python -m example.fenton_karma_example
```

### How to test
```bash
python -m pytest -q
```

### Repository structure
```text
.
├── fenton_karma/                    # equations package (ops.py)
│   ├── __init__.py
│   └── ops.py                       # fill with the model equations (pure functions)
├── implementation/                  # 0D Fenton-Karma implementation
│   ├── __init__.py
│   └── fenton_karma_0d.py
├── example/
│   └── fenton_karma_example.py      # minimal script to run a short trace
├── tests/
│   └── fenton_karma_test.py         # smoke test; extend with reproducibility checks
├── .gitignore
├── LICENSE                          # MIT
├── pyproject.toml                   # placeholders to replace
└── README.md                        # this file
```

### Variables
Model state variables: description, units and ranges (optional)
- `u` — Transmembrane potential (mV)
- `v` - Initial recovery variable (dimensionless)
- `w` - Initial activation variable (dimensionless)

### Parameters
Parameters and their default values
- `tau_r   = 130` - Recovery time constant (ms)
- `tau_o   = 12.5` - Activation time constant (ms)
- `tau_d   = 0.172` - Deactivation time constant (ms)
- `tau_si  = 127` - Slow inactivation time constant (ms)
- `tau_v_m = 18.2` - Membrane time constant (ms)
- `tau_v_p = 10` - Potential time constant (ms)
- `tau_w_m = 80` - Activation time constant for `w` (ms)
- `tau_w_p = 1020` - Activation time constant for `w` (ms)
- `k       = 10` - Scaling factor for recovery dynamics
- `u_c     = 0.13` - Threshold for recovery variable (dimensionless)
- `uc_si   = 0.85` - Slow inactivation threshold (dimensionless)
finitewave-model-barkley 0.2.0
Barkley model.
License: MIT
Requires Python: >=3.10
Keywords: cardiac, electrophysiology, finitewave, model

## Barkley Finitewave model

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 model implementation can be used separately from the Finitewave, allowing for standalone simulations and testing of the model dynamics without the need for the entire framework.

### Reference
Barkley, D. (1991).
A model for fast computer simulation of waves in excitable media.
Physica D: Nonlinear Phenomena, 61-70.

DOI: https://doi.org/10.1016/0167-2789(86)90198-1.

### How to use (quickstart)
```bash
python -m examples.barkley_example
```

### How to test
```bash
python -m pytest -q
```

### Repository structure
```text
.
├── barkley/                 # equations package (ops.py)
│   ├── __init__.py
│   └── ops.py               # model equations (pure functions)
├── implementation/          # 0D model implementation
│   ├── __init__.py
│   └── barkley_0d.py
├── example/
│   └── barkley_example.py   # minimal script to run a short trace
├── tests/
│   └── test.py              # smoke test; reproducibility checks
├── .gitignore
├── LICENSE                  # MIT
├── pyproject.toml           # configuration file
└── README.md                # this file
```

### Variables
- `u` — Transmembrane potential (dimensionless).
- `v` — Recovery variable (dimensionless).

### Parameters
- `a = 0.75`   - Threshold-like parameter controlling excitability.
- `b = 0.02`   - Recovery time scale.
- `eps = 0.02` - Controls sharpness of the activation term (nonlinear gain).