renamed calc_ang_dist() to calc_ang_scat() and removed unit checking

Author: vnmanoharan

pymie/mie.py

@@ -58,11 +58,9 @@
 # User-facing functions for the most often calculated quantities (form factor,
 # efficiencies, asymmetry parameter)
 
-# all arguments should be dimensionless
-@ureg.check('[]', '[]', '[]', None, None)
-def calc_ang_dist(m, x, angles, mie = True, check = False):
+def calc_ang_scat(m, x, angles, mie = True, check = False):
     """
-    Calculates the angular distribution of light intensity for parallel and
+    Calculates the angular scattering of light intensity for parallel and
     perpendicular polarization for a sphere.
 
     Parameters
@@ -71,9 +69,8 @@ def calc_ang_dist(m, x, angles, mie = True, check = False):
         complex particle relative refractive index, n_part/n_med
     x : complex or float, array-like
         size parameter, x = ka = 2*pi*n_med/lambda * a (sphere radius a)
-    angles : ndarray(structcol.Quantity [dimensionless])
-        array of angles. Must be entered as a Quantity to allow specifying
-        units (degrees or radians) explicitly
+    angles : array-like
+        array of angles. Must be specified in radians
     mie : Boolean (optional)
         if true (default) does full Mie calculation; if false, uses RG
         approximation
@@ -88,13 +85,6 @@ def calc_ang_dist(m, x, angles, mie = True, check = False):
     parallel and perpendicular to scattering plane, respectively.  See
     Bohren & Huffman ch. 3 for details.)
     """
-    # convert to radians from whatever units the user specifies
-    if isinstance(angles, Quantity):
-        angles = angles.to('rad').magnitude
-
-    if isinstance(x, Quantity):
-        x = x.to('').magnitude
-
     if mie:
         # Mie scattering preliminaries
         nstop = _nstop(np.array(x).max())
@@ -238,7 +228,7 @@ def calc_integrated_cross_section(m, x, wavelen_media, thetas):
         Dimensional integrated cross-section
     """
     angles = thetas.to('rad')
-    form_factor = calc_ang_dist(m, x, angles)
+    form_factor = calc_ang_scat(m, x, angles)
 
     integrand_par = (form_factor[0]*np.sin(angles)).magnitude
     integrand_perp = (form_factor[1]*np.sin(angles)).magnitude
@@ -1185,7 +1175,7 @@ def diff_scat_intensity_complex_medium(m, x, thetas, kd, phis=None,
     To get dimensional cross-sections, multiply by d^2, where d is the distance
     at which the differential cross-sections are calculated. To compare
     differential cross-sections for non-absorbing media and the far-field to
-    those reported by calc_ang_dist(), which are nondimensionalized by k^2,
+    those reported by calc_ang_scat(), which are nondimensionalized by k^2,
     multiply the results from this function by kd^2.
 
     References

pymie/tests/test_mie.py

@@ -71,7 +71,7 @@ def test_form_factor():
     m = index_ratio(n_particle, n_matrix)
     x = size_parameter(wavelen, n_matrix, radius)
 
-    angles = Quantity(np.linspace(0, 180., 19), 'deg')
+    angles = Quantity(np.linspace(0, 180., 19), 'deg').to("rad").magnitude
     # these values are calculated from MiePlot
     # (http://www.philiplaven.com/mieplot.htm), which uses BHMIE
     iperp_bhmie = np.array([2046.60203864487, 1282.28646423634, 299.631502275208,
@@ -89,7 +89,7 @@ def test_form_factor():
                            7.24176462105438, 76.2910238480798, 54.1983836607738,
                            93.5508557840006])
 
-    iparperp = mie.calc_ang_dist(m, x, angles)
+    iparperp = mie.calc_ang_scat(m, x, angles)
     assert_array_almost_equal(iparperp[0], ipar_bhmie)
     assert_array_almost_equal(iparperp[1], iperp_bhmie)
 
@@ -156,7 +156,7 @@ def test_absorbing_materials():
     m = index_ratio(n_particle, n_matrix)
     x = 10.0
 
-    angles = Quantity(np.linspace(0, 90., 10), 'deg')
+    angles = Quantity(np.linspace(0, 90., 10), 'deg').to("rad").magnitude
     # these values are calculated from MiePlot
     # (http://www.philiplaven.com/mieplot.htm), which uses BHMIE
     iperp_bhmie = np.array([4830.51401095968, 2002.39671236719,
@@ -170,7 +170,7 @@ def test_absorbing_materials():
                            24.9801217735053, 53.2319915708624,
                            8.26505988320951, 47.4736966179677])
 
-    iparperp = mie.calc_ang_dist(m, x, angles)
+    iparperp = mie.calc_ang_scat(m, x, angles)
     assert_array_almost_equal(iparperp[0], ipar_bhmie)
     assert_array_almost_equal(iparperp[1], iperp_bhmie)
 
@@ -186,7 +186,7 @@ def test_multilayer_spheres():
     radius = Quantity('100.0 nm')
     x = size_parameter(wavelen, n_sample, radius)
 
-    f_parperp = mie.calc_ang_dist(m, x, angles)
+    f_parperp = mie.calc_ang_scat(m, x, angles)
     cscat, cext, cabs, cback, asym = mie.calc_cross_sections(m, x, wavelen)
 
     # form factor and cross section for a multilayer particle with a core that
@@ -195,7 +195,7 @@ def test_multilayer_spheres():
     multi_radius = Quantity(np.array([100.0, 100.0]),'nm')
     xarray = size_parameter(wavelen, n_sample, multi_radius)
 
-    f_parperp_multi = mie.calc_ang_dist(marray, xarray, angles)
+    f_parperp_multi = mie.calc_ang_scat(marray, xarray, angles)
     cscat_multi, cext_multi, cabs_multi, cback_multi, asym_multi = mie.calc_cross_sections(marray, xarray, wavelen)
 
     assert_array_almost_equal(f_parperp, f_parperp_multi)
@@ -212,7 +212,7 @@ def test_multilayer_spheres():
     multi_radius2 = Quantity(np.array([100.0, 110.0]),'nm')
     xarray2 = size_parameter(wavelen, n_sample, multi_radius2)
 
-    f_parperp_multi2 = mie.calc_ang_dist(marray2, xarray2, angles)
+    f_parperp_multi2 = mie.calc_ang_scat(marray2, xarray2, angles)
     cscat_multi2, cext_multi2, cabs_multi2, cback_multi2, asym_multi2 = mie.calc_cross_sections(marray2, xarray2, wavelen)
 
     assert_array_almost_equal(f_parperp, f_parperp_multi2)
@@ -228,7 +228,7 @@ def test_multilayer_spheres():
     multi_radius3 = Quantity(np.array([100.0, 100.0, 100.0]),'nm')
     xarray3 = size_parameter(wavelen, n_sample, multi_radius3)
 
-    f_parperp_multi3 = mie.calc_ang_dist(marray3, xarray3, angles)
+    f_parperp_multi3 = mie.calc_ang_scat(marray3, xarray3, angles)
     cscat_multi3, cext_multi3, cabs_multi3, cback_multi3, asym_multi3 = mie.calc_cross_sections(marray3, xarray3, wavelen)
 
     assert_array_almost_equal(f_parperp, f_parperp_multi3)
@@ -245,7 +245,7 @@ def test_multilayer_spheres():
     multi_radius4 = Quantity(np.array([100, 110, 120]),'nm')
     xarray4 = size_parameter(wavelen, n_sample, multi_radius4)
 
-    f_parperp_multi4 = mie.calc_ang_dist(marray4, xarray4, angles)
+    f_parperp_multi4 = mie.calc_ang_scat(marray4, xarray4, angles)
     cscat_multi4, cext_multi4, cabs_multi4, cback_multi4, asym_multi4 = mie.calc_cross_sections(marray4, xarray4, wavelen)
 
     assert_array_almost_equal(f_parperp, f_parperp_multi4)
@@ -266,8 +266,8 @@ def test_multilayer_absorbing_spheres():
     xarray = size_parameter(wavelen, n_sample, multi_radius)
     angles = Quantity(np.linspace(np.pi/2, np.pi, 20), 'rad')
 
-    f_parperp_multi_real = mie.calc_ang_dist(marray_real, xarray, angles)
-    f_parperp_multi_imag = mie.calc_ang_dist(marray_imag, xarray, angles)
+    f_parperp_multi_real = mie.calc_ang_scat(marray_real, xarray, angles)
+    f_parperp_multi_imag = mie.calc_ang_scat(marray_imag, xarray, angles)
 
     cross_sections_multi_real = mie.calc_cross_sections(marray_real, xarray, wavelen)
     cross_sections_multi_imag = mie.calc_cross_sections(marray_imag, xarray, wavelen)
@@ -440,7 +440,7 @@ def test_pis_taus():
 def test_differential_cross_section():
     """
     Tests that the differential cross-sections from diff_scat_complex_medium()
-    and calc_ang_dist() are the same for a non-absorbing medium.
+    and calc_ang_scat() are the same for a non-absorbing medium.
     """
     # set parameters
     wavelen = Quantity("400.0 nm")
@@ -455,7 +455,7 @@ def test_differential_cross_section():
     x = size_parameter(wavelen, n_matrix, radius)
 
     # With far-field Mie solutions
-    I_parperp_cad = mie.calc_ang_dist(m, x, theta)
+    I_parperp_cad = mie.calc_ang_scat(m, x, theta)
 
     # With Mie solutions at surface of particle (but neglecting near-fields)
     kd = (k*distance).to("").magnitude
@@ -465,7 +465,7 @@ def test_differential_cross_section():
                                                        incident_vector,
                                                        cartesian=False)
 
-    # calc_ang_dist returns dimensionless differential cross-sections (times
+    # calc_ang_scat returns dimensionless differential cross-sections (times
     # k^2).  As noted in diff_scat_intensity_complex_medium(), this function
     # returns dimensionless values (scaled by k^2) muliplied by a factor of
     # 1/kd^2 for a non-absorbing medium.  Therefore the
@@ -474,7 +474,7 @@ def test_differential_cross_section():
     # calculation is done.  In short, both functions return dimensionless
     # cross-sections, but the ones returned by
     # diff_scat_intensity_complex_medium() need to be multiplied by a factor of
-    # kd^2 to compare them to those of calc_ang_dist()
+    # kd^2 to compare them to those of calc_ang_scat()
     #
     # since both of these functions rely on the same routine to calculate the
     # amplitude scattering matrix, they should give results to within

pymie/tests/test_mie_vectorized.py

@@ -349,7 +349,7 @@ class TestVectorizedInternalFunctions():
 
     _pis_and_taus() :
         not tested explicitly here, but tested implicitly in
-        `test_vectorized_calc_ang_dist()`.  Vectorization over angles is tested
+        `test_vectorized_calc_ang_scat()`.  Vectorization over angles is tested
         in `test_mie.py::test_pis_taus()`
     _scatcoeffs() :
         tested by `test_vectorized_scatcoeffs()`
@@ -391,10 +391,10 @@ class TestVectorizedInternalFunctions():
         tested by `test_vectorized_angular_functions()`
     _amplitude_scattering_matrix() :
         not tested explicitly here, but tested implicitly in
-        `test_vectorized_calc_ang_dist()`
+        `test_vectorized_calc_ang_scat()`
     _amplitude_scattering_matrix_RG() :
         not tested explicitly here, but tested implicitly in
-        `test_vectorized_calc_ang_dist()`
+        `test_vectorized_calc_ang_scat()`
 
     """
     mxargs = {"start_wavelen": 400,
@@ -723,8 +723,8 @@ class TestVectorizedUserFunctions():
 
     User functions and corresponding tests of vectorization are as follows:
 
-    calc_ang_dist() :
-        tested by test_vectorized_calc_ang_dist()
+    calc_ang_scat() :
+        tested by test_vectorized_calc_ang_scat()
     calc_cross_sections() :
         tested by test_vectorized_cross_sections()
     calc_efficiencies() :
@@ -750,7 +750,8 @@ class TestVectorizedUserFunctions():
               "n_matrix": Quantity(1.00, '')}
 
     num_angle = 19
-    angles = Quantity(np.linspace(0, 180., num_angle), 'deg')
+    angles = Quantity(np.linspace(0, 180., num_angle),
+                      'deg').to("rad").magnitude
 
     @pytest.mark.parametrize("num_wavelen, num_layer",
                              [(10, 1), (1, 5), (10, 5)])
@@ -863,16 +864,16 @@ def test_vectorized_calc_efficiencies(self, num_wavelen, num_layer):
 
     @pytest.mark.parametrize("num_wavelen, num_layer",
                              [(10, 1), (1, 5), (10, 5)])
-    def test_vectorized_calc_ang_dist(self, num_wavelen, num_layer):
-        """Tests that mie.calc_ang_dist() vectorizes properly. Also implicitly
+    def test_vectorized_calc_ang_scat(self, num_wavelen, num_layer):
+        """Tests that mie.calc_ang_scat() vectorizes properly. Also implicitly
         checks that _amplitude_scattering_matrix() and
         _amplitude_scattering_matrix_RG() vectorize properly.  Also checks for
         correctness of RG calculations by comparing against Mie calculations
         for small refractive index difference.
 
         """
         m, x = mx(num_wavelen, num_layer, **self.mxargs)
-        form_factor = mie.calc_ang_dist(m, x, self.angles)
+        form_factor = mie.calc_ang_scat(m, x, self.angles)
         if num_wavelen == 1:
             expected_shape = (2, self.num_angle,)
             assert form_factor.shape == expected_shape
@@ -885,19 +886,19 @@ def test_vectorized_calc_ang_dist(self, num_wavelen, num_layer):
         # we should get same values from loop
         iparperp_loop = np.zeros(expected_shape, dtype=float)
         for i in range(num_wavelen):
-            iparperp = mie.calc_ang_dist(m[i], x[i], self.angles)
+            iparperp = mie.calc_ang_scat(m[i], x[i], self.angles)
             iparperp_loop[:, i] = iparperp
         assert_equal(form_factor, iparperp_loop)
 
         # check vectorization for Rayleigh-Gans approximation
         if num_layer > 1:
             with pytest.raises(ValueError,
                                match="Rayleigh-Gans approximation cannot"):
-                form_factor_RG = mie.calc_ang_dist(m, x, self.angles,
+                form_factor_RG = mie.calc_ang_scat(m, x, self.angles,
                                                    mie=False)
             return
 
-        form_factor_RG = mie.calc_ang_dist(m, x, self.angles,
+        form_factor_RG = mie.calc_ang_scat(m, x, self.angles,
                                                mie=False)
 
         expected_shape = (2, num_wavelen, self.num_angle)
@@ -921,9 +922,10 @@ def test_vectorized_calc_ang_dist(self, num_wavelen, num_layer):
         # 0 degree scattering may give differences between RG and Mie, so we
         # compare at a few degrees and higher; also we do a lot of angles to
         # capture the sharp dips in the form factor
-        angles = Quantity(np.linspace(10, 180., num_angle), 'deg')
-        form_factor_RG = mie.calc_ang_dist(m, x, angles, mie=False)
-        form_factor_mie = mie.calc_ang_dist(m, x, angles)
+        angles = Quantity(np.linspace(10, 180., num_angle),
+                          'deg').to("rad").magnitude
+        form_factor_RG = mie.calc_ang_scat(m, x, angles, mie=False)
+        form_factor_mie = mie.calc_ang_scat(m, x, angles)
 
         # Since we are comparing small numbers at the dips of the form factor,
         # the Mie and RG solutions may have a relative difference of up to a