Make noise backwards compatible (#1240)

* make noise backwards compatible

* fix typo

* adjust test

* fix another typo

* fix docstring

* add no fit case to docstring

* add subscan to docstring again

---------

Co-authored-by: Michael McCrackan <[email protected]>

Author: mmccrackan

sotodlib/preprocess/processes.py

@@ -486,18 +486,19 @@ class Noise(_Preprocess):
     Can run data selection of a "max_noise" value.
 
     When ``fit: True``, the parameter ``wn_est`` can be a float or the name of an
-    axis manager containing an array named ``white_noise``.  If not specified and
-    white noise is fixed, the white noise is calculated with ``calc_wn()`` and used
-    for ``wn_est``.  The calculated white noise is not stored.
+    axis manager containing an array named ``white_noise``.  If not specified
+    the white noise is calculated with ``calc_wn()`` and used
+    for ``wn_est``.  The calculated white noise will be stored in the noise fit
+    axis manager.
 
-    Example config block::
+    Example config block for fitting PSD::
 
-    - name: "noise
+    - name: "noise"
       fit: False
       subscan: False
       calc:
-        wn_f_low: 5
-        wn_f_high: 10
+        fwhite: (5, 10)
+        lowf: 1
         f_max: 25
         mask: True
         wn_est: noise
@@ -507,6 +508,19 @@ class Noise(_Preprocess):
       select:
         max_noise: 2000
 
+    Example config block for calculating white noise only::
+
+    - name: "noise"
+      fit: False
+      subscan: False
+      calc:
+        low_f: 5
+        high_f: 20
+      save: True
+      select:
+        min_noise: 18e-6
+        max_noise: 80e-6
+
     If ``fit: True`` this operation will run
     :func:`sotodlib.tod_ops.fft_ops.fit_noise_model`, else it will run
     :func:`sotodlib.tod_ops.fft_ops.calc_wn`.
@@ -542,15 +556,14 @@ def calc_and_save(self, aman, proc_aman):
                 else:
                     calc_wn = True
             if calc_wn or wn_est is None:
-                wn_f_low = self.calc_cfgs.get("wn_f_low", 5)
-                wn_f_high = self.calc_cfgs.get("wn_f_high", 10)
+                wn_f_low, wn_f_high = self.calc_cfgs.get('fwhite', (5, 10))
                 self.calc_cfgs['wn_est'] = tod_ops.fft_ops.calc_wn(aman, pxx=pxx,
                                                                    freqs=psd.freqs,
                                                                    low_f=wn_f_low,
                                                                    high_f=wn_f_high)
-
             if self.calc_cfgs.get('subscan') is None:
                 self.calc_cfgs['subscan'] = self.subscan
+            self.calc_cfgs.pop('fwhite', None)
             calc_aman = tod_ops.fft_ops.fit_noise_model(aman, pxx=pxx,
                                                         f=psd.freqs,
                                                         merge_fit=True,
@@ -561,8 +574,8 @@ def calc_and_save(self, aman, proc_aman):
                 else:
                     calc_aman.wrap("white_noise", self.calc_cfgs['wn_est'], [(0,"dets"), (1,"subscans")])
         else:
-            wn_f_low = self.calc_cfgs.get("wn_f_low", 5)
-            wn_f_high = self.calc_cfgs.get("wn_f_high", 10)
+            wn_f_low = self.calc_cfgs.get("low_f", 5)
+            wn_f_high = self.calc_cfgs.get("high_f", 10)
             wn = tod_ops.fft_ops.calc_wn(aman, pxx=pxx,
                                          freqs=psd.freqs,
                                          low_f=wn_f_low,

sotodlib/tod_ops/fft_ops.py

@@ -613,7 +613,7 @@ def fit_noise_model(
     wn_est=4E-5,
     alpha_est=3.4,
     merge_fit=False,
-    f_min=None,
+    lowf=None,
     f_max=100,
     merge_name="noise_fit_stats",
     merge_psd=True,
@@ -656,9 +656,9 @@ def fit_noise_model(
         initial values are applied for each detector.
     merge_fit : bool
         Merges fit and fit statistics into input axis manager.
-    f_min : float
+    lowf : float
         Minimum frequency to include in the fitting.
-        Default is None which selects f_min as the second index of f.
+        Default is None which selects lowf as the second index of f.
     f_max : float
         Maximum frequency to include in the fitting. This is particularly
         important for lowpass filtered data such as that post demodulation
@@ -723,18 +723,18 @@ def fit_noise_model(
 
     if subscan:
         fit_noise_model_kwargs = {"fknee_est": fknee_est, "wn_est": wn_est, "alpha_est": alpha_est,
-                                  "f_min": f_min, "f_max": f_max, "fixed_param": fixed_param,
+                                  "lowf": lowf, "f_max": f_max, "fixed_param": fixed_param,
                                   "binning": binning, "unbinned_mode": unbinned_mode, "base": base,
                                   "freq_spacing": freq_spacing}
         fitout, covout = _fit_noise_model_subscan(aman, signal,  f, pxx, fit_noise_model_kwargs)
         axis_map_fit = [(0, "dets"), (1, "noise_model_coeffs"), (2, aman.subscans)]
         axis_map_cov = [(0, "dets"), (1, "noise_model_coeffs"), (2, "noise_model_coeffs"), (3, aman.subscans)]
     else:
         eix = np.argmin(np.abs(f - f_max))
-        if f_min is None:
+        if lowf is None:
             six = 1
         else:
-            six = np.argmin(np.abs(f - f_min))
+            six = np.argmin(np.abs(f - lowf))
         f = f[six:eix]
         pxx = pxx[:, six:eix]
         bin_size = 1

tests/test_tod_ops.py

@@ -352,7 +352,7 @@ def test_psd(self):
 
         tod_ops.detrend_tod(aman)
         freqs_output, Pxx_output = tod_ops.fft_ops.calc_psd(aman, nperseg=200*100)
-        fit_result = tod_ops.fft_ops.fit_noise_model(aman, wn_est=50, fknee_est=1.0, alpha_est=3.3, f_min=0.05, f_max=5,
+        fit_result = tod_ops.fft_ops.fit_noise_model(aman, wn_est=50, fknee_est=1.0, alpha_est=3.3, lowf=0.05, f_max=5,
                                             binning=True, psdargs={'nperseg':200*1000})
         wnl_fit = fit_result.fit[:, 0]
         fk_fit = fit_result.fit[:, 1]