Remove deprecated interpolation code (#228)

Author: berland

pyscal/gasoil.py

@@ -202,11 +202,6 @@ def resetsorg(self):
                 % (self.swirr, self.sgcr, self.swl, self.sorg, self.krgendanchor)
             )
 
-    def add_gasoil_fromtable(self, *args, **kwargs):
-        """Deprecated. Use ``add_fromtable()``"""
-        logger.warning("add_gasoil_fromtable() is deprecated, use add_fromtable()")
-        self.add_fromtable(*args, **kwargs)
-
     def add_fromtable(
         self,
         dframe,

pyscal/scalrecommendation.py

@@ -39,136 +39,7 @@ def __init__(self, low, base, high, tag=None, h=0.01):
         self.h = h
         self.tag = tag
 
-        if isinstance(low, dict) and isinstance(base, dict) and isinstance(high, dict):
-
-            logger.warning(
-                (
-                    "Making SCALrecommendation from dicts is deprecated "
-                    "and will not be supported in future versions\n"
-                )
-            )
-
-            self.defaultshandling("swirr", 0.0, [low, base, high])
-            self.defaultshandling("swcr", 0.0, [low, base, high])
-            self.defaultshandling("sorg", 0.0, [low, base, high])
-            self.defaultshandling("sgcr", 0.0, [low, base, high])
-
-            # Special treatment for backwards compatibility:
-            if "krowend" in low:
-                logger.error("krowend is deprecated, use kroend")
-                krowend = "krowend"
-            else:
-                krowend = "kroend"
-
-            if "krogend" in low:
-                logger.error("krogend is deprecated, use kroend")
-                krogend = "krogend"
-            else:
-                krogend = "kroend"
-
-            self.defaultshandling("kroend", 1.0, [low, base, high])
-            self.defaultshandling("krwmax", 1.0, [low, base, high])
-            self.defaultshandling("krgend", 1.0, [low, base, high])
-            self.defaultshandling("krgmax", 1.0, [low, base, high])
-
-            # Initialize saturation ranges for all curves
-            self.low = WaterOilGas(
-                swirr=low["swirr"],
-                swl=low["swl"],
-                sorw=low["sorw"],
-                sorg=low["sorg"],
-                sgcr=low["sgcr"],
-                swcr=low["swcr"],
-                h=h,
-                tag=tag,
-            )
-            self.base = WaterOilGas(
-                swirr=base["swirr"],
-                swl=base["swl"],
-                sorw=base["sorw"],
-                sorg=base["sorg"],
-                sgcr=base["sgcr"],
-                swcr=base["swcr"],
-                h=h,
-                tag=tag,
-            )
-            self.high = WaterOilGas(
-                swirr=high["swirr"],
-                swl=high["swl"],
-                sorw=high["sorw"],
-                sorg=high["sorg"],
-                sgcr=high["sgcr"],
-                swcr=high["swcr"],
-                h=h,
-                tag=tag,
-            )
-
-            # Add water and oil curves
-            self.low.wateroil.add_LET_water(
-                l=low["Lw"],
-                e=low["Ew"],
-                t=low["Tw"],
-                krwend=low["krwend"],
-                krwmax=low["krwmax"],
-            )
-            self.base.wateroil.add_LET_water(
-                l=base["Lw"],
-                e=base["Ew"],
-                t=base["Tw"],
-                krwend=base["krwend"],
-                krwmax=base["krwmax"],
-            )
-            self.high.wateroil.add_LET_water(
-                l=high["Lw"],
-                e=high["Ew"],
-                t=high["Tw"],
-                krwend=high["krwend"],
-                krwmax=high["krwmax"],
-            )
-
-            self.low.wateroil.add_LET_oil(
-                l=low["Lo"], e=low["Eo"], t=low["To"], kroend=low[krowend]
-            )
-            self.base.wateroil.add_LET_oil(
-                l=base["Lo"], e=base["Eo"], t=base["To"], kroend=base[krowend]
-            )
-            self.high.wateroil.add_LET_oil(
-                l=high["Lo"], e=high["Eo"], t=high["To"], kroend=high[krowend]
-            )
-
-            # Add gas and oil curves:
-            self.low.gasoil.add_LET_gas(
-                l=low["Lg"],
-                e=low["Eg"],
-                t=low["Tg"],
-                krgend=low["krgend"],
-                krgmax=low["krgmax"],
-            )
-            self.base.gasoil.add_LET_gas(
-                l=base["Lg"],
-                e=base["Eg"],
-                t=base["Tg"],
-                krgend=base["krgend"],
-                krgmax=base["krgmax"],
-            )
-            self.high.gasoil.add_LET_gas(
-                l=high["Lg"],
-                e=high["Eg"],
-                t=high["Tg"],
-                krgend=high["krgend"],
-                krgmax=high["krgmax"],
-            )
-            self.low.gasoil.add_LET_oil(
-                l=low["Log"], e=low["Eog"], t=low["Tog"], kroend=low[krogend]
-            )
-            self.base.gasoil.add_LET_oil(
-                l=base["Log"], e=base["Eog"], t=base["Tog"], kroend=base[krogend]
-            )
-            self.high.gasoil.add_LET_oil(
-                l=high["Log"], e=high["Eog"], t=high["Tog"], kroend=high[krogend]
-            )
-            self.type = WaterOilGas
-        elif (
+        if (
             isinstance(low, WaterOilGas)
             and isinstance(base, WaterOilGas)
             and isinstance(high, WaterOilGas)
@@ -390,15 +261,3 @@ def interpolate(self, parameter, parameter2=None, h=0.02):
         interpolant.fast = self.fast
 
         return interpolant
-
-    @staticmethod
-    def defaultshandling(key, value, dicts):
-        """Helper function for __init__ to fill out missing values in
-        dicts with relperm parameter
-
-        This function IS DEPRECATED and will be removed
-        when __init__ no longer supports dicts as arguments.
-        """
-        for dic in dicts:
-            if key not in dic:
-                dic[key] = value

pyscal/utils/interpolation.py

@@ -3,12 +3,9 @@
 
 import logging
 
-import pandas as pd
 from scipy.interpolate import interp1d
 
 import pyscal
-from ..constants import SWINTEGERS
-
 
 logger = logging.getLogger(__name__)
 
@@ -395,88 +392,3 @@ def weighted_value(a, b):
     go_new.tag = _interpolate_tags(go_low, go_high, parameter, tag)
 
     return go_new
-
-
-def interpolator(
-    tableobject, wo_low, wo_high, parameter, sat="sw", kr1="krw", kr2="krow", pc="pc"
-):
-    """Interpolates between two curves.
-
-    DEPRECATED FUNCTION!
-
-    The interpolation parameter is 0 through 1,
-    irrespective of phases or low-base/base-high/low-high.
-
-    Args:
-        tabjeobject (WaterOil or GasOil): A partially setup object where
-            relperm and pc columns are to be filled with numbers.
-        wo_low (WaterOil or GasOil): "Low" case of interpolation (relates
-            to interpolation parameter 0). Must be copies, as they
-            will be modified.
-        wo_high: Ditto, relates to interpolation parameter 1
-        parameter (float): Between 0 and 1, what you want to interpolate to.
-        sat (str): Name of the saturation column, typically 'sw' or 'sg'
-        kr1 (str): Name of the first relperm column ('krw' or 'krg')
-        kr2 (str): Name of the second relperm column ('krow' or 'krog')
-        pc (str): Name of the capillary pressure column ('pc')
-
-    Returns:
-        None, but modifies the first argument.
-    """
-    logger.warning("utils.interpolator() is deprecated and will disappear")
-
-    wo_low.table.rename(columns={kr1: kr1 + "_1"}, inplace=True)
-    wo_high.table.rename(columns={kr1: kr1 + "_2"}, inplace=True)
-    wo_low.table.rename(columns={kr2: kr2 + "_1"}, inplace=True)
-    wo_high.table.rename(columns={kr2: kr2 + "_2"}, inplace=True)
-    wo_low.table.rename(columns={pc: pc + "_1"}, inplace=True)
-    wo_high.table.rename(columns={pc: pc + "_2"}, inplace=True)
-
-    # Result data container:
-    satresult = pd.DataFrame(data=tableobject.table[sat], columns=[sat])
-
-    # Merge swresult with wo_low and wo_high, and interpolate all
-    # columns in sw:
-    intdf = (
-        pd.concat([wo_low.table, wo_high.table, satresult], sort=True)
-        .set_index(sat)
-        .sort_index()
-        .interpolate(method="slinear")
-        .fillna(method="bfill")
-        .fillna(method="ffill")
-    )
-
-    # Normalized saturations does not make sense for the
-    # interpolant, remove:
-    for col in ["swn", "son", "swnpc", "H", "J"]:
-        if col in intdf.columns:
-            del intdf[col]
-
-    intdf[kr1] = intdf[kr1 + "_1"] * (1 - parameter) + intdf[kr1 + "_2"] * parameter
-    intdf[kr2] = intdf[kr2 + "_1"] * (1 - parameter) + intdf[kr2 + "_2"] * parameter
-    if pc + "_1" in wo_low.table.columns and pc + "_2" in wo_high.table.columns:
-        intdf[pc] = intdf[pc + "_1"] * (1 - parameter) + intdf[pc + "_2"] * parameter
-    else:
-        intdf[pc] = 0
-
-    # Slice out the resulting sw values and columns. Slicing on
-    # floating point indices is not robust so we need to slice on an
-    # integer version of the sw column
-    tableobject.table["swint"] = list(
-        map(int, list(map(round, tableobject.table[sat] * SWINTEGERS)))
-    )
-    intdf["swint"] = list(map(int, list(map(round, intdf.index.values * SWINTEGERS))))
-    intdf = intdf.reset_index()
-    intdf.drop_duplicates("swint", inplace=True)
-    intdf.set_index("swint", inplace=True)
-    intdf = intdf.loc[tableobject.table["swint"].values]
-    intdf = intdf[[sat, kr1, kr2, pc]].reset_index()
-
-    # intdf['swint'] = (intdf['sw'] * SWINTEGERS).astype(int)
-    # intdf.drop_duplicates('swint', inplace=True)
-
-    # Populate the WaterOil object
-    tableobject.table[kr1] = intdf[kr1]
-    tableobject.table[kr2] = intdf[kr2]
-    tableobject.table[pc] = intdf[pc]
-    tableobject.table.fillna(method="ffill", inplace=True)

pyscal/wateroil.py

@@ -173,11 +173,6 @@ def __init__(
             "Initialized WaterOil with %s saturation points", str(len(self.table))
         )
 
-    def add_oilwater_fromtable(self, *args, **kwargs):
-        """Deprecated, use ``add_fromtable()``"""
-        logger.warning("add_oilwater_fromtable() is deprecated, use add_fromtable()")
-        self.add_fromtable(*args, **kwargs)
-
     def add_fromtable(
         self,
         dframe,

tests/test_fromtable.py

@@ -21,8 +21,7 @@ def test_wo_fromtable_simple():
     wateroil = WaterOil(h=0.1)
     # With wrong names:
     with pytest.raises(ValueError):
-        # Here we also get a deprecation warning
-        wateroil.add_oilwater_fromtable(df1)
+        wateroil.add_fromtable(df1)
 
     # Set names:
     wateroil.add_fromtable(df1, swcolname="SW")

tests/test_scalrecommendation.py

@@ -89,64 +89,6 @@
 }
 
 
-@settings(max_examples=10, deadline=3000)
-@given(
-    st.floats(min_value=-1.1, max_value=1.1), st.floats(min_value=-1.1, max_value=1.1)
-)
-def test_interpolation_deprecated(param_wo, param_go):
-    """Testing deprecated functionality. Remove
-    this test function when SCALrecommendation class is updated"""
-
-    rec = SCALrecommendation(
-        LOW_SAMPLE_LET, BASE_SAMPLE_LET, HIGH_SAMPLE_LET, "foo", h=0.1
-    )
-
-    rec.add_simple_J()  # Add default pc curve
-    assert rec.type == WaterOilGas
-    try:
-        interpolant = rec.interpolate(param_wo, param_go, h=0.1)
-    except ValueError:
-        # We get here when interpolation parameters are outside [-1, 1]
-        return
-
-    check_table(interpolant.wateroil.table)
-    check_table(interpolant.gasoil.table)
-
-    assert len(interpolant.gasoil.SGOF()) > 100
-    assert len(interpolant.gasoil.SGFN()) > 100
-    assert len(interpolant.wateroil.SWFN()) > 100
-    assert len(interpolant.SOF3()) > 100
-    assert len(interpolant.wateroil.SWOF()) > 100
-    if not interpolant.threephaseconsistency():
-        print(interpolant.wateroil.SWOF())
-        print(interpolant.gasoil.SGOF())
-    assert interpolant.threephaseconsistency()
-
-
-def test_deprecated_kroend():
-    """Testing that the deprecated scalrecommendation can take
-    both kroend and krogend/krowend"""
-
-    low_krowend = dict(LOW_SAMPLE_LET)
-    low_krowend["krowend"] = low_krowend["kroend"]
-    del low_krowend["kroend"]
-
-    base_krowend = dict(BASE_SAMPLE_LET)
-    base_krowend["krowend"] = base_krowend["kroend"]
-    del base_krowend["kroend"]
-
-    high_krowend = dict(HIGH_SAMPLE_LET)
-    high_krowend["krowend"] = high_krowend["kroend"]
-    del high_krowend["kroend"]
-
-    rec = SCALrecommendation(low_krowend, base_krowend, high_krowend, "foo", h=0.1)
-
-    rec.add_simple_J()  # Add default pc curve
-    interpolant = rec.interpolate(0.1, 0, h=0.1)
-    check_table(interpolant.wateroil.table)
-    print(interpolant.SWOF())
-
-
 def test_make_scalrecommendation():
     """Test that we can make scal recommendation objects
     from three WaterOilGas objects"""