Abins Broadening: remove non-optional kwargs

docs/source/concepts/AbinsInterpolatedBroadening.rst

@@ -315,35 +315,27 @@ We can build on this by performing convolution of the full spectrum with each of
    ax1.plot(frequencies, intensities, 'k-', label='Unbroadened spectrum')
 
    # Narrow limit
-   freq_points, spectrum = Broadening.broaden_spectrum(frequencies=frequencies,
-                                                       bins=bins,
-                                                       s_dft=intensities,
-                                                       sigma=(peak1_sigma * np.ones_like(frequencies)),
-                                                       scheme='gaussian')
+   freq_points, spectrum = Broadening.broaden_spectrum(
+       frequencies, bins, intensities,
+       (peak1_sigma * np.ones_like(frequencies)),
+       scheme='gaussian')
    ax2.plot(freq_points, spectrum, label='Convolve with min(sigma)')
 
    # Broad limit
-   freq_points, spectrum = Broadening.broaden_spectrum(frequencies=frequencies,
-                                                       bins=bins,
-                                                       s_dft=intensities,
-                                                       sigma=(peak2_sigma * np.ones_like(frequencies)),
-                                                       scheme='gaussian')
+   freq_points, spectrum = Broadening.broaden_spectrum(
+       frequencies, bins, intensities,
+       (peak2_sigma * np.ones_like(frequencies)),
+       scheme='gaussian')
    ax2.plot(freq_points, spectrum, label='Convolve with max(sigma)')
 
    # Reference method: sum individually
-   freq_points, spectrum = Broadening.broaden_spectrum(frequencies=frequencies,
-                                                       bins=bins,
-                                                       s_dft=intensities,
-                                                       sigma=sigma,
-                                                       scheme='gaussian')
+   freq_points, spectrum = Broadening.broaden_spectrum(
+       frequencies, bins, intensities, sigma, scheme='gaussian')
    ax3.plot(freq_points, spectrum, 'k-', label='Sum individual peaks')
 
    # Interpolated
-   freq_points, spectrum = Broadening.broaden_spectrum(frequencies=frequencies,
-                                                       bins=bins,
-                                                       s_dft=intensities,
-                                                       sigma=sigma,
-                                                       scheme='interpolate')
+   freq_points, spectrum = Broadening.broaden_spectrum(
+       frequencies, bins, intensities, sigma, scheme='interpolate')
    ax2.plot(freq_points, spectrum, c='C2', linestyle='--', label='Interpolated', zorder=0.5)
    ax3.plot(freq_points, spectrum, c='C2', linestyle='--', label='Interpolated', zorder=0.5)
 

scripts/AbinsModules/Instruments/Broadening.py

@@ -12,7 +12,7 @@ from scipy.signal import convolve
 prebin_required_schemes = ['interpolate', 'interpolate_coarse']
 
 
-def broaden_spectrum(frequencies=None, bins=None, s_dft=None, sigma=None, scheme='gaussian_truncated'):
+def broaden_spectrum(frequencies, bins, s_dft, sigma, scheme='gaussian_truncated'):
     """Convert frequency/S data to broadened spectrum on a regular grid
 
     Several algorithms are implemented, for purposes of
@@ -28,13 +28,13 @@ def broaden_spectrum(frequencies=None, bins=None, s_dft=None, sigma=None, scheme
     :param s_dft: scattering values corresponding to *frequencies*
     :type s_dft: 1D array-like
     :param sigma:
-        width of broadening function. This may be a scalar used over the whole spectrum, or a series of values
+        width of broadening function. This should be a scalar used over the whole spectrum, or a series of values
         corresponding to *frequencies*.
     :type sigma: float or 1D array-like
     :param scheme:
         Name of broadening method used. Options:
 
-        - none: Return the input data
+        - none: Return the input data as a histogram, ignoring the value of sigma
         - gaussian: Evaluate a Gaussian on the output grid for every input point and sum them. Simple but slow, and
               recommended only for benchmarking and reference calculations.
         - normal: Generate histograms with appropriately-located normal distributions for every input point. In

scripts/AbinsModules/Instruments/ToscaInstrument.py

@@ -105,9 +105,6 @@ class ToscaInstrument(Instrument, FrequencyPowderGenerator):
 
         sigma = self.get_sigma(frequencies)
 
-        points_freq, broadened_spectrum = broaden_spectrum(frequencies=frequencies,
-                                                           s_dft=s_dft,
-                                                           bins=bins,
-                                                           sigma=sigma,
-                                                           scheme=selected_scheme)
+        points_freq, broadened_spectrum = broaden_spectrum(frequencies, bins, s_dft,
+                                                           sigma, scheme=selected_scheme)
         return points_freq, broadened_spectrum

scripts/test/Abins/AbinsBroadeningTest.py

@@ -86,11 +86,8 @@ class AbinsBroadeningTest(unittest.TestCase):
 
         results = {}
         for scheme in schemes:
-            _, results[scheme] = Broadening.broaden_spectrum(frequencies=freq_points,
-                                                             bins=bins,
-                                                             s_dft=s_dft,
-                                                             sigma=sigma,
-                                                             scheme=scheme)
+            _, results[scheme] = Broadening.broaden_spectrum(
+                freq_points, bins, s_dft, sigma, scheme)
 
         for scheme in schemes:
             # Interpolate scheme is approximate so just check a couple of sig.fig.
@@ -114,9 +111,7 @@ class AbinsBroadeningTest(unittest.TestCase):
                    'normal', 'normal_truncated']
 
         for scheme in schemes:
-            Broadening.broaden_spectrum(frequencies=frequencies,
-                                        bins=bins, s_dft=s_dft, sigma=sigma,
-                                        scheme=scheme)
+            Broadening.broaden_spectrum(frequencies, bins, s_dft, sigma, scheme=scheme)
 
     def test_broadening_normalisation(self):
         """Check broadening implementations do not change overall intensity"""
@@ -137,20 +132,14 @@ class AbinsBroadeningTest(unittest.TestCase):
 
         # Full Gaussian should reproduce null total
         for scheme in ('none', 'gaussian'):
-            freq_points, spectrum = Broadening.broaden_spectrum(frequencies=frequencies,
-                                                                bins=bins,
-                                                                s_dft=s_dft,
-                                                                sigma=sigma,
-                                                                scheme=scheme)
+            freq_points, spectrum = Broadening.broaden_spectrum(
+                frequencies, bins, s_dft, sigma, scheme=scheme)
             self.assertAlmostEqual(sum(spectrum),
                                    pre_broadening_total,)
 
         # Normal scheme reproduces area as well as total;
-        freq_points, full_spectrum = Broadening.broaden_spectrum(frequencies=frequencies,
-                                                                 bins=bins,
-                                                                 s_dft=s_dft,
-                                                                 sigma=sigma,
-                                                                 scheme='normal')
+        freq_points, full_spectrum = Broadening.broaden_spectrum(
+            frequencies, bins, s_dft, sigma, scheme='normal')
         self.assertAlmostEqual(np.trapz(spectrum, x=freq_points),
                                pre_broadening_total * (bins[1] - bins[0]),)
         self.assertAlmostEqual(sum(spectrum), pre_broadening_total)
@@ -158,22 +147,16 @@ class AbinsBroadeningTest(unittest.TestCase):
         # truncated forms will be a little off but shouldn't be _too_ off
         for scheme in ('gaussian_truncated', 'normal_truncated'):
 
-            freq_points, trunc_spectrum = Broadening.broaden_spectrum(frequencies=frequencies,
-                                                                      bins=bins,
-                                                                      s_dft=s_dft,
-                                                                      sigma=sigma,
-                                                                      scheme=scheme)
+            freq_points, trunc_spectrum = Broadening.broaden_spectrum(
+                frequencies, bins, s_dft, sigma, scheme)
             self.assertLess(abs(sum(full_spectrum) - sum(trunc_spectrum)) / sum(full_spectrum),
                                 0.03)
 
         # Interpolated methods need histogram input and smooth sigma
         hist_spec, _ = np.histogram(frequencies, bins, weights=s_dft)
         hist_sigma = sigma_func(freq_points)
-        freq_points, interp_spectrum = Broadening.broaden_spectrum(frequencies=freq_points,
-                                                                   bins=bins,
-                                                                   s_dft=hist_spec,
-                                                                   sigma=hist_sigma,
-                                                                   scheme='interpolate')
+        freq_points, interp_spectrum = Broadening.broaden_spectrum(
+            freq_points, bins, hist_spec, hist_sigma, scheme='interpolate')
         self.assertLess(abs(sum(interp_spectrum) - pre_broadening_total) / pre_broadening_total,
                             0.05)