Added cutoff_error parameter to enable Automatic Linestrength Cutoff

radis/lbl/base.py

@@ -3077,7 +3077,7 @@ def calc_linestrength_noneq(self):
 
     # %%
     def calc_emission_integral(self):
-        r"""Calculate the emission integral (in :math:`mW/sr`) of all lines in DataFrame ``df1``.
+        """Calculate the emission integral (in :math:`mW/sr`) of all lines in DataFrame ``df1``.
 
         .. math::
 
@@ -3145,7 +3145,7 @@ def calc_emission_integral(self):
         return
 
     # %%
-    def _cutoff_linestrength(self, cutoff=None):
+    def _cutoff_linestrength(self, cutoff=None, cutoff_error=None):
         """Discard linestrengths that are lower that this, to reduce
         calculation times. Set the number of lines cut in
         ``self._Nlines_cutoff``
@@ -3157,6 +3157,10 @@ def _cutoff_linestrength(self, cutoff=None):
             discard linestrengths that are lower that this, to reduce calculation
             times. If 0, no cutoff. Default 0
 
+        cutoff_error: float
+            user-inputted value of cutoff error, to keep the estimated error
+            below this value. If None, no error to consider. Default None.
+
         Notes
         -----
 
@@ -3169,9 +3173,12 @@ def _cutoff_linestrength(self, cutoff=None):
         # Update defaults
         if cutoff is not None:
             self.params.cutoff = cutoff
+        if cutoff_error is not None:
+            self.params.cutoff_error = cutoff_error
 
         # Load variables
         cutoff = self.params.cutoff
+        cutoff_error = self.params.cutoff_error
         verbose = self.verbose
         df = self.df1
 
@@ -3202,6 +3209,26 @@ def _cutoff_linestrength(self, cutoff=None):
 
             error = df.S[b].sum() / df.S.sum() * 100
 
+            if cutoff_error is not None:
+                if cutoff_error < error:
+                    # Remove additional lines such that cutoff error is less than user-inputted value
+                    while cutoff_error < error:
+                        cutoff -= 0.0001
+                        b = df.S <= cutoff
+                        error = df.S[b].sum() / df.S.sum() * 100
+                else:
+                    print(
+                        "Cutoff error is greater than the current error."
+                        + " Inputted cutoff error percentage is {0:.2f}%".format(
+                            cutoff_error
+                        )
+                        + " Estimated error: {0:.2f}%".format(error)
+                    )
+
+                Nlines_cutoff = b.sum()
+            else:
+                print("Cutoff error not inputted.")
+
             if verbose >= 2:
                 print(
                     "Discarded {0:.2f}% of lines (linestrength<{1}cm-1/(#.cm-2))".format(

radis/lbl/loader.py

@@ -445,6 +445,7 @@ class Parameters(ConditionDict):
         "neighbour_lines",
         "chunksize",
         "cutoff",
+        "cutoff_error",
         "db_use_cached",
         "dbformat",
         "dbpath",
@@ -477,6 +478,9 @@ def __init__(self):
         self.truncation = None  #: float: cutoff for half-width lineshape calculation (cm-1). Overwritten by SpectrumFactory
         self.neighbour_lines = None  #: float: extra range (cm-1) on each side of the spectrum to account for neighbouring lines. Overwritten by SpectrumFactory
         self.cutoff = None  #: float: linestrength cutoff (molecule/cm)
+        self.cutoff_error = (
+            None  #: float: error percentage below which the cutoff error should be
+        )
         self.broadening_method = ""  #: str:``"voigt"``, ``"convolve"``, ``"fft"``
         self.optimization = None  #: str: ``"simple"``, ``"min-RMS"``, ``None``
         self.db_use_cached = (