diff --git a/.github/neqsim-engine.sha256 b/.github/neqsim-engine.sha256 index 5876b621..c0a0d4af 100644 --- a/.github/neqsim-engine.sha256 +++ b/.github/neqsim-engine.sha256 @@ -1 +1 @@ -0f56e426a999dfc844fe647c0c6f710afd09be306dada2085778dbcc672bfba2 neqsim-3.28.0.jar +d75c8314a0ac14bebdd2be5c0a733be836cbc9752a19bb6c9185b8cbb32d40bb neqsim-3.29.0.jar diff --git a/conda/meta.yaml b/conda/meta.yaml index 917e4c62..1ed5a0e5 100644 --- a/conda/meta.yaml +++ b/conda/meta.yaml @@ -1,5 +1,5 @@ {% set name = "neqsim" %} -{% set version = "3.28.0" %} +{% set version = "3.29.0" %} package: name: {{ name|lower }} diff --git a/docs/release-notes/v3.29.0.md b/docs/release-notes/v3.29.0.md new file mode 100644 index 00000000..6c7a1d4c --- /dev/null +++ b/docs/release-notes/v3.29.0.md @@ -0,0 +1,96 @@ +# NeqSim Python 3.29.0 + +NeqSim Python is the Python interface to the NeqSim engine for thermodynamic +calculations, physical properties, process simulation, and PVT analysis from +Python and Jupyter notebooks. + +## Highlights + +- Bundles the official NeqSim Java 3.29.0 release engine for Java 17 or newer. +- Thermodynamics and flash: speeds up CPA association solving and cubic phase + classification, recovers free water below the overall-water screen, corrects + LBC viscosity pseudo-critical mixing, and preserves phase state and + composition across zero stream flow. +- Reservoir and PVT: extends fixed-cell depletion with dry and wet-gas phase + transitions and conserved-inventory Gibbs comparisons, stabilizes aquifer + influence functions, and adds OLGA PVT table options (configurable grids, + produced water, salinity) and a forward PVT proxy surface process generator. +- Electrolytes and chemistry: adds an exact-source reactive carbonate mode for + Pitzer brines, solid-gas reaction equilibrium (FeS/FeCO3), and reservoir H2S + mineral-buffer screening. +- Process equipment and dynamics: adds compressor power-train integration with + turbine and electric drivers, conservative separator energy integration, + dynamic heat-exchanger control workflows, reference water and seawater + cooling properties, and gas-turbine installation pressure-loss corrections. +- Pipelines and networks: improves two-fluid restart, terrain low-point pool + reporting, pig position events and gas-inventory coupling, and atomic + algebraic-junction network solving. +- Engineering drawings and safety: connects ESD/HIPPS and PSV responses and + compressor automation to DEXPI P&IDs, links System Control Diagrams, and runs + safety scenarios across process models. Review drawings still require + engineering verification. +- Fixes: distillation columns are no longer reported solved while internal flows + are still changing, `.neqsim` files are stamped with the real NeqSim + version, DEXPI import handles standard Proteus XML, and the n-decane molar + mass in the ISO 6976 constants is corrected.- Refreshes the bundled Java API manifest, type stubs, and component-name + metadata for the 3.29.0 engine. +- Retains Python 3.10-3.14 support and the existing NeqSim Python API. + +## Install + +Use pip when you already have Java installed: + +```bash +pip install --upgrade neqsim==3.29.0 +``` + +The matching conda-forge package can be installed once it is published: + +```bash +conda install -c conda-forge neqsim=3.29.0 +``` + +Requirements: + +- Python 3.10 or newer. +- Java 17 or newer for pip installs. Download Java from + [Adoptium](https://adoptium.net/). +- Conda installs include OpenJDK through conda-forge. + +Verify the installed package version without starting the JVM: + +```bash +python -c "from importlib.metadata import version; print(version('neqsim'))" +``` + +## Quick Start + +```python +from neqsim.thermo import TPflash, fluid, printFrame + +natural_gas = fluid("srk") +natural_gas.addComponent("methane", 0.85) +natural_gas.addComponent("ethane", 0.10) +natural_gas.addComponent("propane", 0.05) +natural_gas.setTemperature(25.0, "C") +natural_gas.setPressure(60.0, "bara") +natural_gas.setMixingRule("classic") + +TPflash(natural_gas) +printFrame(natural_gas) +``` + +## Engine Provenance + +The bundled `neqsim-3.29.0.jar` is downloaded from the +[official NeqSim 3.29.0 release](https://github.com/equinor/neqsim/releases/tag/v3.29.0). + +SHA-256: `d75c8314a0ac14bebdd2be5c0a733be836cbc9752a19bb6c9185b8cbb32d40bb` + +## Useful Links + +- Full changelog: https://github.com/equinor/neqsim-python/compare/v3.28.0...v3.29.0 +- NeqSim Java 3.29.0 release: https://github.com/equinor/neqsim/releases/tag/v3.29.0 +- Documentation: https://equinor.github.io/neqsimhome/ +- Python examples: https://github.com/equinor/neqsim-python/tree/master/examples +- Discussions: https://github.com/equinor/neqsim/discussions diff --git a/environment.yml b/environment.yml index 7e1e6bb7..341295e9 100644 --- a/environment.yml +++ b/environment.yml @@ -19,4 +19,4 @@ dependencies: # Install neqsim from PyPI until conda-forge package is available - pip - pip: - - neqsim==3.28.0 + - neqsim==3.29.0 diff --git a/pyproject.toml b/pyproject.toml index f2cbd10b..0997b226 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "neqsim" -version = "3.28.0" +version = "3.29.0" description = "NeqSim is a tool for thermodynamic and process calculations" authors = [{ name = "Even Solbraa", email = "esolbraa@gmail.com" }] requires-python = ">=3.10,<4" diff --git a/src/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/__init__.pyi b/src/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/__init__.pyi index a6846849..c1ee5aea 100644 --- a/src/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/__init__.pyi +++ b/src/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/__init__.pyi @@ -10,6 +10,7 @@ import jneqsim.physicalproperties.methods.liquidphysicalproperties.conductivity import jneqsim.physicalproperties.methods.liquidphysicalproperties.density import jneqsim.physicalproperties.methods.liquidphysicalproperties.diffusivity import jneqsim.physicalproperties.methods.liquidphysicalproperties.viscosity +import jneqsim.physicalproperties.methods.methodinterface import jneqsim.physicalproperties.system import typing @@ -19,11 +20,20 @@ class LiquidPhysicalPropertyMethod(jneqsim.physicalproperties.methods.PhysicalPr def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... def setPhase(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties) -> None: ... +class ReferenceWaterTransportProperties(LiquidPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.DensityInterface, jneqsim.physicalproperties.methods.methodinterface.ViscosityInterface, jneqsim.physicalproperties.methods.methodinterface.ConductivityInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcConductivity(self) -> float: ... + def calcDensity(self) -> float: ... + def calcViscosity(self) -> float: ... + def clone(self) -> 'ReferenceWaterTransportProperties': ... + def getPureComponentViscosity(self, int: int) -> float: ... + class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.liquidphysicalproperties")``. LiquidPhysicalPropertyMethod: typing.Type[LiquidPhysicalPropertyMethod] + ReferenceWaterTransportProperties: typing.Type[ReferenceWaterTransportProperties] conductivity: jneqsim.physicalproperties.methods.liquidphysicalproperties.conductivity.__module_protocol__ density: jneqsim.physicalproperties.methods.liquidphysicalproperties.density.__module_protocol__ diffusivity: jneqsim.physicalproperties.methods.liquidphysicalproperties.diffusivity.__module_protocol__ diff --git a/src/jneqsim-stubs/process/controllerdevice/__init__.pyi b/src/jneqsim-stubs/process/controllerdevice/__init__.pyi index f90847e8..c57126a0 100644 --- a/src/jneqsim-stubs/process/controllerdevice/__init__.pyi +++ b/src/jneqsim-stubs/process/controllerdevice/__init__.pyi @@ -219,6 +219,7 @@ class ControllerDeviceBaseClass(jneqsim.util.NamedBaseClass, ControllerDeviceInt @typing.overload def __init__(self, string: typing.Union[java.lang.String, str]): ... def addGainSchedulePoint(self, double: float, double2: float, double3: float, double4: float) -> None: ... + def applyControlConfiguration(self, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Any], typing.Mapping[typing.Union[java.lang.String, str], typing.Any]]) -> None: ... @typing.overload def autoTune(self, double: float, double2: float) -> None: ... @typing.overload @@ -232,6 +233,7 @@ class ControllerDeviceBaseClass(jneqsim.util.NamedBaseClass, ControllerDeviceInt @typing.overload def autoTuneStepResponse(self, double: float, double2: float, double3: float, boolean: bool) -> None: ... def captureTransientState(self) -> 'ControllerDeviceBaseClass.ControllerTransientState': ... + def getControlConfiguration(self) -> java.util.Map[java.lang.String, typing.Any]: ... def getControllerSetPoint(self) -> float: ... def getDeadBand(self) -> float: ... def getEventLog(self) -> java.util.List[ControllerEvent]: ... @@ -609,7 +611,9 @@ class AntiSurgeController(ControllerDeviceBaseClass): def __init__(self, string: typing.Union[java.lang.String, str]): ... @typing.overload def __init__(self, string: typing.Union[java.lang.String, str], compressor: jneqsim.process.equipment.compressor.Compressor, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve): ... + def applyControlConfiguration(self, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Any], typing.Mapping[typing.Union[java.lang.String, str], typing.Any]]) -> None: ... def getCompressor(self) -> jneqsim.process.equipment.compressor.Compressor: ... + def getControlConfiguration(self) -> java.util.Map[java.lang.String, typing.Any]: ... def getFilteredMarginRate(self) -> float: ... def getIntegralTime(self) -> float: ... @typing.overload @@ -621,6 +625,7 @@ class AntiSurgeController(ControllerDeviceBaseClass): def getProportionalGain(self) -> float: ... def getRecycleValve(self) -> jneqsim.process.equipment.valve.ThrottlingValve: ... def getResponse(self) -> float: ... + def getSurgeMarginMeasurement(self) -> jneqsim.process.measurementdevice.MeasurementDeviceInterface: ... def getSurgeMarginSetPoint(self) -> float: ... def getTargetValveOpening(self) -> float: ... def getValveOpening(self) -> float: ... @@ -640,6 +645,7 @@ class AntiSurgeController(ControllerDeviceBaseClass): def setPredictiveActionEnabled(self, boolean: bool) -> None: ... def setProportionalGain(self, double: float) -> None: ... def setRecycleValve(self, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve) -> None: ... + def setSurgeMarginMeasurement(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface) -> None: ... def setSurgeMarginSetPoint(self, double: float) -> None: ... diff --git a/src/jneqsim-stubs/process/diagnostics/__init__.pyi b/src/jneqsim-stubs/process/diagnostics/__init__.pyi index e3dea6aa..13d3ad7d 100644 --- a/src/jneqsim-stubs/process/diagnostics/__init__.pyi +++ b/src/jneqsim-stubs/process/diagnostics/__init__.pyi @@ -502,6 +502,7 @@ class RelationshipGraph(java.io.Serializable): class RootCauseAnalyzer(java.io.Serializable): def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem, string: typing.Union[java.lang.String, str]): ... + def addIncidentHistoryPrior(self, string: typing.Union[java.lang.String, str], int: int, string2: typing.Union[java.lang.String, str]) -> None: ... def analyze(self) -> 'RootCauseReport': ... @typing.overload def analyzeAutonomous(self) -> 'RootCauseReport': ... diff --git a/src/jneqsim-stubs/process/engineering/__init__.pyi b/src/jneqsim-stubs/process/engineering/__init__.pyi index 6f45359f..29cd24db 100644 --- a/src/jneqsim-stubs/process/engineering/__init__.pyi +++ b/src/jneqsim-stubs/process/engineering/__init__.pyi @@ -8,7 +8,10 @@ else: import com.google.gson import java.io import java.lang +import java.nio.file import java.util +import jpype +import jpype.protocol import jneqsim.process.engineering.automation import jneqsim.process.engineering.calculation import jneqsim.process.engineering.deliverables @@ -27,19 +30,36 @@ import jneqsim.process.engineering.piping import jneqsim.process.engineering.production import jneqsim.process.engineering.rotating import jneqsim.process.engineering.safety +import jneqsim.process.engineering.scd import jneqsim.process.engineering.validation import jneqsim.process.engineering.verticalslice import jneqsim.process.equipment import jneqsim.process.materials import jneqsim.process.processmodel +import jneqsim.process.processmodel.dexpi import jneqsim.process.safety.depressurization import jneqsim.process.safety.esd import jneqsim.process.safety.overpressure import jneqsim.process.safety.scenario +import jneqsim.process.util.scenario import typing +class CompressorAutomationWorkflow: + @staticmethod + def defaultCases() -> java.util.List[jneqsim.process.util.scenario.CompressorAutomationStudy.CaseDefinition]: ... + @staticmethod + def designFromJson(string: typing.Union[java.lang.String, str]) -> jneqsim.process.util.scenario.CompressorAutomationStudy.Design: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + @staticmethod + def run(design: jneqsim.process.util.scenario.CompressorAutomationStudy.Design, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]) -> java.util.Map[java.lang.String, typing.Any]: ... + @typing.overload + @staticmethod + def run(design: jneqsim.process.util.scenario.CompressorAutomationStudy.Design, pidDesignModel: jneqsim.process.engineering.pid.PidDesignModel, list: java.util.List[jneqsim.process.util.scenario.CompressorAutomationStudy.CaseDefinition], path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]) -> java.util.Map[java.lang.String, typing.Any]: ... + class EngineeringApprovalRecord(java.io.Serializable): def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], status: 'EngineeringApprovalRecord.Status', string4: typing.Union[java.lang.String, str], string5: typing.Union[java.lang.String, str], string6: typing.Union[java.lang.String, str]): ... def getDiscipline(self) -> java.lang.String: ... @@ -272,6 +292,12 @@ class EngineeringSimulationRunner: def buildCaseSet(engineeringProject: EngineeringProject) -> jneqsim.process.engineering.designcase.EngineeringCaseSet: ... @staticmethod def run(engineeringProject: EngineeringProject, engineeringCaseRunOptions: jneqsim.process.engineering.designcase.EngineeringCaseRunOptions) -> EngineeringSimulationResult: ... + @typing.overload + @staticmethod + def runStrict(engineeringProject: EngineeringProject) -> EngineeringSimulationResult: ... + @typing.overload + @staticmethod + def runStrict(engineeringProject: EngineeringProject, engineeringCaseRunOptions: jneqsim.process.engineering.designcase.EngineeringCaseRunOptions) -> EngineeringSimulationResult: ... class EngineeringStandard(java.io.Serializable): def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], string4: typing.Union[java.lang.String, str]): ... @@ -307,6 +333,14 @@ class EngineeringValidationReport(java.io.Serializable): @staticmethod def values() -> typing.MutableSequence['EngineeringValidationReport.Severity']: ... +class HeatExchangerAutomationWorkflow: + @staticmethod + def export(engineeringProject: EngineeringProject, dexpi20PlantExportMetadata: jneqsim.process.processmodel.dexpi.Dexpi20PlantExportMetadata, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath], result: jneqsim.process.engineering.pid.HeatExchangerControllerTuning.Result) -> java.nio.file.Path: ... + @staticmethod + def instrument(processSystem: jneqsim.process.processmodel.ProcessSystem, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], settings: 'HeatExchangerAutomationWorkflow.Settings') -> EngineeringProject: ... + class Settings: + def __init__(self, int: int, int2: int, double: float, double2: float, double3: float, double4: float): ... + class LineDesignInput(java.io.Serializable): def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... def addEvidenceReference(self, string: typing.Union[java.lang.String, str]) -> 'LineDesignInput': ... @@ -544,6 +578,7 @@ class SimulationEngineeringDesignRunner: class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.engineering")``. + CompressorAutomationWorkflow: typing.Type[CompressorAutomationWorkflow] EngineeringApprovalRecord: typing.Type[EngineeringApprovalRecord] EngineeringApprovalStatus: typing.Type[EngineeringApprovalStatus] EngineeringBoundary: typing.Type[EngineeringBoundary] @@ -558,6 +593,7 @@ class __module_protocol__(Protocol): EngineeringSimulationRunner: typing.Type[EngineeringSimulationRunner] EngineeringStandard: typing.Type[EngineeringStandard] EngineeringValidationReport: typing.Type[EngineeringValidationReport] + HeatExchangerAutomationWorkflow: typing.Type[HeatExchangerAutomationWorkflow] LineDesignInput: typing.Type[LineDesignInput] NorsokOffshoreEngineeringBuilder: typing.Type[NorsokOffshoreEngineeringBuilder] ProcessToEngineeringDesignBuilder: typing.Type[ProcessToEngineeringDesignBuilder] @@ -585,5 +621,6 @@ class __module_protocol__(Protocol): production: jneqsim.process.engineering.production.__module_protocol__ rotating: jneqsim.process.engineering.rotating.__module_protocol__ safety: jneqsim.process.engineering.safety.__module_protocol__ + scd: jneqsim.process.engineering.scd.__module_protocol__ validation: jneqsim.process.engineering.validation.__module_protocol__ verticalslice: jneqsim.process.engineering.verticalslice.__module_protocol__ diff --git a/src/jneqsim-stubs/process/engineering/dexpi/__init__.pyi b/src/jneqsim-stubs/process/engineering/dexpi/__init__.pyi index 72b88f13..9f236503 100644 --- a/src/jneqsim-stubs/process/engineering/dexpi/__init__.pyi +++ b/src/jneqsim-stubs/process/engineering/dexpi/__init__.pyi @@ -33,8 +33,12 @@ class Dexpi201PidMaterializer: class DexpiEngineeringExporter: @staticmethod def export(engineeringProject: jneqsim.process.engineering.EngineeringProject, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]) -> 'DexpiEngineeringExporter.ExportResult': ... + @typing.overload @staticmethod def exportDexpi201(engineeringProject: jneqsim.process.engineering.EngineeringProject, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath], dexpi20PlantExportMetadata: jneqsim.process.processmodel.dexpi.Dexpi20PlantExportMetadata) -> jneqsim.process.processmodel.dexpi.Dexpi20ConformanceAssessment.Report: ... + @typing.overload + @staticmethod + def exportDexpi201(engineeringProject: jneqsim.process.engineering.EngineeringProject, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath], dexpi20PlantExportMetadata: jneqsim.process.processmodel.dexpi.Dexpi20PlantExportMetadata, boolean: bool) -> jneqsim.process.processmodel.dexpi.Dexpi20ConformanceAssessment.Report: ... @staticmethod def refreshPackageManifest(path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]) -> java.nio.file.Path: ... class ExportResult: diff --git a/src/jneqsim-stubs/process/engineering/pid/__init__.pyi b/src/jneqsim-stubs/process/engineering/pid/__init__.pyi index 1e56abac..956a3b6c 100644 --- a/src/jneqsim-stubs/process/engineering/pid/__init__.pyi +++ b/src/jneqsim-stubs/process/engineering/pid/__init__.pyi @@ -9,6 +9,7 @@ import java.io import java.lang import java.nio.file import java.util +import jpype import jpype.protocol import jneqsim.process.controllerdevice import jneqsim.process.dynamics @@ -22,10 +23,26 @@ import jneqsim.process.measurementdevice import jneqsim.process.processmodel import jneqsim.process.processmodel.dexpi import jneqsim.process.safety.scenario +import jneqsim.process.safety.sif import typing +class HeatExchangerControllerTuning: + @staticmethod + def applyRecommendation(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: 'PidDesignModel', pidSimulationBindings: 'PidSimulationBindings', result: 'HeatExchangerControllerTuning.Result', string: typing.Union[java.lang.String, str]) -> 'PidDesignModel': ... + @staticmethod + def exportEvidence(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: 'PidDesignModel', pidSimulationBindings: 'PidSimulationBindings', result: 'HeatExchangerControllerTuning.Result') -> java.util.Map[java.lang.String, typing.Any]: ... + @staticmethod + def tune(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: 'PidDesignModel', pidSimulationBindings: 'PidSimulationBindings', definition: 'HeatExchangerControllerTuning.Definition') -> 'HeatExchangerControllerTuning.Result': ... + class Definition: + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float, double5: float, double6: float, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class Result(java.io.Serializable): + def getRecommendedParameters(self) -> typing.MutableSequence[float]: ... + def hasRecommendation(self) -> bool: ... + def toJson(self) -> java.lang.String: ... + class NorsokPidRuleCatalog: @staticmethod def completeProposals() -> 'PidRuleCatalog': ... @@ -183,6 +200,27 @@ class PidHazopStudyRunner: @staticmethod def run(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel) -> PidHazopStudyReport: ... +class PidNativeControlSystem: + @staticmethod + def applyCanonicalConfiguration(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings', processSystem: jneqsim.process.processmodel.ProcessSystem) -> 'PidNativeControlSystem.ConfiguredControlSystem': ... + @staticmethod + def automationRegisters(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings') -> java.util.Map[java.lang.String, typing.Any]: ... + @staticmethod + def bind(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel) -> 'PidSimulationBindings': ... + @staticmethod + def fromProcess(engineeringProject: jneqsim.process.engineering.EngineeringProject) -> PidDesignModel: ... + @typing.overload + @staticmethod + def validateConfigured(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings', processSystem: jneqsim.process.processmodel.ProcessSystem) -> 'PidNativeControlSystem.ConfiguredControlSystem': ... + @typing.overload + @staticmethod + def validateConfigured(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings', processSystem: jneqsim.process.processmodel.ProcessSystem, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Any], typing.Mapping[typing.Union[java.lang.String, str], typing.Any]]], typing.Mapping[typing.Union[java.lang.String, str], typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Any], typing.Mapping[typing.Union[java.lang.String, str], typing.Any]]]]) -> 'PidNativeControlSystem.ConfiguredControlSystem': ... + class ConfiguredControlSystem: + def assertSameConfiguration(self, configuredControlSystem: 'PidNativeControlSystem.ConfiguredControlSystem') -> None: ... + def getEvidenceReference(self) -> java.lang.String: ... + def getFingerprint(self) -> java.lang.String: ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class PidPhysicalProjection: def getAttachments(self) -> java.util.Map[java.lang.String, 'PidPhysicalProjection.Attachment']: ... def getSignals(self) -> java.util.List[java.util.Map[java.lang.String, java.lang.String]]: ... @@ -218,6 +256,7 @@ class PidPhysicalProjection: EXISTING_EQUIPMENT: typing.ClassVar['PidPhysicalProjection.Kind'] = ... INLINE_VALVE: typing.ClassVar['PidPhysicalProjection.Kind'] = ... SENSING: typing.ClassVar['PidPhysicalProjection.Kind'] = ... + MANUAL_INPUT: typing.ClassVar['PidPhysicalProjection.Kind'] = ... FUNCTION: typing.ClassVar['PidPhysicalProjection.Kind'] = ... PROCESS_NOZZLE: typing.ClassVar['PidPhysicalProjection.Kind'] = ... AUXILIARY_ROUTE: typing.ClassVar['PidPhysicalProjection.Kind'] = ... @@ -232,6 +271,31 @@ class PidPhysicalProjection: @staticmethod def values() -> typing.MutableSequence['PidPhysicalProjection.Kind']: ... +class PidPressureReliefImporter: + @staticmethod + def fromNativeValve(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings', processSystem: jneqsim.process.processmodel.ProcessSystem, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], string4: typing.Union[java.lang.String, str]) -> PidDesignModel: ... + +class PidPressureReliefValidator: + @typing.overload + @staticmethod + def applyCanonicalConfiguration(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings', processSystem: jneqsim.process.processmodel.ProcessSystem, string: typing.Union[java.lang.String, str]) -> 'PidPressureReliefValidator.ConfiguredRelief': ... + @typing.overload + @staticmethod + def applyCanonicalConfiguration(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings', processSystem: jneqsim.process.processmodel.ProcessSystem, string: typing.Union[java.lang.String, str], map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Any], typing.Mapping[typing.Union[java.lang.String, str], typing.Any]], double: float) -> 'PidPressureReliefValidator.ConfiguredRelief': ... + @staticmethod + def attachResult(configuredRelief: 'PidPressureReliefValidator.ConfiguredRelief', dynamicSafetyScenario: jneqsim.process.safety.scenario.DynamicSafetyScenario, dynamicSafetyScenarioResult: jneqsim.process.safety.scenario.DynamicSafetyScenarioResult, set: java.util.Set[typing.Union[java.lang.String, str]]) -> java.util.Map[java.lang.String, typing.Any]: ... + @typing.overload + @staticmethod + def validateConfigured(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings', processSystem: jneqsim.process.processmodel.ProcessSystem, string: typing.Union[java.lang.String, str]) -> 'PidPressureReliefValidator.ConfiguredRelief': ... + @typing.overload + @staticmethod + def validateConfigured(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings', processSystem: jneqsim.process.processmodel.ProcessSystem, string: typing.Union[java.lang.String, str], map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Any], typing.Mapping[typing.Union[java.lang.String, str], typing.Any]], double: float) -> 'PidPressureReliefValidator.ConfiguredRelief': ... + class ConfiguredRelief: + def assertSameConfiguration(self, configuredRelief: 'PidPressureReliefValidator.ConfiguredRelief') -> None: ... + def getEvidenceReference(self) -> java.lang.String: ... + def getFingerprint(self) -> java.lang.String: ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class PidProposalStatus(java.lang.Enum['PidProposalStatus']): PROPOSED: typing.ClassVar['PidProposalStatus'] = ... REVIEW_REQUIRED: typing.ClassVar['PidProposalStatus'] = ... @@ -252,6 +316,61 @@ class PidRuleCatalog(java.io.Serializable): def add(self, pidDesignRule: PidDesignRule) -> 'PidRuleCatalog': ... def getRules(self) -> java.util.List[PidDesignRule]: ... +class PidSafetyFunctionImporter: + @staticmethod + def fromNativeFunction(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings', processSystem: jneqsim.process.processmodel.ProcessSystem, closedLoopSafetyFunction: jneqsim.process.safety.sif.ClosedLoopSafetyFunction, string: typing.Union[java.lang.String, str]) -> PidDesignModel: ... + +class PidSafetyFunctionValidator: + @staticmethod + def attachResult(configuredFunction: 'PidSafetyFunctionValidator.ConfiguredFunction', dynamicSafetyScenario: jneqsim.process.safety.scenario.DynamicSafetyScenario, dynamicSafetyScenarioResult: jneqsim.process.safety.scenario.DynamicSafetyScenarioResult, set: java.util.Set[typing.Union[java.lang.String, str]]) -> java.util.Map[java.lang.String, typing.Any]: ... + @typing.overload + @staticmethod + def validateConfigured(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings', processSystem: jneqsim.process.processmodel.ProcessSystem, string: typing.Union[java.lang.String, str], closedLoopSafetyFunction: jneqsim.process.safety.sif.ClosedLoopSafetyFunction) -> 'PidSafetyFunctionValidator.ConfiguredFunction': ... + @typing.overload + @staticmethod + def validateConfigured(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings', processSystem: jneqsim.process.processmodel.ProcessSystem, string: typing.Union[java.lang.String, str], closedLoopSafetyFunction: jneqsim.process.safety.sif.ClosedLoopSafetyFunction, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], jneqsim.process.safety.sif.SafetyFunctionChannel.FaultMode], typing.Mapping[typing.Union[java.lang.String, str], jneqsim.process.safety.sif.SafetyFunctionChannel.FaultMode]]) -> 'PidSafetyFunctionValidator.ConfiguredFunction': ... + @typing.overload + @staticmethod + def validateConfigured(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings', processSystem: jneqsim.process.processmodel.ProcessSystem, string: typing.Union[java.lang.String, str], closedLoopSafetyFunction: jneqsim.process.safety.sif.ClosedLoopSafetyFunction, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], jneqsim.process.safety.sif.SafetyFunctionChannel.FaultMode], typing.Mapping[typing.Union[java.lang.String, str], jneqsim.process.safety.sif.SafetyFunctionChannel.FaultMode]], map2: typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Any], typing.Mapping[typing.Union[java.lang.String, str], typing.Any]]], typing.Mapping[typing.Union[java.lang.String, str], typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Any], typing.Mapping[typing.Union[java.lang.String, str], typing.Any]]]]) -> 'PidSafetyFunctionValidator.ConfiguredFunction': ... + class ConfiguredFunction: + def assertSameConfiguration(self, configuredFunction: 'PidSafetyFunctionValidator.ConfiguredFunction') -> None: ... + def getEvidenceReference(self) -> java.lang.String: ... + def getFingerprint(self) -> java.lang.String: ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + +class PidSeparatorControlStudy: + @staticmethod + def compareRefinement(result: 'PidSeparatorControlStudy.Result', result2: 'PidSeparatorControlStudy.Result', refinementLimits: 'PidSeparatorControlStudy.RefinementLimits') -> 'PidSeparatorControlStudy.RefinementResult': ... + @staticmethod + def evidence(result: 'PidSeparatorControlStudy.Result', refinementResult: 'PidSeparatorControlStudy.RefinementResult') -> java.util.Map[java.lang.String, typing.Any]: ... + @staticmethod + def run(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel, pidSimulationBindings: 'PidSimulationBindings', definition: 'PidSeparatorControlStudy.Definition', limits: 'PidSeparatorControlStudy.Limits') -> 'PidSeparatorControlStudy.Result': ... + class Check(java.io.Serializable): + def isPassed(self) -> bool: ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class Definition(java.io.Serializable): + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], string4: typing.Union[java.lang.String, str], string5: typing.Union[java.lang.String, str], string6: typing.Union[java.lang.String, str], string7: typing.Union[java.lang.String, str], string8: typing.Union[java.lang.String, str], string9: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float): ... + def boundPidTags(self) -> java.util.List[java.lang.String]: ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class Limits(java.io.Serializable): + def __init__(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, double9: float, double10: float, double11: float, double12: float, double13: float, double14: float, double15: float, double16: float, double17: float, double18: float): ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class RefinementLimits(java.io.Serializable): + def __init__(self, double: float, double2: float, double3: float, double4: float, double5: float): ... + class RefinementResult(java.io.Serializable): + def isPassed(self) -> bool: ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class Result(java.io.Serializable): + def getChecks(self) -> java.util.Map[java.lang.String, 'PidSeparatorControlStudy.Check']: ... + def getFinalSample(self) -> 'PidSeparatorControlStudy.Sample': ... + def getResultFingerprint(self) -> java.lang.String: ... + def getSamples(self) -> java.util.List['PidSeparatorControlStudy.Sample']: ... + def isPassed(self) -> bool: ... + def toJson(self) -> java.lang.String: ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class Sample(java.io.Serializable): + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class PidSimulationBindings(java.io.Serializable): def assertCurrent(self, engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: PidDesignModel) -> None: ... def bindController(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> 'PidSimulationBindings': ... @@ -296,6 +415,7 @@ class ProfessionalPidPackageExporter: class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.engineering.pid")``. + HeatExchangerControllerTuning: typing.Type[HeatExchangerControllerTuning] NorsokPidRuleCatalog: typing.Type[NorsokPidRuleCatalog] PidCompletenessFinding: typing.Type[PidCompletenessFinding] PidCompletenessReport: typing.Type[PidCompletenessReport] @@ -311,9 +431,15 @@ class __module_protocol__(Protocol): PidEngineeringPackageExporter: typing.Type[PidEngineeringPackageExporter] PidHazopStudyReport: typing.Type[PidHazopStudyReport] PidHazopStudyRunner: typing.Type[PidHazopStudyRunner] + PidNativeControlSystem: typing.Type[PidNativeControlSystem] PidPhysicalProjection: typing.Type[PidPhysicalProjection] + PidPressureReliefImporter: typing.Type[PidPressureReliefImporter] + PidPressureReliefValidator: typing.Type[PidPressureReliefValidator] PidProposalStatus: typing.Type[PidProposalStatus] PidRuleCatalog: typing.Type[PidRuleCatalog] + PidSafetyFunctionImporter: typing.Type[PidSafetyFunctionImporter] + PidSafetyFunctionValidator: typing.Type[PidSafetyFunctionValidator] + PidSeparatorControlStudy: typing.Type[PidSeparatorControlStudy] PidSimulationBindings: typing.Type[PidSimulationBindings] PidSimulationSession: typing.Type[PidSimulationSession] PidTagAllocator: typing.Type[PidTagAllocator] diff --git a/src/jneqsim-stubs/process/engineering/scd/__init__.pyi b/src/jneqsim-stubs/process/engineering/scd/__init__.pyi new file mode 100644 index 00000000..5846ca9a --- /dev/null +++ b/src/jneqsim-stubs/process/engineering/scd/__init__.pyi @@ -0,0 +1,44 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.io +import java.lang +import java.nio.file +import java.util +import jpype.protocol +import jneqsim.process.engineering +import jneqsim.process.engineering.pid +import jneqsim.process.processmodel.dexpi +import typing + + + +class ScdDesignModel(java.io.Serializable): + def __init__(self, engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: jneqsim.process.engineering.pid.PidDesignModel, pidSimulationBindings: jneqsim.process.engineering.pid.PidSimulationBindings, string: typing.Union[java.lang.String, str], engineeringStandard: jneqsim.process.engineering.EngineeringStandard): ... + def assertCurrent(self, engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: jneqsim.process.engineering.pid.PidDesignModel, pidSimulationBindings: jneqsim.process.engineering.pid.PidSimulationBindings) -> None: ... + @staticmethod + def attribute(pidElement: jneqsim.process.engineering.pid.PidElement, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + def getBlocks(self) -> java.util.List[jneqsim.process.engineering.pid.PidElement]: ... + def getDrawingNumber(self) -> java.lang.String: ... + def getRevision(self) -> java.lang.String: ... + def getSignals(self) -> java.util.List[java.util.Map[java.lang.String, java.lang.String]]: ... + def getStandard(self) -> jneqsim.process.engineering.EngineeringStandard: ... + @staticmethod + def template(pidElement: jneqsim.process.engineering.pid.PidElement) -> java.lang.String: ... + def toJson(self) -> java.lang.String: ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + +class ScdPackageExporter: + @staticmethod + def export(engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: jneqsim.process.engineering.pid.PidDesignModel, pidSimulationBindings: jneqsim.process.engineering.pid.PidSimulationBindings, scdDesignModel: ScdDesignModel, dexpi20PlantExportMetadata: jneqsim.process.processmodel.dexpi.Dexpi20PlantExportMetadata, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]) -> java.nio.file.Path: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.engineering.scd")``. + + ScdDesignModel: typing.Type[ScdDesignModel] + ScdPackageExporter: typing.Type[ScdPackageExporter] diff --git a/src/jneqsim-stubs/process/equipment/compressor/__init__.pyi b/src/jneqsim-stubs/process/equipment/compressor/__init__.pyi index bbde1909..4d6dab9a 100644 --- a/src/jneqsim-stubs/process/equipment/compressor/__init__.pyi +++ b/src/jneqsim-stubs/process/equipment/compressor/__init__.pyi @@ -1371,6 +1371,7 @@ class CompressorShaft(java.io.Serializable): def getMotorDriverUnit(self) -> jneqsim.process.equipment.energy.ElectricMotor: ... def getName(self) -> java.lang.String: ... def getOperatingReport(self) -> 'CompressorShaftReport': ... + def getPowerTrainResult(self) -> jneqsim.process.equipment.energy.CompressorPowerTrain.Result: ... def getPowerUtilization(self) -> float: ... def getPressureControl(self) -> 'CompressorShaft.PressureControl': ... def getRequiredDriverPower(self, string: typing.Union[java.lang.String, str]) -> float: ... @@ -1402,6 +1403,7 @@ class CompressorShaft(java.io.Serializable): def setMemberActive(self, compressor: 'Compressor', boolean: bool) -> None: ... def setMemberRequiredDischargePressure(self, compressor: 'Compressor', double: float, string: typing.Union[java.lang.String, str]) -> None: ... def setMotorDriverUnit(self, electricMotor: jneqsim.process.equipment.energy.ElectricMotor) -> None: ... + def setPowerTrain(self, compressorPowerTrain: jneqsim.process.equipment.energy.CompressorPowerTrain) -> None: ... def setPressureControl(self, pressureControl: 'CompressorShaft.PressureControl') -> None: ... def setPressureTolerance(self, double: float) -> None: ... def setRecycleValveFullOpenFraction(self, double: float) -> None: ... @@ -1456,6 +1458,7 @@ class CompressorShaft(java.io.Serializable): PRESSURE_ABOVE_MAX_SPEED: typing.ClassVar['CompressorShaft.SolveStatus'] = ... PRESSURE_BELOW_MIN_SPEED: typing.ClassVar['CompressorShaft.SolveStatus'] = ... OVER_POWER: typing.ClassVar['CompressorShaft.SolveStatus'] = ... + DRIVER_BELOW_MINIMUM_LOAD: typing.ClassVar['CompressorShaft.SolveStatus'] = ... STONEWALL: typing.ClassVar['CompressorShaft.SolveStatus'] = ... SURGE: typing.ClassVar['CompressorShaft.SolveStatus'] = ... NOT_CONFIGURED: typing.ClassVar['CompressorShaft.SolveStatus'] = ... @@ -1478,6 +1481,7 @@ class CompressorShaftReport(java.io.Serializable): def getDriverFuelMassFlowKgPerHr(self) -> float: ... def getMember(self, string: typing.Union[java.lang.String, str]) -> 'CompressorShaftReport.MemberReport': ... def getMembers(self) -> java.util.List['CompressorShaftReport.MemberReport']: ... + def getPowerTrain(self) -> jneqsim.process.equipment.energy.CompressorPowerTrain.Result: ... def getPowerUtilisation(self) -> float: ... def getRequiredDriverPowerW(self) -> float: ... def getShaftName(self) -> java.lang.String: ... diff --git a/src/jneqsim-stubs/process/equipment/distillation/__init__.pyi b/src/jneqsim-stubs/process/equipment/distillation/__init__.pyi index de363b71..e7733876 100644 --- a/src/jneqsim-stubs/process/equipment/distillation/__init__.pyi +++ b/src/jneqsim-stubs/process/equipment/distillation/__init__.pyi @@ -848,6 +848,7 @@ class DistillationColumn(jneqsim.process.equipment.ProcessEquipmentBaseClass, Di def getInletStreams(self) -> java.util.List[jneqsim.process.equipment.stream.StreamInterface]: ... def getInnerLoopSteps(self) -> int: ... def getInternalDiameter(self) -> float: ... + def getInternalFlowStationarityTolerance(self) -> float: ... def getLastAcceleratedFullTraySweepCount(self) -> int: ... def getLastAcceleratedInternalStreamTransferCount(self) -> int: ... def getLastAppliedTemperatureStepResidual(self) -> float: ... @@ -871,6 +872,8 @@ class DistillationColumn(jneqsim.process.equipment.ProcessEquipmentBaseClass, Di def getLastInsideOutOuterFlashSweeps(self) -> int: ... def getLastInsideOutSurrogateResetCount(self) -> int: ... def getLastInsideOutSurrogateResidual(self) -> float: ... + def getLastInternalFlowChange(self) -> float: ... + def getLastInternalFlowGrowth(self) -> float: ... def getLastInternalTrafficRatio(self) -> float: ... def getLastIterationCount(self) -> int: ... def getLastMassResidual(self) -> float: ... @@ -974,6 +977,7 @@ class DistillationColumn(jneqsim.process.equipment.ProcessEquipmentBaseClass, Di def isFullFractionatorFastPathEnabled(self) -> bool: ... def isHardIterationCap(self) -> bool: ... def isHydraulicPressureDropCouplingEnabled(self) -> bool: ... + def isInternalInventoryAccumulating(self) -> bool: ... def isLastColumnTearConverged(self) -> bool: ... def isReactive(self) -> bool: ... @staticmethod @@ -1019,6 +1023,7 @@ class DistillationColumn(jneqsim.process.equipment.ProcessEquipmentBaseClass, Di def setHydraulicPressureDropInternalsType(self, string: typing.Union[java.lang.String, str]) -> None: ... def setInnerLoopSteps(self, int: int) -> None: ... def setInternalDiameter(self, double: float) -> None: ... + def setInternalFlowStationarityTolerance(self, double: float) -> None: ... def setLiquidSideDrawFraction(self, int: int, double: float) -> None: ... def setMassBalanceTolerance(self, double: float) -> None: ... def setMaxAllowableFsFactor(self, double: float) -> None: ... diff --git a/src/jneqsim-stubs/process/equipment/energy/__init__.pyi b/src/jneqsim-stubs/process/equipment/energy/__init__.pyi index f3ff97c4..ede5c1ab 100644 --- a/src/jneqsim-stubs/process/equipment/energy/__init__.pyi +++ b/src/jneqsim-stubs/process/equipment/energy/__init__.pyi @@ -13,6 +13,7 @@ import jneqsim.process.equipment import jneqsim.process.equipment.compressor import jneqsim.process.equipment.compressor.driver import jneqsim.process.equipment.expander +import jneqsim.process.equipment.powergeneration.gasturbine import jneqsim.process.equipment.stream import jneqsim.process.processmodel import jneqsim.process.util.report @@ -57,6 +58,53 @@ class CommittedEnergyGenerator(jneqsim.process.equipment.ProcessEquipmentBaseCla def isStopBlocked(self) -> bool: ... def isStopped(self) -> bool: ... +class CompressorPowerTrain(java.io.Serializable): + @staticmethod + def directDrive(gasTurbineUnit: jneqsim.process.equipment.powergeneration.gasturbine.GasTurbineUnit) -> 'CompressorPowerTrain': ... + @staticmethod + def electricDrive(electricMotor: 'ElectricMotor') -> 'CompressorPowerTrain': ... + @typing.overload + def evaluate(self, double: float, double2: float, double3: float) -> 'CompressorPowerTrain.Result': ... + @typing.overload + def evaluate(self, double: float, double2: float, double3: float, double4: float) -> 'CompressorPowerTrain.Result': ... + @staticmethod + def gasElectricDrive(gasTurbineUnit: jneqsim.process.equipment.powergeneration.gasturbine.GasTurbineUnit, generator: 'Generator', electricMotor: 'ElectricMotor') -> 'CompressorPowerTrain': ... + def getAvailablePowerW(self, double: float, double2: float) -> float: ... + def getMode(self) -> 'CompressorPowerTrain.Mode': ... + def getTurbine(self) -> jneqsim.process.equipment.powergeneration.gasturbine.GasTurbineUnit: ... + def setElectricalAuxiliariesW(self, double: float) -> None: ... + def setElectricalSupplyLimitW(self, double: float) -> None: ... + class Mode(java.lang.Enum['CompressorPowerTrain.Mode']): + DIRECT_TURBINE: typing.ClassVar['CompressorPowerTrain.Mode'] = ... + ELECTRIC_MOTOR: typing.ClassVar['CompressorPowerTrain.Mode'] = ... + TURBINE_GENERATOR_MOTOR: typing.ClassVar['CompressorPowerTrain.Mode'] = ... + _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(class_: typing.Type[_valueOf_0__T], string: typing.Union[java.lang.String, str]) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: typing.Union[java.lang.String, str]) -> 'CompressorPowerTrain.Mode': ... + @staticmethod + def values() -> typing.MutableSequence['CompressorPowerTrain.Mode']: ... + class Result(java.io.Serializable): + def getAvailablePowerW(self) -> float: ... + def getCO2KgPerS(self) -> float: ... + def getConversionLossW(self) -> float: ... + def getDeliveredPowerW(self) -> float: ... + def getElectricalInputW(self) -> float: ... + def getEnergyBalanceResidualW(self) -> float: ... + def getFuelEnergyW(self) -> float: ... + def getFuelMassKgPerS(self) -> float: ... + def getPowerShortfallW(self) -> float: ... + def getRequiredPowerW(self) -> float: ... + def getTurbineShaftW(self) -> float: ... + def isBelowMinimumLoad(self) -> bool: ... + def isFeasible(self) -> bool: ... + def isPowerFeasible(self) -> bool: ... + def toJson(self) -> java.lang.String: ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class CoupledProcessEnergyResult(java.io.Serializable): def __init__(self, boolean: bool, terminationReason: 'CoupledProcessEnergyResult.TerminationReason', int: int, double: float, double2: float, list: java.util.List['CoupledProcessEnergyResult.IterationResult'], list2: java.util.List[jneqsim.process.equipment.stream.EnergyNetworkReport]): ... def getEnergyReports(self) -> java.util.List[jneqsim.process.equipment.stream.EnergyNetworkReport]: ... @@ -446,6 +494,7 @@ class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.energy")``. CommittedEnergyGenerator: typing.Type[CommittedEnergyGenerator] + CompressorPowerTrain: typing.Type[CompressorPowerTrain] CoupledProcessEnergyResult: typing.Type[CoupledProcessEnergyResult] CoupledProcessEnergySolver: typing.Type[CoupledProcessEnergySolver] ElectricMotor: typing.Type[ElectricMotor] diff --git a/src/jneqsim-stubs/process/equipment/heatexchanger/__init__.pyi b/src/jneqsim-stubs/process/equipment/heatexchanger/__init__.pyi index cca432d7..596ab579 100644 --- a/src/jneqsim-stubs/process/equipment/heatexchanger/__init__.pyi +++ b/src/jneqsim-stubs/process/equipment/heatexchanger/__init__.pyi @@ -11,6 +11,7 @@ import java.util import jpype import jneqsim.process import jneqsim.process.design +import jneqsim.process.dynamics import jneqsim.process.electricaldesign.heatexchanger import jneqsim.process.equipment import jneqsim.process.equipment.capacity @@ -21,6 +22,7 @@ import jneqsim.process.mechanicaldesign.heatexchanger import jneqsim.process.ml import jneqsim.process.util.report import jneqsim.thermo.system +import jneqsim.util.validation import typing @@ -50,15 +52,19 @@ class CoolingWaterSystem(java.io.Serializable): def getAnnualOperatingCost(self) -> float: ... def getPumpPower(self) -> float: ... def getTotalCWFlowRate(self) -> float: ... + def getTotalCWMassFlowRate(self) -> float: ... def getTotalDuty(self) -> float: ... def getTotalElectricalPower(self) -> float: ... def getTowerFanPower(self) -> float: ... def setAnnualOperatingHours(self, double: float) -> None: ... + def setCoolingWaterPressure(self, double: float) -> None: ... def setCoolingWaterReturnTemperature(self, double: float) -> None: ... + def setCoolingWaterSalinity(self, double: float) -> None: ... def setCoolingWaterSupplyTemperature(self, double: float) -> None: ... def setElectricityCost(self, double: float) -> None: ... def setPumpEfficiency(self, double: float) -> None: ... def setSystemPressureDrop(self, double: float) -> None: ... + def setTowerFanPowerFraction(self, double: float) -> None: ... def toJson(self) -> java.lang.String: ... class CoolingRequirement(java.io.Serializable): name: java.lang.String = ... @@ -383,17 +389,23 @@ class Cooler(Heater): def __init__(self, string: typing.Union[java.lang.String, str]): ... @typing.overload def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def applyDynamicTemperatureControlConfiguration(self, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Any], typing.Mapping[typing.Union[java.lang.String, str], typing.Any]]) -> None: ... def configureDynamicTemperatureControl(self, double: float, double2: float, double3: float, double4: float, string: typing.Union[java.lang.String, str]) -> None: ... + def getCoolingUtilityAvailabilityFraction(self) -> float: ... def getCoolingValveOpening(self) -> float: ... + def getDynamicTemperatureControlConfiguration(self) -> java.util.Map[java.lang.String, typing.Any]: ... def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.heatexchanger.HeatExchangerMechanicalDesign: ... def initMechanicalDesign(self) -> None: ... + def isDynamicCoolingUtilityAvailable(self) -> bool: ... def isDynamicTemperatureControlEnabled(self) -> bool: ... @typing.overload def runTransient(self, double: float) -> None: ... @typing.overload def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... + def setCoolingUtilityAvailabilityFraction(self, double: float) -> None: ... def setCoolingValveOpening(self, double: float) -> None: ... + def setDynamicCoolingUtilityAvailable(self, boolean: bool) -> None: ... def setDynamicDesignValveOpening(self, double: float) -> None: ... def setDynamicTimeConstants(self, double: float, double2: float) -> None: ... @typing.overload @@ -429,7 +441,7 @@ class FiredHeater(Heater): @typing.overload def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... -class HeatExchanger(Heater, HeatExchangerInterface, jneqsim.process.ml.StateVectorProvider): +class HeatExchanger(Heater, HeatExchangerInterface, jneqsim.process.ml.StateVectorProvider, jneqsim.process.dynamics.TransientStateParticipant['HeatExchanger.Snapshot']): guessOutTemperature: float = ... guessOutTemperatureUnit: java.lang.String = ... thermalEffectiveness: float = ... @@ -450,7 +462,9 @@ class HeatExchanger(Heater, HeatExchangerInterface, jneqsim.process.ml.StateVect @staticmethod def builder(string: typing.Union[java.lang.String, str]) -> 'HeatExchanger.Builder': ... def calcThermalEffectivenes(self, double: float, double2: float) -> float: ... + def captureTransientState(self) -> 'HeatExchanger.Snapshot': ... def clearCapacityConstraints(self) -> None: ... + def copy(self) -> 'HeatExchanger': ... def displayResult(self) -> None: ... @typing.overload def foulingScreening(self, double: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], string: typing.Union[java.lang.String, str]) -> 'HeatExchanger.FoulingScreeningResult': ... @@ -480,6 +494,7 @@ class HeatExchanger(Heater, HeatExchangerInterface, jneqsim.process.ml.StateVect def getInStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... def getInTemperature(self, int: int) -> float: ... def getInletStreams(self) -> java.util.List[jneqsim.process.equipment.stream.StreamInterface]: ... + def getLastThermalBalance(self) -> 'HeatExchanger.Balance': ... @typing.overload def getMassBalance(self) -> float: ... @typing.overload @@ -502,7 +517,11 @@ class HeatExchanger(Heater, HeatExchangerInterface, jneqsim.process.ml.StateVect def getShellSideHtc(self) -> float: ... def getSizingReport(self) -> java.lang.String: ... def getStateVector(self) -> jneqsim.process.ml.StateVector: ... + def getThermalConfiguration(self) -> java.util.Map[java.lang.String, typing.Any]: ... def getThermalEffectiveness(self) -> float: ... + def getThermalInventoryEnergyJ(self) -> float: ... + def getTransientStateCoverageIssue(self) -> java.lang.String: ... + def getTransientStateIdentity(self) -> java.lang.String: ... def getTubeHoldupVolume(self) -> float: ... def getTubeSideHtc(self) -> float: ... def getUAvalue(self) -> float: ... @@ -518,6 +537,7 @@ class HeatExchanger(Heater, HeatExchangerInterface, jneqsim.process.ml.StateVect def isUseRatingPressureDrop(self) -> bool: ... def needRecalculation(self) -> bool: ... def removeCapacityConstraint(self, string: typing.Union[java.lang.String, str]) -> bool: ... + def restoreTransientState(self, snapshot: 'HeatExchanger.Snapshot') -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -578,6 +598,12 @@ class HeatExchanger(Heater, HeatExchangerInterface, jneqsim.process.ml.StateVect def toJson(self) -> java.lang.String: ... @typing.overload def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + def validateSetup(self) -> jneqsim.util.validation.ValidationResult: ... + class Balance(java.io.Serializable): + def getAccumulationJ(self) -> float: ... + def getBoundaryEnergyJ(self) -> float: ... + def getResidualJ(self) -> float: ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... class Builder: def __init__(self, string: typing.Union[java.lang.String, str]): ... def UAvalue(self, double: float) -> 'HeatExchanger.Builder': ... @@ -610,6 +636,7 @@ class HeatExchanger(Heater, HeatExchangerInterface, jneqsim.process.ml.StateVect def getTemperatureUnit(self) -> java.lang.String: ... def getUaFraction(self) -> typing.MutableSequence[float]: ... def toJson(self) -> java.lang.String: ... + class Snapshot(java.io.Serializable): ... class MultiStreamHeatExchanger(Heater, MultiStreamHeatExchangerInterface): @typing.overload @@ -975,11 +1002,13 @@ class WaterCooler(Cooler): @typing.overload def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... def getCoolingWaterFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getCoolingWaterSalinity(self) -> float: ... + def needRecalculation(self) -> bool: ... @typing.overload def run(self) -> None: ... @typing.overload def run(self, uUID: java.util.UUID) -> None: ... - def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setCoolingWaterSalinity(self, double: float) -> None: ... def setWaterInletTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... def setWaterOutletTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... def setWaterPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... diff --git a/src/jneqsim-stubs/process/equipment/network/__init__.pyi b/src/jneqsim-stubs/process/equipment/network/__init__.pyi index 97f3aacc..c63bb7f2 100644 --- a/src/jneqsim-stubs/process/equipment/network/__init__.pyi +++ b/src/jneqsim-stubs/process/equipment/network/__init__.pyi @@ -1635,6 +1635,7 @@ class TransientSpeciesConservationReport(java.io.Serializable): class TwoFluidPipeNetwork(java.io.Serializable): def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addAlgebraicJunction(self, string: typing.Union[java.lang.String, str], double: float, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... def addCompressibleNode(self, string: typing.Union[java.lang.String, str], upstreamCompressibleVolume: jneqsim.process.equipment.pipeline.UpstreamCompressibleVolume) -> None: ... def addConservativeCompressibleNode(self, string: typing.Union[java.lang.String, str], upstreamCompressibleVolume: jneqsim.process.equipment.pipeline.UpstreamCompressibleVolume, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... @typing.overload @@ -1642,6 +1643,13 @@ class TwoFluidPipeNetwork(java.io.Serializable): @typing.overload def addFixedPressureNode(self, string: typing.Union[java.lang.String, str], double: float, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... def addPipe(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], twoFluidPipe: jneqsim.process.equipment.pipeline.TwoFluidPipe) -> None: ... + def getAlgebraicNodeComponentMassFraction(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def getBranchSubcycles(self, string: typing.Union[java.lang.String, str]) -> int: ... + def getLastAlgebraicJunctionNames(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getLastAlgebraicJunctionReport(self) -> 'TwoFluidPipeNetwork.AlgebraicJunctionReport': ... + @typing.overload + def getLastAlgebraicJunctionReport(self, string: typing.Union[java.lang.String, str]) -> 'TwoFluidPipeNetwork.AlgebraicJunctionReport': ... def getLastBalanceReport(self) -> 'TwoFluidPipeNetwork.BalanceReport': ... def getLastThermodynamicBalanceReport(self) -> 'TwoFluidPipeNetwork.ThermodynamicBalanceReport': ... def getName(self) -> java.lang.String: ... @@ -1653,13 +1661,28 @@ class TwoFluidPipeNetwork(java.io.Serializable): def initialize(self, uUID: java.util.UUID) -> None: ... def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... def setBranchOutletPhaseBackflowAllowed(self, string: typing.Union[java.lang.String, str], boolean: bool) -> None: ... + def setBranchSubcycles(self, string: typing.Union[java.lang.String, str], int: int) -> None: ... def setConservativeNodeSourceThermodynamics(self, string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface, double: float) -> None: ... + class AlgebraicJunctionReport(java.io.Serializable): + def getComponentNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getComponentResidualKg(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getEnergyResidualJ(self) -> float: ... + def getInterphaseTransferKg(self, phase: jneqsim.process.equipment.pipeline.TwoFluidMassBalanceReport.Phase) -> float: ... + def getMaximumRelativeComponentResidual(self) -> float: ... + def getMaximumRelativePhaseResidual(self) -> float: ... + def getNodeName(self) -> java.lang.String: ... + def getPhaseResidualKg(self, phase: jneqsim.process.equipment.pipeline.TwoFluidMassBalanceReport.Phase) -> float: ... + def getPressureIterations(self) -> int: ... + def getPressurePa(self) -> float: ... + def getRelativeEnergyResidual(self) -> float: ... + def getThermodynamicIterations(self) -> int: ... class BalanceReport(java.io.Serializable): def getElapsedTimeSeconds(self) -> float: ... def getExternalInletMassKg(self, phase: jneqsim.process.equipment.pipeline.TwoFluidMassBalanceReport.Phase) -> float: ... def getExternalOutletMassKg(self, phase: jneqsim.process.equipment.pipeline.TwoFluidMassBalanceReport.Phase) -> float: ... def getFinalMassKg(self, phase: jneqsim.process.equipment.pipeline.TwoFluidMassBalanceReport.Phase) -> float: ... def getInitialMassKg(self, phase: jneqsim.process.equipment.pipeline.TwoFluidMassBalanceReport.Phase) -> float: ... + def getInternalPhaseTransferKg(self, phase: jneqsim.process.equipment.pipeline.TwoFluidMassBalanceReport.Phase) -> float: ... def getRelativeResidual(self, phase: jneqsim.process.equipment.pipeline.TwoFluidMassBalanceReport.Phase) -> float: ... def getResidualKg(self, phase: jneqsim.process.equipment.pipeline.TwoFluidMassBalanceReport.Phase) -> float: ... def getSourceMassKg(self, phase: jneqsim.process.equipment.pipeline.TwoFluidMassBalanceReport.Phase) -> float: ... diff --git a/src/jneqsim-stubs/process/equipment/pipeline/__init__.pyi b/src/jneqsim-stubs/process/equipment/pipeline/__init__.pyi index 1d90d795..18cb2f98 100644 --- a/src/jneqsim-stubs/process/equipment/pipeline/__init__.pyi +++ b/src/jneqsim-stubs/process/equipment/pipeline/__init__.pyi @@ -195,6 +195,56 @@ class GravityDumpFloodInjectionAnalyzer(java.io.Serializable): def setWaterDepth(self, double: float) -> None: ... def setWellheadSupplyPressure(self, double: float) -> None: ... +class IdealGasPiggingModel(java.io.Serializable): + def __init__(self, pigMotion: 'PigMotion', systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, double9: float): ... + def advance(self, state: 'IdealGasPiggingModel.State', double: float) -> 'IdealGasPiggingModel.Step': ... + def getDownstreamPressurePa(self, state: 'IdealGasPiggingModel.State') -> float: ... + def getDownstreamTemperatureK(self, state: 'IdealGasPiggingModel.State') -> float: ... + def getGamma(self) -> float: ... + def getPipeAreaM2(self) -> float: ... + def getPipeLengthM(self) -> float: ... + def getUpstreamPressurePa(self, state: 'IdealGasPiggingModel.State') -> float: ... + def getUpstreamTemperatureK(self, state: 'IdealGasPiggingModel.State') -> float: ... + def initialise(self, double: float, double2: float, double3: float, double4: float, double5: float) -> 'IdealGasPiggingModel.State': ... + class Location(java.lang.Enum['IdealGasPiggingModel.Location']): + LAUNCHER: typing.ClassVar['IdealGasPiggingModel.Location'] = ... + PIPE: typing.ClassVar['IdealGasPiggingModel.Location'] = ... + RECEIVER: typing.ClassVar['IdealGasPiggingModel.Location'] = ... + _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(class_: typing.Type[_valueOf_0__T], string: typing.Union[java.lang.String, str]) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: typing.Union[java.lang.String, str]) -> 'IdealGasPiggingModel.Location': ... + @staticmethod + def values() -> typing.MutableSequence['IdealGasPiggingModel.Location']: ... + class State(java.io.Serializable): + def getDownstreamInternalEnergyJ(self) -> float: ... + def getDownstreamMassKg(self) -> float: ... + def getElapsedTimeSeconds(self) -> float: ... + def getLocation(self) -> 'IdealGasPiggingModel.Location': ... + def getPigPositionM(self) -> float: ... + def getPigVelocityMps(self) -> float: ... + def getUpstreamInternalEnergyJ(self) -> float: ... + def getUpstreamMassKg(self) -> float: ... + class Step(java.io.Serializable): + def getAbsoluteBypassMassKg(self) -> float: ... + def getChokedSeconds(self) -> float: ... + def getCombinedEnergyResidualJ(self) -> float: ... + def getContactImpactEnergyJ(self) -> float: ... + def getDurationSeconds(self) -> float: ... + def getFinalState(self) -> 'IdealGasPiggingModel.State': ... + def getFrictionHeatJ(self) -> float: ... + def getGasBoundaryWorkJ(self) -> float: ... + def getGravityWorkJ(self) -> float: ... + def getInternalStepCount(self) -> int: ... + def getMaximumAcceptedDonorMassFraction(self) -> float: ... + def getMaximumAcceptedPigTravelFraction(self) -> float: ... + def getPressureWorkJ(self) -> float: ... + def getSignedBypassMassKg(self) -> float: ... + def getTotalMassResidualKg(self) -> float: ... + class MultilayerThermalCalculator(java.io.Serializable): @typing.overload def __init__(self): ... @@ -242,7 +292,16 @@ class MultilayerThermalCalculator(java.io.Serializable): class PigMotion(java.io.Serializable): def __init__(self, double: float, double2: float, double3: float, double4: float): ... def advance(self, double: float, double2: float, double3: float, double4: float, double5: float) -> 'PigMotion.Step': ... + def advanceToPosition(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float) -> 'PigMotion.PositionEvent': ... + def getKineticFrictionN(self) -> float: ... + def getMassKg(self) -> float: ... + def getPressureAreaM2(self) -> float: ... + def getStaticFrictionN(self) -> float: ... def simulate(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[float], jpype.JArray]) -> 'PigMotion.Trajectory': ... + class PositionEvent(java.io.Serializable): + def getEventTimeSeconds(self) -> float: ... + def getStep(self) -> 'PigMotion.Step': ... + def isReached(self) -> bool: ... class Step(java.io.Serializable): def getDisplacementM(self) -> float: ... def getDistanceM(self) -> float: ... @@ -810,6 +869,7 @@ class TwoFluidThermalEnergyBalanceReport(java.io.Serializable): class UpstreamCompressibleVolume(java.io.Serializable): def __init__(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[float], jpype.JArray]): ... + def acceptCandidateState(self, upstreamCompressibleVolume: 'UpstreamCompressibleVolume') -> None: ... def advance(self, double: float, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... def getCumulativeSourceMassKg(self) -> float: ... def getCumulativeWithdrawalMassKg(self) -> float: ... @@ -821,6 +881,7 @@ class UpstreamCompressibleVolume(java.io.Serializable): def getTotalMassKg(self) -> float: ... def getVolumeM3(self) -> float: ... def setSourceMassFlowRates(self, double: float, double2: float, double3: float) -> None: ... + def validateCandidateConfiguration(self, upstreamCompressibleVolume: 'UpstreamCompressibleVolume') -> None: ... class VfpPipeline(jneqsim.process.equipment.TwoPortEquipment): @typing.overload @@ -1335,12 +1396,14 @@ class PipeBeggsAndBrills(Pipeline, jneqsim.process.design.AutoSizeable): def getLiquidSuperficialVelocityProfile(self) -> java.util.List[float]: ... def getMaxAllowableVelocity(self) -> float: ... def getMaxDesignAIV(self) -> float: ... + def getMaxErosionalVelocityRatio(self, double: float) -> float: ... def getMaxVelocityMethod(self) -> java.lang.String: ... def getMixtureDensityProfile(self) -> java.util.List[float]: ... def getMixtureReynoldsNumber(self) -> java.util.List[float]: ... def getMixtureSuperficialVelocityProfile(self) -> java.util.List[float]: ... def getMixtureVelocity(self) -> float: ... def getMixtureViscosityProfile(self) -> java.util.List[float]: ... + def getNoSlipMixtureDensity(self) -> float: ... def getNumberOfIncrements(self) -> int: ... def getOuterHeatTransferCoefficient(self) -> float: ... def getOutletSuperficialVelocity(self) -> float: ... @@ -1711,6 +1774,7 @@ class TwoFluidPipe(Pipeline): def __init__(self, string: typing.Union[java.lang.String, str]): ... @typing.overload def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def acceptTransientCandidate(self, transientCandidate: 'TwoFluidPipe.TransientCandidate') -> None: ... def addLocalLoss(self, double: float, double2: float) -> None: ... def calculateCooldownTime(self, double: float, string: typing.Union[java.lang.String, str]) -> float: ... def calculateHydrateCooldownTime(self) -> float: ... @@ -1778,6 +1842,8 @@ class TwoFluidPipe(Pipeline): def getInclinedSectionLiquidFallbackPotentialProfile(self) -> typing.MutableSequence[bool]: ... def getInitialWallTemperatureProfile(self) -> typing.MutableSequence[float]: ... def getInletBoundaryCondition(self) -> 'TwoFluidPipe.BoundaryCondition': ... + def getInletBoundaryFluid(self) -> jneqsim.thermo.system.SystemInterface: ... + def getInletFacePressure(self, string: typing.Union[java.lang.String, str]) -> float: ... def getInletPressure(self) -> float: ... def getInsulationType(self) -> java.lang.String: ... def getInsulationTypeEnum(self) -> 'TwoFluidPipe.InsulationType': ... @@ -1825,6 +1891,7 @@ class TwoFluidPipe(Pipeline): def getOutletPressure(self) -> float: ... def getOutletSlugCount(self) -> int: ... def getPositionProfile(self) -> typing.MutableSequence[float]: ... + def getPressureInletFlashCount(self) -> int: ... def getPressureProfile(self) -> typing.MutableSequence[float]: ... def getRoughness(self) -> float: ... def getSectionLengths(self) -> typing.MutableSequence[float]: ... @@ -1932,11 +1999,20 @@ class TwoFluidPipe(Pipeline): def openOutlet(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... def prepareConservativeEnergyTransientFromSteadyState(self) -> None: ... @typing.overload + def prepareTransientCandidate(self, double: float, uUID: java.util.UUID) -> 'TwoFluidPipe.TransientCandidate': ... + @typing.overload + def prepareTransientCandidate(self, double: float, uUID: java.util.UUID, double2: float, double3: float, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface) -> 'TwoFluidPipe.TransientCandidate': ... + @typing.overload + def prepareTransientCandidate(self, double: float, uUID: java.util.UUID, double2: float, double3: float, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface, int: int) -> 'TwoFluidPipe.TransientCandidate': ... + @typing.overload + def prepareTransientCandidate(self, double: float, uUID: java.util.UUID, int: int) -> 'TwoFluidPipe.TransientCandidate': ... + @typing.overload def prepareUnsplitTransient(self, double: float, double2: float, unsplitTransientSolver: jneqsim.process.equipment.pipeline.twophasepipe.numerics.UnsplitTransientSolver, phaseDensityModel: typing.Union[jneqsim.process.equipment.pipeline.twophasepipe.numerics.TwoFluidUnsplitModelAdapter.PhaseDensityModel, typing.Callable]) -> jneqsim.process.equipment.pipeline.twophasepipe.numerics.TwoFluidUnsplitIntegrator.PreparedInterval: ... @typing.overload def prepareUnsplitTransient(self, double: float, unsplitTransientSolver: jneqsim.process.equipment.pipeline.twophasepipe.numerics.UnsplitTransientSolver) -> jneqsim.process.equipment.pipeline.twophasepipe.numerics.TwoFluidUnsplitIntegrator.PreparedInterval: ... @typing.overload def prepareUnsplitTransient(self, double: float, unsplitTransientSolver: jneqsim.process.equipment.pipeline.twophasepipe.numerics.UnsplitTransientSolver, phaseDensityModel: typing.Union[jneqsim.process.equipment.pipeline.twophasepipe.numerics.TwoFluidUnsplitModelAdapter.PhaseDensityModel, typing.Callable]) -> jneqsim.process.equipment.pipeline.twophasepipe.numerics.TwoFluidUnsplitIntegrator.PreparedInterval: ... + def rollbackTransientCandidate(self, transientCandidate: 'TwoFluidPipe.TransientCandidate') -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -1988,6 +2064,7 @@ class TwoFluidPipe(Pipeline): def setInitialAqueousFilm(self, systemInterface: jneqsim.thermo.system.SystemInterface, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... def setInitialWallTemperatureProfile(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], string: typing.Union[java.lang.String, str]) -> None: ... def setInletBoundaryCondition(self, boundaryCondition: 'TwoFluidPipe.BoundaryCondition') -> None: ... + def setInletBoundaryFluid(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... def setInletLossCoefficient(self, double: float) -> None: ... @typing.overload def setInletMassFlow(self, double: float) -> None: ... @@ -2071,6 +2148,7 @@ class TwoFluidPipe(Pipeline): def toJson(self) -> java.lang.String: ... @typing.overload def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + def validateTransientCandidate(self, transientCandidate: 'TwoFluidPipe.TransientCandidate') -> None: ... class BoundaryCondition(java.lang.Enum['TwoFluidPipe.BoundaryCondition']): CONSTANT_PRESSURE: typing.ClassVar['TwoFluidPipe.BoundaryCondition'] = ... CONSTANT_FLOW: typing.ClassVar['TwoFluidPipe.BoundaryCondition'] = ... @@ -2145,6 +2223,11 @@ class TwoFluidPipe(Pipeline): def valueOf(string: typing.Union[java.lang.String, str]) -> 'TwoFluidPipe.SlugTrackingMode': ... @staticmethod def values() -> typing.MutableSequence['TwoFluidPipe.SlugTrackingMode']: ... + class TransientCandidate: + def getComponentConservationReport(self) -> TwoFluidComponentConservationReport: ... + def getConservativeEnergyReport(self) -> TwoFluidConservativeEnergyReport: ... + def getMassBalanceReport(self) -> TwoFluidMassBalanceReport: ... + def getSimulationTimeSeconds(self) -> float: ... class TwoPhasePipeLine(Pipeline): @typing.overload @@ -2579,6 +2662,7 @@ class __module_protocol__(Protocol): Fittings: typing.Type[Fittings] FlowSolveReport: typing.Type[FlowSolveReport] GravityDumpFloodInjectionAnalyzer: typing.Type[GravityDumpFloodInjectionAnalyzer] + IdealGasPiggingModel: typing.Type[IdealGasPiggingModel] IncompressiblePipeFlow: typing.Type[IncompressiblePipeFlow] MultilayerThermalCalculator: typing.Type[MultilayerThermalCalculator] MultiphasePipe: typing.Type[MultiphasePipe] diff --git a/src/jneqsim-stubs/process/equipment/pipeline/twophasepipe/__init__.pyi b/src/jneqsim-stubs/process/equipment/pipeline/twophasepipe/__init__.pyi index 3f84d945..788bed0c 100644 --- a/src/jneqsim-stubs/process/equipment/pipeline/twophasepipe/__init__.pyi +++ b/src/jneqsim-stubs/process/equipment/pipeline/twophasepipe/__init__.pyi @@ -176,6 +176,8 @@ class HydrocarbonPoolTransfer(java.io.Serializable): def calculate(self, twoFluidComponentTransport: 'TwoFluidComponentTransport', twoFluidSectionArray: typing.Union[typing.List['TwoFluidSection'], jpype.JArray], systemInterfaceArray: typing.Union[typing.List[jneqsim.thermo.system.SystemInterface], jpype.JArray], double: float) -> 'HydrocarbonPoolTransfer.Result': ... @staticmethod def forHydrostaticPool(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray], doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], double3: float) -> 'HydrocarbonPoolTransfer': ... + @staticmethod + def forStratifiedFlow(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray], doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], double3: float) -> 'HydrocarbonPoolTransfer': ... class Result(java.io.Serializable): def getDonorLimited(self) -> typing.MutableSequence[bool]: ... def getEquilibriumAppearanceArea(self) -> typing.MutableSequence[bool]: ... @@ -928,6 +930,7 @@ class TwoFluidConservationEquations(java.io.Serializable): IDX_LIQUID_MOMENTUM: typing.ClassVar[int] = ... def __init__(self): ... def accumulateLastBoundaryPhaseEnergyFluxes(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], double2: float) -> None: ... + def accumulateLastBoundaryPhaseMomentumFluxes(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], double3: float) -> None: ... def accumulateLastDirectionalPhaseMassFaceFluxes(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[typing.MutableSequence[float]]], jpype.JArray], double2: float) -> None: ... def accumulateLastEnergyFaceFluxes(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], double2: float) -> None: ... def accumulateLastPhaseMassFaceFluxes(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], double2: float) -> None: ... @@ -952,9 +955,12 @@ class TwoFluidConservationEquations(java.io.Serializable): def getFlowRegimeDetector(self) -> FlowRegimeDetector: ... def getFluxCalculator(self) -> jneqsim.process.equipment.pipeline.twophasepipe.numerics.AUSMPlusFluxCalculator: ... def getHeatTransferCoefficient(self) -> float: ... + def getInletFacePressure(self, twoFluidSectionArray: typing.Union[typing.List['TwoFluidSection'], jpype.JArray]) -> float: ... def getInterfacialFriction(self) -> jneqsim.process.equipment.pipeline.twophasepipe.closure.InterfacialFriction: ... def getInterfacialPressureCoefficient(self) -> float: ... def getLastBoundaryPhaseEnergyFluxes(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getLastBoundaryPhaseMomentumFluxes(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getLastBoundaryPhasePressureForces(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... def getLastEnergyFaceFluxes(self) -> typing.MutableSequence[float]: ... def getLastHydrostaticFacePressureCorrections(self) -> typing.MutableSequence[float]: ... def getLastMassBalanceRate(self) -> 'TwoFluidConservationEquations.MassBalanceRate': ... @@ -1008,6 +1014,7 @@ class TwoFluidConservationEquations(java.io.Serializable): def setIncludeMassTransfer(self, boolean: bool) -> None: ... def setInletBoundaryState(self, twoFluidSection: 'TwoFluidSection') -> None: ... def setInletPhaseFlowBoundaryState(self, twoFluidSection: 'TwoFluidSection') -> None: ... + def setInletPressureBoundaryState(self, twoFluidSection: 'TwoFluidSection') -> None: ... def setInterfacialPressureCoefficient(self, double: float) -> None: ... def setLocalEquilibriumStates(self, systemInterfaceArray: typing.Union[typing.List[jneqsim.thermo.system.SystemInterface], jpype.JArray]) -> None: ... def setMassTransferCoefficient(self, double: float) -> None: ... @@ -1029,6 +1036,8 @@ class TwoFluidConservationEquations(java.io.Serializable): def getOutletMassFlowKgPerSecond(self) -> typing.MutableSequence[float]: ... def getSourceMassFlowKgPerSecond(self) -> typing.MutableSequence[float]: ... class TransactionalEvaluation(java.io.Serializable): + def getBoundaryPhaseMomentumFluxes(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getBoundaryPhasePressureForces(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... def getDirectionalPhaseFaceFluxes(self) -> typing.MutableSequence[typing.MutableSequence[jneqsim.process.equipment.pipeline.twophasepipe.numerics.DirectionalPhaseFaceFlux]]: ... def getEnergyFaceFluxes(self) -> typing.MutableSequence[float]: ... def getMassBalanceRate(self) -> 'TwoFluidConservationEquations.MassBalanceRate': ... diff --git a/src/jneqsim-stubs/process/equipment/pipeline/twophasepipe/reporting/__init__.pyi b/src/jneqsim-stubs/process/equipment/pipeline/twophasepipe/reporting/__init__.pyi index f51e6431..329e2c90 100644 --- a/src/jneqsim-stubs/process/equipment/pipeline/twophasepipe/reporting/__init__.pyi +++ b/src/jneqsim-stubs/process/equipment/pipeline/twophasepipe/reporting/__init__.pyi @@ -8,6 +8,7 @@ else: import java.lang import java.nio.file import java.util +import jpype import jpype.protocol import jneqsim.process.equipment.pipeline import jneqsim.process.equipment.pipeline.twophasepipe.validation @@ -16,13 +17,21 @@ import typing class TwoFluidPipeReport: + @staticmethod + def analyzePressureTrace(doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], double3: float) -> 'TwoFluidPipeReport.PressureTraceMetrics': ... @staticmethod def capture(twoFluidPipe: jneqsim.process.equipment.pipeline.TwoFluidPipe) -> 'TwoFluidPipeReport.ProfileSnapshot': ... @staticmethod + def captureLowPointPools(twoFluidPipe: jneqsim.process.equipment.pipeline.TwoFluidPipe) -> 'TwoFluidPipeReport.LowPointPoolSnapshot': ... + @staticmethod + def newLowPointPoolSnapshotList() -> java.util.List['TwoFluidPipeReport.LowPointPoolSnapshot']: ... + @staticmethod def newSnapshotList() -> java.util.List['TwoFluidPipeReport.ProfileSnapshot']: ... @staticmethod def toComparisonCsv(comparison: jneqsim.process.equipment.pipeline.twophasepipe.validation.TwoFluidBenchmarkHarness.Comparison) -> java.lang.String: ... @staticmethod + def toLowPointPoolCsv(list: java.util.List['TwoFluidPipeReport.LowPointPoolSnapshot']) -> java.lang.String: ... + @staticmethod def toSlugAndFlowAssuranceCsv(twoFluidPipe: jneqsim.process.equipment.pipeline.TwoFluidPipe) -> java.lang.String: ... @staticmethod def toSteadyStateProfileCsv(twoFluidPipe: jneqsim.process.equipment.pipeline.TwoFluidPipe) -> java.lang.String: ... @@ -35,6 +44,8 @@ class TwoFluidPipeReport: @staticmethod def writeComparisonCsv(comparison: jneqsim.process.equipment.pipeline.twophasepipe.validation.TwoFluidBenchmarkHarness.Comparison, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]) -> None: ... @staticmethod + def writeLowPointPoolCsv(list: java.util.List['TwoFluidPipeReport.LowPointPoolSnapshot'], path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]) -> None: ... + @staticmethod def writeSlugAndFlowAssuranceCsv(twoFluidPipe: jneqsim.process.equipment.pipeline.TwoFluidPipe, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]) -> None: ... @staticmethod def writeSteadyStateProfileCsv(twoFluidPipe: jneqsim.process.equipment.pipeline.TwoFluidPipe, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]) -> None: ... @@ -44,6 +55,36 @@ class TwoFluidPipeReport: def writeSummaryText(twoFluidPipe: jneqsim.process.equipment.pipeline.TwoFluidPipe, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]) -> None: ... @staticmethod def writeTransientProfileCsv(list: java.util.List['TwoFluidPipeReport.ProfileSnapshot'], path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]) -> None: ... + class LowPointPoolSnapshot: + def getBasinEndCell(self) -> typing.MutableSequence[int]: ... + def getBasinStartCell(self) -> typing.MutableSequence[int]: ... + def getInterfaceAreaSquareMeters(self) -> typing.MutableSequence[float]: ... + def getInterphaseOilMassRateKilogramsPerSecond(self) -> typing.MutableSequence[float]: ... + def getLiquidInventoryCubicMeters(self) -> typing.MutableSequence[float]: ... + def getLowPointCell(self) -> typing.MutableSequence[int]: ... + def getLowPointElevationMeters(self) -> typing.MutableSequence[float]: ... + def getLowPointLiquidDepthMeters(self) -> typing.MutableSequence[float]: ... + def getLowPointPositionMeters(self) -> typing.MutableSequence[float]: ... + def getMaximumAbsoluteGasVelocityMetersPerSecond(self) -> typing.MutableSequence[float]: ... + def getMaximumAbsoluteOilVelocityMetersPerSecond(self) -> typing.MutableSequence[float]: ... + def getMaximumLocalLiquidDepthMeters(self) -> typing.MutableSequence[float]: ... + def getMinimumHeatScale(self) -> typing.MutableSequence[float]: ... + def getOilInventoryCubicMeters(self) -> typing.MutableSequence[float]: ... + def getOilInventoryKilograms(self) -> typing.MutableSequence[float]: ... + def getPoolId(self) -> typing.MutableSequence[int]: ... + def getTimeSeconds(self) -> float: ... + def getTraceAreaFallback(self) -> typing.MutableSequence[bool]: ... + class PressureTraceMetrics: + def getDirectionReversals(self) -> int: ... + def getExcessVariationPa(self) -> float: ... + def getMaximumAbsolutePressureRatePaPerSecond(self) -> float: ... + def getMaximumPressurePa(self) -> float: ... + def getMinimumPressurePa(self) -> float: ... + def getPeakToPeakPressurePa(self) -> float: ... + def getRingingRatio(self) -> float: ... + def getTimeOfMaximumSeconds(self) -> float: ... + def getTimeOfMinimumSeconds(self) -> float: ... + def getTotalVariationPa(self) -> float: ... class ProfileSnapshot: def getTimeSeconds(self) -> float: ... diff --git a/src/jneqsim-stubs/process/equipment/powergeneration/gasturbine/__init__.pyi b/src/jneqsim-stubs/process/equipment/powergeneration/gasturbine/__init__.pyi index 708ba068..14411186 100644 --- a/src/jneqsim-stubs/process/equipment/powergeneration/gasturbine/__init__.pyi +++ b/src/jneqsim-stubs/process/equipment/powergeneration/gasturbine/__init__.pyi @@ -74,6 +74,7 @@ class GasTurbinePerformanceMap(java.io.Serializable): T_ISO_K: typing.ClassVar[float] = ... P_ISO_BARA: typing.ClassVar[float] = ... def __init__(self): ... + def clearPartLoadHeatRateTable(self) -> None: ... @staticmethod def forIndustrial() -> 'GasTurbinePerformanceMap': ... @staticmethod @@ -94,6 +95,7 @@ class GasTurbinePerformanceMap(java.io.Serializable): def setExhaustTemperatureRisePerKelvin(self, double: float) -> None: ... def setHeatRatePolynomial(self, double: float, double2: float, double3: float) -> None: ... def setMinLoadFraction(self, double: float) -> None: ... + def setPartLoadHeatRateTable(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... def setSiteExhaustTemperatureTable(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... def setSiteHeatRateTable(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... def setSiteRatingFromPowerPoints(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], double3: float) -> None: ... @@ -154,6 +156,8 @@ class GasTurbineUnit(jneqsim.process.equipment.TwoPortEquipment): def getFuelEnergyRateW(self) -> float: ... def getFuelMassFlowKgPerHr(self) -> float: ... def getFuelMassFlowKgPerS(self) -> float: ... + def getInstallationHeatRateFactor(self) -> float: ... + def getInstallationPowerFactor(self) -> float: ... def getLoadFraction(self) -> float: ... def getMaxExhaustTemperatureK(self) -> float: ... def getMethaneSlipKgPerS(self) -> float: ... @@ -185,8 +189,11 @@ class GasTurbineUnit(jneqsim.process.equipment.TwoPortEquipment): def setEnforcePowerLimit(self, boolean: bool) -> None: ... def setExhaustLimitPowerLossPerKelvin(self, double: float) -> None: ... def setExhaustSpecificHeatKJPerKgK(self, double: float) -> None: ... + def setInstallationPressureLosses(self, double: float, double2: float) -> None: ... def setMaxExhaustTemperatureK(self, double: float) -> None: ... def setPerformanceMap(self, gasTurbinePerformanceMap: GasTurbinePerformanceMap) -> None: ... + def setPressureLossSensitivities(self, double: float, double2: float, double3: float, double4: float) -> None: ... + def setReferencePressureLosses(self, double: float, double2: float) -> None: ... def setSpec(self, gasTurbineSpec: GasTurbineSpec) -> None: ... class GasTurbineWashPlanner(java.io.Serializable): diff --git a/src/jneqsim-stubs/process/equipment/separator/__init__.pyi b/src/jneqsim-stubs/process/equipment/separator/__init__.pyi index 68c8dc03..052c91ab 100644 --- a/src/jneqsim-stubs/process/equipment/separator/__init__.pyi +++ b/src/jneqsim-stubs/process/equipment/separator/__init__.pyi @@ -157,6 +157,108 @@ class SeparatorInterface(jneqsim.process.SimulationInterface): def setInternalDiameter(self, double: float) -> None: ... def setLiquidLevel(self, double: float) -> None: ... +class SeparatorTransientEnergyBalanceReport(java.io.Serializable): + def assess(self, double: float) -> 'SeparatorTransientEnergyBalanceReport.EnergyVerdict': ... + def getAbsoluteInitialEnergyJ(self) -> float: ... + def getAcceptedStepCount(self) -> int: ... + def getAcceptedVolumeM3(self) -> float: ... + def getAcceptedVuEnergyJ(self) -> float: ... + def getAttemptedElapsedTimeSeconds(self) -> float: ... + def getAttemptedStepCount(self) -> int: ... + def getBeforeEnergyJ(self) -> float: ... + def getCoverageIssue(self) -> 'SeparatorTransientEnergyBalanceReport.CoverageIssue': ... + def getCumulativeAbsoluteLocalVuDefectJ(self) -> float: ... + def getCumulativeDebtJ(self) -> float: ... + def getCumulativeSignedLocalVuDefectJ(self) -> float: ... + def getElapsedTimeSeconds(self) -> float: ... + def getEpoch(self) -> int: ... + def getExpectedEnergyJ(self) -> float: ... + def getGasOutletEnergyJ(self) -> float: ... + def getGasOutletEnthalpyRateW(self) -> float: ... + def getGasOutletMolarRateMolPerSecond(self) -> float: ... + def getHeatInputEnergyJ(self) -> float: ... + def getHeatInputRateW(self) -> float: ... + def getInitialEnergyJ(self) -> float: ... + def getInletEnergyJ(self) -> float: ... + def getInletEnthalpyRateW(self) -> float: ... + def getInletMolarRateMolPerSecond(self) -> float: ... + def getLastAcceptedCalculationIdentifier(self) -> java.util.UUID: ... + def getLiquidOutletEnergyJ(self) -> float: ... + def getLiquidOutletEnthalpyRateW(self) -> float: ... + def getLiquidOutletMolarRateMolPerSecond(self) -> float: ... + def getLocalVuDefectJ(self) -> float: ... + def getMaximumAbsoluteCumulativeDebtJ(self) -> float: ... + def getMaximumAbsoluteLocalVuDefectJ(self) -> float: ... + def getMaximumRelativeCumulativeResidual(self) -> float: ... + def getNativeEquipmentTimeSeconds(self) -> float: ... + def getNetIntegratedEnergyJ(self) -> float: ... + def getNonVuEnergyDifferenceJ(self) -> float: ... + def getNormalizationScaleJ(self) -> float: ... + def getPublishedEnergyJ(self) -> float: ... + def getPublishedVolumeM3(self) -> float: ... + def getRelativeCumulativeResidual(self) -> float: ... + def getRelativeLocalVuDefect(self) -> float: ... + def getRelativeVolumeResidual(self) -> float: ... + def getSkippedStepCount(self) -> int: ... + def getSpecifiedVolumeM3(self) -> float: ... + def getTargetEnergyJ(self) -> float: ... + def getTimeStepSeconds(self) -> float: ... + def getVolumeDefectM3(self) -> float: ... + def isComplete(self) -> bool: ... + def isComponentRemovalLimited(self) -> bool: ... + def isLiquidOutletTermApplied(self) -> bool: ... + class CoverageIssue(java.lang.Enum['SeparatorTransientEnergyBalanceReport.CoverageIssue']): + NONE: typing.ClassVar['SeparatorTransientEnergyBalanceReport.CoverageIssue'] = ... + SKIPPED_EMPTY_INVENTORY: typing.ClassVar['SeparatorTransientEnergyBalanceReport.CoverageIssue'] = ... + SKIPPED_PROPERTY_INITIALIZATION: typing.ClassVar['SeparatorTransientEnergyBalanceReport.CoverageIssue'] = ... + SKIPPED_DEPLETED_INVENTORY: typing.ClassVar['SeparatorTransientEnergyBalanceReport.CoverageIssue'] = ... + INITIALIZATION_FAILED: typing.ClassVar['SeparatorTransientEnergyBalanceReport.CoverageIssue'] = ... + STEADY_STATE_REEVALUATION: typing.ClassVar['SeparatorTransientEnergyBalanceReport.CoverageIssue'] = ... + EXCLUDED_NONZERO_LIQUID_OUTLET: typing.ClassVar['SeparatorTransientEnergyBalanceReport.CoverageIssue'] = ... + NONFINITE_DIAGNOSTIC: typing.ClassVar['SeparatorTransientEnergyBalanceReport.CoverageIssue'] = ... + UNSUPPORTED_BOUNDARY_FLOW: typing.ClassVar['SeparatorTransientEnergyBalanceReport.CoverageIssue'] = ... + COMPONENT_REMOVAL_LIMITED: typing.ClassVar['SeparatorTransientEnergyBalanceReport.CoverageIssue'] = ... + _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(class_: typing.Type[_valueOf_0__T], string: typing.Union[java.lang.String, str]) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: typing.Union[java.lang.String, str]) -> 'SeparatorTransientEnergyBalanceReport.CoverageIssue': ... + @staticmethod + def values() -> typing.MutableSequence['SeparatorTransientEnergyBalanceReport.CoverageIssue']: ... + class EnergyVerdict(java.lang.Enum['SeparatorTransientEnergyBalanceReport.EnergyVerdict']): + DISABLED: typing.ClassVar['SeparatorTransientEnergyBalanceReport.EnergyVerdict'] = ... + NOT_STARTED: typing.ClassVar['SeparatorTransientEnergyBalanceReport.EnergyVerdict'] = ... + INCOMPLETE: typing.ClassVar['SeparatorTransientEnergyBalanceReport.EnergyVerdict'] = ... + UNSUPPORTED: typing.ClassVar['SeparatorTransientEnergyBalanceReport.EnergyVerdict'] = ... + PASS: typing.ClassVar['SeparatorTransientEnergyBalanceReport.EnergyVerdict'] = ... + FAIL: typing.ClassVar['SeparatorTransientEnergyBalanceReport.EnergyVerdict'] = ... + _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(class_: typing.Type[_valueOf_0__T], string: typing.Union[java.lang.String, str]) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: typing.Union[java.lang.String, str]) -> 'SeparatorTransientEnergyBalanceReport.EnergyVerdict': ... + @staticmethod + def values() -> typing.MutableSequence['SeparatorTransientEnergyBalanceReport.EnergyVerdict']: ... + class TrackingStatus(java.lang.Enum['SeparatorTransientEnergyBalanceReport.TrackingStatus']): + DISABLED: typing.ClassVar['SeparatorTransientEnergyBalanceReport.TrackingStatus'] = ... + NOT_STARTED: typing.ClassVar['SeparatorTransientEnergyBalanceReport.TrackingStatus'] = ... + COMPLETE: typing.ClassVar['SeparatorTransientEnergyBalanceReport.TrackingStatus'] = ... + INCOMPLETE: typing.ClassVar['SeparatorTransientEnergyBalanceReport.TrackingStatus'] = ... + UNSUPPORTED: typing.ClassVar['SeparatorTransientEnergyBalanceReport.TrackingStatus'] = ... + _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(class_: typing.Type[_valueOf_0__T], string: typing.Union[java.lang.String, str]) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: typing.Union[java.lang.String, str]) -> 'SeparatorTransientEnergyBalanceReport.TrackingStatus': ... + @staticmethod + def values() -> typing.MutableSequence['SeparatorTransientEnergyBalanceReport.TrackingStatus']: ... + class SolidsSeparator(jneqsim.process.equipment.ProcessEquipmentBaseClass): @typing.overload def __init__(self, string: typing.Union[java.lang.String, str]): ... @@ -233,6 +335,7 @@ class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorIn def addCapacityConstraint(self, capacityConstraint: jneqsim.process.equipment.capacity.CapacityConstraint) -> None: ... def addSeparatorSection(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... def addStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def assessTransientEnergyBalance(self, double: float) -> SeparatorTransientEnergyBalanceReport.EnergyVerdict: ... @typing.overload def autoSize(self) -> None: ... @typing.overload @@ -274,6 +377,7 @@ class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorIn def getCapacityDuty(self) -> float: ... def getCapacityMax(self) -> float: ... def getCapacityUtilization(self) -> float: ... + def getConservativeTransientEnergyTargetJ(self) -> float: ... def getConstraintSummary(self) -> java.lang.String: ... @typing.overload def getDeRatedGasLoadFactor(self) -> float: ... @@ -317,6 +421,7 @@ class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorIn def getInternalDiameter(self) -> float: ... def getKFactor(self) -> float: ... def getKFactorUtilization(self) -> float: ... + def getLastTransientEnergyBalanceReport(self) -> SeparatorTransientEnergyBalanceReport: ... def getLiquid(self) -> jneqsim.process.equipment.stream.StreamInterface: ... def getLiquidCarryoverFraction(self) -> float: ... def getLiquidLevel(self) -> float: ... @@ -355,6 +460,8 @@ class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorIn def getSizingReportJson(self) -> java.lang.String: ... def getStateVector(self) -> jneqsim.process.ml.StateVector: ... def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getTransientEnergyBalanceCoverageIssue(self) -> SeparatorTransientEnergyBalanceReport.CoverageIssue: ... + def getTransientEnergyBalanceTrackingStatus(self) -> SeparatorTransientEnergyBalanceReport.TrackingStatus: ... def getTransientStateCoverageIssue(self) -> java.lang.String: ... def getTransientStateIdentity(self) -> java.lang.String: ... def getUnwettedArea(self) -> float: ... @@ -370,6 +477,7 @@ class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorIn def initializeTransientCalculation(self) -> None: ... def isAutoSized(self) -> bool: ... def isCapacityExceeded(self) -> bool: ... + def isConservativeTransientEnergyIntegrationEnabled(self) -> bool: ... def isConstraintEnabled(self, string: typing.Union[java.lang.String, str]) -> bool: ... def isDetailedEntrainmentCalculation(self) -> bool: ... @typing.overload @@ -396,6 +504,7 @@ class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorIn def isSetHeatInput(self) -> bool: ... def isSimulationValid(self) -> bool: ... def isSinglePhase(self) -> bool: ... + def isTransientEnergyBalanceTrackingEnabled(self) -> bool: ... @typing.overload def isWaterRetentionTimeAboveMinimum(self) -> bool: ... @typing.overload @@ -405,6 +514,8 @@ class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorIn def levelFromVolume(self, double: float) -> float: ... def liquidArea(self, double: float) -> float: ... def removeCapacityConstraint(self, string: typing.Union[java.lang.String, str]) -> bool: ... + def resetConservativeTransientEnergyIntegration(self) -> None: ... + def resetTransientEnergyBalanceTracking(self) -> None: ... def restoreTransientState(self, transientState: 'Separator.TransientState') -> None: ... @typing.overload def run(self) -> None: ... @@ -415,6 +526,7 @@ class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorIn @typing.overload def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... def setBootVolume(self, double: float) -> None: ... + def setConservativeTransientEnergyIntegrationEnabled(self, boolean: bool) -> None: ... def setDesignGasLoadFactor(self, double: float) -> None: ... def setDesignLiquidLevelFraction(self, double: float) -> None: ... def setDetailedEntrainmentCalculation(self, boolean: bool) -> None: ... @@ -456,6 +568,7 @@ class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorIn def setPressureDrop(self, double: float) -> None: ... def setSeparatorLength(self, double: float) -> None: ... def setTempPres(self, double: float, double2: float) -> None: ... + def setTransientEnergyBalanceTrackingEnabled(self, boolean: bool) -> None: ... def setWeirHeight(self, double: float) -> None: ... def setWeirLength(self, double: float) -> None: ... def sizeFromFlow(self, double: float) -> None: ... @@ -681,6 +794,7 @@ class __module_protocol__(Protocol): Separator: typing.Type[Separator] SeparatorCapacityAssessment: typing.Type[SeparatorCapacityAssessment] SeparatorInterface: typing.Type[SeparatorInterface] + SeparatorTransientEnergyBalanceReport: typing.Type[SeparatorTransientEnergyBalanceReport] SolidsCentrifuge: typing.Type[SolidsCentrifuge] SolidsSeparator: typing.Type[SolidsSeparator] ThreePhaseGasScrubber: typing.Type[ThreePhaseGasScrubber] diff --git a/src/jneqsim-stubs/process/equipment/splitter/__init__.pyi b/src/jneqsim-stubs/process/equipment/splitter/__init__.pyi index e30bbfcf..d1b31829 100644 --- a/src/jneqsim-stubs/process/equipment/splitter/__init__.pyi +++ b/src/jneqsim-stubs/process/equipment/splitter/__init__.pyi @@ -5,9 +5,11 @@ if sys.version_info >= (3, 8): else: from typing_extensions import Protocol +import java.io import java.lang import java.util import jpype +import jneqsim.process.dynamics import jneqsim.process.equipment import jneqsim.process.equipment.capacity import jneqsim.process.equipment.stream @@ -142,7 +144,7 @@ class SplitterInterface(jneqsim.process.equipment.ProcessEquipmentInterface): def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... def setSplitNumber(self, int: int) -> None: ... -class Splitter(jneqsim.process.equipment.ProcessEquipmentBaseClass, SplitterInterface, jneqsim.process.equipment.capacity.CapacityConstrainedEquipment): +class Splitter(jneqsim.process.equipment.ProcessEquipmentBaseClass, SplitterInterface, jneqsim.process.equipment.capacity.CapacityConstrainedEquipment, jneqsim.process.dynamics.TransientStateParticipant['Splitter.TransientState']): REMAINDER: typing.ClassVar[float] = ... @typing.overload def __init__(self, string: typing.Union[java.lang.String, str]): ... @@ -152,6 +154,7 @@ class Splitter(jneqsim.process.equipment.ProcessEquipmentBaseClass, SplitterInte def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface, int: int): ... def addCapacityConstraint(self, capacityConstraint: jneqsim.process.equipment.capacity.CapacityConstraint) -> None: ... def calcSplitFactors(self) -> None: ... + def captureTransientState(self) -> 'Splitter.TransientState': ... def clearCapacityConstraints(self) -> None: ... def displayResult(self) -> None: ... def getBottleneckConstraint(self) -> jneqsim.process.equipment.capacity.CapacityConstraint: ... @@ -174,12 +177,16 @@ class Splitter(jneqsim.process.equipment.ProcessEquipmentBaseClass, SplitterInte def getSplitNumber(self) -> int: ... def getSplitStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... def getTransientSplitMode(self) -> 'Splitter.TransientSplitMode': ... + def getTransientStateCoverageIssue(self) -> java.lang.String: ... + def getTransientStateIdentity(self) -> java.lang.String: ... def initMechanicalDesign(self) -> None: ... def isCapacityAnalysisEnabled(self) -> bool: ... def isCapacityExceeded(self) -> bool: ... def isHardLimitExceeded(self) -> bool: ... def needRecalculation(self) -> bool: ... + def refreshTransientBranchIntensiveState(self) -> None: ... def removeCapacityConstraint(self, string: typing.Union[java.lang.String, str]) -> bool: ... + def restoreTransientState(self, transientState: 'Splitter.TransientState') -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -203,6 +210,7 @@ class Splitter(jneqsim.process.equipment.ProcessEquipmentBaseClass, SplitterInte def validateSetup(self) -> jneqsim.util.validation.ValidationResult: ... class TransientSplitMode(java.lang.Enum['Splitter.TransientSplitMode']): DOWNSTREAM_DEMAND: typing.ClassVar['Splitter.TransientSplitMode'] = ... + DOWNSTREAM_DEMAND_ALWAYS: typing.ClassVar['Splitter.TransientSplitMode'] = ... PRESCRIBED_SPLIT: typing.ClassVar['Splitter.TransientSplitMode'] = ... _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # @typing.overload @@ -213,6 +221,7 @@ class Splitter(jneqsim.process.equipment.ProcessEquipmentBaseClass, SplitterInte def valueOf(string: typing.Union[java.lang.String, str]) -> 'Splitter.TransientSplitMode': ... @staticmethod def values() -> typing.MutableSequence['Splitter.TransientSplitMode']: ... + class TransientState(java.io.Serializable): ... class __module_protocol__(Protocol): diff --git a/src/jneqsim-stubs/process/equipment/valve/__init__.pyi b/src/jneqsim-stubs/process/equipment/valve/__init__.pyi index 1c7c7c33..94a7f9a4 100644 --- a/src/jneqsim-stubs/process/equipment/valve/__init__.pyi +++ b/src/jneqsim-stubs/process/equipment/valve/__init__.pyi @@ -458,12 +458,19 @@ class CheckValve(ThrottlingValve): def __init__(self, string: typing.Union[java.lang.String, str]): ... @typing.overload def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def calculateMolarFlow(self) -> float: ... + def captureTransientState(self) -> ThrottlingValve.TransientState: ... def getCrackingPressure(self) -> float: ... + def getTransientStateCoverageIssue(self) -> java.lang.String: ... def isOpen(self) -> bool: ... @typing.overload def run(self) -> None: ... @typing.overload def run(self, uUID: java.util.UUID) -> None: ... + @typing.overload + def runTransient(self, double: float) -> None: ... + @typing.overload + def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... def setCrackingPressure(self, double: float) -> None: ... def toString(self) -> java.lang.String: ... @@ -493,6 +500,7 @@ class ESDValve(ThrottlingValve): def isEnergized(self) -> bool: ... def isPartialStrokeTestActive(self) -> bool: ... def reset(self) -> None: ... + def runController(self, double: float, uUID: java.util.UUID) -> None: ... @typing.overload def runTransient(self, double: float) -> None: ... @typing.overload @@ -605,22 +613,43 @@ class SafetyReliefValve(ThrottlingValve): def __init__(self, string: typing.Union[java.lang.String, str]): ... @typing.overload def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def captureTransientState(self) -> ThrottlingValve.TransientState: ... def configureBalancedModulating(self, double: float, double2: float, double3: float, double4: float) -> 'SafetyReliefValve': ... def configureConventionalSnap(self, double: float, double2: float, double3: float, double4: float) -> 'SafetyReliefValve': ... def getBackpressureSensitivity(self) -> float: ... def getBlowdownFrac(self) -> float: ... + def getCurrentBackpressureFactor(self) -> float: ... + def getCurrentEffectiveCapacityCv(self) -> float: ... def getKbMax(self) -> float: ... def getKd(self) -> float: ... + def getLastCommandedLiftFraction(self) -> float: ... + def getLastResponseStepId(self) -> java.util.UUID: ... + def getMaxLiftRatePerSec(self) -> float: ... + def getMinCloseTimeSec(self) -> float: ... + def getMinOpenTimeSec(self) -> float: ... def getMinStableOpenFrac(self) -> float: ... def getOpenFraction(self) -> float: ... + def getOpeningCycleCount(self) -> int: ... def getOpeningLaw(self) -> 'SafetyReliefValve.OpeningLaw': ... def getOverpressureFrac(self) -> float: ... + def getPressureReliefConfiguration(self) -> java.util.Map[java.lang.String, typing.Any]: ... def getRatedCv(self) -> float: ... def getRelievingPressureBar(self) -> float: ... + def getReseatCycleCount(self) -> int: ... def getReseatPressureBar(self) -> float: ... + def getResponseElapsedSeconds(self) -> float: ... + def getSeatToleranceFraction(self) -> float: ... def getSetPressureBar(self) -> float: ... + def getTauCloseSec(self) -> float: ... + def getTauOpenSec(self) -> float: ... + def getTimeSinceCloseSec(self) -> float: ... + def getTimeSinceOpenSec(self) -> float: ... + def getTransientStateCoverageIssue(self) -> java.lang.String: ... def getValveType(self) -> 'SafetyReliefValve.ValveType': ... def initMechanicalDesign(self) -> None: ... + def initializeLiftState(self, double: float) -> None: ... + def isLiftMotionAvailable(self) -> bool: ... + def isPressureDemandActive(self) -> bool: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -633,6 +662,7 @@ class SafetyReliefValve(ThrottlingValve): def setBlowdownFrac(self, double: float) -> None: ... def setKbMax(self, double: float) -> None: ... def setKd(self, double: float) -> None: ... + def setLiftMotionAvailable(self, boolean: bool) -> None: ... def setMaxLiftRatePerSec(self, double: float) -> None: ... def setMinCloseTimeSec(self, double: float) -> None: ... def setMinOpenTimeSec(self, double: float) -> None: ... @@ -640,6 +670,7 @@ class SafetyReliefValve(ThrottlingValve): def setOpeningLaw(self, openingLaw: 'SafetyReliefValve.OpeningLaw') -> None: ... def setOverpressureFrac(self, double: float) -> None: ... def setRatedCv(self, double: float) -> None: ... + def setSeatToleranceFraction(self, double: float) -> None: ... def setSetPressureBar(self, double: float) -> None: ... def setTauCloseSec(self, double: float) -> None: ... def setTauOpenSec(self, double: float) -> None: ... @@ -656,6 +687,7 @@ class SafetyReliefValve(ThrottlingValve): def valueOf(string: typing.Union[java.lang.String, str]) -> 'SafetyReliefValve.OpeningLaw': ... @staticmethod def values() -> typing.MutableSequence['SafetyReliefValve.OpeningLaw']: ... + class ReliefTransientState(ThrottlingValve.TransientState): ... class ValveType(java.lang.Enum['SafetyReliefValve.ValveType']): CONVENTIONAL: typing.ClassVar['SafetyReliefValve.ValveType'] = ... BALANCED_BELLOWS: typing.ClassVar['SafetyReliefValve.ValveType'] = ... diff --git a/src/jneqsim-stubs/process/fielddevelopment/reservoir/__init__.pyi b/src/jneqsim-stubs/process/fielddevelopment/reservoir/__init__.pyi index ad408186..d8b6e008 100644 --- a/src/jneqsim-stubs/process/fielddevelopment/reservoir/__init__.pyi +++ b/src/jneqsim-stubs/process/fielddevelopment/reservoir/__init__.pyi @@ -474,12 +474,26 @@ class VlpProvider: class ForwardVlpProvider(VlpProvider): def __init__(self, forwardPressureModel: typing.Union['ForwardVlpProvider.ForwardPressureModel', typing.Callable]): ... def bottomHolePressure(self, double: float, double2: float, double3: float, double4: float, double5: float) -> float: ... + def getCollapsedEvaluations(self) -> int: ... def getEvaluations(self) -> int: ... + def setCollapsedProfileDrop(self, double: float) -> 'ForwardVlpProvider': ... def setInletBounds(self, double: float, double2: float) -> 'ForwardVlpProvider': ... def setTolerance(self, double: float) -> 'ForwardVlpProvider': ... class ForwardPressureModel: def outletPressure(self, double: float, double2: float, double3: float, double4: float, double5: float) -> float: ... +class InjectionVlpProvider(VlpProvider): + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[float], jpype.JArray]): ... + def bottomHolePressure(self, double: float, double2: float, double3: float, double4: float, double5: float) -> float: ... + def getEvaluations(self) -> int: ... + def setDensityFactor(self, double: float) -> 'InjectionVlpProvider': ... + def setMaxSegmentLength(self, double: float) -> 'InjectionVlpProvider': ... + def setRoughness(self, double: float) -> 'InjectionVlpProvider': ... + def setTemperatures(self, double: float, double2: float) -> 'InjectionVlpProvider': ... + class RecombinationFluidFactory(VfpFluidFactory): @typing.overload def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface, systemInterface3: jneqsim.thermo.system.SystemInterface): ... @@ -514,6 +528,7 @@ class __module_protocol__(Protocol): ForwardVlpProvider: typing.Type[ForwardVlpProvider] InjectionStrategy: typing.Type[InjectionStrategy] + InjectionVlpProvider: typing.Type[InjectionVlpProvider] InjectionWellModel: typing.Type[InjectionWellModel] RecombinationFluidFactory: typing.Type[RecombinationFluidFactory] ReservoirCouplingExporter: typing.Type[ReservoirCouplingExporter] diff --git a/src/jneqsim-stubs/process/logic/__init__.pyi b/src/jneqsim-stubs/process/logic/__init__.pyi index ef50fcff..086ba247 100644 --- a/src/jneqsim-stubs/process/logic/__init__.pyi +++ b/src/jneqsim-stubs/process/logic/__init__.pyi @@ -25,8 +25,11 @@ import typing class LogicAction: def execute(self) -> None: ... def getDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... def getTargetName(self) -> java.lang.String: ... def isComplete(self) -> bool: ... + def isTargetEquipmentIdentityComplete(self) -> bool: ... + def reset(self) -> None: ... class LogicCondition: def evaluate(self) -> bool: ... diff --git a/src/jneqsim-stubs/process/logic/action/__init__.pyi b/src/jneqsim-stubs/process/logic/action/__init__.pyi index 7a84e6ab..6eb734be 100644 --- a/src/jneqsim-stubs/process/logic/action/__init__.pyi +++ b/src/jneqsim-stubs/process/logic/action/__init__.pyi @@ -5,9 +5,12 @@ if sys.version_info >= (3, 8): else: from typing_extensions import Protocol +import java.io import java.lang import java.util import jpype +import jneqsim.process.equipment +import jneqsim.process.equipment.compressor import jneqsim.process.equipment.separator import jneqsim.process.equipment.splitter import jneqsim.process.equipment.valve @@ -16,21 +19,27 @@ import typing -class ActivateBlowdownAction(jneqsim.process.logic.LogicAction): +class ActivateBlowdownAction(jneqsim.process.logic.LogicAction, java.io.Serializable): def __init__(self, blowdownValve: jneqsim.process.equipment.valve.BlowdownValve): ... def execute(self) -> None: ... def getDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... def getTargetName(self) -> java.lang.String: ... def isComplete(self) -> bool: ... + def isTargetEquipmentIdentityComplete(self) -> bool: ... + def reset(self) -> None: ... -class CloseValveAction(jneqsim.process.logic.LogicAction): +class CloseValveAction(jneqsim.process.logic.LogicAction, java.io.Serializable): def __init__(self, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve): ... def execute(self) -> None: ... def getDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... def getTargetName(self) -> java.lang.String: ... def isComplete(self) -> bool: ... + def isTargetEquipmentIdentityComplete(self) -> bool: ... + def reset(self) -> None: ... -class ConditionalAction(jneqsim.process.logic.LogicAction): +class ConditionalAction(jneqsim.process.logic.LogicAction, java.io.Serializable): @typing.overload def __init__(self, logicCondition: jneqsim.process.logic.LogicCondition, logicAction: jneqsim.process.logic.LogicAction, string: typing.Union[java.lang.String, str]): ... @typing.overload @@ -41,29 +50,37 @@ class ConditionalAction(jneqsim.process.logic.LogicAction): def getDescription(self) -> java.lang.String: ... def getPrimaryAction(self) -> jneqsim.process.logic.LogicAction: ... def getSelectedAction(self) -> jneqsim.process.logic.LogicAction: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... def getTargetName(self) -> java.lang.String: ... def isComplete(self) -> bool: ... def isEvaluated(self) -> bool: ... + def isTargetEquipmentIdentityComplete(self) -> bool: ... def reset(self) -> None: ... -class EnergizeESDValveAction(jneqsim.process.logic.LogicAction): +class EnergizeESDValveAction(jneqsim.process.logic.LogicAction, java.io.Serializable): @typing.overload def __init__(self, eSDValve: jneqsim.process.equipment.valve.ESDValve): ... @typing.overload def __init__(self, eSDValve: jneqsim.process.equipment.valve.ESDValve, double: float): ... def execute(self) -> None: ... def getDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... def getTargetName(self) -> java.lang.String: ... def isComplete(self) -> bool: ... + def isTargetEquipmentIdentityComplete(self) -> bool: ... + def reset(self) -> None: ... -class OpenValveAction(jneqsim.process.logic.LogicAction): +class OpenValveAction(jneqsim.process.logic.LogicAction, java.io.Serializable): def __init__(self, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve): ... def execute(self) -> None: ... def getDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... def getTargetName(self) -> java.lang.String: ... def isComplete(self) -> bool: ... + def isTargetEquipmentIdentityComplete(self) -> bool: ... + def reset(self) -> None: ... -class ParallelActionGroup(jneqsim.process.logic.LogicAction): +class ParallelActionGroup(jneqsim.process.logic.LogicAction, java.io.Serializable): def __init__(self, string: typing.Union[java.lang.String, str]): ... def addAction(self, logicAction: jneqsim.process.logic.LogicAction) -> None: ... def execute(self) -> None: ... @@ -71,40 +88,73 @@ class ParallelActionGroup(jneqsim.process.logic.LogicAction): def getCompletedCount(self) -> int: ... def getCompletionPercentage(self) -> float: ... def getDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... def getTargetName(self) -> java.lang.String: ... def getTotalCount(self) -> int: ... def isComplete(self) -> bool: ... + def isTargetEquipmentIdentityComplete(self) -> bool: ... + def reset(self) -> None: ... def toString(self) -> java.lang.String: ... -class SetSeparatorModeAction(jneqsim.process.logic.LogicAction): +class SetSeparatorModeAction(jneqsim.process.logic.LogicAction, java.io.Serializable): def __init__(self, separator: jneqsim.process.equipment.separator.Separator, boolean: bool): ... def execute(self) -> None: ... def getDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... def getTargetName(self) -> java.lang.String: ... def isComplete(self) -> bool: ... def isSteadyState(self) -> bool: ... + def isTargetEquipmentIdentityComplete(self) -> bool: ... + def reset(self) -> None: ... -class SetSplitterAction(jneqsim.process.logic.LogicAction): +class SetSplitterAction(jneqsim.process.logic.LogicAction, java.io.Serializable): def __init__(self, splitter: jneqsim.process.equipment.splitter.Splitter, doubleArray: typing.Union[typing.List[float], jpype.JArray]): ... def execute(self) -> None: ... def getDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... def getTargetName(self) -> java.lang.String: ... def isComplete(self) -> bool: ... + def isTargetEquipmentIdentityComplete(self) -> bool: ... + def reset(self) -> None: ... -class SetValveOpeningAction(jneqsim.process.logic.LogicAction): +class SetValveOpeningAction(jneqsim.process.logic.LogicAction, java.io.Serializable): def __init__(self, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve, double: float): ... def execute(self) -> None: ... def getDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... def getTargetName(self) -> java.lang.String: ... def getTargetOpening(self) -> float: ... def isComplete(self) -> bool: ... + def isTargetEquipmentIdentityComplete(self) -> bool: ... + def reset(self) -> None: ... -class TripValveAction(jneqsim.process.logic.LogicAction): +class TripCompressorAction(jneqsim.process.logic.LogicAction, java.io.Serializable): + @typing.overload + def __init__(self, compressor: jneqsim.process.equipment.compressor.Compressor): ... + @typing.overload + def __init__(self, compressor: jneqsim.process.equipment.compressor.Compressor, shutdownType: jneqsim.process.equipment.compressor.ShutdownProfile.ShutdownType, double: float): ... + def execute(self) -> None: ... + def getCompressor(self) -> jneqsim.process.equipment.compressor.Compressor: ... + def getDescription(self) -> java.lang.String: ... + def getShutdownType(self) -> jneqsim.process.equipment.compressor.ShutdownProfile.ShutdownType: ... + def getStoppedSpeedRpm(self) -> float: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... + def getTargetName(self) -> java.lang.String: ... + def isCommandAvailable(self) -> bool: ... + def isComplete(self) -> bool: ... + def isTargetEquipmentIdentityComplete(self) -> bool: ... + def reset(self) -> None: ... + def setCommandAvailable(self, boolean: bool) -> None: ... + +class TripValveAction(jneqsim.process.logic.LogicAction, java.io.Serializable): def __init__(self, eSDValve: jneqsim.process.equipment.valve.ESDValve): ... def execute(self) -> None: ... def getDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... def getTargetName(self) -> java.lang.String: ... def isComplete(self) -> bool: ... + def isTargetEquipmentIdentityComplete(self) -> bool: ... + def reset(self) -> None: ... class __module_protocol__(Protocol): @@ -119,4 +169,5 @@ class __module_protocol__(Protocol): SetSeparatorModeAction: typing.Type[SetSeparatorModeAction] SetSplitterAction: typing.Type[SetSplitterAction] SetValveOpeningAction: typing.Type[SetValveOpeningAction] + TripCompressorAction: typing.Type[TripCompressorAction] TripValveAction: typing.Type[TripValveAction] diff --git a/src/jneqsim-stubs/process/logic/esd/__init__.pyi b/src/jneqsim-stubs/process/logic/esd/__init__.pyi index 7fa79b3f..28a7f3d3 100644 --- a/src/jneqsim-stubs/process/logic/esd/__init__.pyi +++ b/src/jneqsim-stubs/process/logic/esd/__init__.pyi @@ -26,6 +26,8 @@ class ESDLogic(jneqsim.process.logic.ProcessLogic): def getState(self) -> jneqsim.process.logic.LogicState: ... def getStatusDescription(self) -> java.lang.String: ... def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... + def getTargetEquipmentCoverageIssue(self) -> java.lang.String: ... + def getTripActionConfiguration(self) -> java.util.Map[java.lang.String, typing.Any]: ... def isActive(self) -> bool: ... def isComplete(self) -> bool: ... def reset(self) -> bool: ... diff --git a/src/jneqsim-stubs/process/measurementdevice/__init__.pyi b/src/jneqsim-stubs/process/measurementdevice/__init__.pyi index e5e52824..b93f6e54 100644 --- a/src/jneqsim-stubs/process/measurementdevice/__init__.pyi +++ b/src/jneqsim-stubs/process/measurementdevice/__init__.pyi @@ -221,6 +221,32 @@ class CompressorMonitor(MeasurementDeviceBaseClass): @typing.overload def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... +class CompressorSurgeMarginMeasurement(MeasurementDeviceBaseClass, TransientMeasurementDevice, jneqsim.process.dynamics.TransientStateParticipant['CompressorSurgeMarginMeasurement.MarginState']): + def __init__(self, string: typing.Union[java.lang.String, str], compressor: jneqsim.process.equipment.compressor.Compressor, volumeFlowTransmitter: 'VolumeFlowTransmitter'): ... + def captureTransientState(self) -> 'CompressorSurgeMarginMeasurement.MarginState': ... + def displayResult(self) -> None: ... + def getCompressor(self) -> jneqsim.process.equipment.compressor.Compressor: ... + def getFlowTransmitter(self) -> 'VolumeFlowTransmitter': ... + def getLastReferenceEvidence(self) -> java.util.Map[java.lang.String, typing.Any]: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getReferenceSurgeFlowM3PerHour(self) -> float: ... + @typing.overload + def getTransientSample(self) -> float: ... + @typing.overload + def getTransientSample(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getTransientStateCoverageIssue(self) -> java.lang.String: ... + def getTransientStateIdentity(self) -> java.lang.String: ... + def hasTransientSample(self, uUID: java.util.UUID) -> bool: ... + def isLastReferenceWithinMap(self) -> bool: ... + def isTransientSamplingEnabled(self) -> bool: ... + def restoreTransientState(self, marginState: 'CompressorSurgeMarginMeasurement.MarginState') -> None: ... + def sampleTransient(self, double: float, uUID: java.util.UUID) -> None: ... + def setTransientSamplingEnabled(self, boolean: bool) -> None: ... + class MarginState(java.io.Serializable): ... + class DifferentialPressureTransmitter(MeasurementDeviceBaseClass, jneqsim.process.dynamics.TransientStateParticipant['DifferentialPressureTransmitter.DifferentialPressureTransmitterState']): @typing.overload def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface): ... @@ -993,6 +1019,7 @@ class __module_protocol__(Protocol): CombustionEmissionsCalculator: typing.Type[CombustionEmissionsCalculator] CompositionAnalyzer: typing.Type[CompositionAnalyzer] CompressorMonitor: typing.Type[CompressorMonitor] + CompressorSurgeMarginMeasurement: typing.Type[CompressorSurgeMarginMeasurement] ConeFlowMeter: typing.Type[ConeFlowMeter] CricondenbarAnalyser: typing.Type[CricondenbarAnalyser] DifferentialPressureFlowMeter: typing.Type[DifferentialPressureFlowMeter] diff --git a/src/jneqsim-stubs/process/mechanicaldesign/subsea/__init__.pyi b/src/jneqsim-stubs/process/mechanicaldesign/subsea/__init__.pyi index 9df8509f..fcd0c427 100644 --- a/src/jneqsim-stubs/process/mechanicaldesign/subsea/__init__.pyi +++ b/src/jneqsim-stubs/process/mechanicaldesign/subsea/__init__.pyi @@ -356,6 +356,7 @@ class SURFCostEstimator: def calculate(self) -> float: ... def clearLineSegments(self) -> None: ... def excludeExportPipeline(self, double: float) -> None: ... + def getBasisWarnings(self) -> java.util.List[java.lang.String]: ... def getCategoryLineItems(self, string: typing.Union[java.lang.String, str]) -> java.util.List[java.util.Map[java.lang.String, typing.Any]]: ... def getCostBreakdown(self) -> java.util.Map[java.lang.String, typing.Any]: ... def getDetailedEstimateResult(self) -> jneqsim.process.costestimation.CostEstimateResult: ... @@ -413,6 +414,7 @@ class SURFCostEstimator: def setSteelPricePerKg(self, double: float) -> None: ... def setTreeBoreSizeInches(self, double: float) -> None: ... def setTreePressureRatingPsi(self, double: float) -> None: ... + def setTreeUnitCostUSD(self, double: float) -> None: ... def setUmbilicalChemicalLines(self, int: int) -> None: ... def setUmbilicalDynamic(self, boolean: bool) -> None: ... def setUmbilicalElectricalCables(self, int: int) -> None: ... diff --git a/src/jneqsim-stubs/process/processmodel/__init__.pyi b/src/jneqsim-stubs/process/processmodel/__init__.pyi index ffef5f3e..a1a90d41 100644 --- a/src/jneqsim-stubs/process/processmodel/__init__.pyi +++ b/src/jneqsim-stubs/process/processmodel/__init__.pyi @@ -890,6 +890,7 @@ class ProcessSystem(jneqsim.process.SimulationBaseClass): def isAutoConvergenceTuning(self) -> bool: ... def isAutoRecycles(self) -> bool: ... def isAutoValidate(self) -> bool: ... + def isDeferPostRecycleUnits(self) -> bool: ... def isInRecycleLoop(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> bool: ... def isMeasurementHistoryRecordingEnabled(self) -> bool: ... def isParallelExecutionBeneficial(self) -> bool: ... @@ -990,6 +991,7 @@ class ProcessSystem(jneqsim.process.SimulationBaseClass): def setAutoTuningFlowFraction(self, double: float) -> None: ... def setAutoValidate(self, boolean: bool) -> None: ... def setCapacityAnalysisEnabled(self, boolean: bool) -> int: ... + def setDeferPostRecycleUnits(self, boolean: bool) -> None: ... def setEnableMassBalanceTracking(self, boolean: bool) -> None: ... def setEventScheduler(self, eventScheduler: jneqsim.process.dynamics.EventScheduler) -> None: ... def setFieldData(self, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]]) -> None: ... diff --git a/src/jneqsim-stubs/process/processmodel/dexpi/__init__.pyi b/src/jneqsim-stubs/process/processmodel/dexpi/__init__.pyi index 151bfb65..c75b7912 100644 --- a/src/jneqsim-stubs/process/processmodel/dexpi/__init__.pyi +++ b/src/jneqsim-stubs/process/processmodel/dexpi/__init__.pyi @@ -1073,6 +1073,12 @@ class DexpiMetadata: @staticmethod def sizingAttributes() -> java.util.Set[java.lang.String]: ... +class DexpiPlantItems: + @staticmethod + def findCandidates(document: org.w3c.dom.Document, string: typing.Union[java.lang.String, str]) -> java.util.List[org.w3c.dom.Element]: ... + @staticmethod + def isNonItemElement(element: org.w3c.dom.Element) -> bool: ... + class DexpiProcessUnit(jneqsim.process.equipment.ProcessEquipmentBaseClass): def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], equipmentEnum: jneqsim.process.equipment.EquipmentEnum, string3: typing.Union[java.lang.String, str], string4: typing.Union[java.lang.String, str]): ... def getDexpiClass(self) -> java.lang.String: ... @@ -1197,6 +1203,89 @@ class DexpiVisualQualityAssessment: @staticmethod def values() -> typing.MutableSequence['DexpiVisualQualityAssessment.Severity']: ... +class DexpiXmlReader: + @typing.overload + @staticmethod + def load(file: typing.Union[java.io.File, jpype.protocol.SupportsPath], processSystem: jneqsim.process.processmodel.ProcessSystem) -> None: ... + @typing.overload + @staticmethod + def load(file: typing.Union[java.io.File, jpype.protocol.SupportsPath], processSystem: jneqsim.process.processmodel.ProcessSystem, stream: jneqsim.process.equipment.stream.Stream) -> None: ... + @typing.overload + @staticmethod + def load(inputStream: java.io.InputStream, processSystem: jneqsim.process.processmodel.ProcessSystem) -> None: ... + @typing.overload + @staticmethod + def load(inputStream: java.io.InputStream, processSystem: jneqsim.process.processmodel.ProcessSystem, stream: jneqsim.process.equipment.stream.Stream) -> None: ... + @typing.overload + @staticmethod + def load(inputStream: java.io.InputStream, processSystem: jneqsim.process.processmodel.ProcessSystem, stream: jneqsim.process.equipment.stream.Stream, boolean: bool) -> None: ... + @typing.overload + @staticmethod + def read(file: typing.Union[java.io.File, jpype.protocol.SupportsPath]) -> jneqsim.process.processmodel.ProcessSystem: ... + @typing.overload + @staticmethod + def read(file: typing.Union[java.io.File, jpype.protocol.SupportsPath], stream: jneqsim.process.equipment.stream.Stream) -> jneqsim.process.processmodel.ProcessSystem: ... + @typing.overload + @staticmethod + def read(inputStream: java.io.InputStream) -> jneqsim.process.processmodel.ProcessSystem: ... + @typing.overload + @staticmethod + def read(inputStream: java.io.InputStream, stream: jneqsim.process.equipment.stream.Stream) -> jneqsim.process.processmodel.ProcessSystem: ... + @typing.overload + @staticmethod + def readInstruments(file: typing.Union[java.io.File, jpype.protocol.SupportsPath]) -> java.util.List[DexpiInstrumentInfo]: ... + @typing.overload + @staticmethod + def readInstruments(inputStream: java.io.InputStream) -> java.util.List[DexpiInstrumentInfo]: ... + @typing.overload + @staticmethod + def readWithDiagnostics(file: typing.Union[java.io.File, jpype.protocol.SupportsPath]) -> 'DexpiXmlReader.ImportResult': ... + @typing.overload + @staticmethod + def readWithDiagnostics(file: typing.Union[java.io.File, jpype.protocol.SupportsPath], stream: jneqsim.process.equipment.stream.Stream) -> 'DexpiXmlReader.ImportResult': ... + @typing.overload + @staticmethod + def readWithDiagnostics(inputStream: java.io.InputStream) -> 'DexpiXmlReader.ImportResult': ... + @typing.overload + @staticmethod + def readWithDiagnostics(inputStream: java.io.InputStream, stream: jneqsim.process.equipment.stream.Stream) -> 'DexpiXmlReader.ImportResult': ... + class ImportDiagnostic(java.io.Serializable): + def getCode(self) -> java.lang.String: ... + def getComponentClass(self) -> java.lang.String: ... + def getElementId(self) -> java.lang.String: ... + def getElementName(self) -> java.lang.String: ... + def getMessage(self) -> java.lang.String: ... + def getSeverity(self) -> 'DexpiXmlReader.ImportDiagnosticSeverity': ... + class ImportDiagnosticSeverity(java.lang.Enum['DexpiXmlReader.ImportDiagnosticSeverity']): + INFO: typing.ClassVar['DexpiXmlReader.ImportDiagnosticSeverity'] = ... + WARNING: typing.ClassVar['DexpiXmlReader.ImportDiagnosticSeverity'] = ... + ERROR: typing.ClassVar['DexpiXmlReader.ImportDiagnosticSeverity'] = ... + _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(class_: typing.Type[_valueOf_0__T], string: typing.Union[java.lang.String, str]) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: typing.Union[java.lang.String, str]) -> 'DexpiXmlReader.ImportDiagnosticSeverity': ... + @staticmethod + def values() -> typing.MutableSequence['DexpiXmlReader.ImportDiagnosticSeverity']: ... + class ImportResult(java.io.Serializable): + def getActuatingFunctions(self) -> java.util.List[DexpiActuatingFunctionInfo]: ... + def getConnectionComponents(self) -> java.util.List[DexpiConnectionComponentInfo]: ... + def getConnectionCycleTransitions(self) -> java.util.List[DexpiConnectionCycleTransitionInfo]: ... + def getConnectionCycles(self) -> java.util.List[DexpiConnectionCycleInfo]: ... + def getConnectionEndpoints(self) -> java.util.List[DexpiConnectionEndpointInfo]: ... + def getConnections(self) -> java.util.List[DexpiConnectionInfo]: ... + def getDiagnostics(self) -> java.util.List['DexpiXmlReader.ImportDiagnostic']: ... + def getInformationFlows(self) -> java.util.List[DexpiInformationFlowInfo]: ... + def getInstrumentationLoops(self) -> java.util.List[DexpiInstrumentationLoopInfo]: ... + def getInstruments(self) -> java.util.List[DexpiInstrumentInfo]: ... + def getProcessSystem(self) -> jneqsim.process.processmodel.ProcessSystem: ... + def hasErrors(self) -> bool: ... + def hasLosses(self) -> bool: ... + def toJson(self) -> java.lang.String: ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class DexpiXmlReaderException(java.lang.Exception): @typing.overload def __init__(self, string: typing.Union[java.lang.String, str]): ... @@ -1306,6 +1395,7 @@ class __module_protocol__(Protocol): DexpiLayoutConfig: typing.Type[DexpiLayoutConfig] DexpiMappingLoader: typing.Type[DexpiMappingLoader] DexpiMetadata: typing.Type[DexpiMetadata] + DexpiPlantItems: typing.Type[DexpiPlantItems] DexpiProcessUnit: typing.Type[DexpiProcessUnit] DexpiRoundTripProfile: typing.Type[DexpiRoundTripProfile] DexpiSimulationBuilder: typing.Type[DexpiSimulationBuilder] @@ -1313,6 +1403,7 @@ class __module_protocol__(Protocol): DexpiStreamUtils: typing.Type[DexpiStreamUtils] DexpiTopologyResolver: typing.Type[DexpiTopologyResolver] DexpiVisualQualityAssessment: typing.Type[DexpiVisualQualityAssessment] + DexpiXmlReader: typing.Type[DexpiXmlReader] DexpiXmlReaderException: typing.Type[DexpiXmlReaderException] DexpiXmlSvgRenderer: typing.Type[DexpiXmlSvgRenderer] DexpiXmlWriter: typing.Type[DexpiXmlWriter] diff --git a/src/jneqsim-stubs/process/processmodel/diagram/__init__.pyi b/src/jneqsim-stubs/process/processmodel/diagram/__init__.pyi index 61c8b7b1..8693f486 100644 --- a/src/jneqsim-stubs/process/processmodel/diagram/__init__.pyi +++ b/src/jneqsim-stubs/process/processmodel/diagram/__init__.pyi @@ -13,6 +13,7 @@ import jpype.protocol import jneqsim.process.engineering import jneqsim.process.engineering.model import jneqsim.process.engineering.pid +import jneqsim.process.engineering.scd import jneqsim.process.equipment import jneqsim.process.equipment.stream import jneqsim.process.processmodel @@ -658,6 +659,7 @@ class ProfessionalPidDiagramRenderer: def getContentReportJson(self) -> java.lang.String: ... def getLayoutSpecifications(self) -> java.util.Map[java.lang.String, java.util.Map[java.lang.String, typing.Any]]: ... def getPhysicalProjection(self) -> jneqsim.process.engineering.pid.PidPhysicalProjection: ... + def getPrimaryEquipmentCount(self) -> int: ... def render(self) -> NativeEngineeringDiagramRenderer.Result: ... def renderProcessFlowOverview(self) -> NativeEngineeringDiagramRenderer.Result: ... @@ -682,7 +684,9 @@ class ProfessionalPidSymbolLibrary: NOZZLE: typing.ClassVar['ProfessionalPidSymbolLibrary.Family'] = ... TERMINAL: typing.ClassVar['ProfessionalPidSymbolLibrary.Family'] = ... TERMINAL_NORTH: typing.ClassVar['ProfessionalPidSymbolLibrary.Family'] = ... + TERMINAL_WEST: typing.ClassVar['ProfessionalPidSymbolLibrary.Family'] = ... PNEUMATIC_OPERATED_VALVE: typing.ClassVar['ProfessionalPidSymbolLibrary.Family'] = ... + PIPE_TEE: typing.ClassVar['ProfessionalPidSymbolLibrary.Family'] = ... UNMAPPED: typing.ClassVar['ProfessionalPidSymbolLibrary.Family'] = ... _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # @typing.overload @@ -694,6 +698,11 @@ class ProfessionalPidSymbolLibrary: @staticmethod def values() -> typing.MutableSequence['ProfessionalPidSymbolLibrary.Family']: ... +class ScdDiagramRenderer: + def __init__(self, engineeringProject: jneqsim.process.engineering.EngineeringProject, pidDesignModel: jneqsim.process.engineering.pid.PidDesignModel, pidSimulationBindings: jneqsim.process.engineering.pid.PidSimulationBindings, scdDesignModel: jneqsim.process.engineering.scd.ScdDesignModel): ... + def getLayoutSpecifications(self) -> java.util.Map[java.lang.String, java.lang.String]: ... + def render(self) -> NativeEngineeringDiagramRenderer.Result: ... + class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.processmodel.diagram")``. @@ -716,3 +725,4 @@ class __module_protocol__(Protocol): ProcessDiagramGraphAdapter: typing.Type[ProcessDiagramGraphAdapter] ProfessionalPidDiagramRenderer: typing.Type[ProfessionalPidDiagramRenderer] ProfessionalPidSymbolLibrary: typing.Type[ProfessionalPidSymbolLibrary] + ScdDiagramRenderer: typing.Type[ScdDiagramRenderer] diff --git a/src/jneqsim-stubs/process/safety/scenario/__init__.pyi b/src/jneqsim-stubs/process/safety/scenario/__init__.pyi index 2b65949c..173c8f06 100644 --- a/src/jneqsim-stubs/process/safety/scenario/__init__.pyi +++ b/src/jneqsim-stubs/process/safety/scenario/__init__.pyi @@ -105,11 +105,13 @@ class DynamicSafetyScenario(java.io.Serializable): def getDurationSeconds(self) -> float: ... def getEquipmentTags(self) -> java.util.List[java.lang.String]: ... def getEvidenceReferences(self) -> java.util.List[java.lang.String]: ... + def getExecutionTarget(self) -> 'DynamicSafetyScenario.ExecutionTarget': ... def getId(self) -> java.lang.String: ... def getInitiatingEventDefinitionId(self) -> java.lang.String: ... def getLogicDefinitionIds(self) -> java.util.List[java.lang.String]: ... def getLogicFactories(self) -> java.util.List['DynamicSafetyScenario.LogicFactory']: ... def getName(self) -> java.lang.String: ... + def getProcessModelLogicFactories(self) -> java.util.List['DynamicSafetyScenario.ProcessModelLogicFactory']: ... def getRequirementIds(self) -> java.util.List[java.lang.String]: ... def getTimeStepSeconds(self) -> float: ... def getTriggerTimeSeconds(self) -> float: ... @@ -123,24 +125,52 @@ class DynamicSafetyScenario(java.io.Serializable): def addLogic(self, string: typing.Union[java.lang.String, str], logicFactory: typing.Union['DynamicSafetyScenario.LogicFactory', typing.Callable]) -> 'DynamicSafetyScenario.Builder': ... @typing.overload def addLogic(self, logicFactory: typing.Union['DynamicSafetyScenario.LogicFactory', typing.Callable]) -> 'DynamicSafetyScenario.Builder': ... + @typing.overload + def addModelLogic(self, string: typing.Union[java.lang.String, str], processModelLogicFactory: typing.Union['DynamicSafetyScenario.ProcessModelLogicFactory', typing.Callable]) -> 'DynamicSafetyScenario.Builder': ... + @typing.overload + def addModelLogic(self, processModelLogicFactory: typing.Union['DynamicSafetyScenario.ProcessModelLogicFactory', typing.Callable]) -> 'DynamicSafetyScenario.Builder': ... def addRequirementId(self, string: typing.Union[java.lang.String, str]) -> 'DynamicSafetyScenario.Builder': ... def build(self) -> 'DynamicSafetyScenario': ... @typing.overload def configureCase(self, string: typing.Union[java.lang.String, str], processManipulator: typing.Union['DynamicSafetyScenario.ProcessManipulator', typing.Callable]) -> 'DynamicSafetyScenario.Builder': ... @typing.overload def configureCase(self, processManipulator: typing.Union['DynamicSafetyScenario.ProcessManipulator', typing.Callable]) -> 'DynamicSafetyScenario.Builder': ... + @typing.overload + def configureModelCase(self, string: typing.Union[java.lang.String, str], processModelManipulator: typing.Union['DynamicSafetyScenario.ProcessModelManipulator', typing.Callable]) -> 'DynamicSafetyScenario.Builder': ... + @typing.overload + def configureModelCase(self, processModelManipulator: typing.Union['DynamicSafetyScenario.ProcessModelManipulator', typing.Callable]) -> 'DynamicSafetyScenario.Builder': ... def durationSeconds(self, double: float) -> 'DynamicSafetyScenario.Builder': ... def eventExactTiming(self, boolean: bool) -> 'DynamicSafetyScenario.Builder': ... @typing.overload def initiatingEvent(self, string: typing.Union[java.lang.String, str], processManipulator: typing.Union['DynamicSafetyScenario.ProcessManipulator', typing.Callable]) -> 'DynamicSafetyScenario.Builder': ... @typing.overload def initiatingEvent(self, processManipulator: typing.Union['DynamicSafetyScenario.ProcessManipulator', typing.Callable]) -> 'DynamicSafetyScenario.Builder': ... + @typing.overload + def modelInitiatingEvent(self, string: typing.Union[java.lang.String, str], processModelManipulator: typing.Union['DynamicSafetyScenario.ProcessModelManipulator', typing.Callable]) -> 'DynamicSafetyScenario.Builder': ... + @typing.overload + def modelInitiatingEvent(self, processModelManipulator: typing.Union['DynamicSafetyScenario.ProcessModelManipulator', typing.Callable]) -> 'DynamicSafetyScenario.Builder': ... def timeStepSeconds(self, double: float) -> 'DynamicSafetyScenario.Builder': ... def triggerTimeSeconds(self, double: float) -> 'DynamicSafetyScenario.Builder': ... + class ExecutionTarget(java.lang.Enum['DynamicSafetyScenario.ExecutionTarget']): + PROCESS_SYSTEM: typing.ClassVar['DynamicSafetyScenario.ExecutionTarget'] = ... + PROCESS_MODEL: typing.ClassVar['DynamicSafetyScenario.ExecutionTarget'] = ... + _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(class_: typing.Type[_valueOf_0__T], string: typing.Union[java.lang.String, str]) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: typing.Union[java.lang.String, str]) -> 'DynamicSafetyScenario.ExecutionTarget': ... + @staticmethod + def values() -> typing.MutableSequence['DynamicSafetyScenario.ExecutionTarget']: ... class LogicFactory(java.io.Serializable): def create(self, processSystem: jneqsim.process.processmodel.ProcessSystem) -> jneqsim.process.logic.ProcessLogic: ... class ProcessManipulator(java.io.Serializable): def apply(self, processSystem: jneqsim.process.processmodel.ProcessSystem) -> None: ... + class ProcessModelLogicFactory(java.io.Serializable): + def create(self, processModel: jneqsim.process.processmodel.ProcessModel) -> jneqsim.process.logic.ProcessLogic: ... + class ProcessModelManipulator(java.io.Serializable): + def apply(self, processModel: jneqsim.process.processmodel.ProcessModel) -> None: ... class DynamicSafetyScenarioEvidenceProvider: def getDynamicSafetyScenarioEvidence(self) -> java.util.Map[java.lang.String, typing.Any]: ... @@ -149,6 +179,7 @@ class DynamicSafetyScenarioResult(java.io.Serializable): def getCompletedDurationSeconds(self) -> float: ... def getCriterionResults(self) -> java.util.Map[java.lang.String, 'DynamicSafetyScenarioResult.CriterionResult']: ... def getEquipmentTags(self) -> java.util.List[java.lang.String]: ... + def getExecutionTarget(self) -> DynamicSafetyScenario.ExecutionTarget: ... def getLogicEvidence(self) -> java.util.Map[java.lang.String, java.util.Map[java.lang.String, typing.Any]]: ... def getPhysicalStepSeconds(self) -> java.util.List[float]: ... def getRequestedDurationSeconds(self) -> float: ... @@ -161,12 +192,21 @@ class DynamicSafetyScenarioResult(java.io.Serializable): def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... class CriterionResult(java.io.Serializable): def getFirstSatisfiedSeconds(self) -> float: ... + def getFirstViolationSeconds(self) -> float: ... def isPassed(self) -> bool: ... def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... class DynamicSafetyScenarioRunner: + @typing.overload + @staticmethod + def run(processModel: jneqsim.process.processmodel.ProcessModel, dynamicSafetyScenario: DynamicSafetyScenario) -> DynamicSafetyScenarioResult: ... + @typing.overload @staticmethod def run(processSystem: jneqsim.process.processmodel.ProcessSystem, dynamicSafetyScenario: DynamicSafetyScenario) -> DynamicSafetyScenarioResult: ... + @typing.overload + @staticmethod + def runStrict(processModel: jneqsim.process.processmodel.ProcessModel, dynamicSafetyScenario: DynamicSafetyScenario) -> DynamicSafetyScenarioResult: ... + @typing.overload @staticmethod def runStrict(processSystem: jneqsim.process.processmodel.ProcessSystem, dynamicSafetyScenario: DynamicSafetyScenario) -> DynamicSafetyScenarioResult: ... @@ -178,19 +218,42 @@ class DynamicScenarioCriterion(java.io.Serializable): @staticmethod def builder(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], extractor: typing.Union['DynamicScenarioCriterion.Extractor', typing.Callable]) -> 'DynamicScenarioCriterion.Builder': ... def getDeadlineSeconds(self) -> float: ... + def getEvaluationMode(self) -> 'DynamicScenarioCriterion.EvaluationMode': ... + def getExecutionTarget(self) -> DynamicSafetyScenario.ExecutionTarget: ... def getExtractorDefinitionId(self) -> java.lang.String: ... def getId(self) -> java.lang.String: ... def getName(self) -> java.lang.String: ... def getUnit(self) -> java.lang.String: ... def isRequired(self) -> bool: ... + @typing.overload + @staticmethod + def processModelBuilder(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], string4: typing.Union[java.lang.String, str], processModelExtractor: typing.Union['DynamicScenarioCriterion.ProcessModelExtractor', typing.Callable]) -> 'DynamicScenarioCriterion.Builder': ... + @typing.overload + @staticmethod + def processModelBuilder(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], processModelExtractor: typing.Union['DynamicScenarioCriterion.ProcessModelExtractor', typing.Callable]) -> 'DynamicScenarioCriterion.Builder': ... def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... class Builder: def acceptanceRange(self, double: float, double2: float) -> 'DynamicScenarioCriterion.Builder': ... def build(self) -> 'DynamicScenarioCriterion': ... def deadlineSeconds(self, double: float) -> 'DynamicScenarioCriterion.Builder': ... + def evaluationMode(self, evaluationMode: 'DynamicScenarioCriterion.EvaluationMode') -> 'DynamicScenarioCriterion.Builder': ... def required(self, boolean: bool) -> 'DynamicScenarioCriterion.Builder': ... + class EvaluationMode(java.lang.Enum['DynamicScenarioCriterion.EvaluationMode']): + REACH_BY_DEADLINE: typing.ClassVar['DynamicScenarioCriterion.EvaluationMode'] = ... + MAINTAIN_BOUNDS: typing.ClassVar['DynamicScenarioCriterion.EvaluationMode'] = ... + _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(class_: typing.Type[_valueOf_0__T], string: typing.Union[java.lang.String, str]) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: typing.Union[java.lang.String, str]) -> 'DynamicScenarioCriterion.EvaluationMode': ... + @staticmethod + def values() -> typing.MutableSequence['DynamicScenarioCriterion.EvaluationMode']: ... class Extractor(java.io.Serializable): def extract(self, processSystem: jneqsim.process.processmodel.ProcessSystem) -> float: ... + class ProcessModelExtractor(java.io.Serializable): + def extract(self, processModel: jneqsim.process.processmodel.ProcessModel) -> float: ... class ReleaseDispersionScenarioGenerator(java.io.Serializable): def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem): ... diff --git a/src/jneqsim-stubs/process/safety/sif/__init__.pyi b/src/jneqsim-stubs/process/safety/sif/__init__.pyi index 3826d1f1..bc8e18ae 100644 --- a/src/jneqsim-stubs/process/safety/sif/__init__.pyi +++ b/src/jneqsim-stubs/process/safety/sif/__init__.pyi @@ -11,6 +11,7 @@ import java.util import jneqsim.process.equipment import jneqsim.process.logic import jneqsim.process.logic.voting +import jneqsim.process.measurementdevice import jneqsim.process.processmodel import jneqsim.process.safety.scenario import typing @@ -23,7 +24,9 @@ class ClosedLoopSafetyFunction(jneqsim.process.logic.ProcessLogic, jneqsim.proce def builder(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], processSystem: jneqsim.process.processmodel.ProcessSystem, votingPattern: jneqsim.process.logic.voting.VotingPattern, processLogic: jneqsim.process.logic.ProcessLogic) -> 'ClosedLoopSafetyFunction.Builder': ... def deactivate(self) -> None: ... def execute(self, double: float) -> None: ... + def getChannels(self) -> java.util.List['SafetyFunctionChannel']: ... def getDynamicSafetyScenarioEvidence(self) -> java.util.Map[java.lang.String, typing.Any]: ... + def getFinalElementLogic(self) -> jneqsim.process.logic.ProcessLogic: ... def getName(self) -> java.lang.String: ... def getSifId(self) -> java.lang.String: ... def getState(self) -> jneqsim.process.logic.LogicState: ... @@ -38,10 +41,18 @@ class ClosedLoopSafetyFunction(jneqsim.process.logic.ProcessLogic, jneqsim.proce def logicSolverDelaySeconds(self, double: float) -> 'ClosedLoopSafetyFunction.Builder': ... class SafetyFunctionChannel(java.io.Serializable): + def getMeasurementSource(self) -> jneqsim.process.measurementdevice.MeasurementDeviceInterface: ... + def getTag(self) -> java.lang.String: ... @staticmethod def highTrip(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], double: float, signalExtractor: typing.Union['SafetyFunctionChannel.SignalExtractor', typing.Callable]) -> 'SafetyFunctionChannel.Builder': ... @staticmethod + def highTripFromMeasurement(measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface, string: typing.Union[java.lang.String, str], double: float) -> 'SafetyFunctionChannel.Builder': ... + @staticmethod def lowTrip(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], double: float, signalExtractor: typing.Union['SafetyFunctionChannel.SignalExtractor', typing.Callable]) -> 'SafetyFunctionChannel.Builder': ... + @staticmethod + def lowTripFromMeasurement(measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface, string: typing.Union[java.lang.String, str], double: float) -> 'SafetyFunctionChannel.Builder': ... + @staticmethod + def manualTripFromPushButton(pushButton: jneqsim.process.measurementdevice.PushButton) -> 'SafetyFunctionChannel.Builder': ... class Builder: def bias(self, double: float) -> 'SafetyFunctionChannel.Builder': ... def build(self) -> 'SafetyFunctionChannel': ... diff --git a/src/jneqsim-stubs/process/util/monitor/__init__.pyi b/src/jneqsim-stubs/process/util/monitor/__init__.pyi index e0b3bab1..6d05369d 100644 --- a/src/jneqsim-stubs/process/util/monitor/__init__.pyi +++ b/src/jneqsim-stubs/process/util/monitor/__init__.pyi @@ -208,6 +208,9 @@ class HXResponse(BaseResponse): def __init__(self): ... @typing.overload def __init__(self, heatExchanger: jneqsim.process.equipment.heatexchanger.HeatExchanger): ... + def getConfiguredSteadyUAvalue(self) -> float: ... + def getThermalBalance(self) -> java.util.Map[java.lang.String, typing.Any]: ... + def getThermalModel(self) -> java.lang.String: ... class HeaterResponse(BaseResponse): data: java.util.HashMap = ... diff --git a/src/jneqsim-stubs/process/util/scenario/__init__.pyi b/src/jneqsim-stubs/process/util/scenario/__init__.pyi index b4fabc39..094c19eb 100644 --- a/src/jneqsim-stubs/process/util/scenario/__init__.pyi +++ b/src/jneqsim-stubs/process/util/scenario/__init__.pyi @@ -5,12 +5,24 @@ if sys.version_info >= (3, 8): else: from typing_extensions import Protocol +import java.io import java.lang import java.util import jneqsim.process.controllerdevice +import jneqsim.process.equipment.compressor +import jneqsim.process.equipment.heatexchanger +import jneqsim.process.equipment.mixer +import jneqsim.process.equipment.separator +import jneqsim.process.equipment.splitter +import jneqsim.process.equipment.stream +import jneqsim.process.equipment.valve import jneqsim.process.logic +import jneqsim.process.logic.action +import jneqsim.process.measurementdevice import jneqsim.process.processmodel import jneqsim.process.safety +import jneqsim.process.safety.scenario +import jneqsim.process.safety.sif import jneqsim.process.util.monitor import typing @@ -33,6 +45,183 @@ class AntiSurgeDynamicBenchmark: def setRecycleAuthority(self, double: float) -> None: ... def setTimeStep(self, double: float) -> None: ... +class CompressorAutomationStudy: + @staticmethod + def create(design: 'CompressorAutomationStudy.Design') -> 'CompressorAutomationStudy.Train': ... + @staticmethod + def createCase(train: 'CompressorAutomationStudy.Train', caseDefinition: 'CompressorAutomationStudy.CaseDefinition', configurationObserver: typing.Union['CompressorAutomationStudy.ConfigurationObserver', typing.Callable]) -> 'CompressorAutomationStudy.CaseBundle': ... + @staticmethod + def defaultCases() -> java.util.List['CompressorAutomationStudy.CaseDefinition']: ... + @staticmethod + def fromProcess(processSystem: jneqsim.process.processmodel.ProcessSystem) -> 'CompressorAutomationStudy.Train': ... + @staticmethod + def run(train: 'CompressorAutomationStudy.Train', caseDefinition: 'CompressorAutomationStudy.CaseDefinition') -> 'CompressorAutomationStudy.Result': ... + class CaseBundle: + def complete(self, dynamicSafetyScenarioResult: jneqsim.process.safety.scenario.DynamicSafetyScenarioResult) -> 'CompressorAutomationStudy.Result': ... + def getConfiguredTrain(self) -> 'CompressorAutomationStudy.Train': ... + def getNativeResult(self) -> jneqsim.process.safety.scenario.DynamicSafetyScenarioResult: ... + def getScenario(self) -> jneqsim.process.safety.scenario.DynamicSafetyScenario: ... + def run(self) -> 'CompressorAutomationStudy.Result': ... + class CaseDefinition(java.io.Serializable): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float): ... + @typing.overload + def __init__(self, profile: 'CompressorAutomationStudy.Profile', double: float, double2: float, double3: float): ... + def getDurationSeconds(self) -> float: ... + def getEventSeconds(self) -> float: ... + def getEvidenceReferences(self) -> java.util.List[java.lang.String]: ... + def getFaultOverrides(self) -> java.util.Map[java.lang.String, typing.Any]: ... + def getProfile(self) -> 'CompressorAutomationStudy.Profile': ... + def getTimeStepSeconds(self) -> float: ... + def withEvidenceReference(self, string: typing.Union[java.lang.String, str]) -> 'CompressorAutomationStudy.CaseDefinition': ... + class ConfigurationObserver(java.io.Serializable): + def inspect(self, train: 'CompressorAutomationStudy.Train', caseDefinition: 'CompressorAutomationStudy.CaseDefinition') -> None: ... + class Design(java.io.Serializable): + def __init__(self): ... + def getAntiSurgeClosingSeconds(self) -> float: ... + def getAntiSurgeCv(self) -> float: ... + def getAntiSurgeIntegralTimeSeconds(self) -> float: ... + def getAntiSurgeOpeningSeconds(self) -> float: ... + def getAntiSurgeProportionalGain(self) -> float: ... + def getCapacityPressureGainRpmPerBar(self) -> float: ... + def getCapacityPressureIntegralTimeSeconds(self) -> float: ... + def getComposition(self) -> java.util.Map[java.lang.String, float]: ... + def getCoolerActuatorTimeConstantSeconds(self) -> float: ... + def getCoolerTemperatureK(self) -> float: ... + def getCoolerThermalTimeConstantSeconds(self) -> float: ... + def getCoolingMediumTemperatureK(self) -> float: ... + def getDischargeDiameterM(self) -> float: ... + def getDischargeInitialLevelFraction(self) -> float: ... + def getDischargeLengthM(self) -> float: ... + def getDischargePressureBara(self) -> float: ... + def getDriverRampRpmPerSecond(self) -> float: ... + def getExportPressureBara(self) -> float: ... + def getFeedFlowKgPerSecond(self) -> float: ... + def getFeedPressureBara(self) -> float: ... + def getFeedTemperatureK(self) -> float: ... + def getIsolationStrokeSeconds(self) -> float: ... + def getLevelSetPointFraction(self) -> float: ... + def getLevelTripFraction(self) -> float: ... + def getMetricLevelToleranceFraction(self) -> float: ... + def getMetricPressureToleranceBar(self) -> float: ... + def getMetricSettlingHoldSeconds(self) -> float: ... + def getMetricTemperatureToleranceK(self) -> float: ... + def getPressureTripBara(self) -> float: ... + def getSuctionDiameterM(self) -> float: ... + def getSuctionInitialLevelFraction(self) -> float: ... + def getSuctionLengthM(self) -> float: ... + def getSuctionPressureBara(self) -> float: ... + def getSurgeMarginSetPoint(self) -> float: ... + def getTemperatureTripK(self) -> float: ... + def setAntiSurgeClosingSeconds(self, double: float) -> None: ... + def setAntiSurgeCv(self, double: float) -> None: ... + def setAntiSurgeIntegralTimeSeconds(self, double: float) -> None: ... + def setAntiSurgeOpeningSeconds(self, double: float) -> None: ... + def setAntiSurgeProportionalGain(self, double: float) -> None: ... + def setCapacityPressureGainRpmPerBar(self, double: float) -> None: ... + def setCapacityPressureIntegralTimeSeconds(self, double: float) -> None: ... + def setComposition(self, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]]) -> None: ... + def setCoolerActuatorTimeConstantSeconds(self, double: float) -> None: ... + def setCoolerTemperatureK(self, double: float) -> None: ... + def setCoolerThermalTimeConstantSeconds(self, double: float) -> None: ... + def setCoolingMediumTemperatureK(self, double: float) -> None: ... + def setDischargeDiameterM(self, double: float) -> None: ... + def setDischargeInitialLevelFraction(self, double: float) -> None: ... + def setDischargeLengthM(self, double: float) -> None: ... + def setDischargePressureBara(self, double: float) -> None: ... + def setDriverRampRpmPerSecond(self, double: float) -> None: ... + def setExportPressureBara(self, double: float) -> None: ... + def setFeedFlowKgPerSecond(self, double: float) -> None: ... + def setFeedPressureBara(self, double: float) -> None: ... + def setFeedTemperatureK(self, double: float) -> None: ... + def setIsolationStrokeSeconds(self, double: float) -> None: ... + def setLevelSetPointFraction(self, double: float) -> None: ... + def setLevelTripFraction(self, double: float) -> None: ... + def setMetricLevelToleranceFraction(self, double: float) -> None: ... + def setMetricPressureToleranceBar(self, double: float) -> None: ... + def setMetricSettlingHoldSeconds(self, double: float) -> None: ... + def setMetricTemperatureToleranceK(self, double: float) -> None: ... + def setPressureTripBara(self, double: float) -> None: ... + def setSuctionDiameterM(self, double: float) -> None: ... + def setSuctionInitialLevelFraction(self, double: float) -> None: ... + def setSuctionLengthM(self, double: float) -> None: ... + def setSuctionPressureBara(self, double: float) -> None: ... + def setSurgeMarginSetPoint(self, double: float) -> None: ... + def setTemperatureTripK(self, double: float) -> None: ... + class Profile(java.lang.Enum['CompressorAutomationStudy.Profile']): + NORMAL: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + LOAD_REJECTION: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + SLOW_RECYCLE: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + STUCK_RECYCLE: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + FT_BIASED_HIGH: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + FT_FROZEN: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + COOLING_LOSS: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + MANUAL_ESD: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + DRIVER_TRIP_FAILED: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + ISOLATION_FAILED: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + ASV_TRIP_FAILED: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + LEVEL_SIGNAL_HIGH: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + DISCHARGE_LEVEL_SIGNAL_HIGH: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + PRESSURE_SIGNAL_HIGH: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + BLOCKED_OUTLET: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + CONTROL_AIR_LOSS: typing.ClassVar['CompressorAutomationStudy.Profile'] = ... + _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(class_: typing.Type[_valueOf_0__T], string: typing.Union[java.lang.String, str]) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: typing.Union[java.lang.String, str]) -> 'CompressorAutomationStudy.Profile': ... + @staticmethod + def values() -> typing.MutableSequence['CompressorAutomationStudy.Profile']: ... + class Result: + def getConfiguredTrain(self) -> 'CompressorAutomationStudy.Train': ... + def getNativeResult(self) -> jneqsim.process.safety.scenario.DynamicSafetyScenarioResult: ... + def getSamples(self) -> java.util.List[java.util.Map[java.lang.String, typing.Any]]: ... + def toMap(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class Train(java.io.Serializable): + def applyFaultOverrides(self, caseDefinition: 'CompressorAutomationStudy.CaseDefinition') -> None: ... + def copy(self) -> 'CompressorAutomationStudy.Train': ... + def getAftercooler(self) -> jneqsim.process.equipment.heatexchanger.Cooler: ... + def getAntiSurgeController(self) -> jneqsim.process.controllerdevice.AntiSurgeController: ... + def getAntiSurgeValve(self) -> jneqsim.process.equipment.valve.ESDValve: ... + def getCapacityPressureController(self) -> jneqsim.process.controllerdevice.ControllerDeviceBaseClass: ... + def getCompressor(self) -> jneqsim.process.equipment.compressor.Compressor: ... + def getControllers(self) -> java.util.List[jneqsim.process.controllerdevice.ControllerDeviceInterface]: ... + def getCoolerTemperatureController(self) -> jneqsim.process.controllerdevice.ControllerDeviceBaseClass: ... + def getDesign(self) -> 'CompressorAutomationStudy.Design': ... + def getDischargeCheckValve(self) -> jneqsim.process.equipment.valve.CheckValve: ... + def getDischargeDrain(self) -> jneqsim.process.equipment.valve.ThrottlingValve: ... + def getDischargeScrubber(self) -> jneqsim.process.equipment.separator.Separator: ... + def getDischargeTee(self) -> jneqsim.process.equipment.splitter.Splitter: ... + def getDriverActions(self) -> java.util.List[jneqsim.process.logic.action.TripCompressorAction]: ... + def getExportValve(self) -> jneqsim.process.equipment.valve.ESDValve: ... + def getFeed(self) -> jneqsim.process.equipment.stream.Stream: ... + def getInletValve(self) -> jneqsim.process.equipment.valve.ESDValve: ... + def getLastBoundary(self) -> java.util.Map[java.lang.String, typing.Any]: ... + def getMeasurements(self) -> java.util.List[jneqsim.process.measurementdevice.MeasurementDeviceInterface]: ... + def getProcess(self) -> jneqsim.process.processmodel.ProcessSystem: ... + def getSafetyFunctions(self) -> java.util.List[jneqsim.process.safety.sif.ClosedLoopSafetyFunction]: ... + def getSuctionDrain(self) -> jneqsim.process.equipment.valve.ThrottlingValve: ... + def getSuctionMixer(self) -> jneqsim.process.equipment.mixer.Mixer: ... + def getSuctionScrubber(self) -> jneqsim.process.equipment.separator.Separator: ... + def getSurgeMeasurement(self) -> jneqsim.process.measurementdevice.CompressorSurgeMarginMeasurement: ... + def initializeDynamics(self) -> None: ... + def resetPermitted(self) -> bool: ... + def resetProtection(self) -> bool: ... + def snapshot(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class TrainProcess(jneqsim.process.processmodel.ProcessSystem): + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + @typing.overload + def runTransient(self, double: float) -> None: ... + @typing.overload + def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... + @typing.overload + def runTransient(self) -> None: ... + class ProcessScenarioRunner: def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem): ... def activateLogic(self, string: typing.Union[java.lang.String, str]) -> bool: ... @@ -100,6 +289,7 @@ class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.util.scenario")``. AntiSurgeDynamicBenchmark: typing.Type[AntiSurgeDynamicBenchmark] + CompressorAutomationStudy: typing.Type[CompressorAutomationStudy] ProcessScenarioRunner: typing.Type[ProcessScenarioRunner] ScenarioExecutionSummary: typing.Type[ScenarioExecutionSummary] ScenarioTestRunner: typing.Type[ScenarioTestRunner] diff --git a/src/jneqsim-stubs/pvtsimulation/simulation/__init__.pyi b/src/jneqsim-stubs/pvtsimulation/simulation/__init__.pyi index c370060f..b1c526e0 100644 --- a/src/jneqsim-stubs/pvtsimulation/simulation/__init__.pyi +++ b/src/jneqsim-stubs/pvtsimulation/simulation/__init__.pyi @@ -100,13 +100,17 @@ class ConstantVolumeDepletion(BasePVTsimulation): @staticmethod def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... def runCalc(self) -> None: ... + def runDryPhaseChangingFixedCellDepletion(self, double: float, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> 'ConstantVolumeDepletion.FixedCellResult': ... def runFixedCellDepletion(self, double: float, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> 'ConstantVolumeDepletion.FixedCellResult': ... def runTuning(self) -> None: ... + def runWetGasFixedCellDepletion(self, double: float, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> 'ConstantVolumeDepletion.FixedCellResult': ... def setRecordDepletionSnapshots(self, boolean: bool) -> None: ... def setRefineSaturationConditions(self, boolean: bool) -> None: ... def setTemperaturesAndPressures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... def validateMaterialBalance(self, double: float) -> bool: ... class FixedCellResult(java.io.Serializable): + def allowsDryPhaseChanges(self) -> bool: ... + def allowsWetGasPhaseChanges(self) -> bool: ... def getReferencePressureBara(self) -> float: ... def getReferenceVolumeM3(self) -> float: ... def getSnapshots(self) -> typing.MutableSequence[DepletionSnapshot]: ... diff --git a/src/jneqsim-stubs/pvtsimulation/util/__init__.pyi b/src/jneqsim-stubs/pvtsimulation/util/__init__.pyi index a42977a9..8b79f4bc 100644 --- a/src/jneqsim-stubs/pvtsimulation/util/__init__.pyi +++ b/src/jneqsim-stubs/pvtsimulation/util/__init__.pyi @@ -401,7 +401,11 @@ class DepletionPvtHistoryGenerator: @staticmethod def replayNative(calibratedPvtModel: CalibratedPvtModel, boolean: bool, path: 'MaterialBalancePvtHistory.Path', string: typing.Union[java.lang.String, str], double: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], pvtSeparatorPath: 'PvtSeparatorPath') -> 'DepletionPvtHistoryGenerator.NativeResult': ... @staticmethod + def replayNativeDryPhaseChangingFixedCell(calibratedPvtModel: CalibratedPvtModel, boolean: bool, string: typing.Union[java.lang.String, str], double: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], pvtSeparatorPath: 'PvtSeparatorPath') -> 'DepletionPvtHistoryGenerator.NativeResult': ... + @staticmethod def replayNativeFixedCell(calibratedPvtModel: CalibratedPvtModel, boolean: bool, string: typing.Union[java.lang.String, str], double: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], pvtSeparatorPath: 'PvtSeparatorPath') -> 'DepletionPvtHistoryGenerator.NativeResult': ... + @staticmethod + def replayNativeWetGasFixedCell(calibratedPvtModel: CalibratedPvtModel, boolean: bool, string: typing.Union[java.lang.String, str], double: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], pvtSeparatorPath: 'PvtSeparatorPath') -> 'DepletionPvtHistoryGenerator.NativeResult': ... class NativeResult(java.io.Serializable): def getFixedCellReference(self) -> jneqsim.pvtsimulation.simulation.ConstantVolumeDepletion.FixedCellResult: ... def getModel(self) -> CalibratedPvtModel: ... @@ -604,6 +608,7 @@ class ReservoirHistoryEnsemble: def getRejectedCandidates(self) -> typing.MutableSequence[java.lang.String]: ... def getRejectedPriorMassFraction(self) -> float: ... def getResults(self) -> typing.MutableSequence[CompositionalReservoirHistory.Result]: ... + def parameterQuantiles(self, double: float) -> typing.MutableSequence[float]: ... def pressureQuantiles(self, double: float) -> typing.MutableSequence[float]: ... class SaturationPressureCorrelation: diff --git a/src/jneqsim-stubs/thermo/component/__init__.pyi b/src/jneqsim-stubs/thermo/component/__init__.pyi index 3619b83e..0793c71e 100644 --- a/src/jneqsim-stubs/thermo/component/__init__.pyi +++ b/src/jneqsim-stubs/thermo/component/__init__.pyi @@ -29,6 +29,7 @@ class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.la def clone(self) -> 'ComponentInterface': ... def createComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... def doSolidCheck(self) -> bool: ... + def fitCompositionDerivativeArrays(self, int: int) -> None: ... def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... def fugcoefDiffPresNumeric(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... def fugcoefDiffTempNumeric(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... @@ -417,7 +418,6 @@ class IapwsHenryLaw: def values() -> typing.MutableSequence['IapwsHenryLaw.Status']: ... class Component(ComponentInterface): - dfugdx: typing.MutableSequence[float] = ... @typing.overload def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... @typing.overload @@ -434,6 +434,7 @@ class Component(ComponentInterface): def createComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... def doSolidCheck(self) -> bool: ... def equals(self, object: typing.Any) -> bool: ... + def fitCompositionDerivativeArrays(self, int: int) -> None: ... def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... def fugcoefDiffPresNumeric(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... def fugcoefDiffTempNumeric(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... @@ -817,8 +818,6 @@ class ComponentEos(Component, ComponentEosInterface): Ai: float = ... AiT: float = ... aDiffDiffT: float = ... - Aij: typing.MutableSequence[float] = ... - Bij: typing.MutableSequence[float] = ... @typing.overload def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... @typing.overload @@ -838,6 +837,7 @@ class ComponentEos(Component, ComponentEosInterface): def diffdiffaT(self, double: float) -> float: ... def diffdiffalphaT(self, double: float) -> float: ... def equals(self, object: typing.Any) -> bool: ... + def fitCompositionDerivativeArrays(self, int: int) -> None: ... def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... def getAder(self) -> float: ... def getAi(self) -> float: ... diff --git a/src/jneqsim-stubs/thermo/phase/__init__.pyi b/src/jneqsim-stubs/thermo/phase/__init__.pyi index 9bf26606..7b1d4c1e 100644 --- a/src/jneqsim-stubs/thermo/phase/__init__.pyi +++ b/src/jneqsim-stubs/thermo/phase/__init__.pyi @@ -605,6 +605,8 @@ class PitzerParameterCoverage(java.io.Serializable): class PitzerParameterDatasets: PHREEQC_CO2_CHLORIDE_USER_ZETA_ID: typing.ClassVar[java.lang.String] = ... PHREEQC_CO2_CHLORIDE_USER_THETA_ZETA_ID: typing.ClassVar[java.lang.String] = ... + PHREEQC_REACTIVE_NACL_CARBONATE_ID: typing.ClassVar[java.lang.String] = ... + PHREEQC_AUTOMATIC_REACTIVE_CARBONATE_ID: typing.ClassVar[java.lang.String] = ... PHREEQC_CO2_NA2SO4_ID: typing.ClassVar[java.lang.String] = ... PHREEQC_NA_K_CL_ID: typing.ClassVar[java.lang.String] = ... PHREEQC_PITZER_CATALOG_ID: typing.ClassVar[java.lang.String] = ... @@ -642,6 +644,8 @@ class PitzerParameterDatasets: @staticmethod def applyPhreeqcCo2SodiumSulfate(phasePitzer: 'PhasePitzer') -> None: ... @staticmethod + def applyPhreeqcReactiveSodiumChlorideCarbonate(phasePitzer: 'PhasePitzer') -> None: ... + @staticmethod def applyPhreeqcSodiumPotassiumChloride(phasePitzer: 'PhasePitzer') -> None: ... @staticmethod def getMissingPhreeqcPitzerCatalogRows(phasePitzer: 'PhasePitzer') -> java.util.List[java.lang.String]: ... @@ -773,6 +777,8 @@ class Phase(PhaseInterface): def addMolesChemReac(self, int: int, double: float) -> None: ... @typing.overload def addMolesChemReac(self, int: int, double: float, double2: float) -> None: ... + @staticmethod + def beginThermoOnlyClone() -> None: ... @typing.overload def calcA(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... @typing.overload @@ -795,6 +801,8 @@ class Phase(PhaseInterface): def dFdTdV(self) -> float: ... def dFdV(self) -> float: ... def dFdVdV(self) -> float: ... + @staticmethod + def endThermoOnlyClone() -> None: ... def equals(self, object: typing.Any) -> bool: ... def fBB(self) -> float: ... def fBV(self) -> float: ... @@ -1043,6 +1051,8 @@ class Phase(PhaseInterface): def initRefPhases(self, boolean: bool, string: typing.Union[java.lang.String, str]) -> None: ... def isConstantPhaseVolume(self) -> bool: ... def isMixingRuleDefined(self) -> bool: ... + @staticmethod + def isThermoOnlyCloneActive() -> bool: ... def normalize(self) -> None: ... def removeComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float) -> None: ... def resetPhysicalProperties(self) -> None: ... @@ -1894,14 +1904,17 @@ class PhasePitzer(PhaseGE): def getOsmoticCoefficientOfWater(self) -> float: ... def getOsmoticCoefficientOfWaterMolality(self) -> float: ... def getParameterDatasetId(self) -> java.lang.String: ... + def getPitzerActivity(self, int: int) -> float: ... def getPitzerAlpha1(self, int: int, int2: int) -> float: ... def getPitzerAlpha2(self, int: int, int2: int) -> float: ... + def getPitzerPH(self) -> float: ... def getPitzerParameterCoverage(self) -> PitzerParameterCoverage: ... def getPitzerReactionParameterCoverage(self) -> PitzerParameterCoverage: ... @typing.overload def getPsiijk(self, int: int, int2: int, int3: int) -> float: ... @typing.overload def getPsiijk(self, int: int, int2: int, int3: int, double: float) -> float: ... + def getReactiveCarbonateSourceZeroDefinitions(self) -> java.util.List[java.lang.String]: ... def getSolventWeight(self) -> float: ... def getSresTP(self) -> float: ... def getSresTV(self) -> float: ... @@ -1926,6 +1939,7 @@ class PhasePitzer(PhaseGE): def isUsePhreeqcCatalogByDefault(self) -> bool: ... def loadParametersFromDatabase(self) -> None: ... def molarVolume(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def prepareAutomaticReactiveCarbonateSelection(self) -> None: ... def requireCompleteNeutralPitzerParameterCoverage(self) -> None: ... def requireCompletePitzerParameterCoverage(self) -> None: ... def requireCompletePitzerReactionParameterCoverage(self) -> None: ... @@ -2170,6 +2184,7 @@ class PhaseWaterIAPWS(PhaseEos): def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... @typing.overload def getInternalEnergy(self) -> float: ... + def getSalinity(self) -> float: ... @typing.overload def getSoundSpeed(self, string: typing.Union[java.lang.String, str]) -> float: ... @typing.overload @@ -2181,6 +2196,7 @@ class PhaseWaterIAPWS(PhaseEos): @typing.overload def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... def molarVolume(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def setSalinity(self, double: float) -> None: ... class PhaseBNS(PhasePrEos): def __init__(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[float], jpype.JArray], doubleArray4: typing.Union[typing.List[float], jpype.JArray], doubleArray5: typing.Union[typing.List[float], jpype.JArray], doubleArray6: typing.Union[typing.List[float], jpype.JArray], doubleArray7: typing.Union[typing.List[float], jpype.JArray]): ... diff --git a/src/jneqsim-stubs/thermo/system/__init__.pyi b/src/jneqsim-stubs/thermo/system/__init__.pyi index 1d801cb4..7e621aa4 100644 --- a/src/jneqsim-stubs/thermo/system/__init__.pyi +++ b/src/jneqsim-stubs/thermo/system/__init__.pyi @@ -194,6 +194,7 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): def chemicalReactionInit(self) -> None: ... def clearAll(self) -> None: ... def clone(self) -> 'SystemInterface': ... + def cloneThermoOnly(self) -> 'SystemInterface': ... @staticmethod def combineReservoirFluids(int: int, *systemInterface: 'SystemInterface') -> 'SystemInterface': ... def createDatabase(self, boolean: bool) -> None: ... @@ -954,7 +955,9 @@ class SystemPitzer(SystemEosGE): @typing.overload def applyPhreeqcCo2ChlorideParameters(self, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]], double: float) -> None: ... def applyPhreeqcCo2SodiumSulfateParameters(self) -> None: ... + def applyPhreeqcReactiveSodiumChlorideCarbonateParameters(self) -> None: ... def applyPhreeqcSodiumPotassiumChlorideParameters(self) -> None: ... + def chemicalReactionInit(self) -> None: ... def clone(self) -> 'SystemPitzer': ... def getChemicalReactionConcentrationBasis(self) -> jneqsim.chemicalreactions.chemicalreaction.ChemicalReactionConcentrationBasis: ... def getChemicalReactionDataSource(self) -> jneqsim.chemicalreactions.chemicalreaction.ChemicalReactionDataSource: ... @@ -1078,6 +1081,16 @@ class SystemSAFTVRMie(jneqsim.thermo.system.SystemSrkEos): @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... +class SystemSeawater(jneqsim.thermo.system.SystemWaterIF97): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float, double3: float): ... + def clone(self) -> 'SystemSeawater': ... + def getSalinity(self) -> float: ... + def hashCode(self) -> int: ... + def setSalinity(self, double: float) -> None: ... + class SystemSolidHelmholtzEos(SystemEos): def __init__(self, double: float, double2: float, string: typing.Union[java.lang.String, str], solidHelmholtzEquation: typing.Union[jneqsim.thermo.util.solid.SolidHelmholtzEquation, typing.Callable]): ... @typing.overload @@ -1609,6 +1622,7 @@ class SystemThermo(SystemInterface): def chemicalReactionInit(self) -> None: ... def clearAll(self) -> None: ... def clone(self) -> 'SystemThermo': ... + def cloneThermoOnly(self) -> SystemInterface: ... def createDatabase(self, boolean: bool) -> None: ... def createTable(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... def deleteFluidPhase(self, int: int) -> None: ... @@ -2027,6 +2041,7 @@ class __module_protocol__(Protocol): SystemPsrkEos: typing.Type[SystemPsrkEos] SystemRKEos: typing.Type[SystemRKEos] SystemSAFTVRMie: typing.Type[SystemSAFTVRMie] + SystemSeawater: typing.Type[SystemSeawater] SystemSolidHelmholtzEos: typing.Type[SystemSolidHelmholtzEos] SystemSoreideWhitson: typing.Type[SystemSoreideWhitson] SystemSpanWagnerEos: typing.Type[SystemSpanWagnerEos] diff --git a/src/jneqsim-stubs/thermo/util/__init__.pyi b/src/jneqsim-stubs/thermo/util/__init__.pyi index bd3602c5..44e2e0c7 100644 --- a/src/jneqsim-stubs/thermo/util/__init__.pyi +++ b/src/jneqsim-stubs/thermo/util/__init__.pyi @@ -20,6 +20,7 @@ import jneqsim.thermo.util.humidair import jneqsim.thermo.util.hydrogen import jneqsim.thermo.util.jni import jneqsim.thermo.util.leachman +import jneqsim.thermo.util.mineral import jneqsim.thermo.util.readwrite import jneqsim.thermo.util.referenceequations import jneqsim.thermo.util.solid @@ -154,6 +155,7 @@ class __module_protocol__(Protocol): hydrogen: jneqsim.thermo.util.hydrogen.__module_protocol__ jni: jneqsim.thermo.util.jni.__module_protocol__ leachman: jneqsim.thermo.util.leachman.__module_protocol__ + mineral: jneqsim.thermo.util.mineral.__module_protocol__ readwrite: jneqsim.thermo.util.readwrite.__module_protocol__ referenceequations: jneqsim.thermo.util.referenceequations.__module_protocol__ solid: jneqsim.thermo.util.solid.__module_protocol__ diff --git a/src/jneqsim-stubs/thermo/util/mineral/__init__.pyi b/src/jneqsim-stubs/thermo/util/mineral/__init__.pyi new file mode 100644 index 00000000..fbacf709 --- /dev/null +++ b/src/jneqsim-stubs/thermo/util/mineral/__init__.pyi @@ -0,0 +1,206 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.io +import java.lang +import java.util +import jpype +import jneqsim.thermo.system +import typing + + + +class MineralH2SBuffers: + @staticmethod + def all() -> java.util.Map[java.lang.String, 'SolidGasReactionEquilibrium']: ... + @staticmethod + def anhydriteSulfateReduction() -> 'SolidGasReactionEquilibrium': ... + @staticmethod + def enthalpyPerMoleH2S(solidGasReactionEquilibrium: 'SolidGasReactionEquilibrium', double: float) -> float: ... + @staticmethod + def pyriteMagnetite() -> 'SolidGasReactionEquilibrium': ... + @staticmethod + def pyritePyrrhotite() -> 'SolidGasReactionEquilibrium': ... + @staticmethod + def pyriteSiderite() -> 'SolidGasReactionEquilibrium': ... + @staticmethod + def pyrrhotiteMagnetite() -> 'SolidGasReactionEquilibrium': ... + @staticmethod + def pyrrhotiteSiderite() -> 'SolidGasReactionEquilibrium': ... + @staticmethod + def sideriteMagnetite() -> 'SolidGasReactionEquilibrium': ... + +class ReservoirH2SEstimator(java.io.Serializable): + NCS_CALIBRATED_FE_CARBONATE_ACTIVITY: typing.ClassVar[float] = ... + def __init__(self): ... + @typing.overload + def equilibrationTemperature(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float) -> float: ... + @typing.overload + def equilibrationTemperature(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float, double3: float) -> float: ... + def estimate(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> 'ReservoirH2SEstimator.Estimate': ... + def getFeCarbonateActivity(self) -> float: ... + def getWaterActivity(self) -> float: ... + def setFeCarbonateActivity(self, double: float) -> None: ... + def setSulfateMineralsPresent(self, boolean: bool) -> None: ... + def setWaterActivity(self, double: float) -> None: ... + class Estimate(java.io.Serializable): + def getFeCarbonateActivity(self) -> float: ... + def getFluid(self) -> jneqsim.thermo.system.SystemInterface: ... + def getH2SFugacity(self) -> float: ... + def getH2SPpm(self) -> float: ... + def getPyriteStabilityMargin(self) -> float: ... + def getSideriteStabilityMargin(self) -> float: ... + def getWarnings(self) -> java.util.List[java.lang.String]: ... + def getWaterActivity(self) -> float: ... + def isBufferConsistent(self) -> bool: ... + def isConverged(self) -> bool: ... + +class SolidGasReactionEquilibrium(java.io.Serializable): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addSpecies(self, standardStateSpecies: 'StandardStateSpecies', double: float) -> 'SolidGasReactionEquilibrium': ... + def checkElementBalance(self) -> None: ... + def getActivity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getCondensedPressureCorrection(self, double: float, double2: float) -> float: ... + def getGasMoleChange(self) -> float: ... + def getGasSpeciesNames(self) -> java.util.List[java.lang.String]: ... + def getLnEquilibriumGasFugacity(self, string: typing.Union[java.lang.String, str], map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]], double: float, double2: float) -> float: ... + def getLnEquilibriumGasFugacityQuotient(self, double: float, double2: float) -> float: ... + def getLnK(self, double: float) -> float: ... + def getLog10K(self, double: float) -> float: ... + def getLog10KUncertainty(self, double: float) -> float: ... + def getName(self) -> java.lang.String: ... + def getSpecies(self) -> java.util.List['StandardStateSpecies']: ... + def getSpeciesWithoutUncertainty(self) -> java.util.List[java.lang.String]: ... + def getStandardEnthalpyOfReaction(self, double: float) -> float: ... + def getStandardEntropyOfReaction(self, double: float) -> float: ... + def getStandardGibbsEnergyOfReaction(self, double: float) -> float: ... + def getWarnings(self, double: float) -> java.util.List[java.lang.String]: ... + @staticmethod + def ironSulfideToSiderite() -> 'SolidGasReactionEquilibrium': ... + def isWithinDataRange(self, double: float) -> bool: ... + def setActivity(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def setMaxIterations(self, int: int) -> None: ... + def setTolerance(self, double: float) -> None: ... + def solveForGas(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str]) -> 'SolidGasReactionEquilibrium.GasExchangeResult': ... + def solveGasExchange(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], exchangeMode: 'SolidGasReactionEquilibrium.ExchangeMode') -> 'SolidGasReactionEquilibrium.GasExchangeResult': ... + class ExchangeMode(java.lang.Enum['SolidGasReactionEquilibrium.ExchangeMode']): + FIXED_REACTANT: typing.ClassVar['SolidGasReactionEquilibrium.ExchangeMode'] = ... + CONSERVE_GAS_SUM: typing.ClassVar['SolidGasReactionEquilibrium.ExchangeMode'] = ... + FIXED_OTHERS: typing.ClassVar['SolidGasReactionEquilibrium.ExchangeMode'] = ... + _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(class_: typing.Type[_valueOf_0__T], string: typing.Union[java.lang.String, str]) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: typing.Union[java.lang.String, str]) -> 'SolidGasReactionEquilibrium.ExchangeMode': ... + @staticmethod + def values() -> typing.MutableSequence['SolidGasReactionEquilibrium.ExchangeMode']: ... + class GasExchangeResult(java.io.Serializable): + def getAchievedFugacityQuotient(self) -> float: ... + def getCondensedPressureCorrection(self) -> float: ... + def getEquilibriumFluid(self) -> jneqsim.thermo.system.SystemInterface: ... + def getGasFugacity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getGasFugacityCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getIterations(self) -> int: ... + def getLog10K(self) -> float: ... + def getLog10KUncertainty(self) -> float: ... + def getMode(self) -> 'SolidGasReactionEquilibrium.ExchangeMode': ... + def getPressure(self) -> float: ... + def getProductFugacityCoefficient(self) -> float: ... + def getProductMoleFraction(self) -> float: ... + def getProductMoleFractionInGas(self) -> float: ... + def getReactantFugacityCoefficient(self) -> float: ... + def getReactantMoleFraction(self) -> float: ... + def getTargetFugacityQuotient(self) -> float: ... + def getTemperature(self) -> float: ... + def getWarnings(self) -> java.util.List[java.lang.String]: ... + def isConverged(self) -> bool: ... + +class StandardStateSpecies(java.io.Serializable): + REFERENCE_TEMPERATURE: typing.ClassVar[float] = ... + STANDARD_PRESSURE: typing.ClassVar[float] = ... + @staticmethod + def anhydrite() -> 'StandardStateSpecies': ... + @staticmethod + def calcite() -> 'StandardStateSpecies': ... + @staticmethod + def carbonDioxideGas() -> 'StandardStateSpecies': ... + def getApparentGibbsEnergy(self, double: float) -> float: ... + def getElements(self) -> java.util.Map[java.lang.String, float]: ... + def getEnthalpyChange(self, double: float) -> float: ... + def getEntropy(self, double: float) -> float: ... + def getEntropy298(self) -> float: ... + def getEntropyUncertainty(self) -> float: ... + def getFormationEnthalpy298(self) -> float: ... + def getFormationEnthalpyUncertainty(self) -> float: ... + def getHeatCapacity(self, double: float) -> float: ... + def getMaximumTemperature(self) -> float: ... + def getMinimumTemperature(self) -> float: ... + def getName(self) -> java.lang.String: ... + def getPhase(self) -> 'StandardStateSpecies.Phase': ... + def getPressureIntegral(self, double: float, double2: float) -> float: ... + def getPressureModel(self) -> 'StandardStateSpecies.PressureModel': ... + def getSource(self) -> java.lang.String: ... + @staticmethod + def hydrogenGas() -> 'StandardStateSpecies': ... + @staticmethod + def hydrogenSulfideGas() -> 'StandardStateSpecies': ... + def isWithinDataRange(self, double: float) -> bool: ... + @staticmethod + def liquidWater() -> 'StandardStateSpecies': ... + @staticmethod + def magnetite() -> 'StandardStateSpecies': ... + @staticmethod + def methaneGas() -> 'StandardStateSpecies': ... + @staticmethod + def pyrite() -> 'StandardStateSpecies': ... + @staticmethod + def robieHemingway(string: typing.Union[java.lang.String, str], phase: 'StandardStateSpecies.Phase', map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]], double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], double4: float, double5: float, pressureModel: 'StandardStateSpecies.PressureModel', double6: float, double7: float, double8: float, string2: typing.Union[java.lang.String, str]) -> 'StandardStateSpecies': ... + @staticmethod + def shomate(string: typing.Union[java.lang.String, str], phase: 'StandardStateSpecies.Phase', map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[float], jpype.JArray], pressureModel: 'StandardStateSpecies.PressureModel', double4: float, double5: float, double6: float, string2: typing.Union[java.lang.String, str]) -> 'StandardStateSpecies': ... + @staticmethod + def siderite() -> 'StandardStateSpecies': ... + @staticmethod + def troilite() -> 'StandardStateSpecies': ... + def usesMetastableLiquidReference(self, double: float) -> bool: ... + class Phase(java.lang.Enum['StandardStateSpecies.Phase']): + SOLID: typing.ClassVar['StandardStateSpecies.Phase'] = ... + LIQUID: typing.ClassVar['StandardStateSpecies.Phase'] = ... + IDEAL_GAS: typing.ClassVar['StandardStateSpecies.Phase'] = ... + _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(class_: typing.Type[_valueOf_0__T], string: typing.Union[java.lang.String, str]) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: typing.Union[java.lang.String, str]) -> 'StandardStateSpecies.Phase': ... + @staticmethod + def values() -> typing.MutableSequence['StandardStateSpecies.Phase']: ... + class PressureModel(java.lang.Enum['StandardStateSpecies.PressureModel']): + IDEAL_GAS: typing.ClassVar['StandardStateSpecies.PressureModel'] = ... + CONSTANT_VOLUME: typing.ClassVar['StandardStateSpecies.PressureModel'] = ... + IAPWS_IF97_LIQUID_WATER: typing.ClassVar['StandardStateSpecies.PressureModel'] = ... + _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(class_: typing.Type[_valueOf_0__T], string: typing.Union[java.lang.String, str]) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: typing.Union[java.lang.String, str]) -> 'StandardStateSpecies.PressureModel': ... + @staticmethod + def values() -> typing.MutableSequence['StandardStateSpecies.PressureModel']: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.mineral")``. + + MineralH2SBuffers: typing.Type[MineralH2SBuffers] + ReservoirH2SEstimator: typing.Type[ReservoirH2SEstimator] + SolidGasReactionEquilibrium: typing.Type[SolidGasReactionEquilibrium] + StandardStateSpecies: typing.Type[StandardStateSpecies] diff --git a/src/jneqsim-stubs/thermo/util/steam/__init__.pyi b/src/jneqsim-stubs/thermo/util/steam/__init__.pyi index 7853ef0c..6ebd0a79 100644 --- a/src/jneqsim-stubs/thermo/util/steam/__init__.pyi +++ b/src/jneqsim-stubs/thermo/util/steam/__init__.pyi @@ -9,14 +9,43 @@ import typing +class BrineSalinityCorrection: + MAX_MASS_FRACTION: typing.ClassVar[float] = ... + @staticmethod + def densityRatio(double: float, double2: float, double3: float) -> float: ... + @staticmethod + def densityRatioPressureDerivative(double: float, double2: float, double3: float) -> float: ... + @staticmethod + def densityRatioTemperatureDerivative(double: float, double2: float, double3: float) -> float: ... + @staticmethod + def massFractionFromConcentration(double: float, double2: float, double3: float) -> float: ... + @staticmethod + def viscosityRatio(double: float, double2: float) -> float: ... + +class CoolingWaterTransport: + @staticmethod + def conductivity(double: float, double2: float, double3: float) -> float: ... + @staticmethod + def seawaterConductivityIncrement(double: float, double2: float, double3: float) -> float: ... + @staticmethod + def viscosity(double: float, double2: float, double3: float) -> float: ... + @staticmethod + def waterConductivity(double: float, double2: float) -> float: ... + @staticmethod + def waterViscosity(double: float, double2: float) -> float: ... + class Iapws_if97: @staticmethod def T4_p(double: float) -> float: ... @staticmethod def cp_pt(double: float, double2: float) -> float: ... @staticmethod + def cv_pt(double: float, double2: float) -> float: ... + @staticmethod def h_pt(double: float, double2: float) -> float: ... @staticmethod + def liquidGibbsDerivative(double: float, double2: float, int: int, int2: int) -> float: ... + @staticmethod def p4_T(double: float) -> float: ... @staticmethod def psat_t(double: float) -> float: ... @@ -29,8 +58,44 @@ class Iapws_if97: @staticmethod def w_pt(double: float, double2: float) -> float: ... +class LiquidWaterReference: + MIN_TEMPERATURE: typing.ClassVar[float] = ... + MAX_TEMPERATURE: typing.ClassVar[float] = ... + MAX_PRESSURE: typing.ClassVar[float] = ... + @staticmethod + def at(double: float, double2: float) -> 'LiquidWaterReference': ... + def getDensity(self) -> float: ... + def getDensityPressureDerivative(self) -> float: ... + def getDensityTemperatureDerivative(self) -> float: ... + def getEnthalpy(self) -> float: ... + def getEntropy(self) -> float: ... + def getHeatCapacityCp(self) -> float: ... + def getThermalConductivity(self) -> float: ... + def getViscosity(self) -> float: ... + @staticmethod + def isInRange(double: float, double2: float) -> bool: ... + def isMetastable(self) -> bool: ... + +class SeawaterProperties: + @staticmethod + def gibbsDerivative(double: float, double2: float, double3: float, int: int, int2: int) -> float: ... + @staticmethod + def isWithinPressureReferenceRange(double: float, double2: float) -> bool: ... + @staticmethod + def salineGibbsDerivative(double: float, double2: float, double3: float, int: int, int2: int) -> float: ... + @staticmethod + def specificEnthalpy(double: float, double2: float, double3: float) -> float: ... + @staticmethod + def specificHeatCapacity(double: float, double2: float, double3: float) -> float: ... + @staticmethod + def validate(double: float, double2: float, double3: float) -> None: ... + class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.steam")``. + BrineSalinityCorrection: typing.Type[BrineSalinityCorrection] + CoolingWaterTransport: typing.Type[CoolingWaterTransport] Iapws_if97: typing.Type[Iapws_if97] + LiquidWaterReference: typing.Type[LiquidWaterReference] + SeawaterProperties: typing.Type[SeawaterProperties] diff --git a/src/jneqsim-stubs/thermodynamicoperations/flashops/__init__.pyi b/src/jneqsim-stubs/thermodynamicoperations/flashops/__init__.pyi index 555427d4..c3dcaea8 100644 --- a/src/jneqsim-stubs/thermodynamicoperations/flashops/__init__.pyi +++ b/src/jneqsim-stubs/thermodynamicoperations/flashops/__init__.pyi @@ -211,6 +211,10 @@ class QfuncFlash(Flash): def run(self) -> None: ... def solveQ(self) -> float: ... +class SeawaterPHflash(Flash): + def __init__(self, systemSeawater: jneqsim.thermo.system.SystemSeawater, double: float): ... + def run(self) -> None: ... + class TPflash(Flash): @typing.overload def __init__(self): ... @@ -530,6 +534,7 @@ class __module_protocol__(Protocol): RachfordRice: typing.Type[RachfordRice] ReactiveCO2BrinePhaseEquilibrium: typing.Type[ReactiveCO2BrinePhaseEquilibrium] SaturateWithWater: typing.Type[SaturateWithWater] + SeawaterPHflash: typing.Type[SeawaterPHflash] SolidFlash: typing.Type[SolidFlash] SolidFlash1: typing.Type[SolidFlash1] SolidFlash12: typing.Type[SolidFlash12] diff --git a/src/jneqsim-stubs/thermodynamicoperations/propertygenerator/__init__.pyi b/src/jneqsim-stubs/thermodynamicoperations/propertygenerator/__init__.pyi index a07c30d0..927fd1cf 100644 --- a/src/jneqsim-stubs/thermodynamicoperations/propertygenerator/__init__.pyi +++ b/src/jneqsim-stubs/thermodynamicoperations/propertygenerator/__init__.pyi @@ -6,6 +6,7 @@ else: from typing_extensions import Protocol import java.lang +import java.util import jpype import jneqsim.thermo.system import jneqsim.thermodynamicoperations @@ -43,12 +44,21 @@ class OLGApropertyTableGeneratorKeywordFormat(jneqsim.thermodynamicoperations.Ba def calcPhaseEnvelope(self) -> None: ... def displayResult(self) -> None: ... def getFluidLabel(self) -> java.lang.String: ... + def getQualityReport(self) -> 'OlgaTableQualityReport': ... + def getTableReport(self) -> java.lang.String: ... def initCalc(self) -> None: ... def run(self) -> None: ... + def setEnvelopeRefinement(self, boolean: bool, double: float) -> None: ... def setFluidLabel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setInsertStandardConditions(self, boolean: bool) -> None: ... + def setMonotonicityCorrection(self, boolean: bool) -> None: ... def setPressureRange(self, double: float, double2: float, int: int) -> None: ... + def setPressures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setStandardConditions(self, double: float, double2: float) -> None: ... def setTemperatureRange(self, double: float, double2: float, int: int) -> None: ... + def setTemperatures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... def writeOLGAinpFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def writeTableReport(self, string: typing.Union[java.lang.String, str]) -> None: ... class OLGApropertyTableGeneratorWater(jneqsim.thermodynamicoperations.BaseOperation): def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... @@ -93,12 +103,28 @@ class OLGApropertyTableGeneratorWaterKeywordFormat(jneqsim.thermodynamicoperatio def calcRSWTOB(self) -> None: ... def displayResult(self) -> None: ... def getFluidLabel(self) -> java.lang.String: ... + def getQualityReport(self) -> 'OlgaTableQualityReport': ... + def getReferenceWaterNodeCount(self) -> int: ... + def getReferenceWaterSkippedNodeCount(self) -> int: ... + def getTableFluid(self) -> jneqsim.thermo.system.SystemInterface: ... + def getTableReport(self) -> java.lang.String: ... + def getWaterSaltMassFraction(self) -> float: ... def initCalc(self) -> None: ... def run(self) -> None: ... + def setEnvelopeRefinement(self, boolean: bool, double: float) -> None: ... def setFluidLabel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setInsertStandardConditions(self, boolean: bool) -> None: ... + def setMonotonicityCorrection(self, boolean: bool) -> None: ... def setPressureRange(self, double: float, double2: float, int: int) -> None: ... + def setPressures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setProducedWater(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setStandardConditions(self, double: float, double2: float) -> None: ... def setTemperatureRange(self, double: float, double2: float, int: int) -> None: ... + def setTemperatures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setUseReferenceWaterProperties(self, boolean: bool) -> None: ... + def setWaterSalinity(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... def writeOLGAinpFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def writeTableReport(self, string: typing.Union[java.lang.String, str]) -> None: ... class OLGApropertyTableGeneratorWaterStudents(jneqsim.thermodynamicoperations.BaseOperation): def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... @@ -134,6 +160,27 @@ class OLGApropertyTableGeneratorWaterStudentsPH(jneqsim.thermodynamicoperations. def writeOLGAinpFile(self, string: typing.Union[java.lang.String, str]) -> None: ... def writeOLGAinpFile2(self, string: typing.Union[java.lang.String, str]) -> None: ... +class OlgaTableQualityReport: + def __init__(self, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray], doubleArray: typing.Union[typing.List[typing.MutableSequence[typing.MutableSequence[float]]], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[float], jpype.JArray], booleanArray: typing.Union[typing.List[typing.MutableSequence[typing.MutableSequence[bool]]], jpype.JArray]): ... + def getColumn(self, string: typing.Union[java.lang.String, str]) -> 'OlgaTableQualityReport.ColumnSummary': ... + def getColumns(self) -> java.util.List['OlgaTableQualityReport.ColumnSummary']: ... + def getExtrapolatedMonotonicityViolations(self) -> int: ... + def isLoadable(self) -> bool: ... + def toJson(self) -> java.lang.String: ... + def writeCsv(self, string: typing.Union[java.lang.String, str]) -> None: ... + class ColumnSummary: + keyword: java.lang.String = ... + minimum: float = ... + maximum: float = ... + nonFiniteCount: int = ... + nonPositiveCount: int = ... + monotonicityViolationsExisting: int = ... + monotonicityViolationsExtrapolated: int = ... + maxInteriorJump: float = ... + maxBoundaryJump: float = ... + existingNodes: int = ... + def __init__(self): ... + class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermodynamicoperations.propertygenerator")``. @@ -146,3 +193,4 @@ class __module_protocol__(Protocol): OLGApropertyTableGeneratorWaterKeywordFormat: typing.Type[OLGApropertyTableGeneratorWaterKeywordFormat] OLGApropertyTableGeneratorWaterStudents: typing.Type[OLGApropertyTableGeneratorWaterStudents] OLGApropertyTableGeneratorWaterStudentsPH: typing.Type[OLGApropertyTableGeneratorWaterStudentsPH] + OlgaTableQualityReport: typing.Type[OlgaTableQualityReport] diff --git a/src/jneqsim-stubs/util/__init__.pyi b/src/jneqsim-stubs/util/__init__.pyi index 9fbc8362..c1a321b7 100644 --- a/src/jneqsim-stubs/util/__init__.pyi +++ b/src/jneqsim-stubs/util/__init__.pyi @@ -89,6 +89,12 @@ class NeqSimThreadPool: @staticmethod def submit(callable: typing.Union[java.util.concurrent.Callable[_submit_1__T], typing.Callable[[], _submit_1__T]]) -> java.util.concurrent.Future[_submit_1__T]: ... +class NeqSimVersion: + VERSION_PROPERTY: typing.ClassVar[java.lang.String] = ... + DEVELOPMENT_VERSION: typing.ClassVar[java.lang.String] = ... + @staticmethod + def get() -> java.lang.String: ... + class NamedBaseClass(NamedInterface, java.io.Serializable): name: java.lang.String = ... def __init__(self, string: typing.Union[java.lang.String, str]): ... @@ -106,6 +112,7 @@ class __module_protocol__(Protocol): NamedInterface: typing.Type[NamedInterface] NeqSimLogging: typing.Type[NeqSimLogging] NeqSimThreadPool: typing.Type[NeqSimThreadPool] + NeqSimVersion: typing.Type[NeqSimVersion] agentic: jneqsim.util.agentic.__module_protocol__ annotation: jneqsim.util.annotation.__module_protocol__ database: jneqsim.util.database.__module_protocol__ diff --git a/src/neqsim/data/neqsim_api.json.gz b/src/neqsim/data/neqsim_api.json.gz index 56bc7a1b..5e46ae10 100644 Binary files a/src/neqsim/data/neqsim_api.json.gz and b/src/neqsim/data/neqsim_api.json.gz differ diff --git a/src/neqsim/lib/neqsim-3.28.0.jar b/src/neqsim/lib/neqsim-3.29.0.jar similarity index 93% rename from src/neqsim/lib/neqsim-3.28.0.jar rename to src/neqsim/lib/neqsim-3.29.0.jar index 100b91fd..3105e2cc 100644 Binary files a/src/neqsim/lib/neqsim-3.28.0.jar and b/src/neqsim/lib/neqsim-3.29.0.jar differ diff --git a/uv.lock b/uv.lock index bdd01a41..7c8ad163 100644 --- a/uv.lock +++ b/uv.lock @@ -1897,7 +1897,7 @@ wheels = [ [[package]] name = "neqsim" -version = "3.28.0" +version = "3.29.0" source = { editable = "." } default-groups = "all" dependencies = [