Merge pull request #1 from michael-petersen/main

Add basic test package, which nicely also resulted in some cleanup!

Author: michael-petersen

.github/workflows/test.yaml

@@ -0,0 +1,33 @@
+name: Tests
+  
+on:
+  - push
+  - pull_request
+  
+jobs:  
+  test:  
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ['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 test_requirements.txt
+          git clone https://github.com/ObservationalExpansions/flex.git
+          pip install -e ./flex
+      - name: Test with pytest  
+        run: |  
+          coverage run -m pytest  -v -s  
+      - name: Upload coverage to Coveralls
+        run: coveralls --service=github
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

README.md

@@ -2,14 +2,15 @@
 
 **Simple exponential disc generation for testing galaxy morphology routines.**
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/michael-petersen/discmodel/blob/main/LICENSE)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/ObservationalExpansions/discmodel/blob/main/LICENSE)
+[![Coverage Status](https://coveralls.io/repos/github/ObservationalExpansions/discmodel/badge.svg?branch=main)](https://coveralls.io/github/ObservationalExpansions/discmodel?branch=main)
 
 
 ## Installation
 
 Installation of `discmodel` currently proceeds from local builds after cloning this repository:
 ```
-git clone https://github.com/michael-petersen/discmodel.git
+git clone https://github.com/ObservationalExpansions/discmodel.git
 ```
 
 ```

src/discmodel/__init__.py

@@ -5,8 +5,14 @@
 
 See README.md for details
 """
+
+from .optional_imports import _check_lintsampler, _check_flex
+HAS_LINTSAMPLER = _check_lintsampler()
+HAS_FLEX = _check_flex()
+
 from .discmodel import DiscGalaxy
 from importlib.metadata import version
 
 __version__ = version("discmodel")
-__all__ = ["DiscGalaxy"]
+__all__ = ["DiscGalaxy"]
+

src/discmodel/discmodel.py

@@ -7,21 +7,16 @@
 # for interpolation
 from scipy import interpolate
 
-# check if lintsampler is available
-try:
+# check if depedendencies are available
+from .optional_imports import _check_lintsampler, _check_flex
+HAS_LINTSAMPLER = _check_lintsampler()
+HAS_FLEX = _check_flex()
+
+if HAS_LINTSAMPLER:
     import lintsampler
-    HAS_LINTSAMPLER = True
-except ImportError:
-    HAS_LINTSAMPLER = False
 
-# check if flex is available
-try:
+if HAS_FLEX:
     import flex
-    HAS_FLEX = True
-except ImportError:
-    HAS_FLEX = False
-
-
 
 
 class DiscGalaxy(object):
@@ -80,7 +75,7 @@ def menclosed(r,a=self.a):
         return x,y,z,u,v,w
 
     @staticmethod
-    def make_rotation_matrix(xrotation,yrotation,zrotation,euler):
+    def make_rotation_matrix(xrotation,yrotation,zrotation,euler=False):
 
         radfac = np.pi/180.
 
@@ -115,7 +110,7 @@ def make_rotation_matrix(xrotation,yrotation,zrotation,euler):
 
     def rotate_disc(self,xrotation=0.,yrotation=0.,zrotation=0.,euler=False):
         '''
-        rotate_point_vector
+        rotate_disc
             take a collection of 3d points and return the positions rotated by a specified set of angles
 
         inputs
@@ -172,19 +167,6 @@ def rotate_disc(self,xrotation=0.,yrotation=0.,zrotation=0.,euler=False):
         self.v = vout
         self.w = wout
 
-    @staticmethod
-    def _angle_from_faceon(xrotation,yrotation,zrotation):
-        """compute the total inclination, relative to face on.
-        
-        we're doing it this way because inclination is degenerate with the two dimensions into the page, 
-        so we just want a rough idea of how to correct.
-        """
-        x = np.array([0,0,1.0])
-        Rmatrix = make_rotation_matrix(xrotation,yrotation,zrotation)
-        y = rotate_point_vector([0,0,1],Rmatrix)
-        print('Angle from faceon: ',(180./np.pi)*np.arccos(np.dot(x,y)/(np.linalg.norm(x)*np.linalg.norm(y))))
-
-
     def generate_image(self,rmax,nbins,noiselevel=-1.0):
 
         x_range = (-rmax, rmax)  # range for the x-axis
@@ -245,7 +227,7 @@ def make_expansion(self,mmax,nmax,rscl,xmax=10000.,noisy=False):
 
         return laguerre
 
-    def make_particle_expansion(self,mmax,nmax,rscl,xmax=10000.,noisy=False):
+    def make_particle_expansion(self,mmax,nmax,rscl):
 
         if not HAS_FLEX:
             raise ImportError("flex is not available. Please install flex to use this method.")

src/discmodel/optional_imports.py

@@ -0,0 +1,17 @@
+
+def _check_lintsampler():
+    try:
+        import importlib
+        importlib.import_module("lintsampler")
+        return True
+    except ImportError:
+        return False
+    
+def _check_flex():
+    try:
+        import importlib
+        importlib.import_module("lintsampler")
+        return True
+    except ImportError:
+        return False
+    

test_requirements.txt

@@ -0,0 +1,6 @@
+numpy==1.26.4
+pytest==7.4.0
+coverage==6.5.0
+coveralls==3.3.1
+lintsampler
+-e .

tests/test_discmodel.py

@@ -0,0 +1,163 @@
+import numpy as np
+
+import discmodel
+
+def test_discmodel_initialization():
+    """Test initialization of DiscGalaxy class."""
+    N = 1000
+    a = 3.0
+    M = 1.0
+    vcirc = 200.0
+    rmax = 30.0
+
+    disc = discmodel.DiscGalaxy(N=N, a=a, M=M, vcirc=vcirc, rmax=rmax)
+
+    assert disc.N == N
+    assert disc.a == a
+    assert disc.M == M
+    assert disc.vcirc == vcirc
+    assert disc.rmax == rmax * a
+
+    assert len(disc.x) == N
+    assert len(disc.y) == N
+    assert len(disc.z) == N
+    assert len(disc.u) == N
+    assert len(disc.v) == N
+    assert len(disc.w) == N
+
+    # Check that mass is correctly assigned
+    expected_mass = M / N
+    assert np.all(disc.mass == expected_mass)
+
+def test_discmodel_rotation():
+    """Test the rotation angles in DiscModel."""
+    N = 1000
+    a = 3.0
+    M = 1.0
+    vcirc = 200.0
+    rmax = 30.0
+
+    disc = discmodel.DiscGalaxy(N=N, a=a, M=M, vcirc=vcirc, rmax=rmax)
+
+    R1 = disc.make_rotation_matrix(45.0,0.,30.,False)
+    # check R1 is 3x3
+    assert R1.shape == (3,3)
+
+    R2 = disc.make_rotation_matrix(45.0,0.,30.,True)
+    # check R2 is 3x3
+    assert R2.shape == (3,3)
+
+    # check R1 and R2 are different
+    assert not np.allclose(R1,R2)
+
+    # apply the rotation
+    disc.rotate_disc(45.0,0.,30.,False)
+    # check lengths are unchanged
+    assert len(disc.x) == N
+    assert len(disc.y) == N 
+    assert len(disc.z) == N
+
+    disc.rotate_disc(45.0,0.,30.,True)
+    # check lengths are unchanged
+    assert len(disc.x) == N
+    assert len(disc.y) == N 
+    assert len(disc.z) == N
+
+    # try special case of N=1
+    N = 1
+
+    disc = discmodel.DiscGalaxy(N=N, a=a, M=M, vcirc=vcirc, rmax=rmax)
+
+    # apply the rotation
+    disc.rotate_disc(45.0,0.,30.,False)
+
+
+
+def test_discmodel_phasespace_input():
+    """Test initialization of DiscGalaxy class with phasespace input."""
+    N = 1000
+    a = 3.0
+    M = 1.0
+    vcirc = 200.0
+    rmax = 30.0
+
+    disc = discmodel.DiscGalaxy(N=N, a=a, M=M, vcirc=vcirc, rmax=rmax)
+
+    newdisc = discmodel.DiscGalaxy(phasespace=(disc.x,disc.y,disc.z,disc.u,disc.v,disc.w))
+
+
+def test_discmodel_version():
+    """Test that the version string is correctly set."""
+    import discmodel
+    assert isinstance(discmodel.__version__, str)
+
+def test_discmodel_image():
+    N = 1000
+    a = 3.0
+    M = 1.0
+    vcirc = 200.0
+    rmax = 30.0
+    noiselevel = -100.0
+    nbins = 50
+
+    disc = discmodel.DiscGalaxy(N=N, a=a, M=M, vcirc=vcirc, rmax=rmax)
+    disc.generate_image(rmax,nbins,noiselevel=noiselevel)
+
+    # add some noise
+    noiselevel = 0.1
+    disc.generate_image(rmax,nbins,noiselevel=noiselevel)
+
+    # check that r and p are set
+    assert hasattr(disc,'r')
+    assert hasattr(disc,'p')
+
+
+def test_discmodel_expansion():
+    N = 1000
+    a = 3.0
+    M = 1.0
+    vcirc = 200.0
+    rmax = 30.0
+    noiselevel = -100.0
+    nbins = 50
+
+    disc = discmodel.DiscGalaxy(N=N, a=a, M=M, vcirc=vcirc, rmax=rmax)
+    disc.generate_image(rmax,nbins,noiselevel=noiselevel)
+
+    # add some noise
+    noiselevel = 0.1
+    disc.generate_image(rmax,nbins,noiselevel=noiselevel)
+
+
+    # compute the expansion
+    E1 = disc.make_expansion(mmax=4,nmax=4,rscl=1.0,xmax=rmax,noisy=False)
+
+    # compute the expansion from the particles
+    E2 = disc.make_particle_expansion(mmax=4,nmax=4,rscl=1.0)
+
+    # compute A1
+    a1 = disc.compute_a1(E1)
+
+    # check it is a float
+    assert isinstance(a1,float)
+
+
+def test_discmodel_resampling():
+    N = 1000
+    a = 3.0
+    M = 1.0
+    vcirc = 200.0
+    rmax = 30.0
+    noiselevel = -100.0
+    nbins = 50
+
+    disc = discmodel.DiscGalaxy(N=N, a=a, M=M, vcirc=vcirc, rmax=rmax)
+    disc.generate_image(rmax,nbins,noiselevel=noiselevel)
+
+    # compute the expansion
+    E1 = disc.make_expansion(mmax=4,nmax=4,rscl=1.0,xmax=rmax,noisy=False)
+
+    newdisc = disc.resample_expansion(E1)
+    
+    # check newdisc is Nx2 (sampled from 2d image only)
+    assert newdisc.shape == (N, 2)

tests/test_optional_imports.py

@@ -0,0 +1,23 @@
+# tests/test_optional_imports.py
+import importlib
+import pytest
+import discmodel.discmodel as dm
+
+def test_check_lintsampler_missing(monkeypatch):
+    # make importlib.import_module raise for lintsampler
+    def raise_for(name):
+        if name == "lintsampler":
+            raise ImportError
+        return importlib.import_module(name)
+    monkeypatch.setattr(importlib, "import_module", raise_for)
+    assert dm._check_lintsampler() is False
+
+def test_check_lintsampler_present(monkeypatch):
+    # make importlib.import_module return a dummy module for lintsampler
+    def stub(name):
+        if name == "lintsampler":
+            import types
+            return types.ModuleType("lintsampler")
+        return importlib.import_module(name)
+    monkeypatch.setattr(importlib, "import_module", stub)
+    assert dm._check_lintsampler() is True