fix

Author: dylanjm

dependencies.xml

@@ -6,7 +6,9 @@
 
 from dataclasses import dataclass, field
 from abc import ABC
-from typing import Literal, Optional, NewType, Any
+from typing import Literal, Optional
+
+DispatchFlexibility = Literal["independent"] | Literal["fixed"]
 
 
 @dataclass(frozen=True)
@@ -24,14 +26,24 @@ class TransferTerm:
 
 
 @dataclass
-class CashFlow:
+class CashFlow(ABC):
     """ """
     name: str
     reference_price: float
     reference_driver: float = 1.0
     scaling_factor_x: float = 1.0
     price_is_levelized: bool = False
 
+@dataclass
+class Cost(CashFlow):
+    """ """
+    sign: int = -1
+
+@dataclass
+class Revenue(CashFlow):
+    """ """
+    sign: int = +1
+
 
 @dataclass(kw_only=True)
 class Component(ABC):
@@ -41,11 +53,11 @@ class Component(ABC):
     and a single CashFlowGroup which is a container for component associated cashflows.
     """
     name: str
-    capacity_var: Resource
     capacity: float | list[float]
-    capacity_factor: float | list[float] | None = None
-    minimum: float | list[float] | None = None
-    dispatch_flexibility: str = "independent"
+    capacity_factor: Optional[float | list[float]] = None
+    minimum: Optional[float | list[float]] = None
+    capacity_resource: Optional[Resource] = None
+    dispatch_flexibility: Literal["independent", "fixed"] = "independent"
     cashflows: list[CashFlow] = field(default_factory=list)
     transfer_terms: list[TransferTerm] = field(default_factory=list)
     levelized_meta: dict = field(default_factory=dict)
@@ -64,6 +76,8 @@ class Source(Component):
     def __post_init__(self) -> None:
         """ """
         super().__post_init__()
+        if self.capacity_resource is None:
+            self.capacity_resource = self.produces
         self.transfer_terms = [TransferTerm(1.0, {self.produces: 1})]
 
 
@@ -76,6 +90,8 @@ class Sink(Component):
     def __post_init__(self) -> None:
         """ """
         super().__post_init__()
+        if self.capacity_resource is None:
+            self.capacity_resource = self.consumes
         self.transfer_terms = [TransferTerm(-1.0, {self.consumes: 1})]
 
 
@@ -88,6 +104,29 @@ class Converter(Component):
     ramp_freq: int = 0
     tracking_vars: list[str] = field(default_factory=lambda: ["production"])
 
+    def __post_init__(self) -> None:
+        """ """
+        super().__post_init__()
+        extras = {c for c in self.consumes if c != self.produces}
+        if extras and self.capacity_resource is None:
+            raise ValueError(
+                f"Ambiguity in Converter '{self.name}' consumes: {self.consumes} and "
+                f"produces: {self.produces} please set 'capacity_resource'."
+            )
+        if extras and not self.transfer_terms:
+            raise ValueError(f"Converter '{self.name}' consumes {self.consumes} but no transfer terms defined.")
+        
+        # Auto‐adjust the sign of any transfer term that involves capacity_var:
+        for term in self.transfer_terms:
+            # Does this term actually involve our capacity resource?
+            if term.exponent.get(self.capacity_resource, 0) != 0:
+                # If capacity_var is in the consumes list → make coeff negative
+                if self.capacity_resource in self.consumes:
+                    term.coeff = -abs(term.coeff)
+                # Otherwise (it’s a produced resource) → make coeff positive
+                else:
+                    term.coeff = +abs(term.coeff)
+
 
 @dataclass
 class Storage(Component):
@@ -98,5 +137,10 @@ class Storage(Component):
     max_discharge_rate: float = 1.0
     initial_stored: float = 0
     periodic_level: bool = True
-    tracking_vars: list[str] = field(default_factory=lambda: ["level", "charge", "discharge",])
+    tracking_vars: list[str] = field(default_factory=lambda: ["level", "charge", "discharge", ])
 
+    def __post_init__(self) -> None:
+        """ """
+        super().__post_init__()
+        if self.capacity_resource is None:
+            self.capacity_resource = self.resource

doc/README.md docs/README.mddoc/README.md renamed to docs/README.md

@@ -15,12 +15,12 @@ def __init__(self) -> None:
     def build_model(self, system) -> pyo.ConcreteModel:
         """ """
 
-        self._normalize_time_series(system)
-
         m = pyo.ConcreteModel()
 
         self._add_sets(m, system)
 
+        self._add_params(m, system)
+
         self._add_vars(m, system)
 
         self._add_constraints(m, system)
@@ -29,21 +29,71 @@ def build_model(self, system) -> pyo.ConcreteModel:
 
         return cast(pyo.ConcreteModel, m)
 
-    def solve_model(self, model):
+    def solve_model(self, model) -> pyo.ConcreteModel:
         """ """
-        pass
+        opt = pyo.SolverFactory("cbc")
+        opt.solve(model, tee=True, keepfiles=False)
+        return model
 
-    def _normalize_time_series(self, system):
-        pass
 
     def _add_sets(self, m, system):
-        pass
+        m.COMPS = pyo.Set(initialize=list(system.comp_map.keys()), ordered=True)
+        m.RESOURCES = pyo.Set(initialize=list(system.res_map.keys()), ordered=True)
+        m.TIMES = pyo.Set(initialize=system.time_index, ordered=True)
+
+    def _add_params(self, m, system):
+        def _cap_init(m, comp_name, t):
+            comp = system.comp_map[comp_name]
+            return comp.capacity[t]
+        m.capacity = pyo.Param(m.COMPS, m.TIMES, initialize=_cap_init, mutable=False)
+
+        def _min_init(m, comp_name, t):
+            comp = system.comp_map[comp_name]
+            return comp.minimum[t]
+        m.minimum = pyo.Param(m.COMPS, m.TIMES, initialize=_min_init, mutable=False)
+
 
     def _add_vars(self, m, system):
-        pass
+        m.dispatch = pyo.Var(m.COMPS, m.TIMES, within=pyo.NonNegativeReals)
+
 
     def _add_constraints(self, m, system):
-        pass
+        def _cap_rule(m, comp_name, t):
+            return m.dispatch[comp_name, t] <= m.capacity[comp_name, t]
+
+        m.CapacityConstraint = pyo.Constraint(m.COMPS, m.TIMES, rule=_cap_rule)
+
+        def _min_rule(m, comp_name, t):
+            return m.dispatch[comp_name, t] >= m.minimum[comp_name, t]
+        m.MinimumConstraint = pyo.Constraint(m.COMPS, m.TIMES, rule=_min_rule)
+
+        def _flow_rule(m, res_name, t):
+            resource = system.res_map[res_name]
+            expr = None
+            for comp_name in m.COMPS:
+                comp = system.comp_map[comp_name]
+                for term in comp.transfer_terms:
+                    exp = term.exponent.get(resource, 0)
+                    if exp != 0:
+                        term_expr = term.coeff * (m.dispatch[comp_name, t] ** exp)
+                        if expr is None:
+                            expr = term_expr
+                        else:
+                            expr += term_expr
+            if expr is None:
+                expr = pyo.Constraint.Skip
+
+            return expr == 0.0
+
+        m.FlowConstraint = pyo.Constraint(m.RESOURCES, m.TIMES, rule=_flow_rule)
+
 
     def _add_objective(self, m, system):
-        pass
+        expr = 0.0
+        for comp in system.components:
+            for cf in comp.cashflows:
+                for t in m.TIMES:
+                    expr += cf.sign * cf.reference_price[t] * (m.dispatch[comp.name, t] / cf.reference_driver[t]) ** cf.scaling_factor_x[t]
+
+        m.Objective = pyo.Objective(expr=expr, sense=pyo.maximize)
+

src/dove/components.py

@@ -0,0 +1,94 @@
+
+"""
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import pyomo.environ as pyo
+import pandas as pd
+from .components import Resource, TransferTerm, Revenue, Cost, Source, Sink, Converter, Storage
+from .system import System
+
+
+if __name__ == '__main__':
+    elec = Resource("electricity")
+    steam = Resource("steam")
+
+    steamer = Source(
+        name="steamer",
+        produces=steam,
+        capacity=100,
+        dispatch_flexibility="fixed"
+    )
+
+    steam_storage = Storage(
+        name="steam_storage",
+        resource=steam,
+        capacity=100,
+        rte=0.9,
+    )
+
+    gen = Converter(
+        name="generator",
+        capacity_resource=steam,
+        capacity=90,
+        consumes=[steam],
+        produces=elec,
+        transfer_terms=[
+            TransferTerm(1, {steam: 1}),
+            TransferTerm(0.5, {elec: 1})
+        ]
+    )
+
+    linear_price = np.arange(0.1, 2.2, 0.1).tolist() * 2
+    market_linear = Sink(
+        name="market_linear",
+        consumes=elec,
+        capacity=2,
+        cashflows=[Revenue("esales", linear_price)],
+    )
+
+    spike_price = np.zeros(len(linear_price))
+    spike_price.put((0, 11, 20, 28, 29, 38), 10)
+    market_spike = Sink(
+        name="market_spike",
+        consumes=elec,
+        capacity=40,
+        cashflows=[Revenue("esales", spike_price.tolist())],
+    )
+
+    steam_offload = Sink(
+        name="steam_offload",
+        consumes=steam,
+        capacity=100,
+        cashflows=[Revenue("steam_offload", 0.01)],
+    )
+
+    components = [steamer, steam_storage, gen, market_linear, market_spike, steam_offload]
+    resources = [elec, steam]
+    sys = System(components, resources, np.arange(0, len(linear_price)).tolist())
+    model = sys.solve()
+
+    time_index = sys.time_index
+    comp_names = list(sys.comp_map.keys())
+
+    # Extract dispatch into a DataFrame
+    data = {
+        comp: [pyo.value(model.dispatch[comp, t]) for t in time_index]
+        for comp in comp_names
+    }
+    df = pd.DataFrame(data, index=time_index)
+    print(df)
+
+    # Plot the dispatch schedules
+    plt.figure()
+    for comp in comp_names:
+        plt.plot(time_index, df[comp], label=comp)
+    plt.xlabel("Time")
+    plt.ylabel("Dispatch")
+    plt.title("Component Dispatch over Time")
+    plt.legend()
+    plt.show()
+
+
+
+

src/dove/pyomo_model_builder.py

@@ -2,16 +2,35 @@
 # ALL RIGHTS RESERVED
 """ """
 
-from typing import Self
+from typing import Self, Union
+import numpy as np
+import pyomo.environ as pyo
+from .pyomo_model_builder import PyomoModelBuilder
+from .components import Component, Resource
 
+ArrayLike = Union[float, list[float], np.ndarray]
+
+def _broadcast(x: ArrayLike, T: int) -> np.ndarray:
+    """Turn a scalar or length-T list/array into an np.ndarray of length T."""
+    if isinstance(x, (int, float)):
+        return np.full(T, float(x))
+    arr = np.asarray(x, float)
+    if arr.shape == (T,):
+        return arr
+    raise ValueError(f"Expected scalar or length-{T} array, got shape {arr.shape}")
 
 class System:
     """ """
 
-    def __init__(self, components: list, resources: list) -> None:
+    def __init__(self, components, resources, time_index, builder=None) -> None:
         """ """
-        self.components: list = components
-        self.resources: list = resources
+        self.components: list[Component] = components
+        self.resources: list[Resource] = resources
+        self.time_index = time_index
+        self.builder = builder if builder else PyomoModelBuilder()
+        self.comp_map = {comp.name: comp for comp in components}
+        self.res_map = {res.name: res for res in resources}
+        self._normalize_time_series()
 
     def add_component(self, comp) -> Self:
         """ """
@@ -23,10 +42,32 @@ def add_resource(self, res) -> Self:
         self.resources.append(res)
         return self
 
-    def build(self) -> None:
+    def build(self) -> pyo.ConcreteModel:
+        """ """
+        model = self.builder.build_model(self)
+        return model
+
+    def solve(self) -> pyo.ConcreteModel:
         """ """
-        pass
+        model = self.builder.build_model(self)
+        return self.builder.solve_model(model)
 
-    def solve(self) -> None:
+    def _normalize_time_series(self) -> None:
         """ """
-        pass
+        for comp in self.components:
+            comp.capacity = _broadcast(comp.capacity, len(self.time_index))
+
+            if comp.capacity_factor is not None:
+                comp.capacity_factor = _broadcast(comp.capacity_factor, len(self.time_index))
+
+            if comp.dispatch_flexibility == "fixed":
+                comp.minimum = comp.capacity
+            elif comp.minimum is not None:
+                comp.minimum = _broadcast(comp.minimum, len(self.time_index))
+            else:
+                comp.minimum = np.zeros(len(self.time_index), dtype=float)
+
+            for cf in comp.cashflows:
+                cf.reference_price = _broadcast(cf.reference_price, len(self.time_index))
+                cf.reference_driver = _broadcast(cf.reference_driver, len(self.time_index))
+                cf.scaling_factor_x = _broadcast(cf.scaling_factor_x, len(self.time_index))