v0.2.1

.github/workflows/coverage.yml

@@ -0,0 +1,58 @@
+name: coverage
+
+on:
+  push:
+    branches: [ master, dev ]
+  pull_request:
+    branches: [ master, dev ]
+
+jobs:
+  coverage:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.11']
+    steps:
+    - name: Check out code from GitHub
+      uses: actions/checkout@v4.1.6
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install -r requirements_test.txt
+        pip install tox
+    - name: Run Coverage
+      run: |
+        tox -r -e cov
+    - name: Upload coverage
+      uses: actions/upload-artifact@v4.3.3
+      with:
+        name: coverage-${{ matrix.python-version }}
+        path: coverage.xml
+        overwrite: true
+  upload-coverage:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.11']
+    needs:
+      - coverage
+    timeout-minutes: 10
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.6
+      - name: Download all coverage artifacts
+        uses: actions/download-artifact@v4.1.7
+        with:
+          name: coverage-${{ matrix.python-version }}
+          path: coverage.xml
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4.4.1
+        with:
+          fail_ci_if_error: true
+          token: ${{ secrets.CODECOV_TOKEN }}
+          name: python-adc-eval

.github/workflows/lint.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.9]
+        python-version: [3.11]
 
     steps:
     - uses: actions/checkout@v2

.github/workflows/tests.yml

@@ -0,0 +1,33 @@
+name: tests
+
+on:
+  push:
+    branches: [ main, dev ]
+  pull_request:
+    branches: [ main, dev ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.platform }}
+    strategy:
+      max-parallel: 4
+      matrix:
+        platform:
+          - ubuntu-latest
+        python-version: ['3.9', '3.10', '3.11', '3.12']
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install -r requirements_test.txt
+        pip install tox
+    - name: Test
+      run: |
+        tox -r

.gitignore

@@ -4,3 +4,4 @@ __pycache__
 python_adc_eval.egg-info
 dist
 .ruff_cache
+.coverage

README.rst

@@ -1,5 +1,5 @@
-python-adc-eval |Lint| |PyPi Version| |Codestyle|
-===================================================
+python-adc-eval |Lint| |PyPi Version| |Codecov| |Codestyle|
+=============================================================
 
 A python-based ADC evaluation tool, suitable for standalone or library-based usage
 
@@ -48,7 +48,9 @@ Given an array of values representing the output of an ADC, the spectrum can be
 
 .. |Lint| image:: https://github.com/fronzbot/python-adc-eval/workflows/Lint/badge.svg
    :target: https://github.com/fronzbot/python-adc-eval/actions?query=workflow%3ALint
-.. |PyPi Version| image:: https://img.shields.io/pypi/v/spithon.svg
+.. |PyPi Version| image:: https://img.shields.io/pypi/v/python-adc-eval.svg
    :target: https://pypi.org/project/python-adc-eval
 .. |Codestyle| image:: https://img.shields.io/badge/code%20style-black-000000.svg
    :target: https://github.com/psf/black
+.. |Codecov| image:: https://codecov.io/gh/fronzbot/python-adc-eval/graph/badge.svg?token=156GMQ4NNV 
+ :target: https://codecov.io/gh/fronzbot/python-adc-eval

adc_eval/spectrum.py

@@ -7,7 +7,7 @@
 def db_to_pow(value, places=3):
     """Convert dBW to W."""
     if isinstance(value, np.ndarray):
-        return 10 * np.log10(value)
+        return 10 ** (0.1 * value)
     return round(10 ** (0.1 * value), places)
 
 
@@ -90,18 +90,25 @@ def find_harmonics(spectrum, freq, nfft, bin_sig, psig, harms=5, leak=20):
             bin_harm = int(harm - (zone - 1) * nfft / 2)
 
         # Make sure we pick the max bin where power is maximized; due to spectral leakage
-        bin_harm_max = bin_harm
+        # if bin_harm == nfft/2, set to bin of 0
+        if bin_harm == nfft / 2:
+            bin_harm = 0
+        pwr_max = spectrum[bin_harm]
         for i in range(bin_harm - leak, bin_harm + leak + 1):
-            if spectrum[i] > spectrum[bin_harm_max]:
-                bin_harm_max = i
-
-        bin_harm = bin_harm_max
+            try:
+                pwr = spectrum[i]
+                if pwr > pwr_max:
+                    bin_harm = i
+                    pwr_max = pwr
+            except IndexError:
+                # bin + leakage out of bounds, so stop looking
+                break
 
         harm_stats["harm"][harm_index]["bin"] = bin_harm
-        harm_stats["harm"][harm_index]["power"] = spectrum[bin_harm]
+        harm_stats["harm"][harm_index]["power"] = pwr
         harm_stats["harm"][harm_index]["freq"] = round(freq[bin_harm] / 1e6, 1)
-        harm_stats["harm"][harm_index]["dBc"] = dBW(spectrum[bin_harm] / psig)
-        harm_stats["harm"][harm_index]["dB"] = dBW(spectrum[bin_harm])
+        harm_stats["harm"][harm_index]["dBc"] = dBW(pwr / psig)
+        harm_stats["harm"][harm_index]["dB"] = dBW(pwr)
 
         harm_index = harm_index + 1
 
@@ -118,7 +125,9 @@ def calc_psd(data, fs, nfft=2**12, single_sided=False):
     psd = np.mean(XF, axis=1) / (fs / nfft)  # average the ffts and divide by bin width
     freq = fs * np.linspace(0, 1, nfft)
     if single_sided:
+        # First we double all the bins, then we halve the DC bin
         psd = 2 * psd[0 : int(nfft / 2)]
+        psd[0] /= 2
         freq = freq[0 : int(nfft / 2)]
     return (freq, psd)
 

pyproject.toml

@@ -21,7 +21,7 @@ classifiers = [
 ]
 requires-python = ">=3.8.0"
 dependencies = [
-    "matplotlib==3.8.4",
+    "matplotlib==3.9.0",
 ]
 
 [project.urls]

requirements.txt

@@ -1 +1 @@
-matplotlib==3.8.4
+matplotlib==3.9.0

requirements_test.txt

@@ -1,7 +1,11 @@
-black==24.4.1
-coverage==7.5.0
-pylint==3.1.0
-ruff==0.4.1
-tox==4.14.2
+black==24.4.2
+coverage==7.5.3
+pylint==3.2.3
+pytest==8.2.2
+pytest-cov==5.0.0
+pytest-sugar==1.0.0
+pytest-timeout==2.3.1
+ruff==0.4.8
+tox==4.15.1
 restructuredtext-lint==1.4.0
-pygments==2.17.2
+pygments==2.18.0

tests/__init__.py

@@ -0,0 +1 @@
+"""Init file for tests directory."""

tests/test_calc_psd.py

@@ -0,0 +1,139 @@
+"""Test the calc_psd method."""
+
+import unittest
+import numpy as np
+from unittest import mock
+from adc_eval import spectrum
+
+
+class TestCalcPSD(unittest.TestCase):
+    """Test the calc_psd method."""
+
+    def setUp(self):
+        """Initialize tests."""
+        self.nfft = 2**8
+        self.nlen = 2**18
+        accuracy = 0.01
+        self.bounds = [1 - accuracy, 1 + accuracy]
+        np.random.seed(1)
+
+    def test_calc_psd_randomized_dual(self):
+        """Test calc_psd with random data."""
+        for i in range(0, 10):
+            data = np.random.randn(self.nlen)
+            (freq, psd) = spectrum.calc_psd(data, 1, nfft=self.nfft, single_sided=False)
+            mean_val = np.mean(psd)
+            self.assertTrue(self.bounds[0] <= mean_val <= self.bounds[1], msg=mean_val)
+
+    def test_calc_psd_randomized_single(self):
+        """Test calc_psd with random data and single-sided."""
+        for i in range(0, 10):
+            data = np.random.randn(self.nlen)
+            (freq, psd) = spectrum.calc_psd(data, 1, nfft=self.nfft, single_sided=True)
+            mean_val = np.mean(psd)
+            self.assertTrue(
+                2 * self.bounds[0] <= mean_val <= 2 * self.bounds[1], msg=mean_val
+            )
+
+    def test_calc_psd_zeros_dual(self):
+        """Test calc_psd with zeros."""
+        data = np.zeros(self.nlen)
+        (freq, psd) = spectrum.calc_psd(data, 1, nfft=self.nfft, single_sided=False)
+        mean_val = np.mean(psd)
+        self.assertTrue(
+            self.bounds[0] - 1 <= mean_val <= self.bounds[1] - 1, msg=mean_val
+        )
+
+    def test_calc_psd_zeros_single(self):
+        """Test calc_psd with zeros and single-sided.."""
+        data = np.zeros(self.nlen)
+        (freq, psd) = spectrum.calc_psd(data, 1, nfft=self.nfft, single_sided=True)
+        mean_val = np.mean(psd)
+        self.assertTrue(
+            self.bounds[0] - 1 <= mean_val <= self.bounds[1] - 1, msg=mean_val
+        )
+
+    def test_calc_psd_ones_dual(self):
+        """Test calc_psd with ones."""
+        data = np.ones(self.nlen)
+        (freq, psd) = spectrum.calc_psd(data, 1, nfft=self.nfft, single_sided=False)
+        mean_val = np.mean(psd)
+        self.assertTrue(self.bounds[0] <= mean_val <= self.bounds[1], msg=mean_val)
+
+    def test_calc_psd_ones_single(self):
+        """Test calc_psd with ones and single-sided."""
+        data = np.ones(self.nlen)
+        (freq, psd) = spectrum.calc_psd(data, 1, nfft=self.nfft, single_sided=True)
+        mean_val = np.mean(psd)
+        self.assertTrue(
+            2 * self.bounds[0] <= mean_val <= 2 * self.bounds[1], msg=mean_val
+        )
+
+    def test_calc_psd_two_sine_dual(self):
+        """Test calc_psd with two sine waves."""
+        fs = 1
+        fbin = fs / self.nfft
+        f1 = 29 * fbin
+        f2 = 97 * fbin
+        a1 = 0.37
+        a2 = 0.11
+        t = 1 / fs * np.linspace(0, self.nlen - 1, self.nlen)
+        data = a1 * np.sin(2 * np.pi * f1 * t) + a2 * np.sin(2 * np.pi * f2 * t)
+        (freq, psd) = spectrum.calc_psd(data, fs, nfft=self.nfft, single_sided=False)
+        exp_peaks = [
+            round(a1**2 / 4 * self.nfft, 3),
+            round(a2**2 / 4 * self.nfft, 3),
+        ]
+        exp_f1 = [round(f1, 2), round(fs - f1, 2)]
+        exp_f2 = [round(f2, 2), round(fs - f2, 2)]
+
+        peak1 = max(psd)
+        ipeaks = np.where(psd >= peak1 * self.bounds[0])[0]
+        fpeaks = [round(freq[ipeaks[0]], 2), round(freq[ipeaks[1]], 2)]
+
+        self.assertEqual(round(peak1, 3), exp_peaks[0])
+        self.assertListEqual(fpeaks, exp_f1)
+
+        psd[ipeaks[0]] = 0
+        psd[ipeaks[1]] = 0
+
+        peak2 = max(psd)
+        ipeaks = np.where(psd >= peak2 * self.bounds[0])[0]
+        fpeaks = [round(freq[ipeaks[0]], 2), round(freq[ipeaks[1]], 2)]
+
+        self.assertEqual(round(peak2, 3), exp_peaks[1])
+        self.assertListEqual(fpeaks, exp_f2)
+
+    def test_calc_psd_two_sine_single(self):
+        """Test calc_psd with two sine waves, single-eided."""
+        fs = 1
+        fbin = fs / self.nfft
+        f1 = 29 * fbin
+        f2 = 97 * fbin
+        a1 = 0.37
+        a2 = 0.11
+        t = 1 / fs * np.linspace(0, self.nlen - 1, self.nlen)
+        data = a1 * np.sin(2 * np.pi * f1 * t) + a2 * np.sin(2 * np.pi * f2 * t)
+        (freq, psd) = spectrum.calc_psd(data, fs, nfft=self.nfft, single_sided=True)
+        exp_peaks = [
+            round(a1**2 / 2 * self.nfft, 3),
+            round(a2**2 / 2 * self.nfft, 3),
+        ]
+        exp_f1 = round(f1, 2)
+        exp_f2 = round(f2, 2)
+
+        peak1 = max(psd)
+        ipeak = np.where(psd == peak1)[0][0]
+        fpeak = round(freq[ipeak], 2)
+
+        self.assertEqual(round(peak1, 3), exp_peaks[0])
+        self.assertEqual(fpeak, exp_f1)
+
+        psd[ipeak] = 0
+
+        peak2 = max(psd)
+        ipeak = np.where(psd == peak2)[0][0]
+        fpeak = round(freq[ipeak], 2)
+
+        self.assertEqual(round(peak2, 3), exp_peaks[1])
+        self.assertEqual(fpeak, exp_f2)