foxes 1.1.1__py3-none-any.whl → 1.2__py3-none-any.whl

foxes/models/turbine_models/power_mask.py

@@ -1,9 +1,9 @@
 import numpy as np
 
 from foxes.core import TurbineModel
-import foxes.variables as FV
-import foxes.constants as FC
+from foxes.config import config
 from foxes.utils import cubic_roots
+import foxes.variables as FV
 
 
 class PowerMask(TurbineModel):
@@ -33,7 +33,13 @@ class PowerMask(TurbineModel):
 
     """
 
-    def __init__(self, var_ws_P=FV.REWS3, factor_P=1.0e3, P_lim=100, induction="Betz"):
+    def __init__(
+        self,
+        var_ws_P=FV.REWS3,
+        factor_P=1.0e3,
+        P_lim=100,
+        induction="Betz",
+    ):
         """
         Constructor.
 
@@ -110,13 +116,13 @@ class PowerMask(TurbineModel):
 
         self._P_rated = []
         for t in algo.farm_controller.turbine_types:
-            Pnom = FC.DTYPE(t.P_nominal)
+            Pnom = config.dtype_double(t.P_nominal)
             if np.isnan(Pnom):
                 raise ValueError(
                     f"Model '{self.name}': P_nominal is NaN for turbine type '{t.name}'"
                 )
             self._P_rated.append(Pnom)
-        self._P_rated = np.array(self._P_rated, dtype=FC.DTYPE)
+        self._P_rated = np.array(self._P_rated, dtype=config.dtype_double)
 
     def calculate(self, algo, mdata, fdata, st_sel):
         """
@@ -183,9 +189,9 @@ class PowerMask(TurbineModel):
 
             # find roots:
             N = len(cp)
-            a3 = np.full(N, 4.0, dtype=FC.DTYPE)
-            a2 = np.full(N, -8.0, dtype=FC.DTYPE)
-            a1 = np.full(N, 4.0, dtype=FC.DTYPE)
+            a3 = np.full(N, 4.0, dtype=config.dtype_double)
+            a2 = np.full(N, -8.0, dtype=config.dtype_double)
+            a1 = np.full(N, 4.0, dtype=config.dtype_double)
             a0 = -cp / e
             rts = cubic_roots(a0, a1, a2, a3)
             rts[np.isnan(rts)] = np.inf

foxes/models/turbine_models/sector_management.py

@@ -3,6 +3,7 @@ import pandas as pd
 
 from foxes.core import TurbineModel
 from foxes.utils import PandasFileHelper
+from foxes.config import get_path
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -90,9 +91,10 @@ class SectorManagement(TurbineModel):
         if isinstance(self.source, pd.DataFrame):
             data = self.source
         else:
+            fpath = get_path(self.source)
             if verbosity > 0:
-                print(f"{self.name}: Reading file {self.source}")
-            data = PandasFileHelper.read_file(self.source, **self._rpars)
+                print(f"{self.name}: Reading file {fpath}")
+            data = PandasFileHelper.read_file(fpath, **self._rpars)
 
         if self._trbs is None:
             if self._col_i is not None and self._col_t is None:

foxes/models/turbine_models/set_farm_vars.py

@@ -1,8 +1,9 @@
 import numpy as np
 
 from foxes.core import TurbineModel
-import foxes.constants as FC
+from foxes.config import config
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 class SetFarmVars(TurbineModel):
@@ -13,12 +14,14 @@ class SetFarmVars(TurbineModel):
     ----------
     vars: list of str
         The variables to be set
+    once: bool
+        Flag for running only once
 
     :group: models.turbine_models
 
     """
 
-    def __init__(self, pre_rotor=False):
+    def __init__(self, pre_rotor=False, once=False):
         """
         Constructor.
 
@@ -27,9 +30,12 @@ class SetFarmVars(TurbineModel):
         pre_rotor: bool
             Flag for running this model before
             running the rotor model.
+        once: bool
+            Flag for running only once
 
         """
         super().__init__(pre_rotor=pre_rotor)
+        self.once = once
         self.reset()
 
     def add_var(self, var, data):
@@ -51,7 +57,7 @@ class SetFarmVars(TurbineModel):
         if self.running:
             raise ValueError(f"Model '{self.name}': Cannot add_var while running")
         self.vars.append(var)
-        self.__vdata.append(np.asarray(data, dtype=FC.DTYPE))
+        self.__vdata.append(np.asarray(data, dtype=config.dtype_double))
 
     def reset(self):
         """
@@ -62,6 +68,23 @@ class SetFarmVars(TurbineModel):
         self.vars = []
         self.__vdata = []
 
+    def initialize(self, algo, verbosity=0, force=False):
+        """
+        Initializes the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        verbosity: int
+            The verbosity level, 0 = silent
+        force: bool
+            Overwrite existing data
+
+        """
+        super().initialize(algo, verbosity, force)
+        self.__once_done = set()
+
     def output_farm_vars(self, algo):
         """
         The variables which are being modified by the model.
@@ -105,7 +128,9 @@ class SetFarmVars(TurbineModel):
         idata = super().load_data(algo, verbosity)
 
         for i, v in enumerate(self.vars):
-            data = np.full((algo.n_states, algo.n_turbines), np.nan, dtype=FC.DTYPE)
+            data = np.full(
+                (algo.n_states, algo.n_turbines), np.nan, dtype=config.dtype_double
+            )
             vdata = self.__vdata[i]
 
             # handle special case of call during vectorized optimization:
@@ -117,7 +142,7 @@ class SetFarmVars(TurbineModel):
                 n_pop = algo.states.n_pop
                 n_ost = algo.states.states.size()
                 n_trb = algo.n_turbines
-                vdata = np.zeros((n_pop, n_ost, n_trb), dtype=FC.DTYPE)
+                vdata = np.zeros((n_pop, n_ost, n_trb), dtype=config.dtype_double)
                 vdata[:] = self.__vdata[i][None, :]
                 vdata = vdata.reshape(n_pop * n_ost, n_trb)
 
@@ -130,7 +155,7 @@ class SetFarmVars(TurbineModel):
                 for ti in range(algo.n_turbines):
                     t = algo.farm.turbines[ti]
                     if len(t.xy.shape) == 1:
-                        xy = np.zeros((algo.n_states, 2), dtype=FC.DTYPE)
+                        xy = np.zeros((algo.n_states, 2), dtype=config.dtype_double)
                         xy[:] = t.xy[None, :]
                         t.xy = xy
                     t.xy[:, i] = np.where(
@@ -141,7 +166,7 @@ class SetFarmVars(TurbineModel):
             if v in [FV.D, FV.H]:
                 for ti in range(algo.n_turbines):
                     t = algo.farm.turbines[ti]
-                    x = np.zeros(algo.n_states, dtype=FC.DTYPE)
+                    x = np.zeros(algo.n_states, dtype=config.dtype_double)
                     if v == FV.D:
                         x[:] = t.D
                         t.D = x
@@ -243,21 +268,26 @@ class SetFarmVars(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
-        if self.pre_rotor:
-            order = np.s_[:]
-            ssel = np.s_[:]
-        else:
-            order = fdata[FV.ORDER]
-            ssel = fdata[FV.ORDER_SSEL]
-
-        bsel = np.zeros((fdata.n_states, fdata.n_turbines), dtype=bool)
-        bsel[st_sel] = True
-
-        for v in self.vars:
-            data = mdata[self.var(v)][ssel, order]
-            hsel = ~np.isnan(data)
-            tsel = bsel & hsel
-
-            fdata[v][tsel] = data[tsel]
+        i0 = mdata.states_i0(counter=True)
+        if not self.once or i0 not in self.__once_done:
+
+            if self.pre_rotor:
+                order = np.s_[:]
+                ssel = np.s_[:]
+            else:
+                order = fdata[FV.ORDER]
+                ssel = fdata[FV.ORDER_SSEL]
+
+            bsel = np.zeros((fdata.n_states, fdata.n_turbines), dtype=bool)
+            bsel[st_sel] = True
+
+            for v in self.vars:
+                data = mdata[self.var(v)][ssel, order]
+                hsel = ~np.isnan(data)
+                tsel = bsel & hsel
+
+                fdata[v][tsel] = data[tsel]
+
+            self.__once_done.add(i0)
 
         return {v: fdata[v] for v in self.vars}

foxes/models/turbine_models/table_factors.py

@@ -4,7 +4,7 @@ from scipy.interpolate import interpn
 
 from foxes.core import TurbineModel
 from foxes.utils import PandasFileHelper
-import foxes.constants as FC
+from foxes.config import config, get_path
 
 
 class TableFactors(TurbineModel):
@@ -106,15 +106,16 @@ class TableFactors(TurbineModel):
         if isinstance(self.data_source, pd.DataFrame):
             self._data = self.data_source
         else:
+            fpath = get_path(self.data_source)
             if verbosity > 0:
-                print(f"{self.name}: Reading file {self.data_source}")
+                print(f"{self.name}: Reading file {fpath}")
             rpars = dict(index_col=0)
             rpars.update(self._rpars)
-            self._data = PandasFileHelper.read_file(self.data_source, **rpars)
+            self._data = PandasFileHelper.read_file(fpath, **rpars)
 
-        self._rvals = self._data.index.to_numpy(FC.DTYPE)
-        self._cvals = self._data.columns.to_numpy(FC.DTYPE)
-        self._data = self._data.to_numpy(FC.DTYPE)
+        self._rvals = self._data.index.to_numpy(config.dtype_double)
+        self._cvals = self._data.columns.to_numpy(config.dtype_double)
+        self._data = self._data.to_numpy(config.dtype_double)
 
     def calculate(self, algo, mdata, fdata, st_sel):
         """
@@ -143,7 +144,7 @@ class TableFactors(TurbineModel):
 
         """
         n_sel = np.sum(st_sel)
-        qts = np.zeros((n_sel, 2), dtype=FC.DTYPE)
+        qts = np.zeros((n_sel, 2), dtype=config.dtype_double)
         qts[:, 0] = fdata[self.row_var][st_sel]
         qts[:, 1] = fdata[self.col_var][st_sel]
 

foxes/models/turbine_models/yaw2yawm.py

@@ -1,6 +1,5 @@
 from foxes.core import TurbineModel
 import foxes.variables as FV
-import foxes.constants as FC
 from foxes.utils import delta_wd
 
 

foxes/models/turbine_models/yawm2yaw.py

@@ -2,7 +2,6 @@ import numpy as np
 
 from foxes.core import TurbineModel
 import foxes.variables as FV
-import foxes.constants as FC
 
 
 class YAWM2YAW(TurbineModel):

foxes/models/turbine_types/CpCt_file.py

@@ -1,11 +1,13 @@
 import numpy as np
 import pandas as pd
 
-from .PCt_file import PCtFile
 from foxes.data import parse_Pct_file_name
 from foxes.utils import PandasFileHelper
+from foxes.config import config, get_path
 import foxes.constants as FC
 
+from .PCt_file import PCtFile
+
 
 class CpCtFile(PCtFile):
     """
@@ -47,7 +49,8 @@ class CpCtFile(PCtFile):
         if not isinstance(data_source, pd.DataFrame):
             pars = parse_Pct_file_name(data_source)
             pars.update(parameters)
-            data = PandasFileHelper.read_file(data_source, **pd_file_read_pars)
+            fpath = get_path(data_source)
+            data = PandasFileHelper.read_file(fpath, **pd_file_read_pars)
         else:
             data = data_source
             pars = parameters
@@ -63,7 +66,7 @@ class CpCtFile(PCtFile):
         ws_max = np.max(ws)
         N = int((ws_max - ws_min) / ws_delta)
 
-        data_P = pd.DataFrame(index=range(N), dtype=FC.DTYPE)
+        data_P = pd.DataFrame(index=range(N), dtype=config.dtype_double)
         data_P["ws"] = np.linspace(ws_min, ws_max, N, endpoint=True)
         data_P["cp"] = np.interp(data_P["ws"], ws, cp, left=0, right=0)
         data_P["P"] = (

foxes/models/turbine_types/CpCt_from_two.py

@@ -4,6 +4,7 @@ import pandas as pd
 from .PCt_from_two import PCtFromTwo
 from foxes.data import parse_Pct_two_files
 from foxes.utils import PandasFileHelper
+from foxes.config import config, get_path
 import foxes.constants as FC
 
 
@@ -55,8 +56,10 @@ class CpCtFromTwo(PCtFromTwo):
             data_source_ct, pd.DataFrame
         ):
             pars = parse_Pct_two_files(data_source_cp, data_source_ct)
-            data_cp = PandasFileHelper.read_file(data_source_cp, **pd_file_read_pars_cp)
-            data_ct = PandasFileHelper.read_file(data_source_ct, **pd_file_read_pars_ct)
+            path_cp = get_path(data_source_cp)
+            path_ct = get_path(data_source_ct)
+            data_cp = PandasFileHelper.read_file(path_cp, **pd_file_read_pars_cp)
+            data_ct = PandasFileHelper.read_file(path_ct, **pd_file_read_pars_ct)
         else:
             data_cp = data_source_cp
             data_ct = data_source_ct
@@ -73,7 +76,7 @@ class CpCtFromTwo(PCtFromTwo):
         ws_max = np.max(ws)
         N = int((ws_max - ws_min) / ws_delta)
 
-        data_P = pd.DataFrame(index=range(N), dtype=FC.DTYPE)
+        data_P = pd.DataFrame(index=range(N), dtype=config.dtype_double)
         data_P["ws"] = np.linspace(ws_min, ws_max, N, endpoint=True)
         data_P["cp"] = np.interp(data_P["ws"], ws, cp, left=0, right=0)
         data_P["P"] = (

foxes/models/turbine_types/PCt_file.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from foxes.core import TurbineType
 from foxes.utils import PandasFileHelper
 from foxes.data import PCTCURVE, parse_Pct_file_name
+from foxes.config import get_path
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -173,15 +174,15 @@ class PCtFile(TurbineType):
         if isinstance(self.source, pd.DataFrame):
             data = self.source
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source, check_raw=True)
-            if verbosity > 0:
-                if not Path(self.source).is_file():
+            fpath = get_path(self.source)
+            if not fpath.is_file():
+                if verbosity > 0:
                     print(
                         f"Turbine type '{self.name}': Reading static data from context '{PCTCURVE}'"
                     )
-                    print(f"Path: {fpath}")
-                else:
-                    print(f"Turbine type '{self.name}': Reading file", self.source)
+                fpath = algo.dbook.get_file_path(PCTCURVE, self.source, check_raw=False)
+            if verbosity > 0:
+                print(f"Turbine type '{self.name}': Reading file", fpath)
             data = PandasFileHelper.read_file(fpath, **self.rpars)
 
         data = data.set_index(self.col_ws).sort_index()

foxes/models/turbine_types/PCt_from_two.py

@@ -4,6 +4,7 @@ import pandas as pd
 from foxes.core import TurbineType
 from foxes.utils import PandasFileHelper
 from foxes.data import PCTCURVE, parse_Pct_two_files
+from foxes.config import get_path
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -194,7 +195,11 @@ class PCtFromTwo(TurbineType):
         if isinstance(self.source_P, pd.DataFrame):
             self._data_P = self.source_P
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source_P, check_raw=True)
+            fpath = get_path(self.source_P)
+            if not fpath.is_file():
+                fpath = algo.dbook.get_file_path(
+                    PCTCURVE, self.source_P, check_raw=False
+                )
             self._data_P = PandasFileHelper.read_file(fpath, **self.rpars_P)
 
         self._data_P = self._data_P.set_index(self.col_ws_P_file).sort_index()
@@ -205,7 +210,11 @@ class PCtFromTwo(TurbineType):
         if isinstance(self.source_ct, pd.DataFrame):
             self._data_ct = self.source_ct
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source_ct, check_raw=True)
+            fpath = get_path(self.source_ct)
+            if not fpath.is_file():
+                fpath = algo.dbook.get_file_path(
+                    PCTCURVE, self.source_ct, check_raw=False
+                )
             self._data_ct = PandasFileHelper.read_file(fpath, **self.rpars_ct)
 
         self._data_ct = self._data_ct.set_index(self.col_ws_ct_file).sort_index()

foxes/models/turbine_types/TBL_file.py

@@ -1,10 +1,9 @@
 import numpy as np
 import pandas as pd
-from pathlib import Path
+
+from foxes.config import get_path
 
 from .PCt_file import PCtFile
-from foxes.data import parse_Pct_file_name
-import foxes.constants as FC
 
 
 class TBLFile(PCtFile):
@@ -58,7 +57,7 @@ class TBLFile(PCtFile):
             Additional parameters for PCtFile class
 
         """
-        fpath = Path(tbl_file)
+        fpath = get_path(tbl_file)
         assert fpath.suffix == ".tbl", f"Expecting *.tbl file, got '{tbl_file}'"
 
         meta = np.genfromtxt(fpath, skip_header=1, max_rows=1)

foxes/models/turbine_types/wsrho2PCt_from_two.py

@@ -5,8 +5,8 @@ from scipy.interpolate import interpn
 from foxes.core import TurbineType
 from foxes.utils import PandasFileHelper
 from foxes.data import PCTCURVE, parse_Pct_two_files
+from foxes.config import config, get_path
 import foxes.variables as FV
-import foxes.constants as FC
 
 
 class WsRho2PCtFromTwo(TurbineType):
@@ -183,31 +183,39 @@ class WsRho2PCtFromTwo(TurbineType):
         if isinstance(self.source_P, pd.DataFrame):
             data = self.source_P
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source_P, check_raw=True)
+            fpath = get_path(self.source_P)
+            if not fpath.is_file():
+                fpath = algo.dbook.get_file_path(
+                    PCTCURVE, self.source_P, check_raw=False
+                )
             pars = {"index_col": 0}
             pars.update(self.rpars_P)
             data = PandasFileHelper.read_file(fpath, **pars)
 
         data.sort_index(inplace=True)
-        data.columns = data.columns.astype(FC.DTYPE)
-        self._ws_P = data.index.to_numpy(FC.DTYPE)
+        data.columns = data.columns.astype(config.dtype_double)
+        self._ws_P = data.index.to_numpy(config.dtype_double)
         self._rho_P = np.sort(data.columns.to_numpy())
-        self._P = data[self._rho_P].to_numpy(FC.DTYPE)
+        self._P = data[self._rho_P].to_numpy(config.dtype_double)
 
         # read ct curve:
         if isinstance(self.source_ct, pd.DataFrame):
             data = self.source_ct
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source_ct, check_raw=True)
+            fpath = get_path(self.source_ct)
+            if not fpath.is_file():
+                fpath = algo.dbook.get_file_path(
+                    PCTCURVE, self.source_ct, check_raw=False
+                )
             pars = {"index_col": 0}
             pars.update(self.rpars_ct)
             data = PandasFileHelper.read_file(fpath, **pars)
 
         data.sort_index(inplace=True)
-        data.columns = data.columns.astype(FC.DTYPE)
-        self._ws_ct = data.index.to_numpy(FC.DTYPE)
+        data.columns = data.columns.astype(config.dtype_double)
+        self._ws_ct = data.index.to_numpy(config.dtype_double)
         self._rho_ct = np.sort(data.columns.to_numpy())
-        self._ct = data[self._rho_ct].to_numpy(FC.DTYPE)
+        self._ct = data[self._rho_ct].to_numpy(config.dtype_double)
 
         return super().load_data(algo, verbosity)
 
@@ -267,7 +275,7 @@ class WsRho2PCtFromTwo(TurbineType):
         if np.any(st_sel_P):
             # prepare interpolation:
             n_sel = np.sum(st_sel_P)
-            qts = np.zeros((n_sel, 2), dtype=FC.DTYPE)  # ws, rho
+            qts = np.zeros((n_sel, 2), dtype=config.dtype_double)  # ws, rho
             qts[:, 0] = fdata[self.WSP][st_sel_P]
             qts[:, 1] = fdata[FV.RHO][st_sel_P]
 
@@ -307,7 +315,7 @@ class WsRho2PCtFromTwo(TurbineType):
         if np.any(st_sel_ct):
             # prepare interpolation:
             n_sel = np.sum(st_sel_ct)
-            qts = np.zeros((n_sel, 2), dtype=FC.DTYPE)  # ws, rho
+            qts = np.zeros((n_sel, 2), dtype=config.dtype_double)  # ws, rho
             qts[:, 0] = fdata[self.WSP][st_sel_ct]
             qts[:, 1] = fdata[FV.RHO][st_sel_ct]
 

foxes/models/turbine_types/wsti2PCt_from_two.py

@@ -6,7 +6,7 @@ from foxes.core import TurbineType
 from foxes.utils import PandasFileHelper
 from foxes.data import PCTCURVE, parse_Pct_two_files
 import foxes.variables as FV
-import foxes.constants as FC
+from foxes.config import config, get_path
 
 
 class WsTI2PCtFromTwo(TurbineType):
@@ -195,31 +195,39 @@ class WsTI2PCtFromTwo(TurbineType):
         if isinstance(self.source_P, pd.DataFrame):
             data = self.source_P
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source_P, check_raw=True)
+            fpath = get_path(self.source_P)
+            if not fpath.is_file():
+                fpath = algo.dbook.get_file_path(
+                    PCTCURVE, self.source_P, check_raw=False
+                )
             pars = {"index_col": 0}
             pars.update(self.rpars_P)
             data = PandasFileHelper.read_file(fpath, **pars)
 
         data.sort_index(inplace=True)
-        data.columns = data.columns.astype(FC.DTYPE)
-        self._ws_P = data.index.to_numpy(FC.DTYPE)
+        data.columns = data.columns.astype(config.dtype_double)
+        self._ws_P = data.index.to_numpy(config.dtype_double)
         self._ti_P = np.sort(data.columns.to_numpy())
-        self._P = data[self._ti_P].to_numpy(FC.DTYPE)
+        self._P = data[self._ti_P].to_numpy(config.dtype_double)
 
         # read ct curve:
         if isinstance(self.source_ct, pd.DataFrame):
             data = self.source_ct
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source_ct, check_raw=True)
+            fpath = get_path(self.source_ct)
+            if not fpath.is_file():
+                fpath = algo.dbook.get_file_path(
+                    PCTCURVE, self.source_ct, check_raw=False
+                )
             pars = {"index_col": 0}
             pars.update(self.rpars_ct)
             data = PandasFileHelper.read_file(fpath, **pars)
 
         data.sort_index(inplace=True)
-        data.columns = data.columns.astype(FC.DTYPE)
-        self._ws_ct = data.index.to_numpy(FC.DTYPE)
+        data.columns = data.columns.astype(config.dtype_double)
+        self._ws_ct = data.index.to_numpy(config.dtype_double)
         self._ti_ct = np.sort(data.columns.to_numpy())
-        self._ct = data[self._ti_ct].to_numpy(FC.DTYPE)
+        self._ct = data[self._ti_ct].to_numpy(config.dtype_double)
 
         return super().load_data(algo, verbosity)
 
@@ -279,7 +287,7 @@ class WsTI2PCtFromTwo(TurbineType):
         if np.any(st_sel_P):
             # prepare interpolation:
             n_sel = np.sum(st_sel_P)
-            qts = np.zeros((n_sel, 2), dtype=FC.DTYPE)  # ws, ti
+            qts = np.zeros((n_sel, 2), dtype=config.dtype_double)  # ws, ti
             qts[:, 0] = fdata[self.WSP][st_sel_P]
             qts[:, 1] = fdata[FV.TI][st_sel_P]
 
@@ -328,7 +336,7 @@ class WsTI2PCtFromTwo(TurbineType):
         if np.any(st_sel_ct):
             # prepare interpolation:
             n_sel = np.sum(st_sel_ct)
-            qts = np.zeros((n_sel, 2), dtype=FC.DTYPE)  # ws, ti
+            qts = np.zeros((n_sel, 2), dtype=config.dtype_double)  # ws, ti
             qts[:, 0] = fdata[self.WSP][st_sel_ct]
             qts[:, 1] = fdata[FV.TI][st_sel_ct]
 

foxes/models/vertical_profiles/abl_log_neutral_ws.py

@@ -1,7 +1,7 @@
 from foxes.core import VerticalProfile
 from foxes.utils.abl import neutral
-import foxes.constants as FC
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 class ABLLogNeutralWsProfile(VerticalProfile):

foxes/models/vertical_profiles/abl_log_stable_ws.py

@@ -1,7 +1,7 @@
 from foxes.core import VerticalProfile
 from foxes.utils.abl import stable
-import foxes.constants as FC
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 class ABLLogStableWsProfile(VerticalProfile):

foxes/models/vertical_profiles/abl_log_unstable_ws.py

@@ -1,7 +1,7 @@
 from foxes.core import VerticalProfile
 from foxes.utils.abl import unstable
-import foxes.constants as FC
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 class ABLLogUnstableWsProfile(VerticalProfile):

foxes/models/vertical_profiles/abl_log_ws.py

@@ -2,8 +2,8 @@ import numpy as np
 
 from foxes.core import VerticalProfile
 from foxes.utils import abl
-import foxes.constants as FC
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 class ABLLogWsProfile(VerticalProfile):