!asdf

Author: Peque

docs/sphinx/source/conf.py

@@ -52,6 +52,9 @@
     'sphinx_gallery.gen_gallery',
     'sphinx_toggleprompt',
 ]
+extensions.append("sphinx_remove_toctrees")
+
+remove_from_toctrees = ["reference/**", "user_guide/forecasts*"]
 
 napoleon_use_rtype = False  # group rtype on same line together with return
 

docs/sphinx/source/user_guide/storage.rst

@@ -422,11 +422,6 @@ load/battery/grid, from battery to load and from grid to load/system:
    plt.close()
 
 
-.. note:: The :py:func:`~pvlib.flow.self_consumption_ac_battery` function
-   allows you to define the AC-DC losses, if you would rather avoid the default
-   values.
-
-
 While the self-consumption with AC-connected battery use case imposes many
 restrictions to the power flow, it still allows some flexibility to decide when
 to allow charging and discharging. If you wanted to simulate a use case where

pvlib/powerflow.py

@@ -77,6 +77,56 @@ def self_consumption_ac_battery(generation, load, battery, model):
     return final_state, df
 
 
+def self_consumption_dc_battery(
+    ac_generation,
+    ac_clipping,
+    inverter_efficiency,
+    inverter_max_output_power_w,
+    load,
+    battery,
+    model,
+):
+    """
+    Calculate the power flow for a self-consumption use case with an
+    AC-connected battery. It assumes the system is connected to the grid.
+
+    Parameters
+    ----------
+    generation : Series
+        The input generation profile. [W]
+    load : Series
+        The input load profile. [W]
+    battery : dict
+        The battery parameters.
+    model : str
+        The battery model to use.
+
+    Returns
+    -------
+    DataFrame
+        The resulting power flow provided by the system, the grid and the
+        battery into the system, grid, battery and load. [W]
+    """
+    df = self_consumption(ac_generation, load)
+    charging = (df["System to grid"] + ac_clipping) / inverter_efficiency
+    discharging = df["Grid to load"]
+    discharging = min(discharging, inverter_max_output_power_w - ac_generation)
+    discharging /= inverter_efficiency
+    dispatch = discharging - charging
+    final_state, results = model(battery, dispatch)
+    df["System to battery"] = -results["Power"].loc[results["Power"] < 0]
+    df["System to battery"] = df["System to battery"].fillna(0.0)
+    df["System to grid"] -= df["System to battery"] * inverter_efficiency
+    df["Battery to load"] = results["Power"].loc[results["Power"] > 0]
+    df["Battery to load"] = df["Battery to load"].fillna(0.0)
+    df["Battery to load"] *= inverter_efficiency
+    df["Grid to load"] -= df["Battery to load"]
+    df["Grid"] = df[["Grid to system", "Grid to load"]].sum(
+        axis=1, skipna=False
+    )
+    return final_state, df
+
+
 def self_consumption_ac_battery_custom_dispatch(
     df, dispatch, battery, model, ac_dc_loss=4, dc_ac_loss=4
 ):
@@ -122,3 +172,50 @@ def self_consumption_ac_battery_custom_dispatch(
         axis=1, skipna=False
     )
     return final_state, df
+
+
+def self_consumption_dc_battery_custom_dispatch(
+    df, dispatch, battery, model, ac_dc_loss=4, dc_ac_loss=4
+):
+    """
+    Calculate the power flow for a self-consumption use case with an
+    AC-connected battery and a custom dispatch series. It assumes the system is
+    connected to the grid.
+
+    Parameters
+    ----------
+    df : DataFrame
+        The self-consumption power flow solution. [W]
+    dispatch : Series
+        The battery model to use.
+    battery : dict
+        The battery parameters.
+    model : str
+        The battery model to use.
+    ac_dc_loss : float
+        The fixed loss when converting AC to DC (i.e.: charging). [%]
+    dc_ac_loss : float
+        The fixed loss when converting DC to AC (i.e.: discharging). [%]
+
+    Returns
+    -------
+    DataFrame
+        The resulting power flow provided by the system, the grid and the
+        battery into the system, grid, battery and load. [W]
+    """
+    final_state, results = model(battery, dispatch)
+    df = df.copy()
+    df["System to battery"] = -results["Power"]
+    df["System to battery"].loc[df["System to battery"] < 0] = 0.0
+    df["System to battery"] = df[["System to battery", "System to grid"]].min(
+        axis=1
+    )
+    df["System to grid"] -= df["System to battery"]
+    df["Battery to load"] = results["Power"]
+    df["Battery to load"].loc[df["Battery to load"] < 0] = 0.0
+    df["Battery to load"] = df[["Battery to load", "Grid to load"]].min(axis=1)
+    df["Grid to load"] -= df["Battery to load"]
+    df["Grid"] = df[["Grid to system", "Grid to load"]].sum(
+        axis=1, skipna=False
+    )
+    return final_state, df

pyproject.toml

@@ -0,0 +1,2 @@
+[tool.black]
+line-length = 79