Apply QC1 and QC4 to multiple sweeps

.github/workflows/pytest.yml

@@ -8,7 +8,7 @@ jobs:
     strategy:
       matrix:
         python-version: ['3.10', 3.11, 3.12, 3.13, 3.14]
-        
+
     steps:
     - name: Checkout repository
       uses: actions/checkout@v4
@@ -53,6 +53,6 @@ jobs:
 
     - uses: codecov/codecov-action@v4
       with:
-        token: ${{ secrets.CODECOV_TOKEN }} # not required for public repos
+        token: ${{ secrets.CODECOV_TOKEN }}
       if: success() && matrix.python-version == 3.14
 

.gitignore

@@ -1,5 +1,7 @@
+pcpostprocess/_version.py
 /tests/test_data
 /test_output
 *__pycache__*
 *.egg-info
 *.DS_Store
+.coverage

CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+This page lists the main changes made to pcpostprocess in each release.
+
+## Unreleased
+- Added
+  - [#104](https://github.com/CardiacModelling/pcpostprocess/pull/104) Added a CHANGELOG.md and CONTRIBUTING.md
+- Changed
+- Deprecated
+- Removed
+- Fixed
+
+## [0.2.0] - 2025-11-11
+First official release.
+

CONTRIBUTING.md

@@ -0,0 +1,188 @@
+# Contributing to pcpostprocess
+
+Contributions to pcpostprocess are always welcome!
+
+We use [GIT](https://en.wikipedia.org/wiki/Git) and [GitHub](https://en.wikipedia.org/wiki/GitHub) to coordinate our work.
+When making changes, we try to follow the procedure below.
+
+1. **Discuss proposed changes before starting any work.**
+   Before coding, always create an [issue](https://docs.github.com/en/issues/tracking-your-work-with-issues/learning-about-issues/about-issues) and disucss the proposed work.
+   Something similar may already exist, be under development, or have been proposed and rejected - so this can save valuable time.
+
+2. **Always work on branches**.
+   Once the idea has been agreed upon, start coding in a new _branch_.
+   If you're in the CardiacModelling team, you can create a [branch](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-and-deleting-branches-within-your-repository) directly in the main pcpostprocess repository.
+   For outside contributions, you'll first need to [create a fork](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/fork-a-repo).
+
+   There are no rules for branch names, but try to make them relate to the issue, e.g. by including the issue number.
+
+   Commit your changes to your branch with useful, descriptive commit messages that will still make sense in years to come.
+
+3. **Conform to style guidelines, and document every class, method, and argument.**
+   For more information, see below.
+
+   **Note: as of 2025-11-11, we are still in the process of making `pcpostprocess` confirm to this rule.**
+
+4. **Test locally, and ensure 100% test coverage**
+    For more information, see below.
+
+    **Note: as of 2025-11-11, we are stillin the process of making `pcpostprocess` confirm to this rule.**
+
+4. **Discuss code in a PR**
+   When your code is finished, or warrants discussion, create a [pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests) (PR).
+   In your branch, update the [Changelog](./CHANGELOG.md) with a link to this PR and a concise summary of the changes.
+   Finally, request a review of the code.
+
+## Project structure
+
+`pcpostprocess` is written in [Python 3](https://en.wikipedia.org/wiki/Python_(programming_language)), but at the moment has a few **non-python dependencies** i.e. latex.
+
+## Developer installation
+
+**TODO: Once there is a "user" way to install, move the git clone etc. information here [#105](https://github.com/CardiacModelling/pcpostprocess/issues/105).**
+
+```
+pip install -e .[test]
+```
+
+## Style guidelines
+
+Style checking is done with [flake8](http://flake8.pycqa.org/en/latest/).
+
+To run locally, use
+```
+$ flake8
+```
+
+Until Flake8 configuration supports [pyproject.toml](https://github.com/PyCQA/flake8/issues/234), it will be configured through [.flake8](./.flake8) ([syntax](http://flake8.pycqa.org/en/latest/user/configuration.html)).
+
+In addition to the rules checked by flake8, we try to use single quotes (`'`) for strings, rather than double quotes (`"`) (but `"""` for docstrings).
+
+### Spelling
+
+**TODO WE SHOULD MAYBE DISCUSS WHICH ENGLISH TO USE? [#106](https://github.com/CardiacModelling/pcpostprocess/issues/106)**
+
+### Import ordering
+
+Import ordering is tested with [isort](https://pycqa.github.io/isort/index.html).
+
+To run locally, use
+```
+isort --check-only --verbose ./pcpostprocess ./tests/
+```
+
+Isort is configured in [pyproject.toml](./pyproject.toml) under the section `tool.isort`.
+
+## Documentation
+
+Every method and every class should have a [docstring](https://www.python.org/dev/peps/pep-0257/) that describes in plain terms what it does, and what the expected input and output is.
+
+Each docstring should start with a one-line explanation.
+If more explanation is needed, this one-liner is followed by a blank line and more information in the following paragraphs.
+
+**TODO: READTHEDOCS [#60](https://github.com/CardiacModelling/pcpostprocess/issues/60)**
+
+**TODO: SYNTAX, RUNNING LOCALLY, ETC**
+
+**TODO: EXAMPLES**
+
+```
+cd doc
+make clean
+make html
+```
+
+[reStructuredText](http://docutils.sourceforge.net/docs/user/rst/quickref.html)
+[Sphinx](http://www.sphinx-doc.org/en/stable/)
+
+## Testing
+
+To run all unit tests, locally:
+
+```
+$ python3 -m unittest
+```
+
+To run a single test, use
+```
+$ python3 -m unittest TestClass.test_method
+```
+
+### Unit tests
+
+Testing is done with [unittest](https://docs.python.org/3/library/unittest.html).
+
+Each method in `pcpostprocess` should have a unit test.
+
+Tests should always aim to compare generated output with reference values, instead of just checking no errors are generated.
+
+### Coverage
+
+Coverage is checked with [coverage](https://coverage.readthedocs.io/en/latest/).
+
+To run locally, use
+```
+coverage run -m unittest
+```
+and, if the tests pass, view the report with
+```
+coverage report
+```
+
+### Github actions
+
+Whenever changes are made to a branch with an open pull request, tests will be run using GitHub actions.
+
+These are configured in a single workflow **TODO THIS IS BEING UPDATED ATM**
+
+Coverage testing is run, and sent to [codecov.io](https://docs.codecov.io/docs) to generate [online reports](https://app.codecov.io/github/CardiacModelling/pcpostprocess).
+
+## Logging changes
+
+Each PR should add a line (or occasionally multiple lines) to [CHANGELOG.md](./CHANGELOG.md).
+This should be a very concise summary of the work done, and link to the PR itself for further info.
+Changes are classified as `Added`, `Changed`, `Deprecated`, `Removed`, or `Fixed`.
+
+For example, the first entry in our Changelog was:
+```
+- Added
+  - [#104](https://github.com/CardiacModelling/pcpostprocess/pull/104) Added a CHANGELOG.md and CONTRIBUTING.md
+```
+
+## Packaging
+
+This project uses a minimal [`setup.py`](./setup.py), and instead uses [pyproject.toml](./pyproject.toml).
+
+### Versioning
+
+Version numbers are not set in the code, but derived from git tags, using [setuptools-scm](https://setuptools-scm.readthedocs.io/en/latest/).
+This is run every time setuptools is run, e.g. with
+```
+pip install -e .[test]
+```
+
+Versions numbers take the form `X.Y.Z` where X, Y, and Z are "major", "minor", and "revision" numbers.
+Changes to the public interface should be reflected in an updated minor version.
+Small changes should be indicated with revisions.
+These numbers don't stop at 9, so e.g. 1.11.12 is a viable number.
+
+**The version number is only changed when a new release is made**
+
+### Releases
+
+Releases, like other changes, are made on a branch, using the following procedure:
+
+1. Create a new branch.
+2. Update the changelog, replacing the "Unreleased" header with a version number and date, e.g. `## [0.2.0] - 2025-11-11`.
+3. Commit the change.
+4. Add a tag using e.g. `git tag v0.2.0`, and push it with `git push --tags`.
+5. Update the changelog, adding a new "Unreleased" header with empty categories.
+6. Merge the PR.
+7. [Add a new release](https://github.com/CardiacModelling/pcpostprocess/releases) in GitHub, using the tag you created, and copy in the changes from the changelog.
+
+**TODO: THERE IS NO PACKAGING ON PYPI ATM [#105](https://github.com/CardiacModelling/pcpostprocess/issues/105)**
+
+### Licensing
+
+Licensing information is provided in a separate [LICENSE](./LICENSE) file.
+

LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2024, University of Nottingham
+Copyright (c) 2024-2025, University of Nottingham
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

README.md

@@ -111,3 +111,11 @@ options:
   --log_level LOG_LEVEL
 ```
 
+## Contributing
+
+Although `pcpostprocess` is still early in its development, we have set up guidelines for user contributions in [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## Licensing
+
+For licensing information, see the [LICENSE](./LICENSE) file.
+

pcpostprocess/detect_ramp_bounds.py

@@ -1,23 +1,23 @@
 import numpy as np
 
 
-def detect_ramp_bounds(times, voltage_sections, ramp_no=0):
+def detect_ramp_bounds(times, voltage_sections, ramp_index=0):
     """
-    Extract the the times at the start and end of the nth ramp in the protocol.
+    Extract the timepoint indices at the start and end of the nth ramp in the protocol.
 
     @param times: np.array containing the time at which each sample was taken
     @param voltage_sections 2d np.array where each row describes a segment of the protocol: (tstart, tend, vstart, end)
-    @param ramp_no: the index of the ramp to select. Defaults to 0 - the first ramp
+    @param ramp_index: the index of the ramp to select. Defaults to 0 - the first ramp
 
-    @returns tstart, tend: the start and end times for the ramp_no+1^nth ramp
+    @returns istart, iend: the start and end timepoint indices for the specified ramp
     """
 
     ramps = [(tstart, tend, vstart, vend) for tstart, tend, vstart, vend
              in voltage_sections if vstart != vend]
     try:
-        ramp = ramps[ramp_no]
+        ramp = ramps[ramp_index]
     except IndexError:
-        print(f"Requested {ramp_no+1}th ramp (ramp_no={ramp_no}),"
+        print(f"Requested {ramp_index+1}th ramp (ramp_index={ramp_index}),"
               " but there are only {len(ramps)} ramps")
 
     tstart, tend = ramp[:2]

pcpostprocess/directory_builder.py

@@ -0,0 +1,63 @@
+import datetime
+import os
+import sys
+
+from ._version import __commit_id__, __version__
+
+
+def get_git_revision_hash():
+    """
+    Get the hash for the git commit currently being used.
+
+    @return The most recent commit hash or a suitable message
+
+    """
+
+    return __commit_id__
+
+
+def get_build_type():
+    if "dev" in __version__:
+        return "Develop"
+    else:
+        return "Release"
+
+
+def setup_output_directory(dirname: str = None, subdir_name: str = None):
+    """
+    Create an output directory if one doesn't already exist. Place an info
+    file in this directory which lists the date/time created, the version of
+    pcpostprocess, the command-line arguments provided, and the most recent git
+    commit. The two parameters allow for a user specified top-level directory and
+    a script-defined name for a subdirectory.
+
+    @param Optional directory name
+    @param Optional subdirectory name
+
+    @return The path to the created file directory (String)
+    """
+
+    if dirname is None:
+        if subdir_name:
+            dirname = os.path.join("output", f"{subdir_name}")
+        else:
+            dirname = os.path.join("output", "output")
+
+    if subdir_name is not None:
+        dirname = os.path.join(dirname, subdir_name)
+    if not os.path.exists(dirname):
+        os.makedirs(dirname)
+
+    with open(os.path.join(dirname, "pcpostprocess_info.txt"), "w") as description_fout:
+        git_hash = get_git_revision_hash()
+        datetimestr = str(datetime.datetime.now())
+        description_fout.write("pcpostprocess output "
+                               "https://github.com/CardiacModelling/pcpostprocess\n")
+        description_fout.write(f"Date: {datetimestr}\n")
+        description_fout.write(f"Version: {__version__}\n")
+        description_fout.write(f"Build type: {get_build_type()}\n")
+        description_fout.write(f"Commit: {git_hash}\n")
+        command = " ".join(sys.argv)
+        description_fout.write(f"Command: {command}\n")
+    return dirname
+

pcpostprocess/infer_reversal.py

@@ -33,10 +33,7 @@ def infer_reversal_potential(current, times, voltage_segments, voltages,
     """
 
     # Get ramp bounds, assuming final ramp is the reversal ramp
-    tstart, tend = detect_ramp_bounds(times, voltage_segments, -1)
-
-    istart = np.argmax(times > tstart)
-    iend = np.argmax(times > tend)
+    istart, iend = detect_ramp_bounds(times, voltage_segments, -1)
 
     current = current[istart:iend]
     voltages = voltages[istart:iend]

pcpostprocess/leak_correct.py

@@ -149,7 +149,7 @@ def fit_linear_leak(current, voltage, times, ramp_start_index, ramp_end_index,
         ax4.plot(times, I_obs, label=r'$I_\mathrm{obs}$')
         ax4.plot(times, I_leak, linestyle='--', label=r'$I_\mathrm{L}$')
         ax4.plot(times, I_obs - I_leak,
-                 linestyle='--', alpha=0.5, label=r'$I_\mathrm{obs} - I_\mathrm{L}$')
+                 alpha=0.5, label=r'$I_\mathrm{obs} - I_\mathrm{L}$')
         ax4.legend(frameon=False)
 
         if not os.path.exists(output_dir):