TST fix tests for JAX-Galsim

tests/galsim_test_helpers.py

@@ -30,6 +30,29 @@
 from numpy.testing import assert_raises
 from numpy.testing import assert_warns
 
+__all__ = [
+    "default_params",
+    "gsobject_compare",
+    "printval",
+    "convertToShear",
+    "check_basic_x",
+    "check_basic_k",
+    "assert_floatlike",
+    "assert_intlike",
+    "check_basic",
+    "do_shoot",
+    "do_kvalue",
+    "radial_integrate",
+    "drawNoise",
+    "check_pickle",
+    "check_all_diff",
+    "timer",
+    "CaptureLog",
+    "assert_raises",
+    "assert_warns",
+    "profile",
+]
+
 # This file has some helper functions that are used by tests from multiple files to help
 # avoid code duplication.
 
@@ -138,20 +161,32 @@ def check_basic_x(prof, name, approx_maxsb=False, scale=None):
         np.testing.assert_allclose(
                 image(i,j), prof._xValue(galsim.PositionD(x,y)), rtol=1.e-5,
                 err_msg="%s profile sb image does not match _xValue at %d,%d"%(name,i,j))
-    assert prof.withFlux.__doc__ == galsim.GSObject.withFlux.__doc__
-    assert prof.__class__.withFlux.__doc__ == galsim.GSObject.withFlux.__doc__
+    if hasattr(galsim, "_galsim"):
+        assert prof.withFlux.__doc__ == galsim.GSObject.withFlux.__doc__
+        assert prof.__class__.withFlux.__doc__ == galsim.GSObject.withFlux.__doc__
+    else:
+        for line in galsim.GSObject.withFlux.__doc__.splitlines():
+            if line.strip() and "LAX" not in line:
+                assert line.strip() in prof.withFlux.__doc__, (
+                    prof.withFlux.__doc__, galsim.GSObject.withFlux.__doc__,
+                )
+        for line in galsim.GSObject.withFlux.__doc__.splitlines():
+            if line.strip() and "LAX" not in line:
+                assert line.strip() in prof.__class__.withFlux.__doc__, (
+                    prof.__class__.withFlux.__doc__, galsim.GSObject.withFlux.__doc__,
+                )
 
     # Check negative flux:
     neg_image = prof.withFlux(-prof.flux).drawImage(method='sb', scale=scale, use_true_center=False)
-    np.testing.assert_almost_equal(neg_image.array/prof.flux, -image.array/prof.flux, 7,
-                                   '%s negative flux drawReal is not negative of +flux image'%name)
+    np.testing.assert_array_almost_equal(neg_image.array/prof.flux, -image.array/prof.flux, 7,
+                                         '%s negative flux drawReal is not negative of +flux image'%name)
 
     # Direct call to drawReal should also work and be equivalent to the above with scale = 1.
     prof.drawImage(image, method='sb', scale=1., use_true_center=False)
     image2 = image.copy()
     prof.drawReal(image2)
-    np.testing.assert_equal(image2.array, image.array,
-                            err_msg="%s drawReal not equivalent to drawImage"%name)
+    np.testing.assert_array_equal(image2.array, image.array,
+                                  err_msg="%s drawReal not equivalent to drawImage"%name)
 
     # If supposed to be axisymmetric, make sure it is.
     if prof.is_axisymmetric:
@@ -199,7 +234,7 @@ def check_basic_k(prof, name):
 
     # Check negative flux:
     neg_image = prof.withFlux(-prof.flux).drawKImage(kimage.copy())
-    np.testing.assert_almost_equal(neg_image.array/prof.flux, -kimage.array/prof.flux, 7,
+    np.testing.assert_array_almost_equal(neg_image.array/prof.flux, -kimage.array/prof.flux, 7,
                                    '%s negative flux drawK is not negative of +flux image'%name)
 
     # If supposed to be axisymmetric, make sure it is in the kValues.
@@ -211,6 +246,30 @@ def check_basic_k(prof, name):
             np.testing.assert_allclose(test_values, ref_value, rtol=1.e-5,
                                        err_msg="%s profile not axisymmetric in kValues"%name)
 
+def assert_floatlike(val):
+    assert (
+        isinstance(val, float)
+        or (
+            (not hasattr(galsim, "_galsim"))
+            and hasattr(val, "shape")
+            and val.shape == ()
+            and hasattr(val, "dtype")
+            and val.dtype.name in ["float", "float32", "float64"]
+        )
+    ), "Value is not float-like: type(%r) = %r" % (val, type(val))
+
+def assert_intlike(val):
+    assert (
+        isinstance(val, int)
+        or (
+            (not hasattr(galsim, "_galsim"))
+            and hasattr(val, "shape")
+            and val.shape == ()
+            and hasattr(val, "dtype")
+            and val.dtype.name in ["int", "int32", "int64"]
+        )
+    ), "Value is not int-like: type(%r) = %r" % (val, type(val))
+
 def check_basic(prof, name, approx_maxsb=False, scale=None, do_x=True, do_k=True):
     """Do some basic sanity checks that should work for all profiles.
     """
@@ -225,12 +284,12 @@ def check_basic(prof, name, approx_maxsb=False, scale=None, do_x=True, do_k=True
             prof.positive_flux - prof.negative_flux, prof.flux,
             err_msg="%s profile flux not equal to posflux + negflux"%name)
     assert isinstance(prof.centroid, galsim.PositionD)
-    assert isinstance(prof.flux, float)
-    assert isinstance(prof.positive_flux, float)
-    assert isinstance(prof.negative_flux, float)
-    assert isinstance(prof.max_sb, float)
-    assert isinstance(prof.stepk, float)
-    assert isinstance(prof.maxk, float)
+    assert_floatlike(prof.flux)
+    assert_floatlike(prof.positive_flux)
+    assert_floatlike(prof.negative_flux)
+    assert_floatlike(prof.max_sb)
+    assert_floatlike(prof.stepk)
+    assert_floatlike(prof.maxk)
     assert isinstance(prof.has_hard_edges, bool)
     assert isinstance(prof.is_axisymmetric, bool)
     assert isinstance(prof.is_analytic_x, bool)

tests/test_convolve.py

@@ -23,8 +23,8 @@
 import galsim
 from galsim_test_helpers import *
 
-imgdir = os.path.join(".", "SBProfile_comparison_images") # Directory containing the reference
-                                                          # images.
+# Directory containing the reference images.
+imgdir = os.path.join(os.path.dirname(__file__), "SBProfile_comparison_images")
 
 @timer
 def test_convolve():
@@ -497,9 +497,9 @@ def test_deconvolve():
 
     cen = galsim.PositionD(0,0)
     np.testing.assert_equal(inv_psf.centroid, cen)
-    np.testing.assert_almost_equal(inv_psf.flux, 1./psf.flux)
+    np.testing.assert_array_almost_equal(inv_psf.flux, 1./psf.flux)
     # This doesn't really have any meaning, but this is what we've assigned to a deconvolve max_sb.
-    np.testing.assert_almost_equal(inv_psf.max_sb, -psf.max_sb / psf.flux**2)
+    np.testing.assert_array_almost_equal(inv_psf.max_sb, -psf.max_sb / psf.flux**2)
 
     check_basic(inv_psf, "Deconvolve(Moffat)", do_x=False)
 

tests/test_fitsheader.py

@@ -51,7 +51,7 @@ def check_tpv(header):
         assert 54384.18627436 in header.itervalues()
 
     file_name = 'tpv.fits'
-    dir = 'fits_files'
+    dir = os.path.join(os.path.dirname(__file__), 'fits_files')
     # First option: give a file_name
     header = galsim.FitsHeader(file_name=os.path.join(dir,file_name))
     check_tpv(header)
@@ -191,7 +191,7 @@ def check_tpv(header):
 def test_scamp():
     """Test that we can read in a SCamp .head file correctly
     """
-    dir = 'fits_files'
+    dir = os.path.join(os.path.dirname(__file__), 'fits_files')
     file_name = 'scamp.head'
 
     header = galsim.FitsHeader(file_name=file_name, dir=dir, text_file=True)

tests/test_interpolatedimage.py

@@ -453,8 +453,8 @@ def test_fluxnorm():
     # First, make some Image with some total flux value (sum of pixel values) and scale
     im = galsim.ImageF(im_lin_scale, im_lin_scale, scale=im_scale, init_value=im_fill_value)
     total_flux = im_fill_value*(im_lin_scale**2)
-    np.testing.assert_equal(total_flux, im.array.sum(),
-                            err_msg='Created array with wrong total flux')
+    np.testing.assert_array_equal(total_flux, im.array.sum(),
+                                  err_msg='Created array with wrong total flux')
 
     # Check that if we make an InterpolatedImage with flux normalization, it keeps that flux
     interp = galsim.InterpolatedImage(im) # note, flux normalization is the default
@@ -744,8 +744,11 @@ def test_operations():
     test_decimal = 3
 
     # Make some nontrivial image
-    im = galsim.fits.read('./real_comparison_images/test_images.fits') # read in first real galaxy
-                                                                       # in test catalog
+    im_path = os.path.join(
+        os.path.dirname(__file__), "real_comparison_images/test_images.fits"
+    )
+    im = galsim.fits.read(im_path) # read in first real galaxy
+                                   # in test catalog
     int_im = galsim.InterpolatedImage(im)
     orig_mom = im.FindAdaptiveMom()
 
@@ -954,7 +957,7 @@ def test_corr_padding():
     # Set up some defaults for tests.
     decimal_precise=4
     decimal_coarse=2
-    imgfile = 'fits_files/blankimg.fits'
+    imgfile = os.path.join(os.path.dirname(__file__), 'fits_files/blankimg.fits')
     orig_nx = 187
     orig_ny = 164
     big_nx = 319
@@ -1697,7 +1700,7 @@ def test_quintic_glagn():
     """This is code that was giving a seg fault.  cf. Issue 1079.
     """
 
-    fname = os.path.join('fits_files','GLAGN_host_427_0_disk.fits')
+    fname = os.path.join(os.path.dirname(__file__), 'fits_files','GLAGN_host_427_0_disk.fits')
     for interpolant in 'linear cubic quintic'.split():
         print(interpolant)
         fits_image = galsim.InterpolatedImage(fname, scale=0.04, x_interpolant=interpolant)
@@ -1844,33 +1847,37 @@ def test_depixelize():
 def test_drawreal_seg_fault():
     """Test to reproduce bug report in Issue #1164 that was causing seg faults
     """
-
-    import pickle
-
-    prof_file = 'input/test_interpolatedimage_seg_fault_prof.pkl'
-    with open(prof_file, 'rb') as f:
-        prof = pickle.load(f)
-    print(repr(prof))
-
-    image = galsim.Image(
-        galsim.BoundsI(
-            xmin=-12,
-            xmax=12,
-            ymin=-12,
-            ymax=12
-        ),
-        dtype=float,
-        scale=1
-    )
-
-    image.fill(3)
-    prof.drawReal(image)
-
-    # The problem was that the object is shifted fully off the target image and that was leading
-    # to an attempt to create a stack of length -1, which caused the seg fault.
-    # So mostly this test just confirms that this runs without seg faulting.
-    # But we can check that the image is now correctly all zeros.
-    np.testing.assert_array_equal(image.array, 0)
+    # this test only runs with real galsim
+    if hasattr(galsim, '_galsim'):
+        import pickle
+
+        prof_file = os.path.join(
+            os.path.dirname(__file__),
+            'input/test_interpolatedimage_seg_fault_prof.pkl'
+        )
+        with open(prof_file, 'rb') as f:
+            prof = pickle.load(f)
+        print(repr(prof))
+
+        image = galsim.Image(
+            galsim.BoundsI(
+                xmin=-12,
+                xmax=12,
+                ymin=-12,
+                ymax=12
+            ),
+            dtype=float,
+            scale=1
+        )
+
+        image.fill(3)
+        prof.drawReal(image)
+
+        # The problem was that the object is shifted fully off the target image and that was leading
+        # to an attempt to create a stack of length -1, which caused the seg fault.
+        # So mostly this test just confirms that this runs without seg faulting.
+        # But we can check that the image is now correctly all zeros.
+        np.testing.assert_array_equal(image.array, 0)
 
 
 

tests/test_shear.py

@@ -118,7 +118,7 @@ def test_shear_initialization():
     vec_ideal = np.zeros(len(vec))
     np.testing.assert_array_almost_equal(vec, vec_ideal, decimal = decimal,
                                          err_msg = "Incorrectly initialized empty shear")
-    np.testing.assert_equal(s.q, 1.)
+    np.testing.assert_array_equal(s.q, 1.)
     # now loop over shear values and ways of initializing
     for ind in range(n_shear):
         # initialize with reduced shear components
@@ -178,17 +178,19 @@ def test_shear_initialization():
     assert_raises(TypeError,galsim.Shear,g1=0.3,e2=0.2)
     assert_raises(TypeError,galsim.Shear,eta1=0.3,beta=0.*galsim.degrees)
     assert_raises(TypeError,galsim.Shear,q=0.3)
-    assert_raises(galsim.GalSimRangeError,galsim.Shear,q=1.3,beta=0.*galsim.degrees)
-    assert_raises(galsim.GalSimRangeError,galsim.Shear,g1=0.9,g2=0.6)
-    assert_raises(galsim.GalSimRangeError,galsim.Shear,e=-1.3,beta=0.*galsim.radians)
-    assert_raises(galsim.GalSimRangeError,galsim.Shear,e=1.3,beta=0.*galsim.radians)
-    assert_raises(galsim.GalSimRangeError,galsim.Shear,e1=0.7,e2=0.9)
+    if hasattr(galsim, "_galsim"):
+        assert_raises(galsim.GalSimRangeError,galsim.Shear,q=1.3,beta=0.*galsim.degrees)
+        assert_raises(galsim.GalSimRangeError,galsim.Shear,g1=0.9,g2=0.6)
+        assert_raises(galsim.GalSimRangeError,galsim.Shear,e=-1.3,beta=0.*galsim.radians)
+        assert_raises(galsim.GalSimRangeError,galsim.Shear,e=1.3,beta=0.*galsim.radians)
+        assert_raises(galsim.GalSimRangeError,galsim.Shear,e1=0.7,e2=0.9)
     assert_raises(TypeError,galsim.Shear,g=0.5)
     assert_raises(TypeError,galsim.Shear,e=0.5)
     assert_raises(TypeError,galsim.Shear,eta=0.5)
-    assert_raises(galsim.GalSimRangeError,galsim.Shear,eta=-0.5,beta=0.*galsim.radians)
-    assert_raises(galsim.GalSimRangeError,galsim.Shear,g=1.3,beta=0.*galsim.radians)
-    assert_raises(galsim.GalSimRangeError,galsim.Shear,g=-0.3,beta=0.*galsim.radians)
+    if hasattr(galsim, "_galsim"):
+        assert_raises(galsim.GalSimRangeError,galsim.Shear,eta=-0.5,beta=0.*galsim.radians)
+        assert_raises(galsim.GalSimRangeError,galsim.Shear,g=1.3,beta=0.*galsim.radians)
+        assert_raises(galsim.GalSimRangeError,galsim.Shear,g=-0.3,beta=0.*galsim.radians)
     assert_raises(TypeError,galsim.Shear,e=0.3,beta=0.)
     assert_raises(TypeError,galsim.Shear,eta=0.3,beta=0.)
     assert_raises(TypeError,galsim.Shear,randomkwarg=0.1)

tests/test_shear_position.py

@@ -88,7 +88,7 @@ def test_shear_position_image_integration_pixelwcs():
     )
 
     print("err:", np.max(np.abs(im1.array - im2.array)))
-    assert np.allclose(im1.array, im2.array, rtol=0, atol=5e-8)
+    np.testing.assert_allclose(im1.array, im2.array, rtol=0, atol=5e-8)
 
 
 @timer
@@ -119,9 +119,7 @@ def test_shear_position_image_integration_offsetwcs():
     )
 
     print("err:", np.max(np.abs(im1.array - im2.array)))
-    assert np.allclose(im1.array, im2.array, rtol=0, atol=2e-7), (
-        np.max(np.abs(im1.array - im2.array))
-    )
+    np.testing.assert_allclose(im1.array, im2.array, rtol=0, atol=2e-7)
 
 
 if __name__ == "__main__":

tests/test_sum.py

@@ -23,8 +23,8 @@
 import galsim
 from galsim_test_helpers import *
 
-imgdir = os.path.join(".", "SBProfile_comparison_images") # Directory containing the reference
-                                                          # images.
+# Directory containing the reference images.
+imgdir = os.path.join(os.path.dirname(__file__), "SBProfile_comparison_images")
 
 @timer
 def test_add():
@@ -260,12 +260,12 @@ def test_sum_transform():
         rgal2_im = rgal2.drawImage(nx=64, ny=64, scale=0.2)
 
         # Check that the objects are equivalent, even if they may be written differently.
-        np.testing.assert_almost_equal(gal1_im.array, sgal1_im.array, decimal=8)
-        np.testing.assert_almost_equal(gal1_im.array, rgal1_im.array, decimal=8)
+        np.testing.assert_array_almost_equal(gal1_im.array, sgal1_im.array, decimal=8)
+        np.testing.assert_array_almost_equal(gal1_im.array, rgal1_im.array, decimal=8)
 
         # These two used to fail.
-        np.testing.assert_almost_equal(gal2_im.array, sgal2_im.array, decimal=8)
-        np.testing.assert_almost_equal(gal2_im.array, rgal2_im.array, decimal=8)
+        np.testing.assert_array_almost_equal(gal2_im.array, sgal2_im.array, decimal=8)
+        np.testing.assert_array_almost_equal(gal2_im.array, rgal2_im.array, decimal=8)
 
         check_pickle(gal0)
         check_pickle(gal1)

tests/test_transforms.py

@@ -23,8 +23,8 @@
 import galsim
 from galsim_test_helpers import *
 
-imgdir = os.path.join(".", "SBProfile_comparison_images") # Directory containing the reference
-                                                          # images.
+# Directory containing the reference images.
+imgdir = os.path.join(os.path.dirname(__file__), "SBProfile_comparison_images")
 
 # for flux normalization tests
 test_flux = 1.8
@@ -948,9 +948,9 @@ def test_compound():
     gal5.drawImage(image=im5_f, method='sb', scale=0.2)
     np.testing.assert_almost_equal(im3_f[1,1], gal3.xValue(-0.7,-0.7), decimal=4)
     np.testing.assert_almost_equal(im5_f[1,1], gal3.xValue(-0.7,-0.7), decimal=4)
-    np.testing.assert_almost_equal(im3_f.array, im5_f.array, decimal=4)
-    np.testing.assert_almost_equal(im3_f.array, im3_d.array, decimal=4)
-    np.testing.assert_almost_equal(im5_f.array, im5_d.array, decimal=4)
+    np.testing.assert_array_almost_equal(im3_f.array, im5_f.array, decimal=4)
+    np.testing.assert_array_almost_equal(im3_f.array, im3_d.array, decimal=4)
+    np.testing.assert_array_almost_equal(im5_f.array, im5_d.array, decimal=4)
 
     gal3.drawKImage(image=im3_cd, scale=0.5)
     gal5.drawKImage(image=im5_cd, scale=0.5)