Bugfix. Before setting the rotorAvgModel of WindFarmModel (which is deprecated) did not work

py_wake/deficit_models/deficit_model.py

@@ -8,8 +8,6 @@ from py_wake.superposition_models import WeightedSum
 
 class DeficitModel(ABC, RotorAvgAndGroundModelContainer):
     deficit_initalized = False
-    _groundModel = None
-    _rotorAvgModel = None
 
     def __init__(self, rotorAvgModel=None, groundModel=None, use_effective_ws=True, use_effective_ti=False):
         RotorAvgAndGroundModelContainer.__init__(self, rotorAvgModel=rotorAvgModel, groundModel=groundModel)

py_wake/tests/test_rotor_avg_models/test_overlap_models.py

@@ -19,7 +19,8 @@ from py_wake.utils.model_utils import get_models
 from py_wake.wind_farm_models.engineering_models import PropagateDownwind, All2AllIterative
 from py_wake.wind_turbines._wind_turbines import WindTurbines
 from py_wake.wind_turbines.power_ct_functions import PowerCtFunction
-from py_wake.superposition_models import WeightedSum
+from py_wake.superposition_models import WeightedSum, SquaredSum
+import warnings
 
 
 def test_overlapping_area_factor_shapes():
@@ -99,3 +100,38 @@ def test_GaussianOverlapAvgModel_WeightedSum():
                             WeightedSum())
     with pytest.raises(NotImplementedError, match=r"calc_deficit_convection \(WeightedSum\) cannot be used in combination with rotorAvgModels and GroundModels"):
         wfm([0, 1000], [0, 0])
+
+
+def test_area_overlapping_deprecated_way():
+    wts = WindTurbines(names=['V80'] * 2, diameters=[80] * 2,
+                       hub_heights=[70] * 2,
+                       # only define for ct
+                       powerCtFunctions=[PowerCtFunction(['ws'], lambda ws, run_only: np.interp(ws, ct_curve[:, 0], ct_curve[:, 1]), 'w'),
+                                         PowerCtFunction(['ws'], lambda ws, run_only: ws * 0, 'w')])
+
+    site = UniformSite([1], 0.1)
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', category=DeprecationWarning)
+        wfm = PropagateDownwind(site, wts, rotorAvgModel=AreaOverlapAvgModel(),
+                                wake_deficitModel=NOJDeficit(rotorAvgModel=None),
+                                superpositionModel=SquaredSum())
+
+    y_lst = np.linspace(-250, 250, 50)
+    y = np.r_[0, y_lst]
+    x = np.r_[0, y_lst * 0 + 400]
+    t = np.r_[0, y_lst * 0 + 1]
+    WS_eff = wfm(x, y, type=t, ws=10, wd=270).WS_eff.values[1:, 0, 0]
+    plt.plot(y_lst, WS_eff, '.-')
+    # print(list(np.round(WS_eff[12:23], 2)))
+    ref = [10.0, 9.99, 9.88, 9.71, 9.51, 9.29, 9.06, 8.83, 8.64, 8.58, 8.58]
+    npt.assert_array_almost_equal(ref, WS_eff[12:23], decimal=2)
+    wfm = PropagateDownwind(site, wts, NOJDeficit(rotorAvgModel=None))
+    WS_eff = wfm(x, y, type=t, ws=10, wd=270).WS_eff.values[1:, 0, 0]
+    # print(list(np.round(WS_eff[12:23], 2)))
+    plt.plot(y_lst, WS_eff)
+    ref = [10.0, 10.0, 10.0, 10.0, 10.0, 8.58, 8.58, 8.58, 8.58, 8.58, 8.58]
+    plt.plot(y_lst[12:23], ref)
+    if 0:
+        plt.show()
+    npt.assert_array_almost_equal(ref, WS_eff[12:23], decimal=2)
+    plt.close('all')

py_wake/tests/test_utils/test_model_gradients.py

@@ -29,6 +29,7 @@ from py_wake.wind_farm_models.wind_farm_model import WindFarmModel
 from py_wake.deficit_models.noj import NOJDeficit
 from py_wake.site.jit_streamline_distance import JITStreamlineDistance
 from py_wake.site.xrsite import XRSite
+from py_wake.rotor_avg_models.area_overlap_model import AreaOverlapAvgModel
 
 
 def check_gradients(wfm, name, wt_x=[-1300, -650, 0], wt_y=[0, 0, 0], wt_h=[110, 110, 110], fd_step=1e-6, fd_decimal=6,
@@ -144,9 +145,12 @@ def test_superposition_models(model):
 @pytest.mark.parametrize('model', get_models(RotorAvgModel))
 def test_rotor_average_models(model):
     if model is not None:
+        if model is AreaOverlapAvgModel:
+            wake_deficitModel = NOJDeficit(rotorAvgModel=model())
+        else:
+            wake_deficitModel = BastankhahGaussianDeficit(rotorAvgModel=model())
         check_gradients(lambda site, wt: PropagateDownwind(
-            site, wt, wake_deficitModel=BastankhahGaussianDeficit(),
-            rotorAvgModel=model()),
+            site, wt, wake_deficitModel=wake_deficitModel),
             model.__name__)
 
 

py_wake/tests/test_utils/test_numpy.py

@@ -28,6 +28,9 @@ from py_wake.wind_farm_models.wind_farm_model import WindFarmModel
 from py_wake.examples.data.hornsrev1 import Hornsrev1Site
 
 from py_wake.rotor_avg_models.gaussian_overlap_model import GaussianOverlapAvgModel
+from py_wake.rotor_avg_models.area_overlap_model import AreaOverlapAvgModel
+from py_wake.deficit_models.noj import NOJDeficit
+import warnings
 
 
 @pytest.mark.parametrize('v,dtype,dtype32', [(5., float, np.float32),
@@ -138,6 +141,8 @@ def test_all_models(model_type, model):
         d['TurbulenceModel'] = STF2017TurbulenceModel(addedTurbulenceSuperpositionModel=model())
     elif model in [GaussianOverlapAvgModel]:
         d['TurbulenceModel'] = None
+    elif model in [AreaOverlapAvgModel]:
+        d['WakeDeficitModel'] = NOJDeficit
     elif model_type == 'GroundModel':
         d['WakeDeficitModel'] = IEA37SimpleBastankhahGaussianDeficit(groundModel=model())
     elif model_type in ['Site', 'Shear']:
@@ -168,5 +173,7 @@ def test_all_models(model_type, model):
                                      ('turbulenceModel', 'TurbulenceModel')] if v in d}
 
     wt = IEA37_WindTurbines()
-    wfm = d['WindFarmModel'](site, wt, **kwargs)
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', category=DeprecationWarning)
+        wfm = d['WindFarmModel'](site, wt, **kwargs)
     check_numpy32(wfm, model.__name__)

py_wake/tests/test_wind_farm_models/test_all2allIterative.py

@@ -37,12 +37,11 @@ def test_All2AllIterativeDeflection(deflection_model, count):
 
     site = IEA37Site(16)
     windTurbines = IEA37_WindTurbines()
-    deficit_model = FugaDeficitCount()
+    deficit_model = FugaDeficitCount(rotorAvgModel=CGIRotorAvg(4),)
     wf_model = All2AllIterative(site, windTurbines,
                                 wake_deficitModel=deficit_model,
                                 superpositionModel=LinearSum(),
                                 blockage_deficitModel=SelfSimilarityDeficit(),
-                                rotorAvgModel=CGIRotorAvg(4),
                                 deflectionModel=deflection_model, convergence_tolerance=0)
     sim_res = wf_model([0, 500, 1000, 1500], [0, 0, 0, 0],
                        wd=270, ws=10, yaw=[30, -30, 30, -30])

py_wake/wind_farm_models/engineering_models.py

@@ -73,7 +73,7 @@ class EngineeringWindFarmModel(WindFarmModel):
             if a rotorAvgModel has not already been specified for the wake_deficitModel""",
                           DeprecationWarning, stacklevel=2)
             check_model(rotorAvgModel, RotorAvgModel, 'rotorAvgModel')
-            self.wake_deficitModel._rotorAvgModel = self.wake_deficitModel._rotorAvgModel or rotorAvgModel
+            self.wake_deficitModel.rotorAvgModel = self.wake_deficitModel.rotorAvgModel or rotorAvgModel
 
         self.superpositionModel = superpositionModel
         self.blockage_deficitModel = blockage_deficitModel