simapy 5.2.0__tar.gz → 5.4.0__tar.gz

simapy-5.4.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: simapy
+Version: 5.4.0
+Summary: Python utilities for SIMA
+Author: SINTEF Ocean
+License: MIT License
+Project-URL: Homepage, https://github.com/SINTEF/simapy
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dmtpy==0.3.6
+Requires-Dist: numpy
+Requires-Dist: simapy-results==5.4.0
+Requires-Dist: tqdm
+Provides-Extra: pandas
+Requires-Dist: simapy-results[pandas]==5.4.0; extra == "pandas"
+Provides-Extra: hdf5
+Requires-Dist: simapy-results[hdf5]==5.4.0; extra == "hdf5"
+Provides-Extra: all
+Requires-Dist: simapy[hdf5,pandas]; extra == "all"
+Dynamic: license-file
+
+SIMAPy - Python utilities for SIMA
+=================================================================
+
+Build SIMA models in Python, run [SIMA](https://sima.sintef.no) without its user interface,
+and read the results back as numpy arrays and pandas frames.
+
+## Installation
+
+```bash
+pip install simapy[all]
+```
+
+Use the SIMAPy version that matches SIMA: SIMAPy 5.4 reads and writes the models of SIMA 5.4.
+
+## Documentation
+
+The [SIMAPy documentation](https://sima.sintef.no/docs/5.4/simapy/) is part of the SIMA
+documentation, with a user guide and examples to download.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

simapy-5.4.0/README.md

@@ -0,0 +1,22 @@
+SIMAPy - Python utilities for SIMA
+=================================================================
+
+Build SIMA models in Python, run [SIMA](https://sima.sintef.no) without its user interface,
+and read the results back as numpy arrays and pandas frames.
+
+## Installation
+
+```bash
+pip install simapy[all]
+```
+
+Use the SIMAPy version that matches SIMA: SIMAPy 5.4 reads and writes the models of SIMA 5.4.
+
+## Documentation
+
+The [SIMAPy documentation](https://sima.sintef.no/docs/5.4/simapy/) is part of the SIMA
+documentation, with a user guide and examples to download.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

simapy-5.4.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["setuptools>=70.0.0", "wheel>=0.38.1"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "simapy"
+version = "5.4.0"
+description = "Python utilities for SIMA"
+readme = "README.md"
+authors = [
+    {name = "SINTEF Ocean"}
+]
+requires-python = ">=3.11"
+license = {text = "MIT License"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "dmtpy==0.3.6",
+    "numpy",
+    "simapy-results==5.4.0",
+    "tqdm",
+]
+
+[project.optional-dependencies]
+pandas = ["simapy-results[pandas]==5.4.0"]
+hdf5 = ["simapy-results[hdf5]==5.4.0"]
+all = ["simapy[pandas,hdf5]"]
+
+[project.urls]
+Homepage = "https://github.com/SINTEF/simapy"
+
+[dependency-groups]
+dev = [
+    "pylint>=4",
+    "pytest>=8.3.5",
+    "simapy[all]",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+packages = {find = {where = ["src"], exclude = ["tests", "tests.*"]}}
+
+[tool.uv.workspace]
+members = ["packages/*"]
+
+[tool.uv.sources]
+simapy-results = { workspace = true }
+
+# Each distribution runs its own tests: both test folders are packages named `tests`.
+[tool.pytest.ini_options]
+testpaths = ["src/tests"]

simapy-5.4.0/setup.cfg

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

simapy-5.4.0/src/simapy/results/__init__.py

@@ -0,0 +1,4 @@
+"""SIMA results, as :mod:`simapy_results` -- kept so scripts importing ``simapy.results`` run unchanged."""
+
+from simapy_results import *  # noqa: F401,F403
+from simapy_results import __all__  # noqa: F401

simapy-5.4.0/src/simapy/sima/condition/__init__.py

@@ -0,0 +1,16 @@
+
+from .addoperation import AddOperation # noqa
+from .conditionresultentrycontainer import ConditionResultEntryContainer # noqa
+from .conditionset import ConditionSet # noqa
+from .conditionsetresultcontainer import ConditionSetResultContainer # noqa
+from .conditionspace import ConditionSpace # noqa
+from .conditiontaskcondition import ConditionTaskCondition # noqa
+from .initialcondition import InitialCondition # noqa
+from .modelvariation import ModelVariation # noqa
+from .modelvariationoperation import ModelVariationOperation # noqa
+from .modelvariationreference import ModelVariationReference # noqa
+from .removeoperation import RemoveOperation # noqa
+from .replaceoperation import ReplaceOperation # noqa
+from .simplecondition import SimpleCondition # noqa
+from .variableitemset import VariableItemSet # noqa
+from .variablemodification import VariableModification # noqa

simapy-5.4.0/src/simapy/sima/hydro/blueprints/retardationfunctioncalculationnode.py

@@ -0,0 +1,31 @@
+# 
+# Generated with RetardationFunctionCalculationNodeBlueprint
+from dmt.blueprint import Blueprint
+from dmt.dimension import Dimension
+from dmt.attribute import Attribute
+from dmt.enum_attribute import EnumAttribute
+from dmt.blueprint_attribute import BlueprintAttribute
+from ...post.blueprints.runnode import RunNodeBlueprint
+
+class RetardationFunctionCalculationNodeBlueprint(RunNodeBlueprint):
+    """"""
+
+    def __init__(self, name="RetardationFunctionCalculationNode", package_path="sima/hydro", description=""):
+        super().__init__(name,package_path,description)
+        self.add_attribute(Attribute("description","string","",default=""))
+        self.add_attribute(BlueprintAttribute("scriptableValues","sima/sima/ScriptableValue","",True,Dimension("*")))
+        self.add_attribute(Attribute("name","string",""))
+        self.add_attribute(Attribute("x","integer","",default=0))
+        self.add_attribute(Attribute("y","integer","",default=0))
+        self.add_attribute(Attribute("h","integer","",default=0))
+        self.add_attribute(Attribute("w","integer","",default=0))
+        self.add_attribute(BlueprintAttribute("controlSignalInputSlots","sima/post/ControlSignalInputSlot","",True,Dimension("*")))
+        self.add_attribute(BlueprintAttribute("radiationData","sima/post/InputSlot","",True))
+        self.add_attribute(BlueprintAttribute("structuralMass","sima/post/InputSlot","",True))
+        self.add_attribute(BlueprintAttribute("extraDamping","sima/post/InputSlot","",True))
+        self.add_attribute(BlueprintAttribute("outputSlot","sima/post/OutputSlot","",True))
+        self.add_attribute(Attribute("timeStep","number","Retardation function timeStep",default=0.5))
+        self.add_attribute(Attribute("powerOfTwo","integer","Exponent n: the FFT uses 2^n samples, and the retardation function has at most 2^(n-1) samples before the near-zero tail is truncated (see Cut factor). Default 13.",default=13))
+        self.add_attribute(Attribute("cutFactor","number","Factor determining the duration of the significant part of the retardation function; the near-zero tail is truncated from the right. Large cut factor means longer duration (less truncation). Default 200.",default=200.0))
+        self.add_attribute(Attribute("useStructuralMass","boolean","Use structural mass together with a cut factor for removing certain degrees of freedom",default=True))
+        self.add_attribute(Attribute("massCutFactor","number","Factor used together with structural mass to determine which coupling terms in the retardation function matrix are close to zero at all t and can be neglected. Small factor means larger chance of neglecting coupling terms. Only used when structural mass is available.",default=100000.0))

simapy-5.4.0/src/simapy/sima/hydro/blueprints/retardationfunctioncalculationparameters.py

@@ -0,0 +1,21 @@
+# 
+# Generated with RetardationFunctionCalculationParametersBlueprint
+from dmt.blueprint import Blueprint
+from dmt.dimension import Dimension
+from dmt.attribute import Attribute
+from dmt.enum_attribute import EnumAttribute
+from dmt.blueprint_attribute import BlueprintAttribute
+from ...sima.blueprints.moao import MOAOBlueprint
+
+class RetardationFunctionCalculationParametersBlueprint(MOAOBlueprint):
+    """"""
+
+    def __init__(self, name="RetardationFunctionCalculationParameters", package_path="sima/hydro", description=""):
+        super().__init__(name,package_path,description)
+        self.add_attribute(Attribute("description","string","",default=""))
+        self.add_attribute(BlueprintAttribute("scriptableValues","sima/sima/ScriptableValue","",True,Dimension("*")))
+        self.add_attribute(Attribute("timeStep","number","Retardation function timeStep",default=0.5))
+        self.add_attribute(Attribute("useLimitingFrequencies","boolean","Use added mass zero and/or added mass infinite if these exist",default=True))
+        self.add_attribute(Attribute("cutFactor","number","Factor determining the duration of the significant part of the retardation function; the near-zero tail is truncated from the right. Large cut factor means longer duration (less truncation). Default 200.",default=200.0))
+        self.add_attribute(Attribute("powerOfTwo","integer","Exponent n: the FFT uses 2^n samples, and the retardation function has at most 2^(n-1) samples before the near-zero tail is truncated (see Cut factor). Default 13.",default=13))
+        self.add_attribute(Attribute("massCutFactor","number","Factor used together with structural mass to determine which coupling terms in the retardation function matrix are close to zero at all t and can be neglected. Small factor means larger chance of neglecting coupling terms. Only used when structural mass is available.",default=100000.0))

simapy-5.4.0/src/simapy/sima/hydro/blueprints/sifimportconfiguration.py

@@ -0,0 +1,22 @@
+# 
+# Generated with SIFImportConfigurationBlueprint
+from dmt.blueprint import Blueprint
+from dmt.dimension import Dimension
+from dmt.attribute import Attribute
+from dmt.enum_attribute import EnumAttribute
+from dmt.blueprint_attribute import BlueprintAttribute
+from ...sima.blueprints.moao import MOAOBlueprint
+
+class SIFImportConfigurationBlueprint(MOAOBlueprint):
+    """"""
+
+    def __init__(self, name="SIFImportConfiguration", package_path="sima/hydro", description=""):
+        super().__init__(name,package_path,description)
+        self.add_attribute(Attribute("description","string","",default=""))
+        self.add_attribute(BlueprintAttribute("scriptableValues","sima/sima/ScriptableValue","",True,Dimension("*")))
+        self.add_attribute(Attribute("taskName","string","Name of task to import into. Required if bodyName is set."))
+        self.add_attribute(Attribute("bodyName","string","Optional. Name of SIMOBody to merge hydrodynamic data into."))
+        self.add_attribute(EnumAttribute("waveDriftOption","sima/hydro/SecondOrderWaveDriftOption",""))
+        self.add_attribute(EnumAttribute("qtfImportOption","sima/hydro/QTFImportOption",""))
+        self.add_attribute(Attribute("overrideConstants","boolean","Override the water depth and physical constants of the task being imported into with the values from the file. Off keeps the values the task already has, and is what a run with no answer uses.",default=False))
+        self.add_attribute(BlueprintAttribute("retardationFunctionParameters","sima/hydro/RetardationFunctionCalculationParameters","",True))

simapy-5.4.0/src/simapy/sima/hydro/retardationfunctioncalculationnode.py

@@ -0,0 +1,250 @@
+# This an autogenerated file
+# 
+# Generated with RetardationFunctionCalculationNode
+from typing import Dict,Sequence,List
+from dmt.blueprint import Blueprint
+from .blueprints.retardationfunctioncalculationnode import RetardationFunctionCalculationNodeBlueprint
+from typing import Dict
+from ..post import ControlSignalInputSlot
+from ..post import InputSlot
+from ..post import OutputSlot
+from ..post import RunNode
+from ..sima import ScriptableValue
+
+class RetardationFunctionCalculationNode(RunNode):
+    """
+    Keyword arguments
+    -----------------
+    description : str
+         (default "")
+    scriptableValues : List[ScriptableValue]
+    name : str
+         (default None)
+    x : int
+         (default 0)
+    y : int
+         (default 0)
+    h : int
+         (default 0)
+    w : int
+         (default 0)
+    controlSignalInputSlots : List[ControlSignalInputSlot]
+    radiationData : InputSlot
+    structuralMass : InputSlot
+    extraDamping : InputSlot
+    outputSlot : OutputSlot
+    timeStep : float
+         Retardation function timeStep(default 0.5)
+    powerOfTwo : int
+         Exponent n: the FFT uses 2^n samples, and the retardation function has at most 2^(n-1) samples before the near-zero tail is truncated (see Cut factor). Default 13.(default 13)
+    cutFactor : float
+         Factor determining the duration of the significant part of the retardation function; the near-zero tail is truncated from the right. Large cut factor means longer duration (less truncation). Default 200.(default 200.0)
+    useStructuralMass : bool
+         Use structural mass together with a cut factor for removing certain degrees of freedom(default True)
+    massCutFactor : float
+         Factor used together with structural mass to determine which coupling terms in the retardation function matrix are close to zero at all t and can be neglected. Small factor means larger chance of neglecting coupling terms. Only used when structural mass is available.(default 100000.0)
+    """
+
+    def __init__(self , description="", x=0, y=0, h=0, w=0, timeStep=0.5, powerOfTwo=13, cutFactor=200.0, useStructuralMass=True, massCutFactor=100000.0, **kwargs):
+        super().__init__(**kwargs)
+        self.description = description
+        self.scriptableValues = list()
+        self.name = None
+        self.x = x
+        self.y = y
+        self.h = h
+        self.w = w
+        self.controlSignalInputSlots = list()
+        self.radiationData = None
+        self.structuralMass = None
+        self.extraDamping = None
+        self.outputSlot = None
+        self.timeStep = timeStep
+        self.powerOfTwo = powerOfTwo
+        self.cutFactor = cutFactor
+        self.useStructuralMass = useStructuralMass
+        self.massCutFactor = massCutFactor
+        for key, value in kwargs.items():
+            if not isinstance(value, Dict):
+                setattr(self, key, value)
+
+
+    @property
+    def blueprint(self) -> Blueprint:
+        """Return blueprint that this entity represents"""
+        return RetardationFunctionCalculationNodeBlueprint()
+
+
+    @property
+    def description(self) -> str:
+        """"""
+        return self.__description
+
+    @description.setter
+    def description(self, value: str):
+        """Set description"""
+        self.__description = value
+
+    @property
+    def scriptableValues(self) -> List[ScriptableValue]:
+        """"""
+        return self.__scriptableValues
+
+    @scriptableValues.setter
+    def scriptableValues(self, value: List[ScriptableValue]):
+        """Set scriptableValues"""
+        if not isinstance(value, Sequence):
+            raise ValueError("Expected sequense, but was " , type(value))
+        self.__scriptableValues = value
+
+    @property
+    def name(self) -> str:
+        """"""
+        return self.__name
+
+    @name.setter
+    def name(self, value: str):
+        """Set name"""
+        self.__name = value
+
+    @property
+    def x(self) -> int:
+        """"""
+        return self.__x
+
+    @x.setter
+    def x(self, value: int):
+        """Set x"""
+        self.__x = int(value)
+
+    @property
+    def y(self) -> int:
+        """"""
+        return self.__y
+
+    @y.setter
+    def y(self, value: int):
+        """Set y"""
+        self.__y = int(value)
+
+    @property
+    def h(self) -> int:
+        """"""
+        return self.__h
+
+    @h.setter
+    def h(self, value: int):
+        """Set h"""
+        self.__h = int(value)
+
+    @property
+    def w(self) -> int:
+        """"""
+        return self.__w
+
+    @w.setter
+    def w(self, value: int):
+        """Set w"""
+        self.__w = int(value)
+
+    @property
+    def controlSignalInputSlots(self) -> List[ControlSignalInputSlot]:
+        """"""
+        return self.__controlSignalInputSlots
+
+    @controlSignalInputSlots.setter
+    def controlSignalInputSlots(self, value: List[ControlSignalInputSlot]):
+        """Set controlSignalInputSlots"""
+        if not isinstance(value, Sequence):
+            raise ValueError("Expected sequense, but was " , type(value))
+        self.__controlSignalInputSlots = value
+
+    @property
+    def radiationData(self) -> InputSlot:
+        """"""
+        return self.__radiationData
+
+    @radiationData.setter
+    def radiationData(self, value: InputSlot):
+        """Set radiationData"""
+        self.__radiationData = value
+
+    @property
+    def structuralMass(self) -> InputSlot:
+        """"""
+        return self.__structuralMass
+
+    @structuralMass.setter
+    def structuralMass(self, value: InputSlot):
+        """Set structuralMass"""
+        self.__structuralMass = value
+
+    @property
+    def extraDamping(self) -> InputSlot:
+        """"""
+        return self.__extraDamping
+
+    @extraDamping.setter
+    def extraDamping(self, value: InputSlot):
+        """Set extraDamping"""
+        self.__extraDamping = value
+
+    @property
+    def outputSlot(self) -> OutputSlot:
+        """"""
+        return self.__outputSlot
+
+    @outputSlot.setter
+    def outputSlot(self, value: OutputSlot):
+        """Set outputSlot"""
+        self.__outputSlot = value
+
+    @property
+    def timeStep(self) -> float:
+        """Retardation function timeStep"""
+        return self.__timeStep
+
+    @timeStep.setter
+    def timeStep(self, value: float):
+        """Set timeStep"""
+        self.__timeStep = float(value)
+
+    @property
+    def powerOfTwo(self) -> int:
+        """Exponent n: the FFT uses 2^n samples, and the retardation function has at most 2^(n-1) samples before the near-zero tail is truncated (see Cut factor). Default 13."""
+        return self.__powerOfTwo
+
+    @powerOfTwo.setter
+    def powerOfTwo(self, value: int):
+        """Set powerOfTwo"""
+        self.__powerOfTwo = int(value)
+
+    @property
+    def cutFactor(self) -> float:
+        """Factor determining the duration of the significant part of the retardation function; the near-zero tail is truncated from the right. Large cut factor means longer duration (less truncation). Default 200."""
+        return self.__cutFactor
+
+    @cutFactor.setter
+    def cutFactor(self, value: float):
+        """Set cutFactor"""
+        self.__cutFactor = float(value)
+
+    @property
+    def useStructuralMass(self) -> bool:
+        """Use structural mass together with a cut factor for removing certain degrees of freedom"""
+        return self.__useStructuralMass
+
+    @useStructuralMass.setter
+    def useStructuralMass(self, value: bool):
+        """Set useStructuralMass"""
+        self.__useStructuralMass = bool(value)
+
+    @property
+    def massCutFactor(self) -> float:
+        """Factor used together with structural mass to determine which coupling terms in the retardation function matrix are close to zero at all t and can be neglected. Small factor means larger chance of neglecting coupling terms. Only used when structural mass is available."""
+        return self.__massCutFactor
+
+    @massCutFactor.setter
+    def massCutFactor(self, value: float):
+        """Set massCutFactor"""
+        self.__massCutFactor = float(value)

simapy-5.4.0/src/simapy/sima/hydro/retardationfunctioncalculationparameters.py

@@ -0,0 +1,120 @@
+# This an autogenerated file
+# 
+# Generated with RetardationFunctionCalculationParameters
+from typing import Dict,Sequence,List
+from dmt.blueprint import Blueprint
+from .blueprints.retardationfunctioncalculationparameters import RetardationFunctionCalculationParametersBlueprint
+from typing import Dict
+from ..sima import MOAO
+from ..sima import ScriptableValue
+
+class RetardationFunctionCalculationParameters(MOAO):
+    """
+    Keyword arguments
+    -----------------
+    description : str
+         (default "")
+    scriptableValues : List[ScriptableValue]
+    timeStep : float
+         Retardation function timeStep(default 0.5)
+    useLimitingFrequencies : bool
+         Use added mass zero and/or added mass infinite if these exist(default True)
+    cutFactor : float
+         Factor determining the duration of the significant part of the retardation function; the near-zero tail is truncated from the right. Large cut factor means longer duration (less truncation). Default 200.(default 200.0)
+    powerOfTwo : int
+         Exponent n: the FFT uses 2^n samples, and the retardation function has at most 2^(n-1) samples before the near-zero tail is truncated (see Cut factor). Default 13.(default 13)
+    massCutFactor : float
+         Factor used together with structural mass to determine which coupling terms in the retardation function matrix are close to zero at all t and can be neglected. Small factor means larger chance of neglecting coupling terms. Only used when structural mass is available.(default 100000.0)
+    """
+
+    def __init__(self , description="", timeStep=0.5, useLimitingFrequencies=True, cutFactor=200.0, powerOfTwo=13, massCutFactor=100000.0, **kwargs):
+        super().__init__(**kwargs)
+        self.description = description
+        self.scriptableValues = list()
+        self.timeStep = timeStep
+        self.useLimitingFrequencies = useLimitingFrequencies
+        self.cutFactor = cutFactor
+        self.powerOfTwo = powerOfTwo
+        self.massCutFactor = massCutFactor
+        for key, value in kwargs.items():
+            if not isinstance(value, Dict):
+                setattr(self, key, value)
+
+
+    @property
+    def blueprint(self) -> Blueprint:
+        """Return blueprint that this entity represents"""
+        return RetardationFunctionCalculationParametersBlueprint()
+
+
+    @property
+    def description(self) -> str:
+        """"""
+        return self.__description
+
+    @description.setter
+    def description(self, value: str):
+        """Set description"""
+        self.__description = value
+
+    @property
+    def scriptableValues(self) -> List[ScriptableValue]:
+        """"""
+        return self.__scriptableValues
+
+    @scriptableValues.setter
+    def scriptableValues(self, value: List[ScriptableValue]):
+        """Set scriptableValues"""
+        if not isinstance(value, Sequence):
+            raise ValueError("Expected sequense, but was " , type(value))
+        self.__scriptableValues = value
+
+    @property
+    def timeStep(self) -> float:
+        """Retardation function timeStep"""
+        return self.__timeStep
+
+    @timeStep.setter
+    def timeStep(self, value: float):
+        """Set timeStep"""
+        self.__timeStep = float(value)
+
+    @property
+    def useLimitingFrequencies(self) -> bool:
+        """Use added mass zero and/or added mass infinite if these exist"""
+        return self.__useLimitingFrequencies
+
+    @useLimitingFrequencies.setter
+    def useLimitingFrequencies(self, value: bool):
+        """Set useLimitingFrequencies"""
+        self.__useLimitingFrequencies = bool(value)
+
+    @property
+    def cutFactor(self) -> float:
+        """Factor determining the duration of the significant part of the retardation function; the near-zero tail is truncated from the right. Large cut factor means longer duration (less truncation). Default 200."""
+        return self.__cutFactor
+
+    @cutFactor.setter
+    def cutFactor(self, value: float):
+        """Set cutFactor"""
+        self.__cutFactor = float(value)
+
+    @property
+    def powerOfTwo(self) -> int:
+        """Exponent n: the FFT uses 2^n samples, and the retardation function has at most 2^(n-1) samples before the near-zero tail is truncated (see Cut factor). Default 13."""
+        return self.__powerOfTwo
+
+    @powerOfTwo.setter
+    def powerOfTwo(self, value: int):
+        """Set powerOfTwo"""
+        self.__powerOfTwo = int(value)
+
+    @property
+    def massCutFactor(self) -> float:
+        """Factor used together with structural mass to determine which coupling terms in the retardation function matrix are close to zero at all t and can be neglected. Small factor means larger chance of neglecting coupling terms. Only used when structural mass is available."""
+        return self.__massCutFactor
+
+    @massCutFactor.setter
+    def massCutFactor(self, value: float):
+        """Set massCutFactor"""
+        self.__massCutFactor = float(value)