Add Repo Org and Logistics

Author: dylanjm

.python-version

@@ -0,0 +1 @@
+3.11

README.md

@@ -7,4 +7,4 @@
 
 # Quick-Start
 
-
+# Developers

src/dove/storage_test.py examples/storage_test.pysrc/dove/storage_test.py renamed to examples/storage_test.py

@@ -1,31 +1,28 @@
-
 """
 """
-import numpy as np
 import matplotlib.pyplot as plt
-import pyomo.environ as pyo
+import numpy as np
 import pandas as pd
-from .components import Resource, TransferTerm, Revenue, Cost, Source, Sink, Converter, Storage
-from .system import System
+import pyomo.environ as pyo
 
+from dove.core.components import Converter, Resource, Revenue, Sink, Source, Storage, TransferTerm
+from dove.core.system import System
 
 if __name__ == '__main__':
+
+    ### System Resources
     elec = Resource("electricity")
     steam = Resource("steam")
 
-    steamer = Source(
-        name="steamer",
-        produces=steam,
-        capacity=100,
-        dispatch_flexibility="fixed"
-    )
+    ### Time-Series Profiles
+    linear_price = np.arange(0.1, 2.2, 0.1).tolist() * 2
+    spike_price = np.zeros(len(linear_price))
+    spike_price.put((0, 11, 20, 28, 29, 38), 10)
 
-    steam_storage = Storage(
-        name="steam_storage",
-        resource=steam,
-        capacity=100,
-        rte=0.9,
-    )
+
+    ### Component Definitions
+    steamer = Source(name="steamer", produces=steam, capacity=100, flexibility="fixed")
+    steam_storage = Storage(name="steam_storage", resource=steam, capacity=100, rte=0.9)
 
     gen = Converter(
         name="generator",
@@ -39,16 +36,13 @@
         ]
     )
 
-    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)],
+        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,
@@ -63,31 +57,24 @@
         cashflows=[Revenue("steam_offload", 0.01)],
     )
 
+    ### System Definition
     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()
+    time_index = np.arange(0, len(linear_price)).tolist()
+    sys = System(components, resources, time_index)
+    results = sys.solve()
+
+    print(results)
+
+    # ### Visualize Results
+    # plt.figure()
+    # for comp in system.comp_names:
+    #     plt.plot(time_index, results[comp], label=comp)
+    # plt.xlabel("Time")
+    # plt.ylabel("Dispatch")
+    # plt.title("Component Dispatch over Time")
+    # plt.legend()
+    # plt.show()
 
 
 

pyproject.toml

@@ -1,49 +1,45 @@
 [project]
 name = "dove"
 version = "0.1.0"
-description = "An extensible Python library for modeling multi-commodity energy systmes."
+description = "An extensible Python library for modeling multi-commodity dispatch of energy systems."
 readme = "README.md"
 requires-python = ">=3.11"
-license = { file = "LICENSE" }
-authors = [{name="Dylan McDowell", email="[email protected]"}]
+authors = [
+    { name = "Dylan McDowell", email = "[email protected]" }
+]
 classifiers = [
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python :: 3.11",
     "Topic :: Scientific/Engineering :: Mathematics",
     "Intended Audience :: Science/Research"
  ]
+
+
 dependencies = [
+    "matplotlib>=3.10.1",
     "numpy>=2.2.5",
     "pandas>=2.2.3",
     "pyomo>=6.9.2",
 ]
 
-[dependency-groups]
-dev = [
-    "build>=1.2.2.post1",
-    "pytest>=8.3.5",
-    "ruff>=0.11.8",
-    "twine>=6.1.0",
-]
-
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.uv]
 managed = true
 
-[[tool.uv.index]]
-url = "https://pypi.org/simple"
-default = true
-
 [tool.ruff]
 indent-width = 4
 line-length = 100
 
+[tool.ruff.format]
+indent-style = "space"
+quote-style = "double"
+line-ending = "auto"
+
+
 [tool.ruff.lint]
 select = ["E", "F", "W", "D1"]
 ignore = ["E402", "E501", "W505"]
 
-[format]
-indent-style = "space"

pytest.ini

@@ -9,9 +9,3 @@
 throughout the system.
 """
 
-from .components import Component
-
-
-__all__ = [
-  "Component",
-]

src/dove/__init__.py

@@ -29,9 +29,9 @@ class TransferTerm:
 class CashFlow(ABC):
     """ """
     name: str
-    reference_price: float
-    reference_driver: float = 1.0
-    scaling_factor_x: float = 1.0
+    alpha: float | list[float]
+    dprime: float | list[float] = 1.0
+    scalex: float | list[float] = 1.0
     price_is_levelized: bool = False
 
 @dataclass
@@ -47,20 +47,15 @@ class Revenue(CashFlow):
 
 @dataclass(kw_only=True)
 class Component(ABC):
-    """
-    Represents a system component in the grid analysis. Each component has a
-    single "interaction" that describes what it can do (produce, store, demand)
-    and a single CashFlowGroup which is a container for component associated cashflows.
-    """
+    """ """
     name: str
     capacity: float | list[float]
     capacity_factor: Optional[float | list[float]] = None
     minimum: Optional[float | list[float]] = None
     capacity_resource: Optional[Resource] = None
-    dispatch_flexibility: Literal["independent", "fixed"] = "independent"
+    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)
 
     def __post_init__(self) -> None:
         """ """
@@ -71,7 +66,6 @@ def __post_init__(self) -> None:
 class Source(Component):
     """ """
     produces: Resource
-    tracking_vars: list[str] = field(default_factory=lambda: ["production"])
 
     def __post_init__(self) -> None:
         """ """
@@ -85,7 +79,6 @@ def __post_init__(self) -> None:
 class Sink(Component):
     """ """
     consumes: Resource
-    tracking_vars: list[str] = field(default_factory=lambda: ["production"])
 
     def __post_init__(self) -> None:
         """ """
@@ -102,20 +95,21 @@ class Converter(Component):
     produces: Resource
     ramp_limit: float = 1.0
     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'."
+                f"Ambiguity! Converter '{self.name}' consumes: {self.consumes} and "
+                f"produces: {self.produces} with no 'capacity_resource' defined!"
             )
+        if not extras and self.capacity_resource is None:
+            self.capacity_resource = self.produces
         if extras and not self.transfer_terms:
-            raise ValueError(f"Converter '{self.name}' consumes {self.consumes} but no transfer terms defined.")
-        
+            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?
@@ -137,7 +131,6 @@ 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", ])
 
     def __post_init__(self) -> None:
         """ """

src/dove/core/__init__.py

@@ -3,35 +3,47 @@
 """ """
 
 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
+
+from ..models import BUILDER_REGISTRY
+from .components import Component, Resource, Storage
 
 ArrayLike = Union[float, list[float], np.ndarray]
 
-def _broadcast(x: ArrayLike, T: int) -> np.ndarray:
+
+def _broadcast(x: ArrayLike, T: int) -> list[float]:
     """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))
+        return list(np.full(T, float(x)))
     arr = np.asarray(x, float)
     if arr.shape == (T,):
-        return arr
+        return list(arr)
     raise ValueError(f"Expected scalar or length-{T} array, got shape {arr.shape}")
 
+
 class System:
     """ """
 
-    def __init__(self, components, resources, time_index, builder=None) -> None:
+    def __init__(self, components, resources, time_index) -> None:
         """ """
         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()
 
+    @property
+    def non_storage_comp_names(self) -> list[str]:
+        """ """
+        return [cn for cn in self.comp_map.keys() if not isinstance(self.comp_map[cn], Storage)]
+
+    @property
+    def storage_comp_names(self) -> list[str]:
+        """ """
+        return [cn for cn in self.comp_map.keys() if isinstance(self.comp_map[cn], Storage)]
+
     def add_component(self, comp) -> Self:
         """ """
         self.components.append(comp)
@@ -42,32 +54,43 @@ def add_resource(self, res) -> Self:
         self.resources.append(res)
         return self
 
-    def build(self) -> pyo.ConcreteModel:
+    def build(self):
         """ """
-        model = self.builder.build_model(self)
-        return model
+        raise NotImplementedError("System method 'build()' is not yet implemented!")
 
-    def solve(self) -> pyo.ConcreteModel:
+    def solve(self, model_type: str = "price_taker", **kw):
         """ """
-        model = self.builder.build_model(self)
-        return self.builder.solve_model(model)
+        try:
+            builder_cls = BUILDER_REGISTRY[model_type]
+        except KeyError:
+            raise ValueError(
+                f"Unknown model type: '{model_type}'! Available: {list(BUILDER_REGISTRY)}"
+            )
+
+        builder = builder_cls(self)
+        builder.build()
+        builder.solve()
+        return builder.extract_results()
 
     def _normalize_time_series(self) -> None:
         """ """
+
+        # I guess these are technically all the variables we might expect
+        # to be varying over time?
         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":
+            if comp.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)
+                comp.minimum = np.zeros(len(self.time_index), dtype=float).tolist()
 
             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))
+                cf.alpha = _broadcast(cf.alpha, len(self.time_index))
+                cf.dprime = _broadcast(cf.dprime, len(self.time_index))
+                cf.scalex = _broadcast(cf.scalex, len(self.time_index))