RunFeemsSim 0.2.2__tar.gz

RunFeemsSim-0.2.2/CONTRIBUTING.md

@@ -0,0 +1,33 @@
+# How to contribute
+
+## How to get started
+
+Before anything else, please install the git hooks that run automatic scripts during each commit and merge to strip the notebooks of superfluous metadata (and avoid merge conflicts). After cloning the repository, run the following command inside it:
+```
+nbdev_install_git_hooks
+```
+
+## Did you find a bug?
+
+* Ensure the bug was not already reported by searching on GitHub under Issues.
+* If you're unable to find an open issue addressing the problem, open a new one. Be sure to include a title and clear description, as much relevant information as possible, and a code sample or an executable test case demonstrating the expected behavior that is not occurring.
+* Be sure to add the complete error messages.
+
+#### Did you write a patch that fixes a bug?
+
+* Open a new GitHub pull request with the patch.
+* Ensure that your PR includes a test that fails without your patch, and pass with it.
+* Ensure the PR description clearly describes the problem and solution. Include the relevant issue number if applicable.
+
+## PR submission guidelines
+
+* Keep each PR focused. While it's more convenient, do not combine several unrelated fixes together. Create as many branches as needing to keep each PR focused.
+* Do not mix style changes/fixes with "functional" changes. It's very difficult to review such PRs and it most likely get rejected.
+* Do not add/remove vertical whitespace. Preserve the original style of the file you edit as much as you can.
+* Do not turn an already submitted PR into your development playground. If after you submitted PR, you discovered that more work is needed - close the PR, do the required work and then submit a new PR. Otherwise each of your commits requires attention from maintainers of the project.
+* If, however, you submitted a PR and received a request for changes, you should proceed with commits inside that PR, so that the maintainer can see the incremental fixes and won't need to review the whole PR again. In the exception case where you realize it'll take many many commits to complete the requests, then it's probably best to close the PR, do the work and then submit it again. Use common sense where you'd choose one way over another.
+
+## Do you want to contribute to the documentation?
+
+* Docs are automatically created from the notebooks in the nbs folder.
+

RunFeemsSim-0.2.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 SINTEF
+
+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.

RunFeemsSim-0.2.2/MANIFEST.in

@@ -0,0 +1,5 @@
+include settings.ini
+include LICENSE
+include CONTRIBUTING.md
+include README.md
+recursive-exclude * __pycache__

RunFeemsSim-0.2.2/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.1
+Name: RunFeemsSim
+Version: 0.2.2
+Summary: A library for running feems simulation
+Home-page: https://SintefOceanEnergySystem@dev.azure.com/SintefOceanEnergySystem/FEEMSService/_git/RunFEEMSSim
+Author: Kevin Koosup Yum
+Author-email: kevinkoosup.yum@sintef.no
+License: Apache Software License 2.0
+Keywords: FEEMS,machinery system,fuel,emissions
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pip
+Requires-Dist: packaging
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: MachSysS
+Provides-Extra: dev
+
+# RunFeemsSim Package
+
+> The RunFeemsSim package is a Python package for running FEEMS simulations. It provides a simple 
+> interface for running FEEMS simulations and for visualizing the results. It also provides a basic 
+> pms model to apply for an electric power system that has a functionality of load dependent 
+> start-stop of gensets.
+
+## Installation of the package
+The package is distributed by the Azure Artifacts package manager. To install the package, 
+you need to install artifacts-keyring package and should have a valid Azure DevOps account. 
+```sh
+pip install artifacts-keyring
+```
+Then, you need to add the package source to your pip configuration. You can do this by copying 
+the pip configuration file (pip.conf for macOS and Linux or pip.ini for Windows) to your 
+virtual environment directory or base python directory. The file should contain the following lines:
+```sh
+[global]
+extra-index-url=https://pkgs.dev.azure.com/SintefOceanEnergySystem/_packaging/SintefOceanEnergySystem/pypi/simple/
+```
+If you already have a pip configuration file, you can add the above lines to the file. Finally, 
+you can install the package by running the following command:
+```sh
+pip install RunFeemsSim
+```
+ 
+## Installation of the development environment
+For the development, one should create a virtual environment and install the package using the 
+requirements.txt file. First, create a virtual environment and activate it. 
+```sh 
+python -m venv venv
+source venv/bin/activate
+```
+Then, you need to add the package source to your pip configuration. You can do this by copying 
+the pip configuration file (pip.conf for macOS and Linux or pip.ini for Windows) to your venv 
+directory or base python directory. The file should contain the following lines:
+```sh
+[global]
+extra-index-url=https://pkgs.dev.azure.com/SintefOceanEnergySystem/_packaging/SintefOceanEnergySystem/pypi/simple/
+```
+
+Then, install the package using the requirements.txt file.
+```sh
+pip install -r requirements.txt
+```
+
+## Usage
+
+

RunFeemsSim-0.2.2/README.md

@@ -0,0 +1,49 @@
+# RunFeemsSim Package
+
+> The RunFeemsSim package is a Python package for running FEEMS simulations. It provides a simple 
+> interface for running FEEMS simulations and for visualizing the results. It also provides a basic 
+> pms model to apply for an electric power system that has a functionality of load dependent 
+> start-stop of gensets.
+
+## Installation of the package
+The package is distributed by the Azure Artifacts package manager. To install the package, 
+you need to install artifacts-keyring package and should have a valid Azure DevOps account. 
+```sh
+pip install artifacts-keyring
+```
+Then, you need to add the package source to your pip configuration. You can do this by copying 
+the pip configuration file (pip.conf for macOS and Linux or pip.ini for Windows) to your 
+virtual environment directory or base python directory. The file should contain the following lines:
+```sh
+[global]
+extra-index-url=https://pkgs.dev.azure.com/SintefOceanEnergySystem/_packaging/SintefOceanEnergySystem/pypi/simple/
+```
+If you already have a pip configuration file, you can add the above lines to the file. Finally, 
+you can install the package by running the following command:
+```sh
+pip install RunFeemsSim
+```
+ 
+## Installation of the development environment
+For the development, one should create a virtual environment and install the package using the 
+requirements.txt file. First, create a virtual environment and activate it. 
+```sh 
+python -m venv venv
+source venv/bin/activate
+```
+Then, you need to add the package source to your pip configuration. You can do this by copying 
+the pip configuration file (pip.conf for macOS and Linux or pip.ini for Windows) to your venv 
+directory or base python directory. The file should contain the following lines:
+```sh
+[global]
+extra-index-url=https://pkgs.dev.azure.com/SintefOceanEnergySystem/_packaging/SintefOceanEnergySystem/pypi/simple/
+```
+
+Then, install the package using the requirements.txt file.
+```sh
+pip install -r requirements.txt
+```
+
+## Usage
+
+

RunFeemsSim-0.2.2/RunFeemsSim/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.2"

RunFeemsSim-0.2.2/RunFeemsSim/_modidx.py

@@ -0,0 +1,117 @@
+# Autogenerated by nbdev
+
+d = {
+    "settings": {
+        "branch": "master",
+        "doc_baseurl": "/RunFeemsSim/",
+        "doc_host": "https://kevinkoosup.yum@sintef.no.github.io",
+        "git_url": "https://SintefOceanEnergySystem@dev.azure.com/SintefOceanEnergySystem/FEEMSService/_git/RunFEEMSSim",
+        "lib_path": "RunFeemsSim",
+    },
+    "syms": {
+        "RunFeemsSim.machinery_calculation": {
+            "RunFeemsSim.machinery_calculation.MachineryCalculation": (
+                "machinery_calculation.html#machinerycalculation",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+            "RunFeemsSim.machinery_calculation.MachineryCalculation.__init__": (
+                "machinery_calculation.html#machinerycalculation.__init__",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+            "RunFeemsSim.machinery_calculation.MachineryCalculation._run_simulation": (
+                "machinery_calculation.html#machinerycalculation._run_simulation",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+            "RunFeemsSim.machinery_calculation.MachineryCalculation._set_equal_load_sharing_on_power_sources": (
+                "machinery_calculation.html#machinerycalculation._set_equal_load_sharing_on_power_sources",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+            "RunFeemsSim.machinery_calculation.MachineryCalculation._set_input_load_from_gymir_result": (
+                "machinery_calculation.html#machinerycalculation._set_input_load_from_gymir_result",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+            "RunFeemsSim.machinery_calculation.MachineryCalculation._set_input_load_time_interval_from_propulsion_power_time_series": (
+                "machinery_calculation.html#machinerycalculation._set_input_load_time_interval_from_propulsion_power_time_series",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+            "RunFeemsSim.machinery_calculation.MachineryCalculation._set_status_for_mechanical_system": (
+                "machinery_calculation.html#machinerycalculation._set_status_for_mechanical_system",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+            "RunFeemsSim.machinery_calculation.MachineryCalculation.calculate_machinery_system_output_from_gymir_result": (
+                "machinery_calculation.html#machinerycalculation.calculate_machinery_system_output_from_gymir_result",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+            "RunFeemsSim.machinery_calculation.MachineryCalculation.calculate_machinery_system_output_from_propulsion_power_time_series": (
+                "machinery_calculation.html#machinerycalculation.calculate_machinery_system_output_from_propulsion_power_time_series",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+            "RunFeemsSim.machinery_calculation.MachineryCalculation.calculate_machinery_system_output_from_statistics": (
+                "machinery_calculation.html#machinerycalculation.calculate_machinery_system_output_from_statistics",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+            "RunFeemsSim.machinery_calculation.MachineryCalculation.calculate_machinery_system_output_from_time_series_result": (
+                "machinery_calculation.html#machinerycalculation.calculate_machinery_system_output_from_time_series_result",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+            "RunFeemsSim.machinery_calculation.MachineryCalculation.electric_system": (
+                "machinery_calculation.html#machinerycalculation.electric_system",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+            "RunFeemsSim.machinery_calculation.MachineryCalculation.system_is_not_electric": (
+                "machinery_calculation.html#machinerycalculation.system_is_not_electric",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+            "RunFeemsSim.machinery_calculation.convert_gymir_result_to_propulsion_power_series": (
+                "machinery_calculation.html#convert_gymir_result_to_propulsion_power_series",
+                "RunFeemsSim/machinery_calculation.py",
+            ),
+        },
+        "RunFeemsSim.pms_basic": {
+            "RunFeemsSim.pms_basic.PmsLoadTable": (
+                "pms_basic.html#pmsloadtable",
+                "RunFeemsSim/pms_basic.py",
+            ),
+            "RunFeemsSim.pms_basic.PmsLoadTable.__post_init__": (
+                "pms_basic.html#pmsloadtable.__post_init__",
+                "RunFeemsSim/pms_basic.py",
+            ),
+            "RunFeemsSim.pms_basic.PmsLoadTable.on_pattern": (
+                "pms_basic.html#pmsloadtable.on_pattern",
+                "RunFeemsSim/pms_basic.py",
+            ),
+            "RunFeemsSim.pms_basic.PmsLoadTable.sorted_load_table": (
+                "pms_basic.html#pmsloadtable.sorted_load_table",
+                "RunFeemsSim/pms_basic.py",
+            ),
+            "RunFeemsSim.pms_basic.PmsLoadTableSimulationInterface": (
+                "pms_basic.html#pmsloadtablesimulationinterface",
+                "RunFeemsSim/pms_basic.py",
+            ),
+            "RunFeemsSim.pms_basic.PmsLoadTableSimulationInterface.__init__": (
+                "pms_basic.html#pmsloadtablesimulationinterface.__init__",
+                "RunFeemsSim/pms_basic.py",
+            ),
+            "RunFeemsSim.pms_basic.PmsLoadTableSimulationInterface.set_status": (
+                "pms_basic.html#pmsloadtablesimulationinterface.set_status",
+                "RunFeemsSim/pms_basic.py",
+            ),
+            "RunFeemsSim.pms_basic.get_min_load_table_dict_from_feems_system": (
+                "pms_basic.html#get_min_load_table_dict_from_feems_system",
+                "RunFeemsSim/pms_basic.py",
+            ),
+            "RunFeemsSim.pms_basic.get_min_load_table_dict_from_proto_system": (
+                "pms_basic.html#get_min_load_table_dict_from_proto_system",
+                "RunFeemsSim/pms_basic.py",
+            ),
+            "RunFeemsSim.pms_basic.get_rated_power_from_power_source": (
+                "pms_basic.html#get_rated_power_from_power_source",
+                "RunFeemsSim/pms_basic.py",
+            ),
+            "RunFeemsSim.pms_basic.min_load_table_dict": (
+                "pms_basic.html#min_load_table_dict",
+                "RunFeemsSim/pms_basic.py",
+            ),
+        },
+    },
+}

RunFeemsSim-0.2.2/RunFeemsSim/_nbdev.py

@@ -0,0 +1,26 @@
+# AUTOGENERATED BY NBDEV! DO NOT EDIT!
+
+__all__ = ["index", "modules", "custom_doc_links", "git_url"]
+
+index = {
+    "convert_gymir_result_to_propulsion_power_series": "00_machinery_calculation.ipynb",
+    "MachineryCalculation": "00_machinery_calculation.ipynb",
+    "PmsLoadTable": "01_pms_basic.ipynb",
+    "get_rated_power_from_power_source": "01_pms_basic.ipynb",
+    "get_min_load_table_dict_from_proto_system": "01_pms_basic.ipynb",
+    "get_min_load_table_dict_from_feems_system": "01_pms_basic.ipynb",
+    "min_load_table_dict": "01_pms_basic.ipynb",
+    "PmsLoadTableSimulationInterface": "01_pms_basic.ipynb",
+    "OnPattern": "01_pms_basic.ipynb",
+    "Load2OnPattern": "01_pms_basic.ipynb",
+}
+
+modules = ["machinery_calculation.py", "pms_basic.py"]
+
+doc_url = "https://kevinkoosup.yum@sintef.no.github.io/RunFeemsSim/"
+
+git_url = "https://"
+
+
+def custom_doc_links(name):
+    return None

RunFeemsSim-0.2.2/RunFeemsSim/machinery_calculation.py

@@ -0,0 +1,341 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../00_machinery_calculation.ipynb.
+
+# %% auto 0
+__all__ = [
+    "Numeric",
+    "convert_gymir_result_to_propulsion_power_series",
+    "MachineryCalculation",
+]
+
+# %% ../00_machinery_calculation.ipynb 3
+from typing import List, Union, Type, TypeVar
+
+import MachSysS.gymir_result_pb2 as proto_gymir
+from MachSysS.convert_proto_timeseries import convert_proto_timeseries_to_pd_dataframe
+import numpy as np
+import pandas as pd
+from feems.components_model.utility import IntegrationMethod
+from feems.system_model import (
+    ElectricPowerSystem,
+    HybridPropulsionSystem,
+    MechanicalPropulsionSystemWithElectricPowerSystem,
+    FEEMSResultForMachinerySystem,
+)
+from feems.types_for_feems import FEEMSResult, TypePower
+from feems.simulation_interface import SimulationInterface
+from feems.fuel import FuelSpecifiedBy
+
+from RunFeemsSim.pms_basic import (
+    PmsLoadTable,
+    get_min_load_table_dict_from_feems_system,
+    PmsLoadTableSimulationInterface,
+)
+
+Numeric = TypeVar("Numeric", int, float, np.ndarray)
+
+
+def convert_gymir_result_to_propulsion_power_series(
+    gymir_result: proto_gymir.GymirResult,
+) -> pd.Series:
+    time = map(lambda each: each.epoch_s, gymir_result.result)
+    power = map(lambda each: each.power_kw, gymir_result.result)
+    return pd.Series(index=time, data=power)
+
+
+class MachineryCalculation:
+    def __init__(
+        self,
+        feems_system: Union[
+            ElectricPowerSystem,
+            MechanicalPropulsionSystemWithElectricPowerSystem,
+            HybridPropulsionSystem,
+        ],
+        pms: SimulationInterface = None,
+        maximum_allowed_power_source_load_percentage: float = 80,
+    ):
+        self.system_feems = feems_system
+        if pms is None:
+            load_table = PmsLoadTable(
+                min_load2on_pattern=get_min_load_table_dict_from_feems_system(
+                    system=feems_system,
+                    maximum_allowed_genset_load_percentage=maximum_allowed_power_source_load_percentage,
+                )
+            )
+            self.pms = PmsLoadTableSimulationInterface(
+                n_bus_ties=1, pms_load_table=load_table
+            )
+        else:
+            self.pms = pms
+        self._set_equal_load_sharing_on_power_sources(n_datapoints=1)
+
+    @property
+    def electric_system(self) -> ElectricPowerSystem:
+        if self.system_is_not_electric:
+            return self.system_feems.electric_system
+        else:
+            return self.system_feems
+
+    @property
+    def system_is_not_electric(self) -> bool:
+        return hasattr(self.system_feems, "electric_system")
+
+    def _set_input_load_from_gymir_result(
+        self,
+        *,
+        gymir_result: proto_gymir.GymirResult,
+    ) -> None:
+        propulsion_power_timeseries = convert_gymir_result_to_propulsion_power_series(
+            gymir_result
+        )
+        self._set_input_load_time_interval_from_propulsion_power_time_series(
+            propulsion_power_time_series=propulsion_power_timeseries,
+            auxiliary_load_kw=gymir_result.auxiliary_load_kw,
+        )
+
+    def _set_input_load_time_interval_from_propulsion_power_time_series(
+        self,
+        *,
+        propulsion_power_time_series: pd.Series,
+        auxiliary_load_kw: Numeric,
+        time_is_given_as_interval: bool = False,
+    ) -> None:
+        if time_is_given_as_interval:
+            propulsion_power = propulsion_power_time_series.values
+            time_interval_s = propulsion_power_time_series.index.to_numpy()
+        else:
+            propulsion_power = propulsion_power_time_series.values[:-1]
+            time_interval_s = np.diff(propulsion_power_time_series.index.to_numpy())
+
+        number_points = len(propulsion_power)
+        auxiliary_load_kw = np.atleast_1d(auxiliary_load_kw)
+        if len(auxiliary_load_kw) > 1:
+            auxiliary_load_kw = auxiliary_load_kw[:number_points]
+        else:
+            auxiliary_load_kw = np.repeat(auxiliary_load_kw, number_points)
+        # set power load
+        number_of_propulsors = len(self.electric_system.propulsion_drives)
+        if self.system_is_not_electric:
+            number_of_propulsors = (
+                self.system_feems.mechanical_system.no_mechanical_loads
+            )
+        number_of_other_loads = len(self.electric_system.other_load)
+        if number_of_other_loads == 0:
+            assert np.all(
+                np.atleast_1d(auxiliary_load_kw) == 0
+            ), "Auxiliary load is not zero while other loads are not defined in the system."
+        for propulsor in self.electric_system.propulsion_drives:
+            propulsor.set_power_input_from_output(
+                propulsion_power / number_of_propulsors
+            )
+        if self.system_is_not_electric:
+            for propulsor in self.system_feems.mechanical_system.mechanical_loads:
+                propulsor.set_power_input_from_output(
+                    propulsion_power / number_of_propulsors
+                )
+        for other_load in self.electric_system.other_load:
+            other_load.power_input = auxiliary_load_kw / number_of_other_loads
+        self.electric_system.set_time_interval(
+            time_interval_s=time_interval_s,
+            integration_method=IntegrationMethod.sum_with_time,
+        )
+        if self.system_is_not_electric:
+            self.system_feems.mechanical_system.set_time_interval(
+                time_interval_s=time_interval_s,
+                integration_method=IntegrationMethod.sum_with_time,
+            )
+
+    def _set_equal_load_sharing_on_power_sources(self, n_datapoints: int) -> None:
+        for power_source in self.electric_system.power_sources:
+            power_source.load_sharing_mode = np.zeros(shape=[n_datapoints])
+        if self.system_is_not_electric:
+            for power_source in self.system_feems.mechanical_system.main_engines:
+                power_source.load_sharing_mode = np.zeros(shape=[n_datapoints])
+
+    def _set_status_for_mechanical_system(self) -> None:
+        """Set the status of main engines for the mechanical system, turning all the gensets on.
+        The main engines that are not used for propulsion after the power balance calculation
+        will be turned off.
+        """
+        if np.isscalar(self.system_feems.mechanical_system.time_interval_s):
+            n_data_points = 1
+        else:
+            n_data_points = len(self.system_feems.mechanical_system.time_interval_s)
+        for main_engine in self.system_feems.mechanical_system.main_engines:
+            main_engine.status = np.ones(n_data_points).astype(bool)
+
+    def _run_simulation(
+        self,
+        fuel_specified_by: FuelSpecifiedBy = FuelSpecifiedBy.IMO,
+        ignore_power_balance: bool = False,
+    ) -> Union[FEEMSResult, FEEMSResultForMachinerySystem]:
+        """Run the simulation and return the result.
+
+        Args:
+            fuel_specified_by(FuelSpecifiedBy): The fuel specified by IMO/EU/USER. Default is IMO.
+            ignore_power_balance(bool): If True, the power balance calculation will be ignored.
+
+        Returns:
+            The result of the simulation. FEEMSResult or FEEMSResultForMachinery system.
+        """
+        if ignore_power_balance:
+            if self.system_is_not_electric:
+                return self.system_feems.get_fuel_energy_consumption_running_time(
+                    time_interval_s=self.system_feems.mechanical_system.time_interval_s,
+                    integration_method=IntegrationMethod.sum_with_time,
+                    fuel_specified_by=fuel_specified_by,
+                )
+            else:
+                return self.system_feems.get_fuel_energy_consumption_running_time(
+                    fuel_specified_by=fuel_specified_by
+                )
+
+        power_kw_per_switchboard = (
+            self.electric_system.get_sum_consumption_kw_sources_switchboard()
+        )
+        self.pms.set_status(
+            power_kw_per_switchboard=power_kw_per_switchboard,
+            electric_power_system=self.electric_system,
+            time_interval_s=self.electric_system.time_interval_s,
+            power_source_priority=None,
+        )
+        if self.system_is_not_electric:
+            self._set_status_for_mechanical_system()
+            self.system_feems.do_power_balance_calculation()
+            return self.system_feems.get_fuel_energy_consumption_running_time(
+                time_interval_s=self.system_feems.mechanical_system.time_interval_s,
+                integration_method=IntegrationMethod.sum_with_time,
+                fuel_specified_by=fuel_specified_by,
+            )
+        else:
+            self.system_feems.do_power_balance_calculation()
+            return self.system_feems.get_fuel_energy_consumption_running_time(
+                fuel_specified_by=fuel_specified_by
+            )
+
+    def calculate_machinery_system_output_from_gymir_result(
+        self,
+        *,
+        gymir_result: proto_gymir.GymirResult,
+        fuel_specified_by: FuelSpecifiedBy = FuelSpecifiedBy.IMO,
+        ignore_power_balance: bool = False,
+    ) -> Union[FEEMSResult, FEEMSResultForMachinerySystem]:
+        """
+        Calculate the machinery system output from a Gymir result.
+
+        Args:
+            gymir_result(GymirResult): Gymir result given as protobuf message.
+            fuel_specified_by(FuelSpecifiedBy): The fuel specified by IMO/EU/USER. Default is IMO.
+            ignore_power_balance(bool): If True, the power balance calculation will be ignored.
+
+        Returns:
+            The result of the calculation. FEEMSResult or FEEMSResultForMachinerySystem.
+        """
+        self._set_input_load_from_gymir_result(gymir_result=gymir_result)
+        return self._run_simulation(
+            fuel_specified_by=fuel_specified_by,
+            ignore_power_balance=ignore_power_balance,
+        )
+
+    def calculate_machinery_system_output_from_propulsion_power_time_series(
+        self,
+        *,
+        propulsion_power: pd.Series,
+        auxiliary_power_kw: Numeric,
+        fuel_specified_by: FuelSpecifiedBy = FuelSpecifiedBy.IMO,
+        ignore_power_balance: bool = False,
+    ) -> Union[FEEMSResult, FEEMSResultForMachinerySystem]:
+        """
+        Calculate the machinery system output from a time series of the propulsion power and
+        auxiliary power.
+
+        Args:
+            propulsion_power(pd.Series): The propulsion power time series.
+            auxiliary_power_kw(Numeric): The auxiliary power in kW. It can be a single value or
+                a numpy array with the same length as the propulsion power.
+            fuel_specified_by(FuelSpecifiedBy): The fuel specified by IMO/EU/USER. Default is IMO.
+            ignore_power_balance(bool): If True, the power balance calculation will be ignored.
+
+        Returns:
+            The result of the calculation. FEEMSResult or FEEMSResultForMachinerySystem.
+        """
+        if not np.isscalar(auxiliary_power_kw):
+            assert (
+                len(propulsion_power) == len(auxiliary_power_kw)
+                or len(auxiliary_power_kw) == 1
+            ), "The length of the auxiliary power must be 1 or the same as the propulsion power"
+        self._set_input_load_time_interval_from_propulsion_power_time_series(
+            propulsion_power_time_series=propulsion_power,
+            auxiliary_load_kw=auxiliary_power_kw,
+        )
+        return self._run_simulation(
+            fuel_specified_by=fuel_specified_by,
+            ignore_power_balance=ignore_power_balance,
+        )
+
+    def calculate_machinery_system_output_from_time_series_result(
+        self,
+        *,
+        time_series: proto_gymir.TimeSeriesResult,
+        fuel_specified_by: FuelSpecifiedBy = FuelSpecifiedBy.IMO,
+        ignore_power_balance: bool = False,
+    ) -> Union[FEEMSResult, FEEMSResultForMachinerySystem]:
+        """
+        Calculate the machinery system output from statistics of the propulsion power.
+        Args:
+            time_series(TimeSeriesResult): Time series result given as protobuf message.
+            fuel_specified_by(FuelSpecifiedBy): The fuel specified by IMO/EU/USER. Default is IMO.
+            ignore_power_balance(bool): If True, the power balance calculation will be ignored.
+
+        Returns:
+            The result of the simulation. FEEMSResult or FEEMSResultForMachinery system.
+        """
+        df = convert_proto_timeseries_to_pd_dataframe(time_series)
+        self._set_input_load_time_interval_from_propulsion_power_time_series(
+            propulsion_power_time_series=df["propulsion_power_kw"],
+            auxiliary_load_kw=df["auxiliary_power_kw"].values,
+        )
+        return self._run_simulation(
+            fuel_specified_by=fuel_specified_by,
+            ignore_power_balance=ignore_power_balance,
+        )
+
+    def calculate_machinery_system_output_from_statistics(
+        self,
+        *,
+        propulsion_power: np.ndarray,
+        frequency: np.ndarray,
+        auxiliary_power_kw: Numeric,
+        fuel_specified_by: FuelSpecifiedBy = FuelSpecifiedBy.IMO,
+        ignore_power_balance: bool = False,
+    ) -> Union[FEEMSResult, FEEMSResultForMachinerySystem]:
+        """
+        Calculate the machinery system output from statistics of the propulsion power.
+
+        Args:
+            propulsion_power(np.ndarray): The propulsion power for each mode in kW.
+            frequency(np.ndarray): The frequency of each mode in seconds. If the frequency is
+                given as normalized value, the output should be interpreted as per second value.
+            auxiliary_power_kw(Numeric): The auxiliary power for each mode in kW. It is also
+                possible to give a single value for all modes.
+            fuel_specified_by(FuelSpecifiedBy): The fuel specified by IMO/EU/USER. Default is IMO.
+            ignore_power_balance(bool): If True, the power balance calculation will be ignored.
+
+        Returns:
+            The result of the simulation. FEEMSResult or FEEMSResultForMachinery system.
+        """
+        if not np.isscalar(auxiliary_power_kw):
+            assert (
+                len(propulsion_power) == len(auxiliary_power_kw)
+                or len(auxiliary_power_kw) == 1
+            ), "The length of the auxiliary power must be 1 or the same as the propulsion power"
+        self._set_input_load_time_interval_from_propulsion_power_time_series(
+            propulsion_power_time_series=pd.Series(
+                data=propulsion_power, index=frequency
+            ),
+            auxiliary_load_kw=auxiliary_power_kw,
+            time_is_given_as_interval=True,
+        )
+        return self._run_simulation(
+            fuel_specified_by=fuel_specified_by,
+            ignore_power_balance=ignore_power_balance,
+        )

RunFeemsSim-0.2.2/RunFeemsSim/pms_basic.py

@@ -0,0 +1,205 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../01_pms_basic.ipynb.
+
+# %% auto 0
+__all__ = [
+    "OnPattern",
+    "Load2OnPattern",
+    "PmsLoadTable",
+    "get_rated_power_from_power_source",
+    "get_min_load_table_dict_from_proto_system",
+    "get_min_load_table_dict_from_feems_system",
+    "min_load_table_dict",
+    "PmsLoadTableSimulationInterface",
+]
+
+# %% ../01_pms_basic.ipynb 3
+import itertools
+from dataclasses import dataclass
+from itertools import chain
+from typing import Dict, List, Tuple, Union
+
+import numpy as np
+
+from feems.components_model import SwbId
+from feems.simulation_interface import SimulationInterface, EnergySourceType
+from feems.system_model import (
+    ElectricPowerSystem,
+    MechanicalPropulsionSystemWithElectricPowerSystem,
+    HybridPropulsionSystem,
+)
+from feems.types_for_feems import Power_kW, TypeComponent
+
+import MachSysS.system_structure_pb2 as proto_system
+import MachSysS.convert_to_feems as feems_converter
+
+
+OnPattern = Tuple[
+    bool, ...
+]  # Tuple of on-status for each producer in a power management system.
+Load2OnPattern = Dict[
+    Power_kW, OnPattern
+]  # Mapping from load power into PMS on-status.
+
+
+@dataclass
+class PmsLoadTable:
+    """Table of producer OnPattern for each minimum load of a power management system."""
+
+    min_load2on_pattern: Load2OnPattern
+
+    def __post_init__(self) -> None:
+        # Sort belonging loads and patterns to obtain increasing loads with keys and values in separate tuples.
+        self._bins, self._i2on = zip(*sorted(self.min_load2on_pattern.items()))
+
+    def sorted_load_table(self) -> Tuple[Tuple[Power_kW, ...], Tuple[OnPattern, ...]]:
+        """Return the sorted load table with loads and patterns separated."""
+        return self._bins, self._i2on
+
+    def on_pattern(
+        self, load: Union[List[float], List[Power_kW], np.ndarray]
+    ) -> List[OnPattern]:
+        """Return one OnPattern for each input value in load vector."""
+        return [self._i2on[i] for i in np.digitize(load, self._bins[1:])]  # type: ignore[no-untyped-call]
+
+
+def get_rated_power_from_power_source(subsystem: proto_system.Subsystem) -> float:
+    if subsystem.rated_power_kw > 0:
+        return subsystem.rated_power_kw
+    else:
+        component = feems_converter.collect_electric_components_from_sub_system(
+            subsystem
+        )[0].get("proto_component")
+        return component.rated_power_kw
+
+
+def get_min_load_table_dict_from_proto_system(
+    system: proto_system.MachinerySystem,
+) -> Load2OnPattern:
+    """Return a minimum load table dict generated from a protubuf message"""
+    gensets_rated_power_kw: List[Power_kW] = []
+    # Loop inspired by system_configuration_graphic.converter.converter.FeemsConverter.model()
+    for switchboard in system.electric_system.switchboards:
+        groups_rated_power = [
+            get_rated_power_from_power_source(subsystem)
+            for subsystem in switchboard.subsystems
+            if subsystem.power_type == proto_system.Subsystem.PowerType.POWER_SOURCE
+        ]
+        gensets_rated_power_kw.extend(groups_rated_power)
+
+    return min_load_table_dict(
+        gensets_rated_power_kw, system.maximum_allowed_genset_load_percentage / 100
+    )
+
+
+def get_min_load_table_dict_from_feems_system(
+    system: Union[
+        ElectricPowerSystem,
+        MechanicalPropulsionSystemWithElectricPowerSystem,
+        HybridPropulsionSystem,
+    ],
+    maximum_allowed_genset_load_percentage,
+    component_types: List[TypeComponent] = None,
+) -> Load2OnPattern:
+    """Return a minimum load table dict generated from a feems model"""
+    electric_system = (
+        system if not hasattr(system, "electric_system") else system.electric_system
+    )
+    power_sources = [component for component in electric_system.power_sources]
+    if component_types is not None:
+        power_sources = [
+            component
+            for component in power_sources
+            if component.type in component_types
+        ]
+    rated_power_all = [power_source.rated_power for power_source in power_sources]
+    return min_load_table_dict(
+        rated_power_all, maximum_allowed_genset_load_percentage / 100
+    )
+
+
+def min_load_table_dict(
+    rated_power_kw: List[Power_kW], max_load_factor: float
+) -> Load2OnPattern:
+    """Return a minimum load table dict generated from a list of genset ratings."""
+    patterns = list(itertools.product([False, True], repeat=len(rated_power_kw)))
+    assert len(patterns) == 2 ** len(rated_power_kw)
+    loads = [
+        Power_kW(
+            max_load_factor * sum(pwr for pwr, on in zip(rated_power_kw, pat) if on)
+        )
+        for pat in patterns
+    ]
+    assert len(loads) == len(patterns)
+    # Sort belonging loads and patterns to obtain increasing loads.
+    loads, patterns = zip(*sorted(zip(loads, patterns)))  # type: ignore[assignment]
+    assert loads[0] == Power_kW(0)
+    assert patterns[0] == (False,) * len(rated_power_kw)
+    assert patterns[-1] == (True,) * len(rated_power_kw)
+    # Use all maximum loads except the highest, as minimum loads to activate the on patterns for the next higher
+    # load, i.e. ignoring the all-off-pattern.
+    return dict(zip(loads[:-1], patterns[1:]))
+
+
+class PmsLoadTableSimulationInterface(SimulationInterface):
+    def __init__(
+        self,
+        *,
+        n_bus_ties: int,
+        pms_load_table: PmsLoadTable,
+    ):
+        _, on_patterns = pms_load_table.sorted_load_table()
+        self._n_power_sources = len(on_patterns[0])
+        self._n_bus_ties = n_bus_ties
+        self._pms_load_table = pms_load_table
+        assert all(
+            self._n_power_sources == len(v)
+            for v in pms_load_table.min_load2on_pattern.values()
+        ), f"All PMS on_pattern lengths must match the genset count = {self._n_power_sources}"
+
+    def set_status(
+        self,
+        *,
+        power_kw_per_switchboard: Dict[SwbId, np.ndarray],
+        electric_power_system: ElectricPowerSystem,
+        time_interval_s: np.ndarray,
+        power_source_priority: EnergySourceType = EnergySourceType.LNG_DIESEL,
+    ) -> None:
+        # Check that all switchboards have the same number of datapoints. If not, check that
+        # the switchboard with different number points has only one datapoint with value 0
+        # where there is no load.
+        n_datapoints = set(len(v) for v in power_kw_per_switchboard.values())
+        n_datapoint_max = max(n_datapoints)
+        if len(n_datapoints) > 1:
+            for swb_id, power_kw in power_kw_per_switchboard.items():
+                if (
+                    len(power_kw) < n_datapoint_max
+                    and len(power_kw) != 1
+                    and power_kw[0] != 0
+                ):
+                    raise ValueError(
+                        f"Load vector for switchboard {swb_id} has length {len(power_kw)} "
+                        f"but should have length {n_datapoint_max} or 1 with 0 value."
+                    )
+        n_datapoints = n_datapoint_max
+        total_power_kw = sum(power_kw_per_switchboard.values(), np.zeros(n_datapoints))
+        off_vector = np.zeros(n_datapoints)
+        on_vector = np.ones(n_datapoints)
+        equal_load_sharing_vector = np.zeros(n_datapoints)
+        number_power_sources = len(electric_power_system.power_sources)
+        on_pattern_per_datapoint = np.array(
+            self._pms_load_table.on_pattern(total_power_kw)
+        )
+        assert on_pattern_per_datapoint.shape == (n_datapoints, self._n_power_sources)
+        if self._n_bus_ties > 0:
+            electric_power_system.set_bus_tie_status_all(
+                np.ones([n_datapoints, self._n_bus_ties])
+            )
+        assert (
+            self._n_power_sources == number_power_sources
+        ), f"The electric_power_system.power_sources count is different from {self._n_power_sources}"
+        for i, source in enumerate(electric_power_system.power_sources):
+            source.status = on_pattern_per_datapoint[:, i]
+            source.load_sharing_mode = equal_load_sharing_vector
+        for component in chain(electric_power_system.energy_storage):
+            component.status = off_vector
+            component.load_sharing_mode = equal_load_sharing_vector

RunFeemsSim-0.2.2/RunFeemsSim.egg-info/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.1
+Name: RunFeemsSim
+Version: 0.2.2
+Summary: A library for running feems simulation
+Home-page: https://SintefOceanEnergySystem@dev.azure.com/SintefOceanEnergySystem/FEEMSService/_git/RunFEEMSSim
+Author: Kevin Koosup Yum
+Author-email: kevinkoosup.yum@sintef.no
+License: Apache Software License 2.0
+Keywords: FEEMS,machinery system,fuel,emissions
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pip
+Requires-Dist: packaging
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: MachSysS
+Provides-Extra: dev
+
+# RunFeemsSim Package
+
+> The RunFeemsSim package is a Python package for running FEEMS simulations. It provides a simple 
+> interface for running FEEMS simulations and for visualizing the results. It also provides a basic 
+> pms model to apply for an electric power system that has a functionality of load dependent 
+> start-stop of gensets.
+
+## Installation of the package
+The package is distributed by the Azure Artifacts package manager. To install the package, 
+you need to install artifacts-keyring package and should have a valid Azure DevOps account. 
+```sh
+pip install artifacts-keyring
+```
+Then, you need to add the package source to your pip configuration. You can do this by copying 
+the pip configuration file (pip.conf for macOS and Linux or pip.ini for Windows) to your 
+virtual environment directory or base python directory. The file should contain the following lines:
+```sh
+[global]
+extra-index-url=https://pkgs.dev.azure.com/SintefOceanEnergySystem/_packaging/SintefOceanEnergySystem/pypi/simple/
+```
+If you already have a pip configuration file, you can add the above lines to the file. Finally, 
+you can install the package by running the following command:
+```sh
+pip install RunFeemsSim
+```
+ 
+## Installation of the development environment
+For the development, one should create a virtual environment and install the package using the 
+requirements.txt file. First, create a virtual environment and activate it. 
+```sh 
+python -m venv venv
+source venv/bin/activate
+```
+Then, you need to add the package source to your pip configuration. You can do this by copying 
+the pip configuration file (pip.conf for macOS and Linux or pip.ini for Windows) to your venv 
+directory or base python directory. The file should contain the following lines:
+```sh
+[global]
+extra-index-url=https://pkgs.dev.azure.com/SintefOceanEnergySystem/_packaging/SintefOceanEnergySystem/pypi/simple/
+```
+
+Then, install the package using the requirements.txt file.
+```sh
+pip install -r requirements.txt
+```
+
+## Usage
+
+

RunFeemsSim-0.2.2/RunFeemsSim.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+CONTRIBUTING.md
+LICENSE
+MANIFEST.in
+README.md
+settings.ini
+setup.py
+RunFeemsSim/__init__.py
+RunFeemsSim/_modidx.py
+RunFeemsSim/_nbdev.py
+RunFeemsSim/machinery_calculation.py
+RunFeemsSim/pms_basic.py
+RunFeemsSim.egg-info/PKG-INFO
+RunFeemsSim.egg-info/SOURCES.txt
+RunFeemsSim.egg-info/dependency_links.txt
+RunFeemsSim.egg-info/not-zip-safe
+RunFeemsSim.egg-info/requires.txt
+RunFeemsSim.egg-info/top_level.txt

RunFeemsSim-0.2.2/RunFeemsSim.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

RunFeemsSim-0.2.2/RunFeemsSim.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

RunFeemsSim-0.2.2/RunFeemsSim.egg-info/requires.txt

@@ -0,0 +1,7 @@
+pip
+packaging
+pandas
+numpy
+MachSysS
+
+[dev]

RunFeemsSim-0.2.2/RunFeemsSim.egg-info/top_level.txt

@@ -0,0 +1 @@
+RunFeemsSim

RunFeemsSim-0.2.2/settings.ini

@@ -0,0 +1,27 @@
+[DEFAULT]
+host = Azure
+lib_name = RunFeemsSim
+user = kevinkoosup.yum@sintef.no
+description = A library for running feems simulation
+keywords = FEEMS, machinery system, fuel, emissions
+author = Kevin Koosup Yum
+author_email = kevinkoosup.yum@sintef.no
+copyright = SINTEF
+branch = master
+version = 0.2.2
+min_python = 3.10
+audience = Developers
+language = English
+custom_sidebar = False
+license = apache2
+status = 2
+requirements = pandas numpy MachSysS
+nbs_path = .
+doc_path = docs
+recursive = False
+doc_baseurl = /RunFeemsSim/
+git_url = https://SintefOceanEnergySystem@dev.azure.com/SintefOceanEnergySystem/FEEMSService/_git/RunFEEMSSim
+lib_path = RunFeemsSim
+title = RunFeemsSim
+doc_host = https://kevinkoosup.yum@sintef.no.github.io
+

RunFeemsSim-0.2.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

RunFeemsSim-0.2.2/setup.py

@@ -0,0 +1,113 @@
+from pkg_resources import parse_version
+from configparser import ConfigParser
+import setuptools, re, sys
+
+assert parse_version(setuptools.__version__) >= parse_version("36.2")
+
+# note: all settings are in settings.ini; edit there, not here
+config = ConfigParser(delimiters=["="])
+config.read("settings.ini")
+cfg = config["DEFAULT"]
+
+cfg_keys = "version description keywords author author_email".split()
+expected = (
+    cfg_keys
+    + "lib_name user branch license status min_python audience language".split()
+)
+for o in expected:
+    assert o in cfg, "missing expected setting: {}".format(o)
+setup_cfg = {o: cfg[o] for o in cfg_keys}
+
+if len(sys.argv) > 1 and sys.argv[1] == "version":
+    print(setup_cfg["version"])
+    exit()
+
+licenses = {
+    "apache2": (
+        "Apache Software License 2.0",
+        "OSI Approved :: Apache Software License",
+    ),
+    "mit": ("MIT License", "OSI Approved :: MIT License"),
+    "gpl2": (
+        "GNU General Public License v2",
+        "OSI Approved :: GNU General Public License v2 (GPLv2)",
+    ),
+    "gpl3": (
+        "GNU General Public License v3",
+        "OSI Approved :: GNU General Public License v3 (GPLv3)",
+    ),
+    "bsd3": ("BSD License", "OSI Approved :: BSD License"),
+}
+statuses = [
+    "1 - Planning",
+    "2 - Pre-Alpha",
+    "3 - Alpha",
+    "4 - Beta",
+    "5 - Production/Stable",
+    "6 - Mature",
+    "7 - Inactive",
+]
+py_versions = "2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10".split()
+
+lic = licenses.get(cfg["license"].lower(), (cfg["license"], None))
+min_python = cfg["min_python"]
+
+requirements = ["pip", "packaging"]
+if cfg.get("requirements"):
+    requirements += cfg.get("requirements", "").split()
+if cfg.get("pip_requirements"):
+    requirements += cfg.get("pip_requirements", "").split()
+dev_requirements = (cfg.get("dev_requirements") or "").split()
+
+long_description = open("README.md").read()
+# ![png](docs/images/output_13_0.png)
+for ext in ["png", "svg"]:
+    long_description = re.sub(
+        r"!\[" + ext + "\]\((.*)\)",
+        "!["
+        + ext
+        + "]("
+        + "https://raw.githubusercontent.com/{}/{}".format(cfg["user"], cfg["lib_name"])
+        + "/"
+        + cfg["branch"]
+        + "/\\1)",
+        long_description,
+    )
+    long_description = re.sub(
+        r"src=\"(.*)\." + ext + '"',
+        'src="https://raw.githubusercontent.com/{}/{}'.format(
+            cfg["user"], cfg["lib_name"]
+        )
+        + "/"
+        + cfg["branch"]
+        + "/\\1."
+        + ext
+        + '"',
+        long_description,
+    )
+
+setuptools.setup(
+    name=cfg["lib_name"],
+    license=lic[0],
+    classifiers=[
+        "Development Status :: " + statuses[int(cfg["status"])],
+        "Intended Audience :: " + cfg["audience"].title(),
+        "Natural Language :: " + cfg["language"].title(),
+    ]
+    + [
+        "Programming Language :: Python :: " + o
+        for o in py_versions[py_versions.index(min_python) :]
+    ]
+    + (["License :: " + lic[1]] if lic[1] else []),
+    url=cfg["git_url"],
+    packages=setuptools.find_packages(),
+    include_package_data=True,
+    install_requires=requirements,
+    extras_require={"dev": dev_requirements},
+    python_requires=">=" + cfg["min_python"],
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    zip_safe=False,
+    entry_points={"console_scripts": cfg.get("console_scripts", "").split()},
+    **setup_cfg
+)