| Name | pyflexad JSON |
| Version |
0.0.3
JSON |
| download |
| home_page | None |
| Summary | Python Flexibility Aggregation and Disaggregation. |
| upload_time | 2024-11-21 20:13:09 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | ~=3.11 |
| license | MIT License
Copyright (c) 2024 Energy Research Centre - FH Vorarlberg University of Applied Sciences
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. |
| keywords |
energy flexibility aggregation
energy storage systems
minkowski sum
optimization
virtual energy storage
virtual power plant
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# PyFlexAD - Python Flexibility Aggregation and Disaggregation
## About
The software package PyFlexAD is designed to apply the vertex-based aggregation of various energy storage devices for optimization purposes.
The software is implemented in the Python 3 programming language and licensed under the MIT license.
The python package is available for download from the Python Project Index (PyPI).
The source code and additional materials can be accessed on [GitHub](https://github.com/rce-fhv/pyflexad).
### Dependencies
The latest version of PyFlexAD requires the installation of at least one mathematical programming solver,
which is supported by the [Pyomo](http://www.pyomo.org/) optimisation modelling library.
We recommend one of the following solvers:
- [CBC](https://projects.coin-or.org/Cbc): open source solver
- [HiGHs](https://highs.dev/): open source solver
- [GLPK](https://www.gnu.org/software/glpk/): open source solver
- [Gurobi](http://www.gurobi.com/): commercial solver, academic license available
## Installation
For installation, it is recommended to create a distinct environment in a conda environment.
### Installation in a Conda environment
```
conda create -n <environment-name> python=3.11
conda activate <environment-name>
pip install pyflexad
```
## Windows
- GLPK: install GLPK with conda: `conda install -c conda-forge glpk`
- CBC: download the cbc zip-file for Windows from [AMPL](https://ampl.com/products/solvers/open-source-solvers/).
Extract the zip-file and copy cbc.exe to the folder of your Python code.
- HiGHS: `conda install -c conda-forge highs`, and `pip install highspy`.
## macOS and Linux
- GLPK: install GLPK with `conda install -c conda-forge glpk`
- CBC: install CBC with `conda install -c conda-forge coincbc`.
- HiGHS: install HiGHS with `conda install -c conda-forge highs` or `pip install highspy`.
## All Platforms
- Gurobi: first get a licence from [Gurobi](http://www.gurobi.com/) then install the gurobi solver.
- GurobiPy: install GurobiPy with `pip install gurobipy`, make sure the licence and gurobi versions are compatible
by enforcing a version with `pip install gurobipy==<version>`,
replace `<version>` with the version of your gurobi license e.g. `pip install gurobipy==10.0.3`.
See also: [How do I install Gurobi for Python?](https://support.gurobi.com/hc/en-us/articles/360044290292-How-do-I-install-Gurobi-for-Python)
## Example usage
```python
import matplotlib.pyplot as plt
import numpy as np
import pyflexad.models.bess.tesla as tesla
from pyflexad.math.signal_vectors import SignalVectors
from pyflexad.optimization.centralized_power_controller import CentralizedPowerController
from pyflexad.optimization.vertex_based_power_controller import VertexBasedPowerController
from pyflexad.physical.stationary_battery import BESSUsage
from pyflexad.physical.stationary_battery import StationaryBattery
from pyflexad.utils.algorithms import Algorithms
from pyflexad.virtual.aggregator import Aggregator
"""settings"""
d = 2 # number of time intervals
dt = 0.25 # interval duration in hours
system_power_demand = np.array([[23.0, 21.0]]) # total power demand for each interval in kW
algorithm = Algorithms.IABVG # virtualization and aggregation algorithm
S_0 = 6.5 # initial battery capacity in kWh
S_f = 5.0 # final battery capacity in kWh
"""instantiate energy storage resources -> 2x Tesla Power Wall 2"""
usage = BESSUsage(initial_capacity=S_0, final_capacity=S_f, d=d, dt=dt)
bess_1 = StationaryBattery.new(hardware=tesla.power_wall_2, usage=usage)
bess_2 = StationaryBattery.new(hardware=tesla.power_wall_2, usage=usage)
"""virtualize"""
direction_vectors = SignalVectors.new(d)
virtual_ess_1 = bess_1.to_virtual(algorithm, direction_vectors)
virtual_ess_2 = bess_2.to_virtual(algorithm, direction_vectors)
"""aggregate"""
aggregator = Aggregator.aggregate([virtual_ess_1, virtual_ess_2], algorithm)
"""optimize power with centralized controller"""
centralized_controller = CentralizedPowerController(system_power_demand)
cc_power = centralized_controller.optimize([bess_1, bess_2])
"""optimize power with vertex-based controller"""
vertex_controller = VertexBasedPowerController(system_power_demand)
vc_power = vertex_controller.optimize(aggregator)
print(f"No Controller: {system_power_demand}")
print(f"Centralized Controller: {system_power_demand + cc_power}")
print(f"Vertex-Based Controller: {system_power_demand + vc_power}")
# %% exact feasibility region
"""virtualize exact"""
virtual_ess_ex_1 = bess_1.to_virtual(Algorithms.EXACT)
virtual_ess_ex_2 = bess_2.to_virtual(Algorithms.EXACT)
"""aggregate exact"""
aggregator_ex = Aggregator.aggregate([virtual_ess_ex_1, virtual_ess_ex_2], Algorithms.EXACT)
"""optimize power with vertex-based controller"""
vc_power_ex = vertex_controller.optimize(aggregator_ex)
# %% plotting
s = 200
"""plot polytopes"""
fig, ax = plt.subplots(figsize=(10, 10))
aggregator_ex.plot_polytope_2d(ax, label="Exact Aggregate Polytope", color='tab:red', line_style='-.')
aggregator.plot_polytope_2d(ax, label="Approx. Aggregate Polytope", color='tab:green', line_style='--')
aggregator_ex.plot_load_profile_2d(ax, label="Centralized / Exact Power Profile", color='tab:red', marker="$E$",
edgecolors=None, s=s)
aggregator.plot_load_profile_2d(ax, label="Approx. Power Profile", color='tab:green', marker="$A$",
edgecolors=None, s=s)
virtual_ess_ex_1.plot_polytope_2d(ax, label="Exact Polytope: BESS 1 & 2", color='tab:red', line_style='-', hatch='//',
fill=True, zorder=2)
virtual_ess_1.plot_polytope_2d(ax, label="Approx. Polytope: BESS 1 & 2", color='tab:green', fill=True, line_style='--')
virtual_ess_ex_1.plot_load_profile_2d(ax, label="Exact Power Profile: BESS 1 & 2", color='tab:red', marker="v", s=s)
virtual_ess_1.plot_load_profile_2d(ax, label="Approx. Power Profile: BESS 1 & 2", color='tab:green', marker="^", s=s)
bess_1.plot_load_profile_2d(ax, label="Centralized Power Profile: BESS 1", color='k', marker="$C_1$", s=s)
bess_2.plot_load_profile_2d(ax, label="Centralized Power Profile: BESS 2", color='k', marker="$C_2$", s=s)
ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))
ax.set_xlabel("$x_1$")
ax.set_ylabel("$x_2$")
ax.set_aspect('equal', adjustable='box')
plt.tight_layout()
plt.show()
```
## Tutorial
The PyFlexAD package comes with several example scripts in the folder
[./scripts](https://github.com/rce-fhv/pyflexad/scripts) on the GitHub repository.
The unit tests can be found in folder [./tests](https://github.com/rce-fhv/pyflexad/tests) on the GitHub repository.
## License
The PyFlexAD package is released by the [Energy Research
Centre](https://www.fhv.at/en/research/energy) of the
[University of Applied Sciences Vorarlberg](https://www.fhv.at/en) under the [MIT License](https://opensource.org/licenses/MIT).
## Related Literature
- [1] E. Öztürk, K. Kaspar, T. Faulwasser, K. Worthmann, P. Kepplinger, and K. Rheinberger, “Towards Efficient Aggregation of Storage Flexibilities in Power Grids,” Mar. 29, 2024, arXiv: arXiv:2403.20104. Accessed: Apr. 02, 2024. [Online]. Available: http://arxiv.org/abs/2403.20104
- [2] E. Öztürk, T. Faulwasser, K. Worthmann, M. Preißinger, and K. Rheinberger, “Alleviating the Curse of Dimensionality in Minkowski Sum Approximations of Storage Flexibility,” Feb. 28, 2024, arXiv: arXiv:2311.01614. Accessed: Mar. 08, 2024. [Online]. Available: http://arxiv.org/abs/2311.01614
- [3] E. Öztürk, K. Rheinberger, T. Faulwasser, K. Worthmann, and M. Preißinger, “Aggregation of Demand-Side Flexibilities: A Comparative Study of Approximation Algorithms,” Energies, vol. 15, no. 7, p. 2501, Mar. 2022, doi: 10.3390/en15072501.
## Further Information
### Energy Storage and Subclasses
The package supports multiple types of energy storage systems, including BESS’s, TCL’s, EV’s and PHES’s.
These models extend the general EnergyStorage class.
The package focuses on modeling energy storage systems and does not include energy resources without storage properties.
Inflexible/non-steerable loads are either included as power demand of the devices (e.g. EV’s or TCLH’s)
or must be managed by the optimizing entity alongside the energy storage systems.
In order to calculate the general parameters of an energy storing system hardware and usage parameters must be provided.
Each subclass of EnergyStorage requires a specific set of parameters
e.g. to instantiate the class StationaryBattery instances of BESSHardware and BESSUsage are required.
For ease of use, the package already includes a sample of hardware parameters for models from BESS manufacturers
like Tesla and GENERAC, of EV manufactures like Tesla, Nissan and Renault for EV models,
and generic air conditioning and water heaters for TCL models.
### Abstraction via Virtualization
A fundamental concept in the PyFlexAD package is the virtualization of energy storage systems.
This involves abstracting individual physical energy storages into virtual representations,
which encapsulate the essential characteristics of the physical devices.
The virtualization process begins with the calculation of polytope extreme actions
to delineate the feasible operation regions of energy storage systems.
Polytope vertices of energy storages can be approximated effectively
using the inner-approximation by vertex-generation algorithm (IABVG) and a set of direction vectors J.
This approximation of vertices to extreme actions is crucial
since the calculation of exact vertices becomes computationally intractable with increasing dimensions.
By utilizing extreme actions, the computational effort required for flexibility optimization is significantly reduced.
Moreover, calculating the extreme actions can be parallelized for each energy storage device,
further decreasing the computational load on the optimization entity.
### Flexibility Provision via Aggregation
To describe the collective flexibility of virtual energy storages, their corresponding extreme actions are summed,
resulting in an aggregate virtual energy storage.
This aggregated virtual energy storage can be controlled like a virtual power plant
and enables the optimization entity to optimize power profiles across the entire system.
Raw data
{
"_id": null,
"home_page": null,
"name": "pyflexad",
"maintainer": null,
"docs_url": null,
"requires_python": "~=3.11",
"maintainer_email": null,
"keywords": "energy flexibility aggregation, energy storage systems, minkowski sum, optimization, virtual energy storage, virtual power plant",
"author": null,
"author_email": "Kevin Kaspar <kevin.kaspar@fhv.at>, Emrah \u00d6zt\u00fcrk <emrah.oeztuerk@fhv.at>",
"download_url": "https://files.pythonhosted.org/packages/2e/8c/451afe6895633f807a1e5ca980cfdb7d028fc823ee1137672a894b73f5e3/pyflexad-0.0.3.tar.gz",
"platform": null,
"description": "# PyFlexAD - Python Flexibility Aggregation and Disaggregation\n\n## About\n\nThe software package PyFlexAD is designed to apply the vertex-based aggregation of various energy storage devices for optimization purposes. \nThe software is implemented in the Python 3 programming language and licensed under the MIT license. \nThe python package is available for download from the Python Project Index (PyPI). \nThe source code and additional materials can be accessed on [GitHub](https://github.com/rce-fhv/pyflexad).\n\n### Dependencies\n\nThe latest version of PyFlexAD requires the installation of at least one mathematical programming solver, \nwhich is supported by the [Pyomo](http://www.pyomo.org/) optimisation modelling library.\n\nWe recommend one of the following solvers:\n\n- [CBC](https://projects.coin-or.org/Cbc): open source solver\n- [HiGHs](https://highs.dev/): open source solver\n- [GLPK](https://www.gnu.org/software/glpk/): open source solver\n- [Gurobi](http://www.gurobi.com/): commercial solver, academic license available\n\n## Installation\n\nFor installation, it is recommended to create a distinct environment in a conda environment.\n\n### Installation in a Conda environment\n\n```\nconda create -n <environment-name> python=3.11\nconda activate <environment-name>\npip install pyflexad\n```\n\n## Windows\n\n- GLPK: install GLPK with conda: `conda install -c conda-forge glpk`\n- CBC: download the cbc zip-file for Windows from [AMPL](https://ampl.com/products/solvers/open-source-solvers/). \nExtract the zip-file and copy cbc.exe to the folder of your Python code. \n- HiGHS: `conda install -c conda-forge highs`, and `pip install highspy`.\n\n## macOS and Linux\n\n- GLPK: install GLPK with `conda install -c conda-forge glpk`\n- CBC: install CBC with `conda install -c conda-forge coincbc`.\n- HiGHS: install HiGHS with `conda install -c conda-forge highs` or `pip install highspy`.\n\n## All Platforms\n\n- Gurobi: first get a licence from [Gurobi](http://www.gurobi.com/) then install the gurobi solver.\n- GurobiPy: install GurobiPy with `pip install gurobipy`, make sure the licence and gurobi versions are compatible \nby enforcing a version with `pip install gurobipy==<version>`,\nreplace `<version>` with the version of your gurobi license e.g. `pip install gurobipy==10.0.3`. \nSee also: [How do I install Gurobi for Python?](https://support.gurobi.com/hc/en-us/articles/360044290292-How-do-I-install-Gurobi-for-Python)\n\n## Example usage\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nimport pyflexad.models.bess.tesla as tesla\nfrom pyflexad.math.signal_vectors import SignalVectors\nfrom pyflexad.optimization.centralized_power_controller import CentralizedPowerController\nfrom pyflexad.optimization.vertex_based_power_controller import VertexBasedPowerController\nfrom pyflexad.physical.stationary_battery import BESSUsage\nfrom pyflexad.physical.stationary_battery import StationaryBattery\nfrom pyflexad.utils.algorithms import Algorithms\nfrom pyflexad.virtual.aggregator import Aggregator\n\n\"\"\"settings\"\"\"\nd = 2 # number of time intervals\ndt = 0.25 # interval duration in hours\nsystem_power_demand = np.array([[23.0, 21.0]]) # total power demand for each interval in kW\nalgorithm = Algorithms.IABVG # virtualization and aggregation algorithm\nS_0 = 6.5 # initial battery capacity in kWh\nS_f = 5.0 # final battery capacity in kWh\n\n\"\"\"instantiate energy storage resources -> 2x Tesla Power Wall 2\"\"\"\nusage = BESSUsage(initial_capacity=S_0, final_capacity=S_f, d=d, dt=dt)\nbess_1 = StationaryBattery.new(hardware=tesla.power_wall_2, usage=usage)\nbess_2 = StationaryBattery.new(hardware=tesla.power_wall_2, usage=usage)\n\n\"\"\"virtualize\"\"\"\ndirection_vectors = SignalVectors.new(d)\nvirtual_ess_1 = bess_1.to_virtual(algorithm, direction_vectors)\nvirtual_ess_2 = bess_2.to_virtual(algorithm, direction_vectors)\n\n\"\"\"aggregate\"\"\"\naggregator = Aggregator.aggregate([virtual_ess_1, virtual_ess_2], algorithm)\n\n\"\"\"optimize power with centralized controller\"\"\"\ncentralized_controller = CentralizedPowerController(system_power_demand)\ncc_power = centralized_controller.optimize([bess_1, bess_2])\n\n\"\"\"optimize power with vertex-based controller\"\"\"\nvertex_controller = VertexBasedPowerController(system_power_demand)\nvc_power = vertex_controller.optimize(aggregator)\n\nprint(f\"No Controller: {system_power_demand}\")\nprint(f\"Centralized Controller: {system_power_demand + cc_power}\")\nprint(f\"Vertex-Based Controller: {system_power_demand + vc_power}\")\n\n# %% exact feasibility region\n\"\"\"virtualize exact\"\"\"\nvirtual_ess_ex_1 = bess_1.to_virtual(Algorithms.EXACT)\nvirtual_ess_ex_2 = bess_2.to_virtual(Algorithms.EXACT)\n\n\"\"\"aggregate exact\"\"\"\naggregator_ex = Aggregator.aggregate([virtual_ess_ex_1, virtual_ess_ex_2], Algorithms.EXACT)\n\n\"\"\"optimize power with vertex-based controller\"\"\"\nvc_power_ex = vertex_controller.optimize(aggregator_ex)\n\n# %% plotting\ns = 200\n\n\"\"\"plot polytopes\"\"\"\nfig, ax = plt.subplots(figsize=(10, 10))\n\naggregator_ex.plot_polytope_2d(ax, label=\"Exact Aggregate Polytope\", color='tab:red', line_style='-.')\naggregator.plot_polytope_2d(ax, label=\"Approx. Aggregate Polytope\", color='tab:green', line_style='--')\n\naggregator_ex.plot_load_profile_2d(ax, label=\"Centralized / Exact Power Profile\", color='tab:red', marker=\"$E$\",\n edgecolors=None, s=s)\naggregator.plot_load_profile_2d(ax, label=\"Approx. Power Profile\", color='tab:green', marker=\"$A$\",\n edgecolors=None, s=s)\n\nvirtual_ess_ex_1.plot_polytope_2d(ax, label=\"Exact Polytope: BESS 1 & 2\", color='tab:red', line_style='-', hatch='//',\n fill=True, zorder=2)\nvirtual_ess_1.plot_polytope_2d(ax, label=\"Approx. Polytope: BESS 1 & 2\", color='tab:green', fill=True, line_style='--')\n\nvirtual_ess_ex_1.plot_load_profile_2d(ax, label=\"Exact Power Profile: BESS 1 & 2\", color='tab:red', marker=\"v\", s=s)\nvirtual_ess_1.plot_load_profile_2d(ax, label=\"Approx. Power Profile: BESS 1 & 2\", color='tab:green', marker=\"^\", s=s)\n\nbess_1.plot_load_profile_2d(ax, label=\"Centralized Power Profile: BESS 1\", color='k', marker=\"$C_1$\", s=s)\nbess_2.plot_load_profile_2d(ax, label=\"Centralized Power Profile: BESS 2\", color='k', marker=\"$C_2$\", s=s)\n\nax.legend(loc='center left', bbox_to_anchor=(1, 0.5))\nax.set_xlabel(\"$x_1$\")\nax.set_ylabel(\"$x_2$\")\nax.set_aspect('equal', adjustable='box')\n\nplt.tight_layout()\nplt.show()\n```\n\n## Tutorial\n\nThe PyFlexAD package comes with several example scripts in the folder \n[./scripts](https://github.com/rce-fhv/pyflexad/scripts) on the GitHub repository.\n\nThe unit tests can be found in folder [./tests](https://github.com/rce-fhv/pyflexad/tests) on the GitHub repository.\n\n## License\n\nThe PyFlexAD package is released by the [Energy Research \nCentre](https://www.fhv.at/en/research/energy) of the \n[University of Applied Sciences Vorarlberg](https://www.fhv.at/en) under the [MIT License](https://opensource.org/licenses/MIT).\n\n## Related Literature\n\n- [1] E. \u00d6zt\u00fcrk, K. Kaspar, T. Faulwasser, K. Worthmann, P. Kepplinger, and K. Rheinberger, \u201cTowards Efficient Aggregation of Storage Flexibilities in Power Grids,\u201d Mar. 29, 2024, arXiv: arXiv:2403.20104. Accessed: Apr. 02, 2024. [Online]. Available: http://arxiv.org/abs/2403.20104\n- [2] E. \u00d6zt\u00fcrk, T. Faulwasser, K. Worthmann, M. Prei\u00dfinger, and K. Rheinberger, \u201cAlleviating the Curse of Dimensionality in Minkowski Sum Approximations of Storage Flexibility,\u201d Feb. 28, 2024, arXiv: arXiv:2311.01614. Accessed: Mar. 08, 2024. [Online]. Available: http://arxiv.org/abs/2311.01614\n- [3] E. \u00d6zt\u00fcrk, K. Rheinberger, T. Faulwasser, K. Worthmann, and M. Prei\u00dfinger, \u201cAggregation of Demand-Side Flexibilities: A Comparative Study of Approximation Algorithms,\u201d Energies, vol. 15, no. 7, p. 2501, Mar. 2022, doi: 10.3390/en15072501.\n\n## Further Information\n\n### Energy Storage and Subclasses\n\nThe package supports multiple types of energy storage systems, including BESS\u2019s, TCL\u2019s, EV\u2019s and PHES\u2019s. \nThese models extend the general EnergyStorage class. \nThe package focuses on modeling energy storage systems and does not include energy resources without storage properties. \nInflexible/non-steerable loads are either included as power demand of the devices (e.g. EV\u2019s or TCLH\u2019s) \nor must be managed by the optimizing entity alongside the energy storage systems. \nIn order to calculate the general parameters of an energy storing system hardware and usage parameters must be provided. \nEach subclass of EnergyStorage requires a specific set of parameters \ne.g. to instantiate the class StationaryBattery instances of BESSHardware and BESSUsage are required. \nFor ease of use, the package already includes a sample of hardware parameters for models from BESS manufacturers \nlike Tesla and GENERAC, of EV manufactures like Tesla, Nissan and Renault for EV models, \nand generic air conditioning and water heaters for TCL models.\n\n### Abstraction via Virtualization\n\nA fundamental concept in the PyFlexAD package is the virtualization of energy storage systems. \nThis involves abstracting individual physical energy storages into virtual representations, \nwhich encapsulate the essential characteristics of the physical devices. \nThe virtualization process begins with the calculation of polytope extreme actions \nto delineate the feasible operation regions of energy storage systems. \nPolytope vertices of energy storages can be approximated effectively \nusing the inner-approximation by vertex-generation algorithm (IABVG) and a set of direction vectors J. \nThis approximation of vertices to extreme actions is crucial \nsince the calculation of exact vertices becomes computationally intractable with increasing dimensions.\nBy utilizing extreme actions, the computational effort required for flexibility optimization is significantly reduced. \nMoreover, calculating the extreme actions can be parallelized for each energy storage device, \nfurther decreasing the computational load on the optimization entity.\n\n\n### Flexibility Provision via Aggregation\n\nTo describe the collective flexibility of virtual energy storages, their corresponding extreme actions are summed, \nresulting in an aggregate virtual energy storage. \nThis aggregated virtual energy storage can be controlled like a virtual power plant \nand enables the optimization entity to optimize power profiles across the entire system.",
"bugtrack_url": null,
"license": "MIT License\n \n Copyright (c) 2024 Energy Research Centre - FH Vorarlberg University of Applied Sciences\n \n Permission is hereby granted, free of charge, to any person obtaining a copy\n of this software and associated documentation files (the \"Software\"), to deal\n in the Software without restriction, including without limitation the rights\n to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n copies of the Software, and to permit persons to whom the Software is\n furnished to do so, subject to the following conditions:\n \n The above copyright notice and this permission notice shall be included in all\n copies or substantial portions of the Software.\n \n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n SOFTWARE.",
"summary": "Python Flexibility Aggregation and Disaggregation. ",
"version": "0.0.3",
"project_urls": {
"Homepage": "https://github.com/rce-fhv/pyflexad",
"Source": "https://github.com/rce-fhv/pyflexad"
},
"split_keywords": [
"energy flexibility aggregation",
" energy storage systems",
" minkowski sum",
" optimization",
" virtual energy storage",
" virtual power plant"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "13a2af42eb3c2f560754d0fec01c6ff38419495db2199d3f63d552641a3ab9b2",
"md5": "5933a708e7e3fceed1b9017545d62d44",
"sha256": "2e683e8082a1c410ab8137568da6e69e6b6d16e8f74487bb86779d19550ca16b"
},
"downloads": -1,
"filename": "pyflexad-0.0.3-py3-none-any.whl",
"has_sig": false,
"md5_digest": "5933a708e7e3fceed1b9017545d62d44",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": "~=3.11",
"size": 53814,
"upload_time": "2024-11-21T20:13:07",
"upload_time_iso_8601": "2024-11-21T20:13:07.303543Z",
"url": "https://files.pythonhosted.org/packages/13/a2/af42eb3c2f560754d0fec01c6ff38419495db2199d3f63d552641a3ab9b2/pyflexad-0.0.3-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "2e8c451afe6895633f807a1e5ca980cfdb7d028fc823ee1137672a894b73f5e3",
"md5": "27465462ad57971e7c4116403f2787c2",
"sha256": "e2a5ba3f4ffe33e8a496e71e94341b1431dd4fe4ca7d92555574cd74fe46d621"
},
"downloads": -1,
"filename": "pyflexad-0.0.3.tar.gz",
"has_sig": false,
"md5_digest": "27465462ad57971e7c4116403f2787c2",
"packagetype": "sdist",
"python_version": "source",
"requires_python": "~=3.11",
"size": 48107,
"upload_time": "2024-11-21T20:13:09",
"upload_time_iso_8601": "2024-11-21T20:13:09.391535Z",
"url": "https://files.pythonhosted.org/packages/2e/8c/451afe6895633f807a1e5ca980cfdb7d028fc823ee1137672a894b73f5e3/pyflexad-0.0.3.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-11-21 20:13:09",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "rce-fhv",
"github_project": "pyflexad",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "pyflexad"
}
