diff --git a/.github/workflows/generate-stubs.yml b/.github/workflows/generate-stubs.yml new file mode 100644 index 00000000..ced4210b --- /dev/null +++ b/.github/workflows/generate-stubs.yml @@ -0,0 +1,45 @@ +name: Generate Java Stubs + +on: + # Run when JAR files are updated + push: + paths: + - 'src/neqsim/lib/**/*.jar' + # Run on release + release: + types: [published] + # Allow manual trigger + workflow_dispatch: + +jobs: + generate-stubs: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.11' + + - name: Set up Java + uses: actions/setup-java@v4 + with: + distribution: 'temurin' + java-version: '17' + + - name: Install dependencies + run: | + pip install poetry + poetry install --with dev + + - name: Generate stubs + run: | + poetry run python scripts/generate_stubs.py + + - name: Commit updated stubs + uses: stefanzweifel/git-auto-commit-action@v5 + with: + commit_message: "chore: regenerate Java stubs" + file_pattern: "src/jneqsim-stubs/**" diff --git a/pyproject.toml b/pyproject.toml index 221a98e8..8f540b82 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,6 +27,7 @@ tabulate = { version = "^0.9.0", optional = true } black = ">=23.12,<25.0" pytest = "^7.4.3" pre-commit = "^3.5.0" # Higher versions require python 3.9+ +stubgenj = "^0.2.12" # Generate type stubs for Java classes [tool.poetry.extras] interactive = ["matplotlib", "jupyter", "tabulate"] diff --git a/scripts/generate_stubs.py b/scripts/generate_stubs.py new file mode 100644 index 00000000..566a9996 --- /dev/null +++ b/scripts/generate_stubs.py @@ -0,0 +1,117 @@ +""" +Script to generate Python type stubs for neqsim Java classes using stubgenj. + +This enables IDE autocompletion and type checking for the neqsim Java library +accessed via JPype. + +The Java package 'neqsim' is exposed as 'jneqsim' in Python to avoid naming +conflicts with the Python 'neqsim' package. The stubs are generated accordingly. + +Usage: + python scripts/generate_stubs.py + +The stubs will be generated in the src/jneqsim-stubs directory. +""" + +import re +import shutil +import sys +from pathlib import Path + +# Add src to path +src_path = Path(__file__).parent.parent / "src" +sys.path.insert(0, str(src_path)) + + +def rename_package_in_stubs(stubs_dir: Path, old_name: str, new_name: str): + """ + Rename all references from old_name to new_name in stub files. + This handles the neqsim -> jneqsim renaming to avoid conflicts + with the Python neqsim package. + """ + for pyi_file in stubs_dir.rglob("*.pyi"): + content = pyi_file.read_text(encoding="utf-8") + + # Replace import statements and type references + # Match 'neqsim.' but not 'jneqsim.' (negative lookbehind) + new_content = re.sub( + rf"(? jneqsim in all stub files to avoid conflict + # with Python neqsim package + neqsim_stubs = temp_output_dir / "neqsim-stubs" + if neqsim_stubs.exists(): + print("Renaming 'neqsim' -> 'jneqsim' in stubs to avoid naming conflict...") + rename_package_in_stubs(temp_output_dir, "neqsim", "jneqsim") + + # Clean up existing output + if final_output_dir.exists(): + shutil.rmtree(final_output_dir) + final_output_dir.mkdir(exist_ok=True) + + # Move jpype-stubs as-is (it's at temp_output_dir/jpype-stubs) + jpype_stubs = temp_output_dir / "jpype-stubs" + if jpype_stubs.exists(): + shutil.move(str(jpype_stubs), str(final_output_dir / "jpype-stubs")) + + # Rename folder neqsim-stubs -> jneqsim-stubs + target = final_output_dir / "jneqsim-stubs" + shutil.move(str(neqsim_stubs), str(target)) + + # Clean up temp directory + shutil.rmtree(temp_output_dir) + + print(f"Stubs generated successfully in {final_output_dir}") + print("\n" + "=" * 60) + print("USAGE INSTRUCTIONS") + print("=" * 60) + print("\nThe Java 'neqsim' package stubs are available as 'jneqsim'") + print("to avoid conflicts with the Python 'neqsim' package.") + print("\nFor VS Code with Pylance, add to settings.json:") + print(' "python.analysis.extraPaths": ["src/jneqsim-stubs"]') + print("\nFor mypy, add to pyproject.toml:") + print(' [tool.mypy]') + print(' mypy_path = "src/jneqsim-stubs"') + + +if __name__ == "__main__": + generate_stubs() diff --git a/src/jneqsim-stubs/jneqsim-stubs/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/__init__.pyi new file mode 100644 index 00000000..fa331b64 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/__init__.pyi @@ -0,0 +1,41 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.api +import jneqsim.blackoil +import jneqsim.chemicalreactions +import jneqsim.datapresentation +import jneqsim.fluidmechanics +import jneqsim.mathlib +import jneqsim.physicalproperties +import jneqsim.process +import jneqsim.pvtsimulation +import jneqsim.standards +import jneqsim.statistics +import jneqsim.thermo +import jneqsim.thermodynamicoperations +import jneqsim.util +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("neqsim")``. + + api: jneqsim.api.__module_protocol__ + blackoil: jneqsim.blackoil.__module_protocol__ + chemicalreactions: jneqsim.chemicalreactions.__module_protocol__ + datapresentation: jneqsim.datapresentation.__module_protocol__ + fluidmechanics: jneqsim.fluidmechanics.__module_protocol__ + mathlib: jneqsim.mathlib.__module_protocol__ + physicalproperties: jneqsim.physicalproperties.__module_protocol__ + process: jneqsim.process.__module_protocol__ + pvtsimulation: jneqsim.pvtsimulation.__module_protocol__ + standards: jneqsim.standards.__module_protocol__ + statistics: jneqsim.statistics.__module_protocol__ + thermo: jneqsim.thermo.__module_protocol__ + thermodynamicoperations: jneqsim.thermodynamicoperations.__module_protocol__ + util: jneqsim.util.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/api/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/api/__init__.pyi new file mode 100644 index 00000000..9a813888 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/api/__init__.pyi @@ -0,0 +1,15 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.api.ioc +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.api")``. + + ioc: jneqsim.api.ioc.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/api/ioc/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/api/ioc/__init__.pyi new file mode 100644 index 00000000..eb216820 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/api/ioc/__init__.pyi @@ -0,0 +1,25 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import typing + + + +class CalculationResult: + fluidProperties: typing.MutableSequence[typing.MutableSequence[float]] = ... + calculationError: typing.MutableSequence[java.lang.String] = ... + def __init__(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]): ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.api.ioc")``. + + CalculationResult: typing.Type[CalculationResult] diff --git a/src/jneqsim-stubs/jneqsim-stubs/blackoil/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/blackoil/__init__.pyi new file mode 100644 index 00000000..dc3079a4 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/blackoil/__init__.pyi @@ -0,0 +1,113 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.util +import jpype +import jneqsim.blackoil.io +import jneqsim.thermo.system +import typing + + + +class BlackOilConverter: + def __init__(self): ... + @staticmethod + def convert(systemInterface: jneqsim.thermo.system.SystemInterface, double: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], double3: float, double4: float) -> 'BlackOilConverter.Result': ... + class Result: + pvt: 'BlackOilPVTTable' = ... + blackOilSystem: 'SystemBlackOil' = ... + rho_o_sc: float = ... + rho_g_sc: float = ... + rho_w_sc: float = ... + bubblePoint: float = ... + def __init__(self): ... + +class BlackOilFlash: + def __init__(self, blackOilPVTTable: 'BlackOilPVTTable', double: float, double2: float, double3: float): ... + def flash(self, double: float, double2: float, double3: float, double4: float, double5: float) -> 'BlackOilFlashResult': ... + +class BlackOilFlashResult: + O_std: float = ... + Gf_std: float = ... + W_std: float = ... + V_o: float = ... + V_g: float = ... + V_w: float = ... + rho_o: float = ... + rho_g: float = ... + rho_w: float = ... + mu_o: float = ... + mu_g: float = ... + mu_w: float = ... + Rs: float = ... + Rv: float = ... + Bo: float = ... + Bg: float = ... + Bw: float = ... + def __init__(self): ... + +class BlackOilPVTTable: + def __init__(self, list: java.util.List['BlackOilPVTTable.Record'], double: float): ... + def Bg(self, double: float) -> float: ... + def Bo(self, double: float) -> float: ... + def Bw(self, double: float) -> float: ... + def Rs(self, double: float) -> float: ... + def RsEffective(self, double: float) -> float: ... + def Rv(self, double: float) -> float: ... + def getBubblePointP(self) -> float: ... + def mu_g(self, double: float) -> float: ... + def mu_o(self, double: float) -> float: ... + def mu_w(self, double: float) -> float: ... + class Record: + p: float = ... + Rs: float = ... + Bo: float = ... + mu_o: float = ... + Bg: float = ... + mu_g: float = ... + Rv: float = ... + Bw: float = ... + mu_w: float = ... + def __init__(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, double9: float): ... + +class SystemBlackOil: + def __init__(self, blackOilPVTTable: BlackOilPVTTable, double: float, double2: float, double3: float): ... + def copyShallow(self) -> 'SystemBlackOil': ... + def flash(self) -> BlackOilFlashResult: ... + def getBg(self) -> float: ... + def getBo(self) -> float: ... + def getBw(self) -> float: ... + def getGasDensity(self) -> float: ... + def getGasReservoirVolume(self) -> float: ... + def getGasStdTotal(self) -> float: ... + def getGasViscosity(self) -> float: ... + def getOilDensity(self) -> float: ... + def getOilReservoirVolume(self) -> float: ... + def getOilStdTotal(self) -> float: ... + def getOilViscosity(self) -> float: ... + def getPressure(self) -> float: ... + def getRs(self) -> float: ... + def getRv(self) -> float: ... + def getTemperature(self) -> float: ... + def getWaterDensity(self) -> float: ... + def getWaterReservoirVolume(self) -> float: ... + def getWaterStd(self) -> float: ... + def getWaterViscosity(self) -> float: ... + def setPressure(self, double: float) -> None: ... + def setStdTotals(self, double: float, double2: float, double3: float) -> None: ... + def setTemperature(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.blackoil")``. + + BlackOilConverter: typing.Type[BlackOilConverter] + BlackOilFlash: typing.Type[BlackOilFlash] + BlackOilFlashResult: typing.Type[BlackOilFlashResult] + BlackOilPVTTable: typing.Type[BlackOilPVTTable] + SystemBlackOil: typing.Type[SystemBlackOil] + io: jneqsim.blackoil.io.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/blackoil/io/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/blackoil/io/__init__.pyi new file mode 100644 index 00000000..7cca1deb --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/blackoil/io/__init__.pyi @@ -0,0 +1,51 @@ + +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.blackoil +import typing + + + +class EclipseBlackOilImporter: + def __init__(self): ... + @staticmethod + def fromFile(path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]) -> 'EclipseBlackOilImporter.Result': ... + @staticmethod + def fromReader(reader: java.io.Reader) -> 'EclipseBlackOilImporter.Result': ... + class Result: + pvt: jneqsim.blackoil.BlackOilPVTTable = ... + system: jneqsim.blackoil.SystemBlackOil = ... + rho_o_sc: float = ... + rho_w_sc: float = ... + rho_g_sc: float = ... + bubblePoint: float = ... + log: java.util.List = ... + def __init__(self): ... + class Units(java.lang.Enum['EclipseBlackOilImporter.Units']): + METRIC: typing.ClassVar['EclipseBlackOilImporter.Units'] = ... + FIELD: typing.ClassVar['EclipseBlackOilImporter.Units'] = ... + LAB: typing.ClassVar['EclipseBlackOilImporter.Units'] = ... + _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]) -> 'EclipseBlackOilImporter.Units': ... + @staticmethod + def values() -> typing.MutableSequence['EclipseBlackOilImporter.Units']: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.blackoil.io")``. + + EclipseBlackOilImporter: typing.Type[EclipseBlackOilImporter] diff --git a/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/__init__.pyi new file mode 100644 index 00000000..15fbc77a --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/__init__.pyi @@ -0,0 +1,58 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.chemicalreactions.chemicalequilibrium +import jneqsim.chemicalreactions.chemicalreaction +import jneqsim.chemicalreactions.kinetics +import jneqsim.thermo +import jneqsim.thermo.phase +import jneqsim.thermo.system +import typing + + + +class ChemicalReactionOperations(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.Cloneable): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def addNewComponents(self) -> None: ... + def calcBVector(self) -> typing.MutableSequence[float]: ... + def calcChemRefPot(self, int: int) -> typing.MutableSequence[float]: ... + def calcInertMoles(self, int: int) -> float: ... + def calcNVector(self) -> typing.MutableSequence[float]: ... + def clone(self) -> 'ChemicalReactionOperations': ... + def getAllElements(self) -> typing.MutableSequence[java.lang.String]: ... + def getDeltaReactionHeat(self) -> float: ... + def getKinetics(self) -> jneqsim.chemicalreactions.kinetics.Kinetics: ... + def getReactionList(self) -> jneqsim.chemicalreactions.chemicalreaction.ChemicalReactionList: ... + def hasReactions(self) -> bool: ... + def reacHeat(self, int: int, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def setComponents(self) -> None: ... + @typing.overload + def setComponents(self, int: int) -> None: ... + def setDeltaReactionHeat(self, double: float) -> None: ... + @typing.overload + def setReactiveComponents(self) -> None: ... + @typing.overload + def setReactiveComponents(self, int: int) -> None: ... + def setSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + @typing.overload + def solveChemEq(self, int: int) -> bool: ... + @typing.overload + def solveChemEq(self, int: int, int2: int) -> bool: ... + def solveKinetics(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int) -> float: ... + def sortReactiveComponents(self) -> None: ... + def updateMoles(self, int: int) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.chemicalreactions")``. + + ChemicalReactionOperations: typing.Type[ChemicalReactionOperations] + chemicalequilibrium: jneqsim.chemicalreactions.chemicalequilibrium.__module_protocol__ + chemicalreaction: jneqsim.chemicalreactions.chemicalreaction.__module_protocol__ + kinetics: jneqsim.chemicalreactions.kinetics.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/chemicalequilibrium/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/chemicalequilibrium/__init__.pyi new file mode 100644 index 00000000..cbcae533 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/chemicalequilibrium/__init__.pyi @@ -0,0 +1,69 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import Jama +import java.io +import java.lang +import java.util +import jpype +import jneqsim.chemicalreactions +import jneqsim.thermo +import jneqsim.thermo.component +import jneqsim.thermo.system +import typing + + + +class ChemEq(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + @typing.overload + def __init__(self, double: float, double2: 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], doubleArray4: typing.Union[typing.List[float], jpype.JArray]): ... + @typing.overload + def __init__(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + def chemSolve(self) -> None: ... + def innerStep(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], int: int, double2: float) -> float: ... + @typing.overload + def solve(self) -> None: ... + @typing.overload + def solve(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def step(self) -> float: ... + +class ChemicalEquilibrium(java.io.Serializable): + def __init__(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], systemInterface: jneqsim.thermo.system.SystemInterface, componentInterfaceArray: typing.Union[typing.List[jneqsim.thermo.component.ComponentInterface], jpype.JArray], int: int): ... + def calcRefPot(self) -> None: ... + def chemSolve(self) -> None: ... + def getMoles(self) -> typing.MutableSequence[float]: ... + def innerStep(self, int: int, doubleArray: typing.Union[typing.List[float], jpype.JArray], int2: int, double2: float, boolean: bool) -> float: ... + def printComp(self) -> None: ... + def solve(self) -> bool: ... + def step(self) -> float: ... + def updateMoles(self) -> None: ... + +class LinearProgrammingChemicalEquilibrium(jneqsim.thermo.ThermodynamicConstantsInterface): + def __init__(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], componentInterfaceArray: typing.Union[typing.List[jneqsim.thermo.component.ComponentInterface], jpype.JArray], stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray], chemicalReactionOperations: jneqsim.chemicalreactions.ChemicalReactionOperations, int: int): ... + def calcA(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def calcx(self, matrix: Jama.Matrix, matrix2: Jama.Matrix) -> None: ... + def changePrimaryComponents(self) -> None: ... + def generateInitialEstimates(self, systemInterface: jneqsim.thermo.system.SystemInterface, doubleArray: typing.Union[typing.List[float], jpype.JArray], double2: float, int: int) -> typing.MutableSequence[float]: ... + def getA(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getRefPot(self) -> typing.MutableSequence[float]: ... + +class ReferencePotComparator(java.util.Comparator[jneqsim.thermo.component.ComponentInterface], java.io.Serializable): + def __init__(self): ... + def compare(self, componentInterface: jneqsim.thermo.component.ComponentInterface, componentInterface2: jneqsim.thermo.component.ComponentInterface) -> int: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.chemicalreactions.chemicalequilibrium")``. + + ChemEq: typing.Type[ChemEq] + ChemicalEquilibrium: typing.Type[ChemicalEquilibrium] + LinearProgrammingChemicalEquilibrium: typing.Type[LinearProgrammingChemicalEquilibrium] + ReferencePotComparator: typing.Type[ReferencePotComparator] diff --git a/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/chemicalreaction/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/chemicalreaction/__init__.pyi new file mode 100644 index 00000000..a0aa6923 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/chemicalreaction/__init__.pyi @@ -0,0 +1,88 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import Jama +import java.lang +import java.util +import jpype +import jneqsim.thermo +import jneqsim.thermo.component +import jneqsim.thermo.phase +import jneqsim.thermo.system +import jneqsim.util +import typing + + + +class ChemicalReaction(jneqsim.util.NamedBaseClass, jneqsim.thermo.ThermodynamicConstantsInterface): + def __init__(self, string: typing.Union[java.lang.String, str], 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, double4: float, double5: float): ... + def calcK(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int) -> float: ... + def calcKgamma(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int) -> float: ... + def calcKx(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int) -> float: ... + def checkK(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def getActivationEnergy(self) -> float: ... + @typing.overload + def getK(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getK(self) -> typing.MutableSequence[float]: ... + def getNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getProductNames(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getRateFactor(self) -> float: ... + @typing.overload + def getRateFactor(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getReactantNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getReactionHeat(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getSaturationRatio(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int) -> float: ... + def getStocCoefs(self) -> typing.MutableSequence[float]: ... + def init(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def initMoleNumbers(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, componentInterfaceArray: typing.Union[typing.List[jneqsim.thermo.component.ComponentInterface], jpype.JArray], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def reactantsContains(self, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> bool: ... + def setActivationEnergy(self, double: float) -> None: ... + @typing.overload + def setK(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setK(self, int: int, double: float) -> None: ... + def setRateFactor(self, double: float) -> None: ... + +class ChemicalReactionFactory: + @staticmethod + def getChemicalReaction(string: typing.Union[java.lang.String, str]) -> ChemicalReaction: ... + @staticmethod + def getChemicalReactionNames() -> typing.MutableSequence[java.lang.String]: ... + +class ChemicalReactionList(jneqsim.thermo.ThermodynamicConstantsInterface): + def __init__(self): ... + def calcReacMatrix(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def calcReacRates(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, componentInterfaceArray: typing.Union[typing.List[jneqsim.thermo.component.ComponentInterface], jpype.JArray]) -> Jama.Matrix: ... + def calcReferencePotentials(self) -> typing.MutableSequence[float]: ... + def checkReactions(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def createReactionMatrix(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, componentInterfaceArray: typing.Union[typing.List[jneqsim.thermo.component.ComponentInterface], jpype.JArray]) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getAllComponents(self) -> typing.MutableSequence[java.lang.String]: ... + def getChemicalReactionList(self) -> java.util.ArrayList[ChemicalReaction]: ... + def getReacMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + def getReaction(self, int: int) -> ChemicalReaction: ... + @typing.overload + def getReaction(self, string: typing.Union[java.lang.String, str]) -> ChemicalReaction: ... + def getReactionGMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getReactionMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getStocMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def initMoleNumbers(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, componentInterfaceArray: typing.Union[typing.List[jneqsim.thermo.component.ComponentInterface], jpype.JArray], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def reacHeat(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, string: typing.Union[java.lang.String, str]) -> float: ... + def readReactions(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def removeJunkReactions(self, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def setChemicalReactionList(self, arrayList: java.util.ArrayList[ChemicalReaction]) -> None: ... + def updateReferencePotentials(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, componentInterfaceArray: typing.Union[typing.List[jneqsim.thermo.component.ComponentInterface], jpype.JArray]) -> typing.MutableSequence[float]: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.chemicalreactions.chemicalreaction")``. + + ChemicalReaction: typing.Type[ChemicalReaction] + ChemicalReactionFactory: typing.Type[ChemicalReactionFactory] + ChemicalReactionList: typing.Type[ChemicalReactionList] diff --git a/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/kinetics/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/kinetics/__init__.pyi new file mode 100644 index 00000000..4582d9a0 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/kinetics/__init__.pyi @@ -0,0 +1,27 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.io +import jneqsim.chemicalreactions +import jneqsim.thermo.phase +import typing + + + +class Kinetics(java.io.Serializable): + def __init__(self, chemicalReactionOperations: jneqsim.chemicalreactions.ChemicalReactionOperations): ... + def calcKinetics(self) -> None: ... + def calcReacMatrix(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, phaseInterface2: jneqsim.thermo.phase.PhaseInterface, int: int) -> float: ... + def getPhiInfinite(self) -> float: ... + def getPseudoFirstOrderCoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, phaseInterface2: jneqsim.thermo.phase.PhaseInterface, int: int) -> float: ... + def isIrreversible(self) -> bool: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.chemicalreactions.kinetics")``. + + Kinetics: typing.Type[Kinetics] diff --git a/src/jneqsim-stubs/jneqsim-stubs/datapresentation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/datapresentation/__init__.pyi new file mode 100644 index 00000000..b0c27dc0 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/datapresentation/__init__.pyi @@ -0,0 +1,42 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.datapresentation.filehandling +import jneqsim.datapresentation.jfreechart +import typing + + + +class DataHandling: + def __init__(self): ... + def getItemCount(self, int: int) -> int: ... + def getLegendItemCount(self) -> int: ... + def getLegendItemLabels(self) -> typing.MutableSequence[java.lang.String]: ... + def getSeriesCount(self) -> int: ... + def getSeriesName(self, int: int) -> java.lang.String: ... + def getXValue(self, int: int, int2: int) -> java.lang.Number: ... + def getYValue(self, int: int, int2: int) -> java.lang.Number: ... + def printToFile(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], string: typing.Union[java.lang.String, str]) -> None: ... + +class SampleXYDataSource: + def __init__(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], string4: typing.Union[java.lang.String, str]): ... + def getItemCount(self, int: int) -> int: ... + def getSeriesCount(self) -> int: ... + def getSeriesName(self, int: int) -> java.lang.String: ... + def getXValue(self, int: int, int2: int) -> java.lang.Number: ... + def getYValue(self, int: int, int2: int) -> java.lang.Number: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.datapresentation")``. + + DataHandling: typing.Type[DataHandling] + SampleXYDataSource: typing.Type[SampleXYDataSource] + filehandling: jneqsim.datapresentation.filehandling.__module_protocol__ + jfreechart: jneqsim.datapresentation.jfreechart.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/datapresentation/filehandling/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/datapresentation/filehandling/__init__.pyi new file mode 100644 index 00000000..1a332122 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/datapresentation/filehandling/__init__.pyi @@ -0,0 +1,29 @@ + +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 jpype +import typing + + + +class TextFile(java.io.Serializable): + def __init__(self): ... + def createFile(self) -> None: ... + def newFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setOutputFileName(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setValues(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setValues(self, stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.datapresentation.filehandling")``. + + TextFile: typing.Type[TextFile] diff --git a/src/jneqsim-stubs/jneqsim-stubs/datapresentation/jfreechart/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/datapresentation/jfreechart/__init__.pyi new file mode 100644 index 00000000..41806bf3 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/datapresentation/jfreechart/__init__.pyi @@ -0,0 +1,40 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.awt.image +import java.lang +import javax.swing +import jpype +import org.jfree.chart +import org.jfree.data.category +import typing + + + +class Graph2b(javax.swing.JFrame): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + @typing.overload + def __init__(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], string4: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], string4: typing.Union[java.lang.String, str]): ... + def createCategoryDataSource(self) -> org.jfree.data.category.CategoryDataset: ... + def getBufferedImage(self) -> java.awt.image.BufferedImage: ... + def getChart(self) -> org.jfree.chart.JFreeChart: ... + def getChartPanel(self) -> org.jfree.chart.ChartPanel: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def saveFigure(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setChart(self, jFreeChart: org.jfree.chart.JFreeChart) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.datapresentation.jfreechart")``. + + Graph2b: typing.Type[Graph2b] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/__init__.pyi new file mode 100644 index 00000000..e8ed463d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/__init__.pyi @@ -0,0 +1,31 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flowleg +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flowsolver +import jneqsim.fluidmechanics.flowsystem +import jneqsim.fluidmechanics.geometrydefinitions +import jneqsim.fluidmechanics.util +import typing + + + +class FluidMech: + def __init__(self): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics")``. + + FluidMech: typing.Type[FluidMech] + flowleg: jneqsim.fluidmechanics.flowleg.__module_protocol__ + flownode: jneqsim.fluidmechanics.flownode.__module_protocol__ + flowsolver: jneqsim.fluidmechanics.flowsolver.__module_protocol__ + flowsystem: jneqsim.fluidmechanics.flowsystem.__module_protocol__ + geometrydefinitions: jneqsim.fluidmechanics.geometrydefinitions.__module_protocol__ + util: jneqsim.fluidmechanics.util.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/__init__.pyi new file mode 100644 index 00000000..fb4311a1 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/__init__.pyi @@ -0,0 +1,62 @@ + +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 jneqsim.fluidmechanics.flowleg.pipeleg +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.geometrydefinitions +import jneqsim.thermo.system +import typing + + + +class FlowLegInterface: + @typing.overload + def createFlowNodes(self) -> None: ... + @typing.overload + def createFlowNodes(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> None: ... + def getFlowNodes(self) -> typing.MutableSequence[jneqsim.fluidmechanics.flownode.FlowNodeInterface]: ... + def getNode(self, int: int) -> jneqsim.fluidmechanics.flownode.FlowNodeInterface: ... + def getNumberOfNodes(self) -> int: ... + def setEquipmentGeometry(self, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface) -> None: ... + def setFlowPattern(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setHeightCoordinates(self, double: float, double2: float) -> None: ... + def setLongitudionalCoordinates(self, double: float, double2: float) -> None: ... + def setNumberOfNodes(self, int: int) -> None: ... + def setOuterHeatTransferCoefficients(self, double: float, double2: float) -> None: ... + def setOuterTemperatures(self, double: float, double2: float) -> None: ... + def setThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setWallHeatTransferCoefficients(self, double: float, double2: float) -> None: ... + +class FlowLeg(FlowLegInterface, java.io.Serializable): + def __init__(self): ... + @typing.overload + def createFlowNodes(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> None: ... + @typing.overload + def createFlowNodes(self) -> None: ... + def getFlowNodes(self) -> typing.MutableSequence[jneqsim.fluidmechanics.flownode.FlowNodeInterface]: ... + def getNode(self, int: int) -> jneqsim.fluidmechanics.flownode.FlowNodeInterface: ... + def getNumberOfNodes(self) -> int: ... + def setEquipmentGeometry(self, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface) -> None: ... + def setFlowNodeTypes(self) -> None: ... + def setFlowPattern(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setHeightCoordinates(self, double: float, double2: float) -> None: ... + def setLongitudionalCoordinates(self, double: float, double2: float) -> None: ... + def setNumberOfNodes(self, int: int) -> None: ... + def setOuterHeatTransferCoefficients(self, double: float, double2: float) -> None: ... + def setOuterTemperatures(self, double: float, double2: float) -> None: ... + def setThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setWallHeatTransferCoefficients(self, double: float, double2: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowleg")``. + + FlowLeg: typing.Type[FlowLeg] + FlowLegInterface: typing.Type[FlowLegInterface] + pipeleg: jneqsim.fluidmechanics.flowleg.pipeleg.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/pipeleg/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/pipeleg/__init__.pyi new file mode 100644 index 00000000..68ab91bf --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/pipeleg/__init__.pyi @@ -0,0 +1,25 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flowleg +import jneqsim.fluidmechanics.flownode +import typing + + + +class PipeLeg(jneqsim.fluidmechanics.flowleg.FlowLeg): + def __init__(self): ... + @typing.overload + def createFlowNodes(self) -> None: ... + @typing.overload + def createFlowNodes(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowleg.pipeleg")``. + + PipeLeg: typing.Type[PipeLeg] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/__init__.pyi new file mode 100644 index 00000000..98340f26 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/__init__.pyi @@ -0,0 +1,260 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.fluidmechanics.flownode.fluidboundary +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient +import jneqsim.fluidmechanics.flownode.multiphasenode +import jneqsim.fluidmechanics.flownode.onephasenode +import jneqsim.fluidmechanics.flownode.twophasenode +import jneqsim.fluidmechanics.geometrydefinitions +import jneqsim.thermo +import jneqsim.thermo.system +import jneqsim.thermodynamicoperations +import jneqsim.util.util +import typing + + + +class FlowNodeInterface(java.lang.Cloneable): + def calcFluxes(self) -> None: ... + def calcNusseltNumber(self, double: float, int: int) -> float: ... + def calcSherwoodNumber(self, double: float, int: int) -> float: ... + def calcStantonNumber(self, double: float, int: int) -> float: ... + def calcTotalHeatTransferCoefficient(self, int: int) -> float: ... + @typing.overload + def display(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def display(self) -> None: ... + def getArea(self, int: int) -> float: ... + def getBulkSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getDistanceToCenterOfNode(self) -> float: ... + def getEffectiveSchmidtNumber(self, int: int, int2: int) -> float: ... + def getFlowDirection(self, int: int) -> int: ... + def getFlowNodeType(self) -> java.lang.String: ... + def getFluidBoundary(self) -> jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface: ... + def getGeometry(self) -> jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface: ... + def getHydraulicDiameter(self, int: int) -> float: ... + def getInterPhaseFrictionFactor(self) -> float: ... + def getInterphaseContactArea(self) -> float: ... + def getInterphaseContactLength(self, int: int) -> float: ... + def getInterphaseSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getInterphaseTransportCoefficient(self) -> jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.InterphaseTransportCoefficientInterface: ... + def getLengthOfNode(self) -> float: ... + def getMassFlowRate(self, int: int) -> float: ... + def getMolarMassTransferRate(self, int: int) -> float: ... + def getNextNode(self) -> 'FlowNodeInterface': ... + def getOperations(self) -> jneqsim.thermodynamicoperations.ThermodynamicOperations: ... + def getPhaseFraction(self, int: int) -> float: ... + def getPrandtlNumber(self, int: int) -> float: ... + @typing.overload + def getReynoldsNumber(self, int: int) -> float: ... + @typing.overload + def getReynoldsNumber(self) -> float: ... + def getSchmidtNumber(self, int: int, int2: int, int3: int) -> float: ... + def getSuperficialVelocity(self, int: int) -> float: ... + @typing.overload + def getVelocity(self, int: int) -> float: ... + @typing.overload + def getVelocity(self) -> float: ... + @typing.overload + def getVelocityIn(self, int: int) -> jneqsim.util.util.DoubleCloneable: ... + @typing.overload + def getVelocityIn(self) -> jneqsim.util.util.DoubleCloneable: ... + @typing.overload + def getVelocityOut(self, int: int) -> jneqsim.util.util.DoubleCloneable: ... + @typing.overload + def getVelocityOut(self) -> jneqsim.util.util.DoubleCloneable: ... + def getVerticalPositionOfNode(self) -> float: ... + def getVolumetricFlow(self) -> float: ... + def getWallContactLength(self, int: int) -> float: ... + @typing.overload + def getWallFrictionFactor(self, int: int) -> float: ... + @typing.overload + def getWallFrictionFactor(self) -> float: ... + def increaseMolarRate(self, double: float) -> None: ... + def init(self) -> None: ... + def initBulkSystem(self) -> None: ... + def initFlowCalc(self) -> None: ... + def setBulkSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setDistanceToCenterOfNode(self, double: float) -> None: ... + def setEnhancementType(self, int: int) -> None: ... + def setFlowDirection(self, int: int, int2: int) -> None: ... + def setFluxes(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setFrictionFactorType(self, int: int) -> None: ... + def setGeometryDefinitionInterface(self, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface) -> None: ... + def setInterphaseModelType(self, int: int) -> None: ... + def setInterphaseSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setLengthOfNode(self, double: float) -> None: ... + def setPhaseFraction(self, int: int, double: float) -> None: ... + @typing.overload + def setVelocity(self, int: int, double: float) -> None: ... + @typing.overload + def setVelocity(self, double: float) -> None: ... + @typing.overload + def setVelocityIn(self, int: int, double: float) -> None: ... + @typing.overload + def setVelocityIn(self, int: int, doubleCloneable: jneqsim.util.util.DoubleCloneable) -> None: ... + @typing.overload + def setVelocityIn(self, double: float) -> None: ... + @typing.overload + def setVelocityIn(self, doubleCloneable: jneqsim.util.util.DoubleCloneable) -> None: ... + @typing.overload + def setVelocityOut(self, int: int, double: float) -> None: ... + @typing.overload + def setVelocityOut(self, int: int, doubleCloneable: jneqsim.util.util.DoubleCloneable) -> None: ... + @typing.overload + def setVelocityOut(self, double: float) -> None: ... + @typing.overload + def setVelocityOut(self, doubleCloneable: jneqsim.util.util.DoubleCloneable) -> None: ... + def setVerticalPositionOfNode(self, double: float) -> None: ... + @typing.overload + def setWallFrictionFactor(self, int: int, double: float) -> None: ... + @typing.overload + def setWallFrictionFactor(self, double: float) -> None: ... + def update(self) -> None: ... + def updateMolarFlow(self) -> None: ... + def write(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], boolean: bool) -> None: ... + +class FlowNodeSelector: + def __init__(self): ... + def getFlowNodeType(self, flowNodeInterfaceArray: typing.Union[typing.List[FlowNodeInterface], jpype.JArray]) -> None: ... + def setFlowPattern(self, flowNodeInterfaceArray: typing.Union[typing.List[FlowNodeInterface], jpype.JArray], string: typing.Union[java.lang.String, str]) -> None: ... + +class FlowNode(FlowNodeInterface, jneqsim.thermo.ThermodynamicConstantsInterface): + molarFlowRate: typing.MutableSequence[float] = ... + massFlowRate: typing.MutableSequence[float] = ... + volumetricFlowRate: typing.MutableSequence[float] = ... + bulkSystem: jneqsim.thermo.system.SystemInterface = ... + velocityIn: typing.MutableSequence[jneqsim.util.util.DoubleCloneable] = ... + velocityOut: typing.MutableSequence[jneqsim.util.util.DoubleCloneable] = ... + superficialVelocity: typing.MutableSequence[float] = ... + interphaseContactArea: float = ... + velocity: typing.MutableSequence[float] = ... + pipe: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface, double: float, double2: float): ... + def calcFluxes(self) -> None: ... + def calcNusseltNumber(self, double: float, int: int) -> float: ... + def calcSherwoodNumber(self, double: float, int: int) -> float: ... + def calcStantonNumber(self, double: float, int: int) -> float: ... + def calcTotalHeatTransferCoefficient(self, int: int) -> float: ... + def clone(self) -> 'FlowNode': ... + def createTable(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + @typing.overload + def display(self) -> None: ... + @typing.overload + def display(self, string: typing.Union[java.lang.String, str]) -> None: ... + def getArea(self, int: int) -> float: ... + def getBulkSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getDistanceToCenterOfNode(self) -> float: ... + def getEffectiveSchmidtNumber(self, int: int, int2: int) -> float: ... + def getFlowDirection(self, int: int) -> int: ... + def getFlowNodeType(self) -> java.lang.String: ... + def getFluidBoundary(self) -> jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface: ... + def getGeometry(self) -> jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface: ... + def getHydraulicDiameter(self, int: int) -> float: ... + def getInterPhaseFrictionFactor(self) -> float: ... + def getInterphaseContactArea(self) -> float: ... + def getInterphaseContactLength(self, int: int) -> float: ... + def getInterphaseSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getInterphaseTransportCoefficient(self) -> jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.InterphaseTransportCoefficientInterface: ... + def getLengthOfNode(self) -> float: ... + def getMassFlowRate(self, int: int) -> float: ... + def getMolarMassTransferRate(self, int: int) -> float: ... + def getNextNode(self) -> FlowNodeInterface: ... + def getOperations(self) -> jneqsim.thermodynamicoperations.ThermodynamicOperations: ... + def getPhaseFraction(self, int: int) -> float: ... + def getPrandtlNumber(self, int: int) -> float: ... + @typing.overload + def getReynoldsNumber(self) -> float: ... + @typing.overload + def getReynoldsNumber(self, int: int) -> float: ... + def getSchmidtNumber(self, int: int, int2: int, int3: int) -> float: ... + def getSuperficialVelocity(self, int: int) -> float: ... + @typing.overload + def getVelocity(self) -> float: ... + @typing.overload + def getVelocity(self, int: int) -> float: ... + @typing.overload + def getVelocityIn(self) -> jneqsim.util.util.DoubleCloneable: ... + @typing.overload + def getVelocityIn(self, int: int) -> jneqsim.util.util.DoubleCloneable: ... + @typing.overload + def getVelocityOut(self) -> jneqsim.util.util.DoubleCloneable: ... + @typing.overload + def getVelocityOut(self, int: int) -> jneqsim.util.util.DoubleCloneable: ... + def getVerticalPositionOfNode(self) -> float: ... + def getVolumetricFlow(self) -> float: ... + def getWallContactLength(self, int: int) -> float: ... + @typing.overload + def getWallFrictionFactor(self) -> float: ... + @typing.overload + def getWallFrictionFactor(self, int: int) -> float: ... + def increaseMolarRate(self, double: float) -> None: ... + def init(self) -> None: ... + def initBulkSystem(self) -> None: ... + def setBulkSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setDistanceToCenterOfNode(self, double: float) -> None: ... + def setEnhancementType(self, int: int) -> None: ... + def setFlowDirection(self, int: int, int2: int) -> None: ... + def setFluxes(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setFrictionFactorType(self, int: int) -> None: ... + def setGeometryDefinitionInterface(self, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface) -> None: ... + def setInterphaseModelType(self, int: int) -> None: ... + def setInterphaseSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setLengthOfNode(self, double: float) -> None: ... + def setOperations(self, thermodynamicOperations: jneqsim.thermodynamicoperations.ThermodynamicOperations) -> None: ... + def setPhaseFraction(self, int: int, double: float) -> None: ... + @typing.overload + def setVelocity(self, double: float) -> None: ... + @typing.overload + def setVelocity(self, int: int, double: float) -> None: ... + @typing.overload + def setVelocityIn(self, double: float) -> None: ... + @typing.overload + def setVelocityIn(self, doubleCloneable: jneqsim.util.util.DoubleCloneable) -> None: ... + @typing.overload + def setVelocityIn(self, int: int, double: float) -> None: ... + @typing.overload + def setVelocityIn(self, int: int, doubleCloneable: jneqsim.util.util.DoubleCloneable) -> None: ... + @typing.overload + def setVelocityOut(self, double: float) -> None: ... + @typing.overload + def setVelocityOut(self, doubleCloneable: jneqsim.util.util.DoubleCloneable) -> None: ... + @typing.overload + def setVelocityOut(self, int: int, double: float) -> None: ... + @typing.overload + def setVelocityOut(self, int: int, doubleCloneable: jneqsim.util.util.DoubleCloneable) -> None: ... + def setVerticalPositionOfNode(self, double: float) -> None: ... + @typing.overload + def setWallFrictionFactor(self, double: float) -> None: ... + @typing.overload + def setWallFrictionFactor(self, int: int, double: float) -> None: ... + def update(self) -> None: ... + def updateMolarFlow(self) -> None: ... + def write(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], boolean: bool) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode")``. + + FlowNode: typing.Type[FlowNode] + FlowNodeInterface: typing.Type[FlowNodeInterface] + FlowNodeSelector: typing.Type[FlowNodeSelector] + fluidboundary: jneqsim.fluidmechanics.flownode.fluidboundary.__module_protocol__ + multiphasenode: jneqsim.fluidmechanics.flownode.multiphasenode.__module_protocol__ + onephasenode: jneqsim.fluidmechanics.flownode.onephasenode.__module_protocol__ + twophasenode: jneqsim.fluidmechanics.flownode.twophasenode.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/__init__.pyi new file mode 100644 index 00000000..a14f83ec --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/__init__.pyi @@ -0,0 +1,17 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary")``. + + heatmasstransfercalc: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.__module_protocol__ + interphasetransportcoefficient: jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/__init__.pyi new file mode 100644 index 00000000..d5d830ea --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/__init__.pyi @@ -0,0 +1,120 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import Jama +import java.io +import java.lang +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.equilibriumfluidboundary +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.reactivefilmmodel.enhancementfactor +import jneqsim.thermo.system +import jneqsim.thermodynamicoperations +import typing + + + +class FluidBoundaryInterface(java.lang.Cloneable): + def calcFluxes(self) -> typing.MutableSequence[float]: ... + def clone(self) -> 'FluidBoundaryInterface': ... + def display(self, string: typing.Union[java.lang.String, str]) -> None: ... + def getBinaryMassTransferCoefficient(self, int: int, int2: int, int3: int) -> float: ... + def getBulkSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getBulkSystemOpertions(self) -> jneqsim.thermodynamicoperations.ThermodynamicOperations: ... + def getEffectiveMassTransferCoefficient(self, int: int, int2: int) -> float: ... + def getEnhancementFactor(self) -> jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.reactivefilmmodel.enhancementfactor.EnhancementFactor: ... + def getInterphaseHeatFlux(self, int: int) -> float: ... + def getInterphaseMolarFlux(self, int: int) -> float: ... + def getInterphaseSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getMassTransferCoefficientMatrix(self) -> typing.MutableSequence[Jama.Matrix]: ... + def heatTransSolve(self) -> None: ... + def isHeatTransferCalc(self) -> bool: ... + def massTransSolve(self) -> None: ... + def setEnhancementType(self, int: int) -> None: ... + def setHeatTransferCalc(self, boolean: bool) -> None: ... + def setInterphaseSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setMassTransferCalc(self, boolean: bool) -> None: ... + def solve(self) -> None: ... + @typing.overload + def useFiniteFluxCorrection(self, int: int) -> bool: ... + @typing.overload + def useFiniteFluxCorrection(self, boolean: bool) -> None: ... + @typing.overload + def useFiniteFluxCorrection(self, boolean: bool, int: int) -> None: ... + @typing.overload + def useThermodynamicCorrections(self, int: int) -> bool: ... + @typing.overload + def useThermodynamicCorrections(self, boolean: bool) -> None: ... + @typing.overload + def useThermodynamicCorrections(self, boolean: bool, int: int) -> None: ... + def write(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], boolean: bool) -> None: ... + +class FluidBoundary(FluidBoundaryInterface, java.io.Serializable): + interphaseHeatFlux: typing.MutableSequence[float] = ... + massTransferCalc: bool = ... + heatTransferCalc: bool = ... + thermodynamicCorrections: typing.MutableSequence[bool] = ... + finiteFluxCorrection: typing.MutableSequence[bool] = ... + binaryMassTransferCoefficient: typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[float]]] = ... + heatTransferCoefficient: typing.MutableSequence[float] = ... + heatTransferCorrection: typing.MutableSequence[float] = ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcFluxTypeCorrectionMatrix(self, int: int, int2: int) -> None: ... + def calcNonIdealCorrections(self, int: int) -> None: ... + def clone(self) -> 'FluidBoundary': ... + def createTable(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def display(self, string: typing.Union[java.lang.String, str]) -> None: ... + def getBinaryMassTransferCoefficient(self, int: int, int2: int, int3: int) -> float: ... + def getBulkSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getBulkSystemOpertions(self) -> jneqsim.thermodynamicoperations.ThermodynamicOperations: ... + def getEffectiveMassTransferCoefficient(self, int: int, int2: int) -> float: ... + def getEnhancementFactor(self) -> jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.reactivefilmmodel.enhancementfactor.EnhancementFactor: ... + def getInterphaseHeatFlux(self, int: int) -> float: ... + def getInterphaseMolarFlux(self, int: int) -> float: ... + def getInterphaseOpertions(self) -> jneqsim.thermodynamicoperations.ThermodynamicOperations: ... + def getInterphaseSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getMassTransferCoefficientMatrix(self) -> typing.MutableSequence[Jama.Matrix]: ... + def heatTransSolve(self) -> None: ... + def init(self) -> None: ... + def initHeatTransferCalc(self) -> None: ... + def initInterphaseSystem(self) -> None: ... + def initMassTransferCalc(self) -> None: ... + def isHeatTransferCalc(self) -> bool: ... + def massTransSolve(self) -> None: ... + def setBulkSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setEnhancementType(self, int: int) -> None: ... + def setHeatTransferCalc(self, boolean: bool) -> None: ... + def setInterphaseSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setMassTransferCalc(self, boolean: bool) -> None: ... + def setSolverType(self, int: int) -> None: ... + @typing.overload + def useFiniteFluxCorrection(self, int: int) -> bool: ... + @typing.overload + def useFiniteFluxCorrection(self, boolean: bool) -> None: ... + @typing.overload + def useFiniteFluxCorrection(self, boolean: bool, int: int) -> None: ... + @typing.overload + def useThermodynamicCorrections(self, int: int) -> bool: ... + @typing.overload + def useThermodynamicCorrections(self, boolean: bool) -> None: ... + @typing.overload + def useThermodynamicCorrections(self, boolean: bool, int: int) -> None: ... + def write(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], boolean: bool) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc")``. + + FluidBoundary: typing.Type[FluidBoundary] + FluidBoundaryInterface: typing.Type[FluidBoundaryInterface] + equilibriumfluidboundary: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.equilibriumfluidboundary.__module_protocol__ + finitevolumeboundary: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.__module_protocol__ + nonequilibriumfluidboundary: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/equilibriumfluidboundary/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/equilibriumfluidboundary/__init__.pyi new file mode 100644 index 00000000..9d218f41 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/equilibriumfluidboundary/__init__.pyi @@ -0,0 +1,31 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc +import jneqsim.thermo.system +import typing + + + +class EquilibriumFluidBoundary(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundary): + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcFluxes(self) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def solve(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.equilibriumfluidboundary")``. + + EquilibriumFluidBoundary: typing.Type[EquilibriumFluidBoundary] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/__init__.pyi new file mode 100644 index 00000000..c4b2b51b --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/__init__.pyi @@ -0,0 +1,19 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysolver +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary")``. + + fluidboundarynode: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode.__module_protocol__ + fluidboundarysolver: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysolver.__module_protocol__ + fluidboundarysystem: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarynode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarynode/__init__.pyi new file mode 100644 index 00000000..13e342b7 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarynode/__init__.pyi @@ -0,0 +1,32 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode.fluidboundarynonreactivenode +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode.fluidboundaryreactivenode +import jneqsim.thermo.system +import typing + + + +class FluidBoundaryNodeInterface: + def getBulkSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + +class FluidBoundaryNode(FluidBoundaryNodeInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getBulkSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode")``. + + FluidBoundaryNode: typing.Type[FluidBoundaryNode] + FluidBoundaryNodeInterface: typing.Type[FluidBoundaryNodeInterface] + fluidboundarynonreactivenode: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode.fluidboundarynonreactivenode.__module_protocol__ + fluidboundaryreactivenode: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode.fluidboundaryreactivenode.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarynode/fluidboundarynonreactivenode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarynode/fluidboundarynonreactivenode/__init__.pyi new file mode 100644 index 00000000..0352e096 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarynode/fluidboundarynonreactivenode/__init__.pyi @@ -0,0 +1,24 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode +import jneqsim.thermo.system +import typing + + + +class FluidBoundaryNodeNonReactive(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode.FluidBoundaryNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode.fluidboundarynonreactivenode")``. + + FluidBoundaryNodeNonReactive: typing.Type[FluidBoundaryNodeNonReactive] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarynode/fluidboundaryreactivenode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarynode/fluidboundaryreactivenode/__init__.pyi new file mode 100644 index 00000000..595bb4dd --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarynode/fluidboundaryreactivenode/__init__.pyi @@ -0,0 +1,24 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode +import jneqsim.thermo.system +import typing + + + +class FluidBoundaryNodeReactive(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode.FluidBoundaryNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode.fluidboundaryreactivenode")``. + + FluidBoundaryNodeReactive: typing.Type[FluidBoundaryNodeReactive] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysolver/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysolver/__init__.pyi new file mode 100644 index 00000000..aee2c3cf --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysolver/__init__.pyi @@ -0,0 +1,38 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysolver.fluidboundaryreactivesolver +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem +import typing + + + +class FluidBoundarySolverInterface: + def getMolarFlux(self, int: int) -> float: ... + def solve(self) -> None: ... + +class FluidBoundarySolver(FluidBoundarySolverInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, fluidBoundarySystemInterface: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem.FluidBoundarySystemInterface): ... + @typing.overload + def __init__(self, fluidBoundarySystemInterface: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem.FluidBoundarySystemInterface, boolean: bool): ... + def getMolarFlux(self, int: int) -> float: ... + def initComposition(self, int: int) -> None: ... + def initMatrix(self) -> None: ... + def initProfiles(self) -> None: ... + def setComponentConservationMatrix(self, int: int) -> None: ... + def solve(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysolver")``. + + FluidBoundarySolver: typing.Type[FluidBoundarySolver] + FluidBoundarySolverInterface: typing.Type[FluidBoundarySolverInterface] + fluidboundaryreactivesolver: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysolver.fluidboundaryreactivesolver.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysolver/fluidboundaryreactivesolver/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysolver/fluidboundaryreactivesolver/__init__.pyi new file mode 100644 index 00000000..eb963873 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysolver/fluidboundaryreactivesolver/__init__.pyi @@ -0,0 +1,20 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysolver +import typing + + + +class FluidBoundaryReactiveSolver(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysolver.FluidBoundarySolver): + def __init__(self): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysolver.fluidboundaryreactivesolver")``. + + FluidBoundaryReactiveSolver: typing.Type[FluidBoundaryReactiveSolver] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysystem/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysystem/__init__.pyi new file mode 100644 index 00000000..6ca7b29d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysystem/__init__.pyi @@ -0,0 +1,51 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem.fluidboundarynonreactive +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem.fluidboundarysystemreactive +import typing + + + +class FluidBoundarySystemInterface: + def addBoundary(self, fluidBoundaryInterface: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface) -> None: ... + def createSystem(self) -> None: ... + def getFilmThickness(self) -> float: ... + def getFluidBoundary(self) -> jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface: ... + def getNode(self, int: int) -> jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode.FluidBoundaryNodeInterface: ... + def getNodeLength(self) -> float: ... + def getNumberOfNodes(self) -> int: ... + def setFilmThickness(self, double: float) -> None: ... + def setNumberOfNodes(self, int: int) -> None: ... + def solve(self) -> None: ... + +class FluidBoundarySystem(FluidBoundarySystemInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, fluidBoundaryInterface: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface): ... + def addBoundary(self, fluidBoundaryInterface: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface) -> None: ... + def createSystem(self) -> None: ... + def getFilmThickness(self) -> float: ... + def getFluidBoundary(self) -> jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface: ... + def getNode(self, int: int) -> jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode.FluidBoundaryNodeInterface: ... + def getNodeLength(self) -> float: ... + def getNumberOfNodes(self) -> int: ... + def setFilmThickness(self, double: float) -> None: ... + def setNumberOfNodes(self, int: int) -> None: ... + def solve(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem")``. + + FluidBoundarySystem: typing.Type[FluidBoundarySystem] + FluidBoundarySystemInterface: typing.Type[FluidBoundarySystemInterface] + fluidboundarynonreactive: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem.fluidboundarynonreactive.__module_protocol__ + fluidboundarysystemreactive: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem.fluidboundarysystemreactive.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysystem/fluidboundarynonreactive/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysystem/fluidboundarynonreactive/__init__.pyi new file mode 100644 index 00000000..eea1a2f0 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysystem/fluidboundarynonreactive/__init__.pyi @@ -0,0 +1,29 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem +import typing + + + +class FluidBoundarySystemNonReactive(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem.FluidBoundarySystem): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, fluidBoundaryInterface: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface): ... + def createSystem(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem.fluidboundarynonreactive")``. + + FluidBoundarySystemNonReactive: typing.Type[FluidBoundarySystemNonReactive] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysystem/fluidboundarysystemreactive/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysystem/fluidboundarysystemreactive/__init__.pyi new file mode 100644 index 00000000..2daa6377 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/finitevolumeboundary/fluidboundarysystem/fluidboundarysystemreactive/__init__.pyi @@ -0,0 +1,29 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem +import typing + + + +class FluidBoundarySystemReactive(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem.FluidBoundarySystem): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, fluidBoundaryInterface: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface): ... + def createSystem(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem.fluidboundarysystemreactive")``. + + FluidBoundarySystemReactive: typing.Type[FluidBoundarySystemReactive] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/nonequilibriumfluidboundary/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/nonequilibriumfluidboundary/__init__.pyi new file mode 100644 index 00000000..6f80cd92 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/nonequilibriumfluidboundary/__init__.pyi @@ -0,0 +1,45 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary +import jneqsim.thermo.system +import typing + + + +class NonEquilibriumFluidBoundary(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundary): + molFractionDifference: typing.MutableSequence[typing.MutableSequence[float]] = ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcFluxes(self) -> typing.MutableSequence[float]: ... + def calcHeatTransferCoefficients(self, int: int) -> None: ... + def calcHeatTransferCorrection(self, int: int) -> None: ... + def calcMolFractionDifference(self) -> None: ... + def clone(self) -> 'NonEquilibriumFluidBoundary': ... + def heatTransSolve(self) -> None: ... + def init(self) -> None: ... + def initHeatTransferCalc(self) -> None: ... + def initMassTransferCalc(self) -> None: ... + def massTransSolve(self) -> None: ... + def setJacMassTrans(self) -> None: ... + def setJacMassTrans2(self) -> None: ... + def setfvecMassTrans(self) -> None: ... + def setfvecMassTrans2(self) -> None: ... + def setuMassTrans(self) -> None: ... + def solve(self) -> None: ... + def updateMassTrans(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary")``. + + NonEquilibriumFluidBoundary: typing.Type[NonEquilibriumFluidBoundary] + filmmodelboundary: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/nonequilibriumfluidboundary/filmmodelboundary/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/nonequilibriumfluidboundary/filmmodelboundary/__init__.pyi new file mode 100644 index 00000000..3bf40546 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/nonequilibriumfluidboundary/filmmodelboundary/__init__.pyi @@ -0,0 +1,46 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.reactivefilmmodel +import jneqsim.thermo +import jneqsim.thermo.system +import typing + + + +class KrishnaStandartFilmModel(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.NonEquilibriumFluidBoundary, jneqsim.thermo.ThermodynamicConstantsInterface): + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcBinaryMassTransferCoefficients(self, int: int) -> float: ... + def calcBinarySchmidtNumbers(self, int: int) -> float: ... + def calcCorrectionMatrix(self, int: int) -> None: ... + def calcMassTransferCoefficients(self, int: int) -> float: ... + def calcPhiMatrix(self, int: int) -> None: ... + def calcRedCorrectionMatrix(self, int: int) -> None: ... + def calcRedPhiMatrix(self, int: int) -> None: ... + def calcTotalMassTransferCoefficientMatrix(self, int: int) -> None: ... + def clone(self) -> 'KrishnaStandartFilmModel': ... + def init(self) -> None: ... + def initCorrections(self, int: int) -> None: ... + def initHeatTransferCalc(self) -> None: ... + def initMassTransferCalc(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def solve(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary")``. + + KrishnaStandartFilmModel: typing.Type[KrishnaStandartFilmModel] + reactivefilmmodel: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.reactivefilmmodel.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/nonequilibriumfluidboundary/filmmodelboundary/reactivefilmmodel/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/nonequilibriumfluidboundary/filmmodelboundary/reactivefilmmodel/__init__.pyi new file mode 100644 index 00000000..18c88ea7 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/nonequilibriumfluidboundary/filmmodelboundary/reactivefilmmodel/__init__.pyi @@ -0,0 +1,55 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.reactivefilmmodel.enhancementfactor +import jneqsim.thermo.system +import typing + + + +class ReactiveFluidBoundary(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.KrishnaStandartFilmModel): + molFractionDifference: typing.MutableSequence[typing.MutableSequence[float]] = ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcFluxes(self) -> typing.MutableSequence[float]: ... + def calcFluxes2(self) -> typing.MutableSequence[float]: ... + def calcHeatTransferCoefficients(self, int: int) -> None: ... + def calcHeatTransferCorrection(self, int: int) -> None: ... + def calcMolFractionDifference(self) -> None: ... + def clone(self) -> 'ReactiveFluidBoundary': ... + def heatTransSolve(self) -> None: ... + def init(self) -> None: ... + def initHeatTransferCalc(self) -> None: ... + def initMassTransferCalc(self) -> None: ... + def massTransSolve(self) -> None: ... + def setJacMassTrans(self) -> None: ... + def setJacMassTrans2(self) -> None: ... + def setfvecMassTrans(self) -> None: ... + def setfvecMassTrans2(self) -> None: ... + def setuMassTrans(self) -> None: ... + def solve(self) -> None: ... + def updateMassTrans(self) -> None: ... + +class ReactiveKrishnaStandartFilmModel(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.KrishnaStandartFilmModel): + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcTotalMassTransferCoefficientMatrix(self, int: int) -> None: ... + def setEnhancementType(self, int: int) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.reactivefilmmodel")``. + + ReactiveFluidBoundary: typing.Type[ReactiveFluidBoundary] + ReactiveKrishnaStandartFilmModel: typing.Type[ReactiveKrishnaStandartFilmModel] + enhancementfactor: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.reactivefilmmodel.enhancementfactor.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/nonequilibriumfluidboundary/filmmodelboundary/reactivefilmmodel/enhancementfactor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/nonequilibriumfluidboundary/filmmodelboundary/reactivefilmmodel/enhancementfactor/__init__.pyi new file mode 100644 index 00000000..774d694d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/nonequilibriumfluidboundary/filmmodelboundary/reactivefilmmodel/enhancementfactor/__init__.pyi @@ -0,0 +1,61 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jpype +import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc +import typing + + + +class EnhancementFactorInterface: + def calcEnhancementVec(self, int: int) -> None: ... + def getEnhancementVec(self, int: int) -> float: ... + def getHattaNumber(self, int: int) -> float: ... + +class EnhancementFactor(EnhancementFactorInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, fluidBoundaryInterface: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface): ... + @typing.overload + def calcEnhancementVec(self, int: int) -> None: ... + @typing.overload + def calcEnhancementVec(self, int: int, int2: int) -> None: ... + @typing.overload + def getEnhancementVec(self, int: int) -> float: ... + @typing.overload + def getEnhancementVec(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getHattaNumber(self, int: int) -> float: ... + @typing.overload + def getHattaNumber(self) -> typing.MutableSequence[float]: ... + @typing.overload + def setEnhancementVec(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setEnhancementVec(self, int: int, double: float) -> None: ... + def setHattaNumber(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setOnesVec(self, int: int) -> None: ... + +class EnhancementFactorAlg(EnhancementFactor): + def __init__(self, fluidBoundaryInterface: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface): ... + @typing.overload + def calcEnhancementVec(self, int: int, int2: int) -> None: ... + @typing.overload + def calcEnhancementVec(self, int: int) -> None: ... + +class EnhancementFactorNumeric(EnhancementFactor): + def __init__(self, fluidBoundaryInterface: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface): ... + def calcEnhancementMatrix(self, int: int) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.reactivefilmmodel.enhancementfactor")``. + + EnhancementFactor: typing.Type[EnhancementFactor] + EnhancementFactorAlg: typing.Type[EnhancementFactorAlg] + EnhancementFactorInterface: typing.Type[EnhancementFactorInterface] + EnhancementFactorNumeric: typing.Type[EnhancementFactorNumeric] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/__init__.pyi new file mode 100644 index 00000000..bc6265e2 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/__init__.pyi @@ -0,0 +1,54 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphaseonephase +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase +import typing + + + +class InterphaseTransportCoefficientInterface: + def calcInterPhaseFrictionFactor(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcInterphaseHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcInterphaseMassTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallFrictionFactor(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallFrictionFactor(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcWallMassTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + +class InterphaseTransportCoefficientBaseClass(InterphaseTransportCoefficientInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + def calcInterPhaseFrictionFactor(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcInterphaseHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcInterphaseMassTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallFrictionFactor(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallFrictionFactor(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcWallMassTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient")``. + + InterphaseTransportCoefficientBaseClass: typing.Type[InterphaseTransportCoefficientBaseClass] + InterphaseTransportCoefficientInterface: typing.Type[InterphaseTransportCoefficientInterface] + interphaseonephase: jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphaseonephase.__module_protocol__ + interphasetwophase: jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphaseonephase/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphaseonephase/__init__.pyi new file mode 100644 index 00000000..e7791a37 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphaseonephase/__init__.pyi @@ -0,0 +1,26 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphaseonephase.interphasepipeflow +import typing + + + +class InterphaseOnePhase(jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.InterphaseTransportCoefficientBaseClass): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphaseonephase")``. + + InterphaseOnePhase: typing.Type[InterphaseOnePhase] + interphasepipeflow: jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphaseonephase.interphasepipeflow.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphaseonephase/interphasepipeflow/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphaseonephase/interphasepipeflow/__init__.pyi new file mode 100644 index 00000000..12d08770 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphaseonephase/interphasepipeflow/__init__.pyi @@ -0,0 +1,33 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphaseonephase +import typing + + + +class InterphasePipeFlow(jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphaseonephase.InterphaseOnePhase): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + @typing.overload + def calcWallFrictionFactor(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallFrictionFactor(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcWallMassTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphaseonephase.interphasepipeflow")``. + + InterphasePipeFlow: typing.Type[InterphasePipeFlow] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphasetwophase/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphasetwophase/__init__.pyi new file mode 100644 index 00000000..6871db55 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphasetwophase/__init__.pyi @@ -0,0 +1,30 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.interphasepipeflow +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.interphasereactorflow +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.stirredcell +import typing + + + +class InterphaseTwoPhase(jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.InterphaseTransportCoefficientBaseClass): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase")``. + + InterphaseTwoPhase: typing.Type[InterphaseTwoPhase] + interphasepipeflow: jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.interphasepipeflow.__module_protocol__ + interphasereactorflow: jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.interphasereactorflow.__module_protocol__ + stirredcell: jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.stirredcell.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphasetwophase/interphasepipeflow/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphasetwophase/interphasepipeflow/__init__.pyi new file mode 100644 index 00000000..5ed7bf75 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphasetwophase/interphasepipeflow/__init__.pyi @@ -0,0 +1,70 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase +import jneqsim.thermo +import typing + + + +class InterphaseTwoPhasePipeFlow(jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.InterphaseTwoPhase): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + +class InterphaseDropletFlow(InterphaseTwoPhasePipeFlow, jneqsim.thermo.ThermodynamicConstantsInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + def calcInterPhaseFrictionFactor(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcInterphaseHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcInterphaseMassTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallFrictionFactor(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallFrictionFactor(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcWallMassTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + +class InterphaseStratifiedFlow(InterphaseTwoPhasePipeFlow, jneqsim.thermo.ThermodynamicConstantsInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + def calcInterPhaseFrictionFactor(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcInterphaseHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcInterphaseMassTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallFrictionFactor(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallFrictionFactor(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcWallMassTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + +class InterphaseAnnularFlow(InterphaseStratifiedFlow): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.interphasepipeflow")``. + + InterphaseAnnularFlow: typing.Type[InterphaseAnnularFlow] + InterphaseDropletFlow: typing.Type[InterphaseDropletFlow] + InterphaseStratifiedFlow: typing.Type[InterphaseStratifiedFlow] + InterphaseTwoPhasePipeFlow: typing.Type[InterphaseTwoPhasePipeFlow] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphasetwophase/interphasereactorflow/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphasetwophase/interphasereactorflow/__init__.pyi new file mode 100644 index 00000000..b3baf11f --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphasetwophase/interphasereactorflow/__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 jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase +import jneqsim.thermo +import typing + + + +class InterphaseReactorFlow(jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.InterphaseTwoPhase): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + +class InterphasePackedBed(InterphaseReactorFlow, jneqsim.thermo.ThermodynamicConstantsInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + def calcInterPhaseFrictionFactor(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcInterphaseHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcInterphaseMassTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallFrictionFactor(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallFrictionFactor(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcWallMassTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.interphasereactorflow")``. + + InterphasePackedBed: typing.Type[InterphasePackedBed] + InterphaseReactorFlow: typing.Type[InterphaseReactorFlow] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphasetwophase/stirredcell/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphasetwophase/stirredcell/__init__.pyi new file mode 100644 index 00000000..de38a3cc --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/interphasetwophase/stirredcell/__init__.pyi @@ -0,0 +1,31 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.interphasepipeflow +import typing + + + +class InterphaseStirredCellFlow(jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.interphasepipeflow.InterphaseStratifiedFlow): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + def calcInterphaseHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcInterphaseMassTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + @typing.overload + def calcWallHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcWallMassTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.stirredcell")``. + + InterphaseStirredCellFlow: typing.Type[InterphaseStirredCellFlow] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/multiphasenode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/multiphasenode/__init__.pyi new file mode 100644 index 00000000..ddb10290 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/multiphasenode/__init__.pyi @@ -0,0 +1,42 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jpype +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.multiphasenode.waxnode +import jneqsim.fluidmechanics.flownode.twophasenode +import jneqsim.fluidmechanics.geometrydefinitions +import jneqsim.thermo.system +import typing + + + +class MultiPhaseFlowNode(jneqsim.fluidmechanics.flownode.FlowNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + def calcContactLength(self) -> float: ... + def calcFluxes(self) -> None: ... + def calcGasLiquidContactArea(self) -> float: ... + def calcHydraulicDiameter(self) -> float: ... + def calcReynoldNumber(self) -> float: ... + def calcWallFrictionFactor(self) -> float: ... + def clone(self) -> jneqsim.fluidmechanics.flownode.twophasenode.TwoPhaseFlowNode: ... + def init(self) -> None: ... + def initFlowCalc(self) -> None: ... + def initVelocity(self) -> float: ... + def setFluxes(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def update(self) -> None: ... + def updateMolarFlow(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.multiphasenode")``. + + MultiPhaseFlowNode: typing.Type[MultiPhaseFlowNode] + waxnode: jneqsim.fluidmechanics.flownode.multiphasenode.waxnode.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/multiphasenode/waxnode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/multiphasenode/waxnode/__init__.pyi new file mode 100644 index 00000000..184b718e --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/multiphasenode/waxnode/__init__.pyi @@ -0,0 +1,37 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.multiphasenode +import jneqsim.fluidmechanics.flownode.twophasenode.twophasepipeflownode +import jneqsim.fluidmechanics.geometrydefinitions +import jneqsim.thermo.system +import typing + + + +class WaxDepositionFlowNode(jneqsim.fluidmechanics.flownode.multiphasenode.MultiPhaseFlowNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + def calcContactLength(self) -> float: ... + def clone(self) -> jneqsim.fluidmechanics.flownode.twophasenode.twophasepipeflownode.StratifiedFlowNode: ... + def getNextNode(self) -> jneqsim.fluidmechanics.flownode.FlowNodeInterface: ... + def init(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.multiphasenode.waxnode")``. + + WaxDepositionFlowNode: typing.Type[WaxDepositionFlowNode] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/onephasenode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/onephasenode/__init__.pyi new file mode 100644 index 00000000..bb517645 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/onephasenode/__init__.pyi @@ -0,0 +1,35 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.onephasenode.onephasepipeflownode +import jneqsim.fluidmechanics.geometrydefinitions +import jneqsim.thermo.system +import typing + + + +class onePhaseFlowNode(jneqsim.fluidmechanics.flownode.FlowNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + def calcReynoldsNumber(self) -> float: ... + def clone(self) -> 'onePhaseFlowNode': ... + def increaseMolarRate(self, double: float) -> None: ... + def init(self) -> None: ... + def initFlowCalc(self) -> None: ... + def updateMolarFlow(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.onephasenode")``. + + onePhaseFlowNode: typing.Type[onePhaseFlowNode] + onephasepipeflownode: jneqsim.fluidmechanics.flownode.onephasenode.onephasepipeflownode.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/onephasenode/onephasepipeflownode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/onephasenode/onephasepipeflownode/__init__.pyi new file mode 100644 index 00000000..7b538aa9 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/onephasenode/onephasepipeflownode/__init__.pyi @@ -0,0 +1,31 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.fluidmechanics.flownode.onephasenode +import jneqsim.fluidmechanics.geometrydefinitions +import jneqsim.thermo.system +import typing + + + +class onePhasePipeFlowNode(jneqsim.fluidmechanics.flownode.onephasenode.onePhaseFlowNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + def calcReynoldsNumber(self) -> float: ... + def clone(self) -> 'onePhasePipeFlowNode': ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.onephasenode.onephasepipeflownode")``. + + onePhasePipeFlowNode: typing.Type[onePhasePipeFlowNode] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/__init__.pyi new file mode 100644 index 00000000..a13a5c10 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/__init__.pyi @@ -0,0 +1,48 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jpype +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.twophasenode.twophasepipeflownode +import jneqsim.fluidmechanics.flownode.twophasenode.twophasereactorflownode +import jneqsim.fluidmechanics.flownode.twophasenode.twophasestirredcellnode +import jneqsim.fluidmechanics.geometrydefinitions +import jneqsim.thermo.system +import typing + + + +class TwoPhaseFlowNode(jneqsim.fluidmechanics.flownode.FlowNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + def calcContactLength(self) -> float: ... + def calcFluxes(self) -> None: ... + def calcGasLiquidContactArea(self) -> float: ... + def calcHydraulicDiameter(self) -> float: ... + def calcReynoldNumber(self) -> float: ... + def calcWallFrictionFactor(self) -> float: ... + def clone(self) -> 'TwoPhaseFlowNode': ... + def init(self) -> None: ... + def initFlowCalc(self) -> None: ... + def initVelocity(self) -> float: ... + def setFluxes(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def update(self) -> None: ... + @typing.overload + def update(self, double: float) -> None: ... + def updateMolarFlow(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.twophasenode")``. + + TwoPhaseFlowNode: typing.Type[TwoPhaseFlowNode] + twophasepipeflownode: jneqsim.fluidmechanics.flownode.twophasenode.twophasepipeflownode.__module_protocol__ + twophasereactorflownode: jneqsim.fluidmechanics.flownode.twophasenode.twophasereactorflownode.__module_protocol__ + twophasestirredcellnode: jneqsim.fluidmechanics.flownode.twophasenode.twophasestirredcellnode.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasepipeflownode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasepipeflownode/__init__.pyi new file mode 100644 index 00000000..422b426e --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasepipeflownode/__init__.pyi @@ -0,0 +1,91 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.twophasenode +import jneqsim.fluidmechanics.geometrydefinitions +import jneqsim.thermo.system +import typing + + + +class AnnularFlow(jneqsim.fluidmechanics.flownode.twophasenode.TwoPhaseFlowNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + def calcContactLength(self) -> float: ... + def clone(self) -> 'AnnularFlow': ... + def getNextNode(self) -> jneqsim.fluidmechanics.flownode.FlowNodeInterface: ... + def init(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class BubbleFlowNode(jneqsim.fluidmechanics.flownode.twophasenode.TwoPhaseFlowNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + def calcContactLength(self) -> float: ... + def calcGasLiquidContactArea(self) -> float: ... + def clone(self) -> 'BubbleFlowNode': ... + def getAverageBubbleDiameter(self) -> float: ... + def getNextNode(self) -> jneqsim.fluidmechanics.flownode.FlowNodeInterface: ... + def init(self) -> None: ... + def initFlowCalc(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def setAverageBubbleDiameter(self, double: float) -> None: ... + +class DropletFlowNode(jneqsim.fluidmechanics.flownode.twophasenode.TwoPhaseFlowNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + def calcContactLength(self) -> float: ... + def calcGasLiquidContactArea(self) -> float: ... + def clone(self) -> 'DropletFlowNode': ... + def getAverageDropletDiameter(self) -> float: ... + def getNextNode(self) -> jneqsim.fluidmechanics.flownode.FlowNodeInterface: ... + def init(self) -> None: ... + def initFlowCalc(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @staticmethod + def mainOld(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def setAverageDropletDiameter(self, double: float) -> None: ... + +class StratifiedFlowNode(jneqsim.fluidmechanics.flownode.twophasenode.TwoPhaseFlowNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + def calcContactLength(self) -> float: ... + def clone(self) -> 'StratifiedFlowNode': ... + def getNextNode(self) -> jneqsim.fluidmechanics.flownode.FlowNodeInterface: ... + def init(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.twophasenode.twophasepipeflownode")``. + + AnnularFlow: typing.Type[AnnularFlow] + BubbleFlowNode: typing.Type[BubbleFlowNode] + DropletFlowNode: typing.Type[DropletFlowNode] + StratifiedFlowNode: typing.Type[StratifiedFlowNode] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasereactorflownode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasereactorflownode/__init__.pyi new file mode 100644 index 00000000..5178367d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasereactorflownode/__init__.pyi @@ -0,0 +1,59 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.twophasenode +import jneqsim.fluidmechanics.geometrydefinitions +import jneqsim.thermo.system +import typing + + + +class TwoPhasePackedBedFlowNode(jneqsim.fluidmechanics.flownode.twophasenode.TwoPhaseFlowNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + def calcContactLength(self) -> float: ... + def calcGasLiquidContactArea(self) -> float: ... + def calcHydraulicDiameter(self) -> float: ... + def calcReynoldNumber(self) -> float: ... + def clone(self) -> 'TwoPhasePackedBedFlowNode': ... + def getNextNode(self) -> jneqsim.fluidmechanics.flownode.FlowNodeInterface: ... + def init(self) -> None: ... + def initFlowCalc(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def update(self, double: float) -> None: ... + @typing.overload + def update(self) -> None: ... + +class TwoPhaseTrayTowerFlowNode(jneqsim.fluidmechanics.flownode.twophasenode.TwoPhaseFlowNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + def calcContactLength(self) -> float: ... + def clone(self) -> 'TwoPhaseTrayTowerFlowNode': ... + def getNextNode(self) -> jneqsim.fluidmechanics.flownode.FlowNodeInterface: ... + def init(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.twophasenode.twophasereactorflownode")``. + + TwoPhasePackedBedFlowNode: typing.Type[TwoPhasePackedBedFlowNode] + TwoPhaseTrayTowerFlowNode: typing.Type[TwoPhaseTrayTowerFlowNode] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasestirredcellnode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasestirredcellnode/__init__.pyi new file mode 100644 index 00000000..742b80a5 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasestirredcellnode/__init__.pyi @@ -0,0 +1,56 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.flownode.twophasenode +import jneqsim.fluidmechanics.geometrydefinitions +import jneqsim.thermo.system +import typing + + + +class StirredCellNode(jneqsim.fluidmechanics.flownode.twophasenode.TwoPhaseFlowNode): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface, geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface): ... + def calcContactLength(self) -> float: ... + def calcGasLiquidContactArea(self) -> float: ... + def calcHydraulicDiameter(self) -> float: ... + def calcReynoldNumber(self) -> float: ... + def clone(self) -> 'StirredCellNode': ... + def getDt(self) -> float: ... + def getNextNode(self) -> jneqsim.fluidmechanics.flownode.FlowNodeInterface: ... + def getStirrerDiameter(self) -> typing.MutableSequence[float]: ... + def getStirrerRate(self, int: int) -> float: ... + def init(self) -> None: ... + def initFlowCalc(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def setDt(self, double: float) -> None: ... + @typing.overload + def setStirrerDiameter(self, double: float) -> None: ... + @typing.overload + def setStirrerDiameter(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setStirrerSpeed(self, double: float) -> None: ... + @typing.overload + def setStirrerSpeed(self, int: int, double: float) -> None: ... + @typing.overload + def update(self, double: float) -> None: ... + @typing.overload + def update(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flownode.twophasenode.twophasestirredcellnode")``. + + StirredCellNode: typing.Type[StirredCellNode] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/__init__.pyi new file mode 100644 index 00000000..191f0f95 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/__init__.pyi @@ -0,0 +1,39 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.io +import jneqsim.fluidmechanics.flowsolver.onephaseflowsolver +import jneqsim.fluidmechanics.flowsolver.twophaseflowsolver +import typing + + + +class FlowSolverInterface: + def setBoundarySpecificationType(self, int: int) -> None: ... + def setDynamic(self, boolean: bool) -> None: ... + def setSolverType(self, int: int) -> None: ... + def setTimeStep(self, double: float) -> None: ... + def solve(self) -> None: ... + def solveTDMA(self) -> None: ... + +class FlowSolver(FlowSolverInterface, java.io.Serializable): + def __init__(self): ... + def setBoundarySpecificationType(self, int: int) -> None: ... + def setDynamic(self, boolean: bool) -> None: ... + def setSolverType(self, int: int) -> None: ... + def setTimeStep(self, double: float) -> None: ... + def solve(self) -> None: ... + def solveTDMA(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsolver")``. + + FlowSolver: typing.Type[FlowSolver] + FlowSolverInterface: typing.Type[FlowSolverInterface] + onephaseflowsolver: jneqsim.fluidmechanics.flowsolver.onephaseflowsolver.__module_protocol__ + twophaseflowsolver: jneqsim.fluidmechanics.flowsolver.twophaseflowsolver.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/onephaseflowsolver/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/onephaseflowsolver/__init__.pyi new file mode 100644 index 00000000..4c753bbf --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/onephaseflowsolver/__init__.pyi @@ -0,0 +1,22 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flowsolver +import jneqsim.fluidmechanics.flowsolver.onephaseflowsolver.onephasepipeflowsolver +import typing + + + +class OnePhaseFlowSolver(jneqsim.fluidmechanics.flowsolver.FlowSolver): + def __init__(self): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsolver.onephaseflowsolver")``. + + OnePhaseFlowSolver: typing.Type[OnePhaseFlowSolver] + onephasepipeflowsolver: jneqsim.fluidmechanics.flowsolver.onephaseflowsolver.onephasepipeflowsolver.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/onephaseflowsolver/onephasepipeflowsolver/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/onephaseflowsolver/onephasepipeflowsolver/__init__.pyi new file mode 100644 index 00000000..4eb13069 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/onephaseflowsolver/onephasepipeflowsolver/__init__.pyi @@ -0,0 +1,46 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flowsolver.onephaseflowsolver +import jneqsim.fluidmechanics.flowsystem.onephaseflowsystem.pipeflowsystem +import jneqsim.thermo +import typing + + + +class OnePhasePipeFlowSolver(jneqsim.fluidmechanics.flowsolver.onephaseflowsolver.OnePhaseFlowSolver): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, pipeFlowSystem: jneqsim.fluidmechanics.flowsystem.onephaseflowsystem.pipeflowsystem.PipeFlowSystem, double: float, int: int): ... + def clone(self) -> 'OnePhasePipeFlowSolver': ... + +class OnePhaseFixedStaggeredGrid(OnePhasePipeFlowSolver, jneqsim.thermo.ThermodynamicConstantsInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, pipeFlowSystem: jneqsim.fluidmechanics.flowsystem.onephaseflowsystem.pipeflowsystem.PipeFlowSystem, double: float, int: int, boolean: bool): ... + def clone(self) -> 'OnePhaseFixedStaggeredGrid': ... + def initComposition(self, int: int) -> None: ... + def initFinalResults(self) -> None: ... + def initMatrix(self) -> None: ... + def initPressure(self, int: int) -> None: ... + def initProfiles(self) -> None: ... + def initTemperature(self, int: int) -> None: ... + def initVelocity(self, int: int) -> None: ... + def setComponentConservationMatrix(self, int: int) -> None: ... + def setEnergyMatrixTDMA(self) -> None: ... + def setImpulsMatrixTDMA(self) -> None: ... + def setMassConservationMatrixTDMA(self) -> None: ... + def solveTDMA(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsolver.onephaseflowsolver.onephasepipeflowsolver")``. + + OnePhaseFixedStaggeredGrid: typing.Type[OnePhaseFixedStaggeredGrid] + OnePhasePipeFlowSolver: typing.Type[OnePhasePipeFlowSolver] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/__init__.pyi new file mode 100644 index 00000000..c076e8ef --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/__init__.pyi @@ -0,0 +1,17 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flowsolver.twophaseflowsolver.stirredcellsolver +import jneqsim.fluidmechanics.flowsolver.twophaseflowsolver.twophasepipeflowsolver +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsolver.twophaseflowsolver")``. + + stirredcellsolver: jneqsim.fluidmechanics.flowsolver.twophaseflowsolver.stirredcellsolver.__module_protocol__ + twophasepipeflowsolver: jneqsim.fluidmechanics.flowsolver.twophaseflowsolver.twophasepipeflowsolver.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/stirredcellsolver/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/stirredcellsolver/__init__.pyi new file mode 100644 index 00000000..65f532c1 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/stirredcellsolver/__init__.pyi @@ -0,0 +1,39 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flowsolver.twophaseflowsolver.twophasepipeflowsolver +import jneqsim.fluidmechanics.flowsystem +import jneqsim.thermo +import typing + + + +class StirredCellSolver(jneqsim.fluidmechanics.flowsolver.twophaseflowsolver.twophasepipeflowsolver.TwoPhasePipeFlowSolver, jneqsim.thermo.ThermodynamicConstantsInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface, double: float, int: int): ... + @typing.overload + def __init__(self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface, double: float, int: int, boolean: bool): ... + def calcFluxes(self) -> None: ... + def clone(self) -> jneqsim.fluidmechanics.flowsolver.twophaseflowsolver.twophasepipeflowsolver.TwoPhaseFixedStaggeredGridSolver: ... + def initComposition(self, int: int, int2: int) -> None: ... + def initFinalResults(self, int: int) -> None: ... + def initMatrix(self) -> None: ... + def initNodes(self) -> None: ... + def initPhaseFraction(self, int: int) -> None: ... + def initPressure(self, int: int) -> None: ... + def initProfiles(self) -> None: ... + def initTemperature(self, int: int) -> None: ... + def initVelocity(self, int: int) -> None: ... + def solveTDMA(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsolver.twophaseflowsolver.stirredcellsolver")``. + + StirredCellSolver: typing.Type[StirredCellSolver] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/twophasepipeflowsolver/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/twophasepipeflowsolver/__init__.pyi new file mode 100644 index 00000000..234cc0dc --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/twophasepipeflowsolver/__init__.pyi @@ -0,0 +1,53 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flowsolver.onephaseflowsolver +import jneqsim.fluidmechanics.flowsystem +import jneqsim.thermo +import typing + + + +class TwoPhasePipeFlowSolver(jneqsim.fluidmechanics.flowsolver.onephaseflowsolver.OnePhaseFlowSolver): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface, double: float, int: int): ... + def clone(self) -> 'TwoPhasePipeFlowSolver': ... + +class TwoPhaseFixedStaggeredGridSolver(TwoPhasePipeFlowSolver, jneqsim.thermo.ThermodynamicConstantsInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface, double: float, int: int): ... + @typing.overload + def __init__(self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface, double: float, int: int, boolean: bool): ... + def calcFluxes(self) -> None: ... + def clone(self) -> 'TwoPhaseFixedStaggeredGridSolver': ... + def initComposition(self, int: int, int2: int) -> None: ... + def initFinalResults(self, int: int) -> None: ... + def initMatrix(self) -> None: ... + def initNodes(self) -> None: ... + def initPhaseFraction(self, int: int) -> None: ... + def initPressure(self, int: int) -> None: ... + def initProfiles(self) -> None: ... + def initTemperature(self, int: int) -> None: ... + def initVelocity(self, int: int) -> None: ... + def setComponentConservationMatrix(self, int: int, int2: int) -> None: ... + def setComponentConservationMatrix2(self, int: int, int2: int) -> None: ... + def setEnergyMatrixTDMA(self, int: int) -> None: ... + def setImpulsMatrixTDMA(self, int: int) -> None: ... + def setMassConservationMatrix(self, int: int) -> None: ... + def setPhaseFractionMatrix(self, int: int) -> None: ... + def solveTDMA(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsolver.twophaseflowsolver.twophasepipeflowsolver")``. + + TwoPhaseFixedStaggeredGridSolver: typing.Type[TwoPhaseFixedStaggeredGridSolver] + TwoPhasePipeFlowSolver: typing.Type[TwoPhasePipeFlowSolver] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/__init__.pyi new file mode 100644 index 00000000..a5c09187 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/__init__.pyi @@ -0,0 +1,131 @@ + +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.fluidmechanics.flownode +import jneqsim.fluidmechanics.flowsolver +import jneqsim.fluidmechanics.flowsystem.onephaseflowsystem +import jneqsim.fluidmechanics.flowsystem.twophaseflowsystem +import jneqsim.fluidmechanics.geometrydefinitions +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization +import jneqsim.fluidmechanics.util.timeseries +import jneqsim.thermo.system +import typing + + + +class FlowSystemInterface: + def calcFluxes(self) -> None: ... + def createSystem(self) -> None: ... + def getDisplay(self) -> jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.FlowSystemVisualizationInterface: ... + def getFlowNodes(self) -> typing.MutableSequence[jneqsim.fluidmechanics.flownode.FlowNodeInterface]: ... + def getInletPressure(self) -> float: ... + def getInletTemperature(self) -> float: ... + def getLegHeights(self) -> typing.MutableSequence[float]: ... + def getNode(self, int: int) -> jneqsim.fluidmechanics.flownode.FlowNodeInterface: ... + def getNumberOfLegs(self) -> int: ... + def getNumberOfNodesInLeg(self, int: int) -> int: ... + def getSolver(self) -> jneqsim.fluidmechanics.flowsolver.FlowSolverInterface: ... + def getSystemLength(self) -> float: ... + def getTimeSeries(self) -> jneqsim.fluidmechanics.util.timeseries.TimeSeries: ... + @typing.overload + def getTotalMolarMassTransferRate(self, int: int) -> float: ... + @typing.overload + def getTotalMolarMassTransferRate(self, int: int, int2: int) -> float: ... + def getTotalNumberOfNodes(self) -> int: ... + @typing.overload + def getTotalPressureDrop(self) -> float: ... + @typing.overload + def getTotalPressureDrop(self, int: int) -> float: ... + def init(self) -> None: ... + def print_(self) -> None: ... + def setEndPressure(self, double: float) -> None: ... + def setEquilibriumHeatTransfer(self, boolean: bool) -> None: ... + def setEquilibriumMassTransfer(self, boolean: bool) -> None: ... + def setEquipmentGeometry(self, geometryDefinitionInterfaceArray: typing.Union[typing.List[jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface], jpype.JArray]) -> None: ... + def setFlowPattern(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setInitialFlowPattern(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setInletThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setLegHeights(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setLegOuterHeatTransferCoefficients(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setLegOuterTemperatures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setLegPositions(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setLegWallHeatTransferCoefficients(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setNodes(self) -> None: ... + def setNumberOfLegs(self, int: int) -> None: ... + def setNumberOfNodesInLeg(self, int: int) -> None: ... + @typing.overload + def solveSteadyState(self, int: int, uUID: java.util.UUID) -> None: ... + @typing.overload + def solveSteadyState(self, int: int) -> None: ... + @typing.overload + def solveTransient(self, int: int, uUID: java.util.UUID) -> None: ... + @typing.overload + def solveTransient(self, int: int) -> None: ... + +class FlowSystem(FlowSystemInterface, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcFluxes(self) -> None: ... + def calcTotalNumberOfNodes(self) -> int: ... + def createSystem(self) -> None: ... + def flowLegInit(self) -> None: ... + def getDisplay(self) -> jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.FlowSystemVisualizationInterface: ... + def getFlowNodes(self) -> typing.MutableSequence[jneqsim.fluidmechanics.flownode.FlowNodeInterface]: ... + def getInletPressure(self) -> float: ... + def getInletTemperature(self) -> float: ... + def getLegHeights(self) -> typing.MutableSequence[float]: ... + def getNode(self, int: int) -> jneqsim.fluidmechanics.flownode.FlowNodeInterface: ... + def getNumberOfLegs(self) -> int: ... + def getNumberOfNodesInLeg(self, int: int) -> int: ... + def getSolver(self) -> jneqsim.fluidmechanics.flowsolver.FlowSolverInterface: ... + def getSystemLength(self) -> float: ... + def getTimeSeries(self) -> jneqsim.fluidmechanics.util.timeseries.TimeSeries: ... + @typing.overload + def getTotalMolarMassTransferRate(self, int: int) -> float: ... + @typing.overload + def getTotalMolarMassTransferRate(self, int: int, int2: int) -> float: ... + def getTotalNumberOfNodes(self) -> int: ... + @typing.overload + def getTotalPressureDrop(self) -> float: ... + @typing.overload + def getTotalPressureDrop(self, int: int) -> float: ... + def init(self) -> None: ... + def print_(self) -> None: ... + def setEndPressure(self, double: float) -> None: ... + def setEquilibriumHeatTransfer(self, boolean: bool) -> None: ... + def setEquilibriumHeatTransferModel(self, int: int, int2: int) -> None: ... + def setEquilibriumMassTransfer(self, boolean: bool) -> None: ... + def setEquilibriumMassTransferModel(self, int: int, int2: int) -> None: ... + def setEquipmentGeometry(self, geometryDefinitionInterfaceArray: typing.Union[typing.List[jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface], jpype.JArray]) -> None: ... + def setFlowPattern(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setInitialFlowPattern(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setInletThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setLegHeights(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setLegOuterHeatTransferCoefficients(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setLegOuterTemperatures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setLegPositions(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setLegWallHeatTransferCoefficients(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setNodes(self) -> None: ... + def setNonEquilibriumHeatTransferModel(self, int: int, int2: int) -> None: ... + def setNonEquilibriumMassTransferModel(self, int: int, int2: int) -> None: ... + def setNumberOfLegs(self, int: int) -> None: ... + def setNumberOfNodesInLeg(self, int: int) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsystem")``. + + FlowSystem: typing.Type[FlowSystem] + FlowSystemInterface: typing.Type[FlowSystemInterface] + onephaseflowsystem: jneqsim.fluidmechanics.flowsystem.onephaseflowsystem.__module_protocol__ + twophaseflowsystem: jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/onephaseflowsystem/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/onephaseflowsystem/__init__.pyi new file mode 100644 index 00000000..c9fb0710 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/onephaseflowsystem/__init__.pyi @@ -0,0 +1,28 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flowsystem +import jneqsim.fluidmechanics.flowsystem.onephaseflowsystem.pipeflowsystem +import jneqsim.fluidmechanics.geometrydefinitions.pipe +import jneqsim.thermo.system +import typing + + + +class OnePhaseFlowSystem(jneqsim.fluidmechanics.flowsystem.FlowSystem): + pipe: jneqsim.fluidmechanics.geometrydefinitions.pipe.PipeData = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsystem.onephaseflowsystem")``. + + OnePhaseFlowSystem: typing.Type[OnePhaseFlowSystem] + pipeflowsystem: jneqsim.fluidmechanics.flowsystem.onephaseflowsystem.pipeflowsystem.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/onephaseflowsystem/pipeflowsystem/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/onephaseflowsystem/pipeflowsystem/__init__.pyi new file mode 100644 index 00000000..4f0c9b28 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/onephaseflowsystem/pipeflowsystem/__init__.pyi @@ -0,0 +1,31 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.util +import jneqsim.fluidmechanics.flowsystem.onephaseflowsystem +import typing + + + +class PipeFlowSystem(jneqsim.fluidmechanics.flowsystem.onephaseflowsystem.OnePhaseFlowSystem): + def __init__(self): ... + def createSystem(self) -> None: ... + def init(self) -> None: ... + @typing.overload + def solveSteadyState(self, int: int) -> None: ... + @typing.overload + def solveSteadyState(self, int: int, uUID: java.util.UUID) -> None: ... + @typing.overload + def solveTransient(self, int: int) -> None: ... + @typing.overload + def solveTransient(self, int: int, uUID: java.util.UUID) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsystem.onephaseflowsystem.pipeflowsystem")``. + + PipeFlowSystem: typing.Type[PipeFlowSystem] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/__init__.pyi new file mode 100644 index 00000000..ae05f3e1 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/__init__.pyi @@ -0,0 +1,34 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flowsystem +import jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.shipsystem +import jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.stirredcellsystem +import jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.twophasepipeflowsystem +import jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.twophasereactorflowsystem +import jneqsim.fluidmechanics.geometrydefinitions.pipe +import jneqsim.thermo.system +import typing + + + +class TwoPhaseFlowSystem(jneqsim.fluidmechanics.flowsystem.FlowSystem): + pipe: jneqsim.fluidmechanics.geometrydefinitions.pipe.PipeData = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsystem.twophaseflowsystem")``. + + TwoPhaseFlowSystem: typing.Type[TwoPhaseFlowSystem] + shipsystem: jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.shipsystem.__module_protocol__ + stirredcellsystem: jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.stirredcellsystem.__module_protocol__ + twophasepipeflowsystem: jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.twophasepipeflowsystem.__module_protocol__ + twophasereactorflowsystem: jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.twophasereactorflowsystem.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/shipsystem/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/shipsystem/__init__.pyi new file mode 100644 index 00000000..6c0e45d6 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/shipsystem/__init__.pyi @@ -0,0 +1,64 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.fluidmechanics.flowsystem.twophaseflowsystem +import jneqsim.standards.gasquality +import jneqsim.thermo.system +import typing + + + +class LNGship(jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.TwoPhaseFlowSystem): + totalTankVolume: float = ... + numberOffTimeSteps: int = ... + initialNumberOffMoles: float = ... + dailyBoilOffVolume: float = ... + volume: typing.MutableSequence[float] = ... + tankTemperature: typing.MutableSequence[float] = ... + endVolume: float = ... + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + def createSystem(self) -> None: ... + def getEndTime(self) -> float: ... + def getInitialTemperature(self) -> float: ... + def getLiquidDensity(self) -> float: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getResults(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getStandardISO6976(self) -> jneqsim.standards.gasquality.Standard_ISO6976: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def init(self) -> None: ... + def isBackCalculate(self) -> bool: ... + def isSetInitialTemperature(self) -> bool: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def setBackCalculate(self, boolean: bool) -> None: ... + def setEndTime(self, double: float) -> None: ... + @typing.overload + def setInitialTemperature(self, boolean: bool) -> None: ... + @typing.overload + def setInitialTemperature(self, double: float) -> None: ... + def setLiquidDensity(self, double: float) -> None: ... + def setResultTable(self, stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> None: ... + def setStandardISO6976(self, standard_ISO6976: jneqsim.standards.gasquality.Standard_ISO6976) -> None: ... + def setThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + @typing.overload + def solveSteadyState(self, int: int) -> None: ... + @typing.overload + def solveSteadyState(self, int: int, uUID: java.util.UUID) -> None: ... + @typing.overload + def solveTransient(self, int: int) -> None: ... + @typing.overload + def solveTransient(self, int: int, uUID: java.util.UUID) -> None: ... + def useStandardVersion(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.shipsystem")``. + + LNGship: typing.Type[LNGship] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/stirredcellsystem/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/stirredcellsystem/__init__.pyi new file mode 100644 index 00000000..007411f6 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/stirredcellsystem/__init__.pyi @@ -0,0 +1,35 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.fluidmechanics.flowsystem.twophaseflowsystem +import typing + + + +class StirredCellSystem(jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.TwoPhaseFlowSystem): + def __init__(self): ... + def createSystem(self) -> None: ... + def init(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def solveSteadyState(self, int: int) -> None: ... + @typing.overload + def solveSteadyState(self, int: int, uUID: java.util.UUID) -> None: ... + @typing.overload + def solveTransient(self, int: int) -> None: ... + @typing.overload + def solveTransient(self, int: int, uUID: java.util.UUID) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.stirredcellsystem")``. + + StirredCellSystem: typing.Type[StirredCellSystem] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/twophasepipeflowsystem/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/twophasepipeflowsystem/__init__.pyi new file mode 100644 index 00000000..91fa6b0b --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/twophasepipeflowsystem/__init__.pyi @@ -0,0 +1,41 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.fluidmechanics.flowsystem.twophaseflowsystem +import typing + + + +class TwoPhasePipeFlowSystem(jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.TwoPhaseFlowSystem): + def __init__(self): ... + def createSystem(self) -> None: ... + def init(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def solveSteadyState(self, int: int) -> None: ... + @typing.overload + def solveSteadyState(self, int: int, uUID: java.util.UUID) -> None: ... + @typing.overload + def solveTransient(self, int: int) -> None: ... + @typing.overload + def solveTransient(self, int: int, uUID: java.util.UUID) -> None: ... + +class TwoPhasePipeFlowSystemReac(TwoPhasePipeFlowSystem): + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.twophasepipeflowsystem")``. + + TwoPhasePipeFlowSystem: typing.Type[TwoPhasePipeFlowSystem] + TwoPhasePipeFlowSystemReac: typing.Type[TwoPhasePipeFlowSystemReac] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/twophasereactorflowsystem/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/twophasereactorflowsystem/__init__.pyi new file mode 100644 index 00000000..f523ccba --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/twophasereactorflowsystem/__init__.pyi @@ -0,0 +1,35 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.fluidmechanics.flowsystem.twophaseflowsystem +import typing + + + +class TwoPhaseReactorFlowSystem(jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.TwoPhaseFlowSystem): + def __init__(self): ... + def createSystem(self) -> None: ... + def init(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def solveSteadyState(self, int: int) -> None: ... + @typing.overload + def solveSteadyState(self, int: int, uUID: java.util.UUID) -> None: ... + @typing.overload + def solveTransient(self, int: int) -> None: ... + @typing.overload + def solveTransient(self, int: int, uUID: java.util.UUID) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.twophasereactorflowsystem")``. + + TwoPhaseReactorFlowSystem: typing.Type[TwoPhaseReactorFlowSystem] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/__init__.pyi new file mode 100644 index 00000000..8d08de57 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/__init__.pyi @@ -0,0 +1,106 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.fluidmechanics.geometrydefinitions.internalgeometry +import jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.packings +import jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.wall +import jneqsim.fluidmechanics.geometrydefinitions.pipe +import jneqsim.fluidmechanics.geometrydefinitions.reactor +import jneqsim.fluidmechanics.geometrydefinitions.stirredcell +import jneqsim.fluidmechanics.geometrydefinitions.surrounding +import jneqsim.thermo +import typing + + + +class GeometryDefinitionInterface(java.lang.Cloneable): + def clone(self) -> 'GeometryDefinitionInterface': ... + def getArea(self) -> float: ... + def getCircumference(self) -> float: ... + def getDiameter(self) -> float: ... + def getGeometry(self) -> 'GeometryDefinitionInterface': ... + def getInnerSurfaceRoughness(self) -> float: ... + def getInnerWallTemperature(self) -> float: ... + def getNodeLength(self) -> float: ... + def getPacking(self) -> jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.packings.PackingInterface: ... + def getRadius(self) -> float: ... + @typing.overload + def getRelativeRoughnes(self) -> float: ... + @typing.overload + def getRelativeRoughnes(self, double: float) -> float: ... + def getSurroundingEnvironment(self) -> jneqsim.fluidmechanics.geometrydefinitions.surrounding.SurroundingEnvironment: ... + def getWallHeatTransferCoefficient(self) -> float: ... + def init(self) -> None: ... + def setDiameter(self, double: float) -> None: ... + def setInnerSurfaceRoughness(self, double: float) -> None: ... + def setInnerWallTemperature(self, double: float) -> None: ... + def setNodeLength(self, double: float) -> None: ... + @typing.overload + def setPackingType(self, int: int) -> None: ... + @typing.overload + def setPackingType(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], int: int) -> None: ... + def setSurroundingEnvironment(self, surroundingEnvironment: jneqsim.fluidmechanics.geometrydefinitions.surrounding.SurroundingEnvironment) -> None: ... + def setWallHeatTransferCoefficient(self, double: float) -> None: ... + +class GeometryDefinition(GeometryDefinitionInterface, jneqsim.thermo.ThermodynamicConstantsInterface): + diameter: float = ... + radius: float = ... + innerSurfaceRoughness: float = ... + nodeLength: float = ... + area: float = ... + relativeRoughnes: float = ... + layerConductivity: typing.MutableSequence[float] = ... + layerThickness: typing.MutableSequence[float] = ... + wall: jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.wall.Wall = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + def clone(self) -> GeometryDefinitionInterface: ... + def getArea(self) -> float: ... + def getCircumference(self) -> float: ... + def getDiameter(self) -> float: ... + def getGeometry(self) -> GeometryDefinitionInterface: ... + def getInnerSurfaceRoughness(self) -> float: ... + def getInnerWallTemperature(self) -> float: ... + def getNodeLength(self) -> float: ... + def getPacking(self) -> jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.packings.PackingInterface: ... + def getRadius(self) -> float: ... + @typing.overload + def getRelativeRoughnes(self) -> float: ... + @typing.overload + def getRelativeRoughnes(self, double: float) -> float: ... + def getSurroundingEnvironment(self) -> jneqsim.fluidmechanics.geometrydefinitions.surrounding.SurroundingEnvironment: ... + def getWall(self) -> jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.wall.Wall: ... + def getWallHeatTransferCoefficient(self) -> float: ... + def init(self) -> None: ... + def setDiameter(self, double: float) -> None: ... + def setInnerSurfaceRoughness(self, double: float) -> None: ... + def setInnerWallTemperature(self, double: float) -> None: ... + def setNodeLength(self, double: float) -> None: ... + @typing.overload + def setPackingType(self, int: int) -> None: ... + @typing.overload + def setPackingType(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], int: int) -> None: ... + def setSurroundingEnvironment(self, surroundingEnvironment: jneqsim.fluidmechanics.geometrydefinitions.surrounding.SurroundingEnvironment) -> None: ... + def setWall(self, wall: jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.wall.Wall) -> None: ... + def setWallHeatTransferCoefficient(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.geometrydefinitions")``. + + GeometryDefinition: typing.Type[GeometryDefinition] + GeometryDefinitionInterface: typing.Type[GeometryDefinitionInterface] + internalgeometry: jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.__module_protocol__ + pipe: jneqsim.fluidmechanics.geometrydefinitions.pipe.__module_protocol__ + reactor: jneqsim.fluidmechanics.geometrydefinitions.reactor.__module_protocol__ + stirredcell: jneqsim.fluidmechanics.geometrydefinitions.stirredcell.__module_protocol__ + surrounding: jneqsim.fluidmechanics.geometrydefinitions.surrounding.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/__init__.pyi new file mode 100644 index 00000000..7463f8c9 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/__init__.pyi @@ -0,0 +1,17 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.packings +import jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.wall +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.geometrydefinitions.internalgeometry")``. + + packings: jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.packings.__module_protocol__ + wall: jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.wall.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/packings/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/packings/__init__.pyi new file mode 100644 index 00000000..ec83b712 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/packings/__init__.pyi @@ -0,0 +1,54 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.util +import typing + + + +class PackingInterface: + def getSize(self) -> float: ... + def getSurfaceAreaPrVolume(self) -> float: ... + def getVoidFractionPacking(self) -> float: ... + def setVoidFractionPacking(self, double: float) -> None: ... + +class Packing(jneqsim.util.NamedBaseClass, PackingInterface): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], int: int): ... + def getSize(self) -> float: ... + def getSurfaceAreaPrVolume(self) -> float: ... + def getVoidFractionPacking(self) -> float: ... + def setSize(self, double: float) -> None: ... + def setVoidFractionPacking(self, double: float) -> None: ... + +class BerlSaddlePacking(Packing): + def __init__(self): ... + +class PallRingPacking(Packing): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], int: int): ... + +class RachigRingPacking(Packing): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], int: int): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.packings")``. + + BerlSaddlePacking: typing.Type[BerlSaddlePacking] + Packing: typing.Type[Packing] + PackingInterface: typing.Type[PackingInterface] + PallRingPacking: typing.Type[PallRingPacking] + RachigRingPacking: typing.Type[RachigRingPacking] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/wall/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/wall/__init__.pyi new file mode 100644 index 00000000..b19934d6 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/wall/__init__.pyi @@ -0,0 +1,51 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import typing + + + +class MaterialLayer: + def __init__(self, string: typing.Union[java.lang.String, str], double: float): ... + def getConductivity(self) -> float: ... + def getCv(self) -> float: ... + def getDensity(self) -> float: ... + def getHeatTransferCoefficient(self) -> float: ... + def getInsideTemperature(self) -> float: ... + def getOutsideTemperature(self) -> float: ... + def getThickness(self) -> float: ... + def setConductivity(self, double: float) -> None: ... + def setCv(self, double: float) -> None: ... + def setDensity(self, double: float) -> None: ... + def setInsideTemperature(self, double: float) -> None: ... + def setOutsideTemperature(self, double: float) -> None: ... + def setThickness(self, double: float) -> None: ... + +class WallInterface: + def addMaterialLayer(self, materialLayer: MaterialLayer) -> None: ... + def getWallMaterialLayer(self, int: int) -> MaterialLayer: ... + +class Wall(WallInterface): + def __init__(self): ... + def addMaterialLayer(self, materialLayer: MaterialLayer) -> None: ... + def calcHeatTransferCoefficient(self) -> float: ... + def getHeatTransferCoefficient(self) -> float: ... + def getWallMaterialLayer(self, int: int) -> MaterialLayer: ... + def setHeatTransferCoefficient(self, double: float) -> None: ... + +class PipeWall(Wall): + def __init__(self): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.wall")``. + + MaterialLayer: typing.Type[MaterialLayer] + PipeWall: typing.Type[PipeWall] + Wall: typing.Type[Wall] + WallInterface: typing.Type[WallInterface] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/pipe/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/pipe/__init__.pyi new file mode 100644 index 00000000..e8af144e --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/pipe/__init__.pyi @@ -0,0 +1,26 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.geometrydefinitions +import typing + + + +class PipeData(jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinition): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + def clone(self) -> 'PipeData': ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.geometrydefinitions.pipe")``. + + PipeData: typing.Type[PipeData] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/reactor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/reactor/__init__.pyi new file mode 100644 index 00000000..765c65d4 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/reactor/__init__.pyi @@ -0,0 +1,35 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.fluidmechanics.geometrydefinitions +import typing + + + +class ReactorData(jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinition): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, int: int): ... + def clone(self) -> 'ReactorData': ... + @typing.overload + def setPackingType(self, int: int) -> None: ... + @typing.overload + def setPackingType(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setPackingType(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], int: int) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.geometrydefinitions.reactor")``. + + ReactorData: typing.Type[ReactorData] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/stirredcell/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/stirredcell/__init__.pyi new file mode 100644 index 00000000..4d6bd40b --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/stirredcell/__init__.pyi @@ -0,0 +1,26 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.geometrydefinitions +import typing + + + +class StirredCell(jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinition): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + def clone(self) -> 'StirredCell': ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.geometrydefinitions.stirredcell")``. + + StirredCell: typing.Type[StirredCell] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/surrounding/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/surrounding/__init__.pyi new file mode 100644 index 00000000..89200bd0 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/surrounding/__init__.pyi @@ -0,0 +1,38 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import typing + + + +class SurroundingEnvironment: + def getHeatTransferCoefficient(self) -> float: ... + def getTemperature(self) -> float: ... + def setHeatTransferCoefficient(self, double: float) -> None: ... + def setTemperature(self, double: float) -> None: ... + +class SurroundingEnvironmentBaseClass(SurroundingEnvironment): + def __init__(self): ... + def getHeatTransferCoefficient(self) -> float: ... + def getTemperature(self) -> float: ... + def setHeatTransferCoefficient(self, double: float) -> None: ... + def setTemperature(self, double: float) -> None: ... + +class PipeSurroundingEnvironment(SurroundingEnvironmentBaseClass): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.geometrydefinitions.surrounding")``. + + PipeSurroundingEnvironment: typing.Type[PipeSurroundingEnvironment] + SurroundingEnvironment: typing.Type[SurroundingEnvironment] + SurroundingEnvironmentBaseClass: typing.Type[SurroundingEnvironmentBaseClass] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/__init__.pyi new file mode 100644 index 00000000..537592a0 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/__init__.pyi @@ -0,0 +1,35 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization +import jneqsim.fluidmechanics.util.timeseries +import typing + + + +class FrictionFactorCalculator: + RE_LAMINAR_LIMIT: typing.ClassVar[float] = ... + RE_TURBULENT_LIMIT: typing.ClassVar[float] = ... + @staticmethod + def calcDarcyFrictionFactor(double: float, double2: float) -> float: ... + @staticmethod + def calcFanningFrictionFactor(double: float, double2: float) -> float: ... + @staticmethod + def calcHaalandFrictionFactor(double: float, double2: float) -> float: ... + @staticmethod + def calcPressureDropPerLength(double: float, double2: float, double3: float, double4: float) -> float: ... + @staticmethod + def getFlowRegime(double: float) -> java.lang.String: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.util")``. + + FrictionFactorCalculator: typing.Type[FrictionFactorCalculator] + fluidmechanicsvisualization: jneqsim.fluidmechanics.util.fluidmechanicsvisualization.__module_protocol__ + timeseries: jneqsim.fluidmechanics.util.timeseries.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/__init__.pyi new file mode 100644 index 00000000..4ab16300 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/__init__.pyi @@ -0,0 +1,17 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.util.fluidmechanicsvisualization")``. + + flownodevisualization: jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.__module_protocol__ + flowsystemvisualization: jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/__init__.pyi new file mode 100644 index 00000000..4eb052b8 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/__init__.pyi @@ -0,0 +1,74 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.onephaseflownodevisualization +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.twophaseflownodevisualization +import typing + + + +class FlowNodeVisualizationInterface: + def getBulkComposition(self, int: int, int2: int) -> float: ... + def getDistanceToCenterOfNode(self) -> float: ... + def getEffectiveMassTransferCoefficient(self, int: int, int2: int) -> float: ... + def getEffectiveSchmidtNumber(self, int: int, int2: int) -> float: ... + def getInterfaceComposition(self, int: int, int2: int) -> float: ... + def getInterfaceTemperature(self, int: int) -> float: ... + def getInterphaseContactLength(self) -> float: ... + def getMolarFlux(self, int: int, int2: int) -> float: ... + def getNumberOfComponents(self) -> int: ... + def getPhaseFraction(self, int: int) -> float: ... + def getPressure(self, int: int) -> float: ... + def getReynoldsNumber(self, int: int) -> float: ... + def getTemperature(self, int: int) -> float: ... + def getVelocity(self, int: int) -> float: ... + def getWallContactLength(self, int: int) -> float: ... + def setData(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> None: ... + +class FlowNodeVisualization(FlowNodeVisualizationInterface): + temperature: typing.MutableSequence[float] = ... + reynoldsNumber: typing.MutableSequence[float] = ... + interfaceTemperature: typing.MutableSequence[float] = ... + pressure: typing.MutableSequence[float] = ... + velocity: typing.MutableSequence[float] = ... + phaseFraction: typing.MutableSequence[float] = ... + wallContactLength: typing.MutableSequence[float] = ... + bulkComposition: typing.MutableSequence[typing.MutableSequence[float]] = ... + interfaceComposition: typing.MutableSequence[typing.MutableSequence[float]] = ... + effectiveMassTransferCoefficient: typing.MutableSequence[typing.MutableSequence[float]] = ... + effectiveSchmidtNumber: typing.MutableSequence[typing.MutableSequence[float]] = ... + molarFlux: typing.MutableSequence[typing.MutableSequence[float]] = ... + interphaseContactLength: float = ... + nodeCenter: float = ... + numberOfComponents: int = ... + def __init__(self): ... + def getBulkComposition(self, int: int, int2: int) -> float: ... + def getDistanceToCenterOfNode(self) -> float: ... + def getEffectiveMassTransferCoefficient(self, int: int, int2: int) -> float: ... + def getEffectiveSchmidtNumber(self, int: int, int2: int) -> float: ... + def getInterfaceComposition(self, int: int, int2: int) -> float: ... + def getInterfaceTemperature(self, int: int) -> float: ... + def getInterphaseContactLength(self) -> float: ... + def getMolarFlux(self, int: int, int2: int) -> float: ... + def getNumberOfComponents(self) -> int: ... + def getPhaseFraction(self, int: int) -> float: ... + def getPressure(self, int: int) -> float: ... + def getReynoldsNumber(self, int: int) -> float: ... + def getTemperature(self, int: int) -> float: ... + def getVelocity(self, int: int) -> float: ... + def getWallContactLength(self, int: int) -> float: ... + def setData(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization")``. + + FlowNodeVisualization: typing.Type[FlowNodeVisualization] + FlowNodeVisualizationInterface: typing.Type[FlowNodeVisualizationInterface] + onephaseflownodevisualization: jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.onephaseflownodevisualization.__module_protocol__ + twophaseflownodevisualization: jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.twophaseflownodevisualization.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/onephaseflownodevisualization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/onephaseflownodevisualization/__init__.pyi new file mode 100644 index 00000000..529b2ea9 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/onephaseflownodevisualization/__init__.pyi @@ -0,0 +1,22 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.onephaseflownodevisualization.onephasepipeflownodevisualization +import typing + + + +class OnePhaseFlowNodeVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.FlowNodeVisualization): + def __init__(self): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.onephaseflownodevisualization")``. + + OnePhaseFlowNodeVisualization: typing.Type[OnePhaseFlowNodeVisualization] + onephasepipeflownodevisualization: jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.onephaseflownodevisualization.onephasepipeflownodevisualization.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/onephaseflownodevisualization/onephasepipeflownodevisualization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/onephaseflownodevisualization/onephasepipeflownodevisualization/__init__.pyi new file mode 100644 index 00000000..22e3a21e --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/onephaseflownodevisualization/onephasepipeflownodevisualization/__init__.pyi @@ -0,0 +1,22 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.onephaseflownodevisualization +import typing + + + +class OnePhasePipeFlowNodeVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.onephaseflownodevisualization.OnePhaseFlowNodeVisualization): + def __init__(self): ... + def setData(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.onephaseflownodevisualization.onephasepipeflownodevisualization")``. + + OnePhasePipeFlowNodeVisualization: typing.Type[OnePhasePipeFlowNodeVisualization] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/twophaseflownodevisualization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/twophaseflownodevisualization/__init__.pyi new file mode 100644 index 00000000..89734b0d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/twophaseflownodevisualization/__init__.pyi @@ -0,0 +1,22 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.flownode +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization +import typing + + + +class TwoPhaseFlowNodeVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.FlowNodeVisualization): + def __init__(self): ... + def setData(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.twophaseflownodevisualization")``. + + TwoPhaseFlowNodeVisualization: typing.Type[TwoPhaseFlowNodeVisualization] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/__init__.pyi new file mode 100644 index 00000000..5fcd20b8 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/__init__.pyi @@ -0,0 +1,43 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.fluidmechanics.flowsystem +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.onephaseflowvisualization +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.twophaseflowvisualization +import typing + + + +class FlowSystemVisualizationInterface: + def displayResult(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setNextData(self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface) -> None: ... + @typing.overload + def setNextData(self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface, double: float) -> None: ... + def setPoints(self) -> None: ... + +class FlowSystemVisualization(FlowSystemVisualizationInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + def displayResult(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setNextData(self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface) -> None: ... + @typing.overload + def setNextData(self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface, double: float) -> None: ... + def setPoints(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization")``. + + FlowSystemVisualization: typing.Type[FlowSystemVisualization] + FlowSystemVisualizationInterface: typing.Type[FlowSystemVisualizationInterface] + onephaseflowvisualization: jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.onephaseflowvisualization.__module_protocol__ + twophaseflowvisualization: jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.twophaseflowvisualization.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/onephaseflowvisualization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/onephaseflowvisualization/__init__.pyi new file mode 100644 index 00000000..e8afd882 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/onephaseflowvisualization/__init__.pyi @@ -0,0 +1,25 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.onephaseflowvisualization.pipeflowvisualization +import typing + + + +class OnePhaseFlowVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.FlowSystemVisualization): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.onephaseflowvisualization")``. + + OnePhaseFlowVisualization: typing.Type[OnePhaseFlowVisualization] + pipeflowvisualization: jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.onephaseflowvisualization.pipeflowvisualization.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/onephaseflowvisualization/pipeflowvisualization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/onephaseflowvisualization/pipeflowvisualization/__init__.pyi new file mode 100644 index 00000000..620aa4af --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/onephaseflowvisualization/pipeflowvisualization/__init__.pyi @@ -0,0 +1,28 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.onephaseflowvisualization +import typing + + + +class PipeFlowVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.onephaseflowvisualization.OnePhaseFlowVisualization): + bulkComposition: typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[float]]] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + def calcPoints(self, string: typing.Union[java.lang.String, str]) -> None: ... + def displayResult(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPoints(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.onephaseflowvisualization.pipeflowvisualization")``. + + PipeFlowVisualization: typing.Type[PipeFlowVisualization] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/twophaseflowvisualization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/twophaseflowvisualization/__init__.pyi new file mode 100644 index 00000000..5af529e1 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/twophaseflowvisualization/__init__.pyi @@ -0,0 +1,25 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.twophaseflowvisualization.twophasepipeflowvisualization +import typing + + + +class TwoPhaseFlowVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.FlowSystemVisualization): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.twophaseflowvisualization")``. + + TwoPhaseFlowVisualization: typing.Type[TwoPhaseFlowVisualization] + twophasepipeflowvisualization: jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.twophaseflowvisualization.twophasepipeflowvisualization.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/twophaseflowvisualization/twophasepipeflowvisualization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/twophaseflowvisualization/twophasepipeflowvisualization/__init__.pyi new file mode 100644 index 00000000..73b872c6 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/twophaseflowvisualization/twophasepipeflowvisualization/__init__.pyi @@ -0,0 +1,33 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.twophaseflowvisualization +import typing + + + +class TwoPhasePipeFlowVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.twophaseflowvisualization.TwoPhaseFlowVisualization): + bulkComposition: typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[float]]]] = ... + interfaceComposition: typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[float]]]] = ... + effectiveMassTransferCoefficient: typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[float]]]] = ... + molarFlux: typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[float]]]] = ... + schmidtNumber: typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[float]]]] = ... + totalMolarMassTransferRate: typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[float]]]] = ... + totalVolumetricMassTransferRate: typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[float]]]] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + def displayResult(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPoints(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.twophaseflowvisualization.twophasepipeflowvisualization")``. + + TwoPhasePipeFlowVisualization: typing.Type[TwoPhasePipeFlowVisualization] diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/timeseries/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/timeseries/__init__.pyi new file mode 100644 index 00000000..d8f5f76d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/timeseries/__init__.pyi @@ -0,0 +1,35 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.io +import jpype +import jneqsim.fluidmechanics.flowsystem +import jneqsim.thermo.system +import typing + + + +class TimeSeries(java.io.Serializable): + def __init__(self): ... + def getOutletMolarFlowRates(self) -> typing.MutableSequence[float]: ... + def getThermoSystem(self) -> typing.MutableSequence[jneqsim.thermo.system.SystemInterface]: ... + @typing.overload + def getTime(self, int: int) -> float: ... + @typing.overload + def getTime(self) -> typing.MutableSequence[float]: ... + def getTimeStep(self) -> typing.MutableSequence[float]: ... + def init(self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface) -> None: ... + def setInletThermoSystems(self, systemInterfaceArray: typing.Union[typing.List[jneqsim.thermo.system.SystemInterface], jpype.JArray]) -> None: ... + def setNumberOfTimeStepsInInterval(self, int: int) -> None: ... + def setOutletMolarFlowRate(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setTimes(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.util.timeseries")``. + + TimeSeries: typing.Type[TimeSeries] diff --git a/src/jneqsim-stubs/jneqsim-stubs/mathlib/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/mathlib/__init__.pyi new file mode 100644 index 00000000..1268c6e8 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/mathlib/__init__.pyi @@ -0,0 +1,17 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.mathlib.generalmath +import jneqsim.mathlib.nonlinearsolver +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.mathlib")``. + + generalmath: jneqsim.mathlib.generalmath.__module_protocol__ + nonlinearsolver: jneqsim.mathlib.nonlinearsolver.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/mathlib/generalmath/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/mathlib/generalmath/__init__.pyi new file mode 100644 index 00000000..cf8aaf86 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/mathlib/generalmath/__init__.pyi @@ -0,0 +1,21 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jpype +import typing + + + +class TDMAsolve: + @staticmethod + def solve(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]) -> typing.MutableSequence[float]: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.mathlib.generalmath")``. + + TDMAsolve: typing.Type[TDMAsolve] diff --git a/src/jneqsim-stubs/jneqsim-stubs/mathlib/nonlinearsolver/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/mathlib/nonlinearsolver/__init__.pyi new file mode 100644 index 00000000..dbd97c1d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/mathlib/nonlinearsolver/__init__.pyi @@ -0,0 +1,66 @@ + +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 jpype +import jneqsim.thermo.component +import jneqsim.thermo.phase +import jneqsim.thermo.system +import typing + + + +class NewtonRhapson(java.io.Serializable): + def __init__(self): ... + def derivValue(self, double: float) -> float: ... + def dubDerivValue(self, double: float) -> float: ... + def funkValue(self, double: float) -> float: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def setConstants(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setMaxIterations(self, int: int) -> None: ... + def setOrder(self, int: int) -> None: ... + def solve(self, double: float) -> float: ... + def solve1order(self, double: float) -> float: ... + +class NumericalDerivative(java.io.Serializable): + @staticmethod + def fugcoefDiffPres(componentInterface: jneqsim.thermo.component.ComponentInterface, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + @staticmethod + def fugcoefDiffTemp(componentInterface: jneqsim.thermo.component.ComponentInterface, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + +class NumericalIntegration: + def __init__(self): ... + +class SysNewtonRhapson(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int, int2: int): ... + def calcInc(self, int: int) -> None: ... + def calcInc2(self, int: int) -> None: ... + def findSpecEq(self) -> None: ... + def findSpecEqInit(self) -> None: ... + def getNpCrit(self) -> int: ... + def init(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def setJac(self) -> None: ... + def setfvec(self) -> None: ... + def setu(self) -> None: ... + def sign(self, double: float, double2: float) -> float: ... + def solve(self, int: int) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.mathlib.nonlinearsolver")``. + + NewtonRhapson: typing.Type[NewtonRhapson] + NumericalDerivative: typing.Type[NumericalDerivative] + NumericalIntegration: typing.Type[NumericalIntegration] + SysNewtonRhapson: typing.Type[SysNewtonRhapson] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/__init__.pyi new file mode 100644 index 00000000..833ca43a --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/__init__.pyi @@ -0,0 +1,52 @@ + +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 jneqsim.physicalproperties.interfaceproperties +import jneqsim.physicalproperties.methods +import jneqsim.physicalproperties.mixingrule +import jneqsim.physicalproperties.system +import jneqsim.physicalproperties.util +import jneqsim.thermo.phase +import typing + + + +class PhysicalPropertyHandler(java.lang.Cloneable, java.io.Serializable): + def __init__(self): ... + def clone(self) -> 'PhysicalPropertyHandler': ... + def getPhysicalProperties(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> jneqsim.physicalproperties.system.PhysicalProperties: ... + def setPhysicalProperties(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, physicalPropertyModel: jneqsim.physicalproperties.system.PhysicalPropertyModel) -> None: ... + +class PhysicalPropertyType(java.lang.Enum['PhysicalPropertyType']): + MASS_DENSITY: typing.ClassVar['PhysicalPropertyType'] = ... + DYNAMIC_VISCOSITY: typing.ClassVar['PhysicalPropertyType'] = ... + THERMAL_CONDUCTIVITY: typing.ClassVar['PhysicalPropertyType'] = ... + @staticmethod + def byName(string: typing.Union[java.lang.String, str]) -> 'PhysicalPropertyType': ... + _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]) -> 'PhysicalPropertyType': ... + @staticmethod + def values() -> typing.MutableSequence['PhysicalPropertyType']: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties")``. + + PhysicalPropertyHandler: typing.Type[PhysicalPropertyHandler] + PhysicalPropertyType: typing.Type[PhysicalPropertyType] + interfaceproperties: jneqsim.physicalproperties.interfaceproperties.__module_protocol__ + methods: jneqsim.physicalproperties.methods.__module_protocol__ + mixingrule: jneqsim.physicalproperties.mixingrule.__module_protocol__ + system: jneqsim.physicalproperties.system.__module_protocol__ + util: jneqsim.physicalproperties.util.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/__init__.pyi new file mode 100644 index 00000000..31339608 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/__init__.pyi @@ -0,0 +1,79 @@ + +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 jpype +import jneqsim.physicalproperties.interfaceproperties.solidadsorption +import jneqsim.physicalproperties.interfaceproperties.surfacetension +import jneqsim.thermo.system +import typing + + + +class InterphasePropertiesInterface(java.lang.Cloneable): + def calcAdsorption(self) -> None: ... + def clone(self) -> 'InterphasePropertiesInterface': ... + @typing.overload + def getAdsorptionCalc(self, string: typing.Union[java.lang.String, str]) -> jneqsim.physicalproperties.interfaceproperties.solidadsorption.AdsorptionInterface: ... + @typing.overload + def getAdsorptionCalc(self) -> typing.MutableSequence[jneqsim.physicalproperties.interfaceproperties.solidadsorption.AdsorptionInterface]: ... + def getInterfacialTensionModel(self) -> int: ... + @typing.overload + def getSurfaceTension(self, int: int, int2: int) -> float: ... + @typing.overload + def getSurfaceTension(self, int: int, int2: int, string: typing.Union[java.lang.String, str]) -> float: ... + def getSurfaceTensionModel(self, int: int) -> jneqsim.physicalproperties.interfaceproperties.surfacetension.SurfaceTensionInterface: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def initAdsorption(self) -> None: ... + def setAdsorptionCalc(self, adsorptionInterfaceArray: typing.Union[typing.List[jneqsim.physicalproperties.interfaceproperties.solidadsorption.AdsorptionInterface], jpype.JArray]) -> None: ... + @typing.overload + def setInterfacialTensionModel(self, int: int) -> None: ... + @typing.overload + def setInterfacialTensionModel(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]) -> None: ... + def setSolidAdsorbentMaterial(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class InterfaceProperties(InterphasePropertiesInterface, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcAdsorption(self) -> None: ... + def clone(self) -> 'InterfaceProperties': ... + @typing.overload + def getAdsorptionCalc(self, string: typing.Union[java.lang.String, str]) -> jneqsim.physicalproperties.interfaceproperties.solidadsorption.AdsorptionInterface: ... + @typing.overload + def getAdsorptionCalc(self) -> typing.MutableSequence[jneqsim.physicalproperties.interfaceproperties.solidadsorption.AdsorptionInterface]: ... + def getInterfacialTensionModel(self) -> int: ... + @typing.overload + def getSurfaceTension(self, int: int, int2: int) -> float: ... + @typing.overload + def getSurfaceTension(self, int: int, int2: int, string: typing.Union[java.lang.String, str]) -> float: ... + def getSurfaceTensionModel(self, int: int) -> jneqsim.physicalproperties.interfaceproperties.surfacetension.SurfaceTensionInterface: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def initAdsorption(self) -> None: ... + def setAdsorptionCalc(self, adsorptionInterfaceArray: typing.Union[typing.List[jneqsim.physicalproperties.interfaceproperties.solidadsorption.AdsorptionInterface], jpype.JArray]) -> None: ... + @typing.overload + def setInterfacialTensionModel(self, int: int) -> None: ... + @typing.overload + def setInterfacialTensionModel(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]) -> None: ... + def setSolidAdsorbentMaterial(self, string: typing.Union[java.lang.String, str]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.interfaceproperties")``. + + InterfaceProperties: typing.Type[InterfaceProperties] + InterphasePropertiesInterface: typing.Type[InterphasePropertiesInterface] + solidadsorption: jneqsim.physicalproperties.interfaceproperties.solidadsorption.__module_protocol__ + surfacetension: jneqsim.physicalproperties.interfaceproperties.surfacetension.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/solidadsorption/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/solidadsorption/__init__.pyi new file mode 100644 index 00000000..9a0dc8d8 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/solidadsorption/__init__.pyi @@ -0,0 +1,41 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.thermo +import jneqsim.thermo.system +import typing + + + +class AdsorptionInterface(jneqsim.thermo.ThermodynamicConstantsInterface): + def calcAdsorption(self, int: int) -> None: ... + @typing.overload + def getSurfaceExcess(self, int: int) -> float: ... + @typing.overload + def getSurfaceExcess(self, string: typing.Union[java.lang.String, str]) -> float: ... + def setSolidMaterial(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class PotentialTheoryAdsorption(AdsorptionInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcAdsorption(self, int: int) -> None: ... + @typing.overload + def getSurfaceExcess(self, int: int) -> float: ... + @typing.overload + def getSurfaceExcess(self, string: typing.Union[java.lang.String, str]) -> float: ... + def readDBParameters(self) -> None: ... + def setSolidMaterial(self, string: typing.Union[java.lang.String, str]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.interfaceproperties.solidadsorption")``. + + AdsorptionInterface: typing.Type[AdsorptionInterface] + PotentialTheoryAdsorption: typing.Type[PotentialTheoryAdsorption] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/surfacetension/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/surfacetension/__init__.pyi new file mode 100644 index 00000000..d9d0043f --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/surfacetension/__init__.pyi @@ -0,0 +1,132 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jpype +import jneqsim.physicalproperties.interfaceproperties +import jneqsim.thermo.system +import org.apache.commons.math3.ode +import typing + + + +class GTSurfaceTensionFullGT: + normtol: float = ... + reltol: float = ... + abstol: float = ... + maxit: int = ... + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int, int2: int): ... + @staticmethod + def Newton(doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], double2: float, int: int, double3: float, boolean: bool, boolean2: bool, doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], systemInterface: jneqsim.thermo.system.SystemInterface, int2: int, double5: float, doubleArray3: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + def calc_std_integral(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> float: ... + @staticmethod + def debugPlot(doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @staticmethod + def delta_mu(systemInterface: jneqsim.thermo.system.SystemInterface, int: int, double: 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], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @staticmethod + def directsolve(doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[typing.MutableSequence[float]]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], double4: float, int: int, doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], int2: int) -> None: ... + @staticmethod + def initmu(systemInterface: jneqsim.thermo.system.SystemInterface, int: int, double: 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], doubleArray4: typing.Union[typing.List[float], jpype.JArray], double6: float) -> None: ... + @staticmethod + def linspace(double: float, double2: float, int: int) -> typing.MutableSequence[float]: ... + def runcase(self) -> float: ... + @staticmethod + def sigmaCalc(double: float, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], boolean: bool, doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], int: int) -> float: ... + +class GTSurfaceTensionODE(org.apache.commons.math3.ode.FirstOrderDifferentialEquations): + normtol: float = ... + reltol: float = ... + abstol: float = ... + maxit: int = ... + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int, int2: int, int3: int, double: float): ... + def computeDerivatives(self, double: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def fjacfun(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[float], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def getDimension(self) -> int: ... + def initmu(self) -> None: ... + +class GTSurfaceTensionUtils: + @staticmethod + def mufun(systemInterface: jneqsim.thermo.system.SystemInterface, int: int, double: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class SurfaceTensionInterface: + def calcSurfaceTension(self, int: int, int2: int) -> float: ... + +class SurfaceTension(jneqsim.physicalproperties.interfaceproperties.InterfaceProperties, SurfaceTensionInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcPureComponentSurfaceTension(self, int: int) -> float: ... + def calcSurfaceTension(self, int: int, int2: int) -> float: ... + def getComponentWithHighestBoilingpoint(self) -> int: ... + +class FirozabadiRamleyInterfaceTension(SurfaceTension): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcPureComponentSurfaceTension(self, int: int) -> float: ... + def calcSurfaceTension(self, int: int, int2: int) -> float: ... + +class GTSurfaceTension(SurfaceTension): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcSurfaceTension(self, int: int, int2: int) -> float: ... + @staticmethod + def solveFullDensityProfile(systemInterface: jneqsim.thermo.system.SystemInterface, int: int, int2: int) -> float: ... + @staticmethod + def solveWithRefcomp(systemInterface: jneqsim.thermo.system.SystemInterface, int: int, int2: int, int3: int) -> float: ... + +class GTSurfaceTensionSimple(SurfaceTension): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcInfluenceParameters(self) -> None: ... + def calcSurfaceTension(self, int: int, int2: int) -> float: ... + def getDmudn2(self) -> typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[float]]]: ... + def getInfluenceParameter(self, double: float, int: int) -> float: ... + def getMolarDensity(self, int: int) -> typing.MutableSequence[float]: ... + def getMolarDensityTotal(self) -> typing.MutableSequence[float]: ... + def getPressure(self) -> typing.MutableSequence[float]: ... + def getz(self) -> typing.MutableSequence[float]: ... + def setDmudn2(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[typing.MutableSequence[float]]], jpype.JArray]) -> None: ... + +class LGTSurfaceTension(SurfaceTension): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcSurfaceTension(self, int: int, int2: int) -> float: ... + def getMolarDensity(self, int: int) -> typing.MutableSequence[float]: ... + def getMolarDensityTotal(self) -> typing.MutableSequence[float]: ... + def getPressure(self) -> typing.MutableSequence[float]: ... + def getz(self) -> typing.MutableSequence[float]: ... + +class ParachorSurfaceTension(SurfaceTension): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcPureComponentSurfaceTension(self, int: int) -> float: ... + def calcSurfaceTension(self, int: int, int2: int) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.interfaceproperties.surfacetension")``. + + FirozabadiRamleyInterfaceTension: typing.Type[FirozabadiRamleyInterfaceTension] + GTSurfaceTension: typing.Type[GTSurfaceTension] + GTSurfaceTensionFullGT: typing.Type[GTSurfaceTensionFullGT] + GTSurfaceTensionODE: typing.Type[GTSurfaceTensionODE] + GTSurfaceTensionSimple: typing.Type[GTSurfaceTensionSimple] + GTSurfaceTensionUtils: typing.Type[GTSurfaceTensionUtils] + LGTSurfaceTension: typing.Type[LGTSurfaceTension] + ParachorSurfaceTension: typing.Type[ParachorSurfaceTension] + SurfaceTension: typing.Type[SurfaceTension] + SurfaceTensionInterface: typing.Type[SurfaceTensionInterface] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/__init__.pyi new file mode 100644 index 00000000..68b6c72c --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/__init__.pyi @@ -0,0 +1,40 @@ + +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 jneqsim.physicalproperties.methods.commonphasephysicalproperties +import jneqsim.physicalproperties.methods.gasphysicalproperties +import jneqsim.physicalproperties.methods.liquidphysicalproperties +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.methods.solidphysicalproperties +import jneqsim.physicalproperties.system +import typing + + + +class PhysicalPropertyMethodInterface(java.lang.Cloneable, java.io.Serializable): + def clone(self) -> 'PhysicalPropertyMethodInterface': ... + def setPhase(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties) -> None: ... + def tuneModel(self, double: float, double2: float, double3: float) -> None: ... + +class PhysicalPropertyMethod(PhysicalPropertyMethodInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def clone(self) -> 'PhysicalPropertyMethod': ... + def tuneModel(self, double: float, double2: float, double3: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods")``. + + PhysicalPropertyMethod: typing.Type[PhysicalPropertyMethod] + PhysicalPropertyMethodInterface: typing.Type[PhysicalPropertyMethodInterface] + commonphasephysicalproperties: jneqsim.physicalproperties.methods.commonphasephysicalproperties.__module_protocol__ + gasphysicalproperties: jneqsim.physicalproperties.methods.gasphysicalproperties.__module_protocol__ + liquidphysicalproperties: jneqsim.physicalproperties.methods.liquidphysicalproperties.__module_protocol__ + methodinterface: jneqsim.physicalproperties.methods.methodinterface.__module_protocol__ + solidphysicalproperties: jneqsim.physicalproperties.methods.solidphysicalproperties.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/__init__.pyi new file mode 100644 index 00000000..535a6cfe --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/__init__.pyi @@ -0,0 +1,28 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods +import jneqsim.physicalproperties.methods.commonphasephysicalproperties.conductivity +import jneqsim.physicalproperties.methods.commonphasephysicalproperties.diffusivity +import jneqsim.physicalproperties.methods.commonphasephysicalproperties.viscosity +import jneqsim.physicalproperties.system +import typing + + + +class CommonPhysicalPropertyMethod(jneqsim.physicalproperties.methods.PhysicalPropertyMethod): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def setPhase(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.commonphasephysicalproperties")``. + + CommonPhysicalPropertyMethod: typing.Type[CommonPhysicalPropertyMethod] + conductivity: jneqsim.physicalproperties.methods.commonphasephysicalproperties.conductivity.__module_protocol__ + diffusivity: jneqsim.physicalproperties.methods.commonphasephysicalproperties.diffusivity.__module_protocol__ + viscosity: jneqsim.physicalproperties.methods.commonphasephysicalproperties.viscosity.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/conductivity/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/conductivity/__init__.pyi new file mode 100644 index 00000000..5bbc5bd6 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/conductivity/__init__.pyi @@ -0,0 +1,38 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods.commonphasephysicalproperties +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.system +import jneqsim.thermo.system +import typing + + + +class Conductivity(jneqsim.physicalproperties.methods.commonphasephysicalproperties.CommonPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.ConductivityInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def clone(self) -> 'Conductivity': ... + +class CO2ConductivityMethod(Conductivity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcConductivity(self) -> float: ... + +class PFCTConductivityMethodMod86(Conductivity): + referenceSystem: typing.ClassVar[jneqsim.thermo.system.SystemInterface] = ... + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcConductivity(self) -> float: ... + def calcMixLPViscosity(self) -> float: ... + def getRefComponentConductivity(self, double: float, double2: float) -> float: ... + def getRefComponentViscosity(self, double: float, double2: float) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.commonphasephysicalproperties.conductivity")``. + + CO2ConductivityMethod: typing.Type[CO2ConductivityMethod] + Conductivity: typing.Type[Conductivity] + PFCTConductivityMethodMod86: typing.Type[PFCTConductivityMethodMod86] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/diffusivity/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/diffusivity/__init__.pyi new file mode 100644 index 00000000..68d90647 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/diffusivity/__init__.pyi @@ -0,0 +1,34 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods.commonphasephysicalproperties +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.system +import typing + + + +class Diffusivity(jneqsim.physicalproperties.methods.commonphasephysicalproperties.CommonPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.DiffusivityInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcBinaryDiffusionCoefficient(self, int: int, int2: int, int3: int) -> float: ... + def calcDiffusionCoefficients(self, int: int, int2: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def calcEffectiveDiffusionCoefficients(self) -> None: ... + def clone(self) -> 'Diffusivity': ... + def getEffectiveDiffusionCoefficient(self, int: int) -> float: ... + def getFickBinaryDiffusionCoefficient(self, int: int, int2: int) -> float: ... + def getMaxwellStefanBinaryDiffusionCoefficient(self, int: int, int2: int) -> float: ... + +class CorrespondingStatesDiffusivity(Diffusivity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcBinaryDiffusionCoefficient(self, int: int, int2: int, int3: int) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.commonphasephysicalproperties.diffusivity")``. + + CorrespondingStatesDiffusivity: typing.Type[CorrespondingStatesDiffusivity] + Diffusivity: typing.Type[Diffusivity] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/viscosity/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/viscosity/__init__.pyi new file mode 100644 index 00000000..247793e7 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/viscosity/__init__.pyi @@ -0,0 +1,105 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jpype +import jneqsim.physicalproperties.methods.commonphasephysicalproperties +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.system +import jneqsim.thermo +import typing + + + +class Viscosity(jneqsim.physicalproperties.methods.commonphasephysicalproperties.CommonPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.ViscosityInterface): + pureComponentViscosity: typing.MutableSequence[float] = ... + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcPureComponentViscosity(self) -> None: ... + def clone(self) -> 'Viscosity': ... + def getPureComponentViscosity(self, int: int) -> float: ... + def getViscosityPressureCorrection(self, int: int) -> float: ... + +class CO2ViscosityMethod(Viscosity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + +class FrictionTheoryViscosityMethod(Viscosity, jneqsim.thermo.ThermodynamicConstantsInterface): + pureComponentViscosity: typing.MutableSequence[float] = ... + Fc: typing.MutableSequence[float] = ... + omegaVisc: typing.MutableSequence[float] = ... + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + def getPureComponentViscosity(self, int: int) -> float: ... + def getRedKapa(self, double: float, double2: float) -> float: ... + def getRedKapr(self, double: float, double2: float) -> float: ... + def getRedKaprr(self, double: float, double2: float) -> float: ... + def getTBPviscosityCorrection(self) -> float: ... + def initChungPureComponentViscosity(self) -> None: ... + def setFrictionTheoryConstants(self, double: float, double2: float, double3: float, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], double6: float) -> None: ... + def setTBPviscosityCorrection(self, double: float) -> None: ... + def tuneModel(self, double: float, double2: float, double3: float) -> None: ... + +class KTAViscosityMethod(Viscosity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + +class KTAViscosityMethodMod(Viscosity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + +class LBCViscosityMethod(Viscosity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + def clone(self) -> 'LBCViscosityMethod': ... + def getDenseContributionParameters(self) -> typing.MutableSequence[float]: ... + def getPureComponentViscosity(self, int: int) -> float: ... + def setDenseContributionParameter(self, int: int, double: float) -> None: ... + def setDenseContributionParameters(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class MethaneViscosityMethod(Viscosity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + +class MuznyModViscosityMethod(Viscosity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + +class MuznyViscosityMethod(Viscosity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + +class PFCTViscosityMethod(Viscosity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + def getPureComponentViscosity(self, int: int) -> float: ... + def getRefComponentViscosity(self, double: float, double2: float) -> float: ... + +class PFCTViscosityMethodHeavyOil(Viscosity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + def getRefComponentViscosity(self, double: float, double2: float) -> float: ... + +class PFCTViscosityMethodMod86(Viscosity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + def getRefComponentViscosity(self, double: float, double2: float) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.commonphasephysicalproperties.viscosity")``. + + CO2ViscosityMethod: typing.Type[CO2ViscosityMethod] + FrictionTheoryViscosityMethod: typing.Type[FrictionTheoryViscosityMethod] + KTAViscosityMethod: typing.Type[KTAViscosityMethod] + KTAViscosityMethodMod: typing.Type[KTAViscosityMethodMod] + LBCViscosityMethod: typing.Type[LBCViscosityMethod] + MethaneViscosityMethod: typing.Type[MethaneViscosityMethod] + MuznyModViscosityMethod: typing.Type[MuznyModViscosityMethod] + MuznyViscosityMethod: typing.Type[MuznyViscosityMethod] + PFCTViscosityMethod: typing.Type[PFCTViscosityMethod] + PFCTViscosityMethodHeavyOil: typing.Type[PFCTViscosityMethodHeavyOil] + PFCTViscosityMethodMod86: typing.Type[PFCTViscosityMethodMod86] + Viscosity: typing.Type[Viscosity] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/__init__.pyi new file mode 100644 index 00000000..3d5a53ad --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/__init__.pyi @@ -0,0 +1,33 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods +import jneqsim.physicalproperties.methods.gasphysicalproperties.conductivity +import jneqsim.physicalproperties.methods.gasphysicalproperties.density +import jneqsim.physicalproperties.methods.gasphysicalproperties.diffusivity +import jneqsim.physicalproperties.methods.gasphysicalproperties.viscosity +import jneqsim.physicalproperties.system +import typing + + + +class GasPhysicalPropertyMethod(jneqsim.physicalproperties.methods.PhysicalPropertyMethod): + binaryMolecularDiameter: typing.MutableSequence[typing.MutableSequence[float]] = ... + binaryEnergyParameter: typing.MutableSequence[typing.MutableSequence[float]] = ... + binaryMolecularMass: typing.MutableSequence[typing.MutableSequence[float]] = ... + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def setPhase(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.gasphysicalproperties")``. + + GasPhysicalPropertyMethod: typing.Type[GasPhysicalPropertyMethod] + conductivity: jneqsim.physicalproperties.methods.gasphysicalproperties.conductivity.__module_protocol__ + density: jneqsim.physicalproperties.methods.gasphysicalproperties.density.__module_protocol__ + diffusivity: jneqsim.physicalproperties.methods.gasphysicalproperties.diffusivity.__module_protocol__ + viscosity: jneqsim.physicalproperties.methods.gasphysicalproperties.viscosity.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/conductivity/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/conductivity/__init__.pyi new file mode 100644 index 00000000..1dceae9a --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/conductivity/__init__.pyi @@ -0,0 +1,30 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods.gasphysicalproperties +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.system +import typing + + + +class Conductivity(jneqsim.physicalproperties.methods.gasphysicalproperties.GasPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.ConductivityInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def clone(self) -> 'Conductivity': ... + +class ChungConductivityMethod(Conductivity): + pureComponentConductivity: typing.MutableSequence[float] = ... + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcConductivity(self) -> float: ... + def calcPureComponentConductivity(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.gasphysicalproperties.conductivity")``. + + ChungConductivityMethod: typing.Type[ChungConductivityMethod] + Conductivity: typing.Type[Conductivity] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/density/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/density/__init__.pyi new file mode 100644 index 00000000..4aba4d2e --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/density/__init__.pyi @@ -0,0 +1,24 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods.gasphysicalproperties +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.system +import typing + + + +class Density(jneqsim.physicalproperties.methods.gasphysicalproperties.GasPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.DensityInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcDensity(self) -> float: ... + def clone(self) -> 'Density': ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.gasphysicalproperties.density")``. + + Density: typing.Type[Density] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/diffusivity/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/diffusivity/__init__.pyi new file mode 100644 index 00000000..ab001405 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/diffusivity/__init__.pyi @@ -0,0 +1,34 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods.gasphysicalproperties +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.system +import typing + + + +class Diffusivity(jneqsim.physicalproperties.methods.gasphysicalproperties.GasPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.DiffusivityInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcBinaryDiffusionCoefficient(self, int: int, int2: int, int3: int) -> float: ... + def calcDiffusionCoefficients(self, int: int, int2: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def calcEffectiveDiffusionCoefficients(self) -> None: ... + def clone(self) -> 'Diffusivity': ... + def getEffectiveDiffusionCoefficient(self, int: int) -> float: ... + def getFickBinaryDiffusionCoefficient(self, int: int, int2: int) -> float: ... + def getMaxwellStefanBinaryDiffusionCoefficient(self, int: int, int2: int) -> float: ... + +class WilkeLeeDiffusivity(Diffusivity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcBinaryDiffusionCoefficient(self, int: int, int2: int, int3: int) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.gasphysicalproperties.diffusivity")``. + + Diffusivity: typing.Type[Diffusivity] + WilkeLeeDiffusivity: typing.Type[WilkeLeeDiffusivity] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/viscosity/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/viscosity/__init__.pyi new file mode 100644 index 00000000..3f8a06f9 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/viscosity/__init__.pyi @@ -0,0 +1,34 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods.gasphysicalproperties +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.system +import typing + + + +class Viscosity(jneqsim.physicalproperties.methods.gasphysicalproperties.GasPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.ViscosityInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def clone(self) -> 'Viscosity': ... + +class ChungViscosityMethod(Viscosity): + pureComponentViscosity: typing.MutableSequence[float] = ... + relativeViscosity: typing.MutableSequence[float] = ... + Fc: typing.MutableSequence[float] = ... + omegaVisc: typing.MutableSequence[float] = ... + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + def getPureComponentViscosity(self, int: int) -> float: ... + def initChungPureComponentViscosity(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.gasphysicalproperties.viscosity")``. + + ChungViscosityMethod: typing.Type[ChungViscosityMethod] + Viscosity: typing.Type[Viscosity] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/__init__.pyi new file mode 100644 index 00000000..a6846849 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/__init__.pyi @@ -0,0 +1,30 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods +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.system +import typing + + + +class LiquidPhysicalPropertyMethod(jneqsim.physicalproperties.methods.PhysicalPropertyMethod): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def setPhase(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.liquidphysicalproperties")``. + + LiquidPhysicalPropertyMethod: typing.Type[LiquidPhysicalPropertyMethod] + conductivity: jneqsim.physicalproperties.methods.liquidphysicalproperties.conductivity.__module_protocol__ + density: jneqsim.physicalproperties.methods.liquidphysicalproperties.density.__module_protocol__ + diffusivity: jneqsim.physicalproperties.methods.liquidphysicalproperties.diffusivity.__module_protocol__ + viscosity: jneqsim.physicalproperties.methods.liquidphysicalproperties.viscosity.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/conductivity/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/conductivity/__init__.pyi new file mode 100644 index 00000000..62fc06f7 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/conductivity/__init__.pyi @@ -0,0 +1,26 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods.liquidphysicalproperties +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.system +import typing + + + +class Conductivity(jneqsim.physicalproperties.methods.liquidphysicalproperties.LiquidPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.ConductivityInterface): + pureComponentConductivity: typing.MutableSequence[float] = ... + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcConductivity(self) -> float: ... + def calcPureComponentConductivity(self) -> None: ... + def clone(self) -> 'Conductivity': ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.liquidphysicalproperties.conductivity")``. + + Conductivity: typing.Type[Conductivity] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/density/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/density/__init__.pyi new file mode 100644 index 00000000..bd085daf --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/density/__init__.pyi @@ -0,0 +1,38 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods.liquidphysicalproperties +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.system +import typing + + + +class Costald(jneqsim.physicalproperties.methods.liquidphysicalproperties.LiquidPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.DensityInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcDensity(self) -> float: ... + def clone(self) -> 'Costald': ... + +class Density(jneqsim.physicalproperties.methods.liquidphysicalproperties.LiquidPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.DensityInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcDensity(self) -> float: ... + def clone(self) -> 'Density': ... + +class Water(jneqsim.physicalproperties.methods.liquidphysicalproperties.LiquidPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.DensityInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcDensity(self) -> float: ... + @staticmethod + def calculatePureWaterDensity(double: float, double2: float) -> float: ... + def clone(self) -> 'Water': ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.liquidphysicalproperties.density")``. + + Costald: typing.Type[Costald] + Density: typing.Type[Density] + Water: typing.Type[Water] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/diffusivity/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/diffusivity/__init__.pyi new file mode 100644 index 00000000..2abd9ce2 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/diffusivity/__init__.pyi @@ -0,0 +1,38 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import neqsim +import jneqsim.physicalproperties.system +import typing + + + +class AmineDiffusivity(jneqsim.physicalproperties.methods.liquidphysicalproperties.diffusivity.SiddiqiLucasMethod): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcBinaryDiffusionCoefficient(self, int: int, int2: int, int3: int) -> float: ... + def calcDiffusionCoefficients(self, int: int, int2: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def calcEffectiveDiffusionCoefficients(self) -> None: ... + +class CO2water(jneqsim.physicalproperties.methods.liquidphysicalproperties.diffusivity.Diffusivity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcBinaryDiffusionCoefficient(self, int: int, int2: int, int3: int) -> float: ... + +class SiddiqiLucasMethod(jneqsim.physicalproperties.methods.liquidphysicalproperties.diffusivity.Diffusivity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcBinaryDiffusionCoefficient(self, int: int, int2: int, int3: int) -> float: ... + def calcBinaryDiffusionCoefficient2(self, int: int, int2: int, int3: int) -> float: ... + +class Diffusivity: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.liquidphysicalproperties.diffusivity")``. + + AmineDiffusivity: typing.Type[AmineDiffusivity] + CO2water: typing.Type[CO2water] + Diffusivity: typing.Type[Diffusivity] + SiddiqiLucasMethod: typing.Type[SiddiqiLucasMethod] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/viscosity/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/viscosity/__init__.pyi new file mode 100644 index 00000000..20b5c21b --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/viscosity/__init__.pyi @@ -0,0 +1,39 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods.liquidphysicalproperties +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.system +import typing + + + +class Viscosity(jneqsim.physicalproperties.methods.liquidphysicalproperties.LiquidPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.ViscosityInterface): + pureComponentViscosity: typing.MutableSequence[float] = ... + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcPureComponentViscosity(self) -> None: ... + def calcViscosity(self) -> float: ... + def clone(self) -> 'Viscosity': ... + def getPureComponentViscosity(self, int: int) -> float: ... + def getViscosityPressureCorrection(self, int: int) -> float: ... + +class AmineViscosity(Viscosity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + +class Water(Viscosity): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcViscosity(self) -> float: ... + def clone(self) -> 'Water': ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.liquidphysicalproperties.viscosity")``. + + AmineViscosity: typing.Type[AmineViscosity] + Viscosity: typing.Type[Viscosity] + Water: typing.Type[Water] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/methodinterface/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/methodinterface/__init__.pyi new file mode 100644 index 00000000..6e22bfa4 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/methodinterface/__init__.pyi @@ -0,0 +1,43 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods +import jneqsim.thermo +import typing + + + +class ConductivityInterface(jneqsim.thermo.ThermodynamicConstantsInterface, jneqsim.physicalproperties.methods.PhysicalPropertyMethodInterface): + def calcConductivity(self) -> float: ... + def clone(self) -> 'ConductivityInterface': ... + +class DensityInterface(jneqsim.thermo.ThermodynamicConstantsInterface, jneqsim.physicalproperties.methods.PhysicalPropertyMethodInterface): + def calcDensity(self) -> float: ... + def clone(self) -> 'DensityInterface': ... + +class DiffusivityInterface(jneqsim.thermo.ThermodynamicConstantsInterface, jneqsim.physicalproperties.methods.PhysicalPropertyMethodInterface): + def calcBinaryDiffusionCoefficient(self, int: int, int2: int, int3: int) -> float: ... + def calcDiffusionCoefficients(self, int: int, int2: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def calcEffectiveDiffusionCoefficients(self) -> None: ... + def clone(self) -> 'DiffusivityInterface': ... + def getEffectiveDiffusionCoefficient(self, int: int) -> float: ... + def getFickBinaryDiffusionCoefficient(self, int: int, int2: int) -> float: ... + def getMaxwellStefanBinaryDiffusionCoefficient(self, int: int, int2: int) -> float: ... + +class ViscosityInterface(jneqsim.physicalproperties.methods.PhysicalPropertyMethodInterface): + def calcViscosity(self) -> float: ... + def clone(self) -> 'ViscosityInterface': ... + def getPureComponentViscosity(self, int: int) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.methodinterface")``. + + ConductivityInterface: typing.Type[ConductivityInterface] + DensityInterface: typing.Type[DensityInterface] + DiffusivityInterface: typing.Type[DiffusivityInterface] + ViscosityInterface: typing.Type[ViscosityInterface] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/__init__.pyi new file mode 100644 index 00000000..2b1af6e3 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/__init__.pyi @@ -0,0 +1,30 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods +import jneqsim.physicalproperties.methods.solidphysicalproperties.conductivity +import jneqsim.physicalproperties.methods.solidphysicalproperties.density +import jneqsim.physicalproperties.methods.solidphysicalproperties.diffusivity +import jneqsim.physicalproperties.methods.solidphysicalproperties.viscosity +import jneqsim.physicalproperties.system +import typing + + + +class SolidPhysicalPropertyMethod(jneqsim.physicalproperties.methods.PhysicalPropertyMethod): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def setPhase(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.solidphysicalproperties")``. + + SolidPhysicalPropertyMethod: typing.Type[SolidPhysicalPropertyMethod] + conductivity: jneqsim.physicalproperties.methods.solidphysicalproperties.conductivity.__module_protocol__ + density: jneqsim.physicalproperties.methods.solidphysicalproperties.density.__module_protocol__ + diffusivity: jneqsim.physicalproperties.methods.solidphysicalproperties.diffusivity.__module_protocol__ + viscosity: jneqsim.physicalproperties.methods.solidphysicalproperties.viscosity.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/conductivity/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/conductivity/__init__.pyi new file mode 100644 index 00000000..c825dc55 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/conductivity/__init__.pyi @@ -0,0 +1,24 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.methods.solidphysicalproperties +import jneqsim.physicalproperties.system +import typing + + + +class Conductivity(jneqsim.physicalproperties.methods.solidphysicalproperties.SolidPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.ConductivityInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcConductivity(self) -> float: ... + def clone(self) -> 'Conductivity': ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.solidphysicalproperties.conductivity")``. + + Conductivity: typing.Type[Conductivity] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/density/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/density/__init__.pyi new file mode 100644 index 00000000..b040be27 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/density/__init__.pyi @@ -0,0 +1,24 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.methods.solidphysicalproperties +import jneqsim.physicalproperties.system +import typing + + + +class Density(jneqsim.physicalproperties.methods.solidphysicalproperties.SolidPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.DensityInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcDensity(self) -> float: ... + def clone(self) -> 'Density': ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.solidphysicalproperties.density")``. + + Density: typing.Type[Density] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/diffusivity/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/diffusivity/__init__.pyi new file mode 100644 index 00000000..4a643c08 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/diffusivity/__init__.pyi @@ -0,0 +1,29 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.methods.solidphysicalproperties +import jneqsim.physicalproperties.system +import typing + + + +class Diffusivity(jneqsim.physicalproperties.methods.solidphysicalproperties.SolidPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.DiffusivityInterface): + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcBinaryDiffusionCoefficient(self, int: int, int2: int, int3: int) -> float: ... + def calcDiffusionCoefficients(self, int: int, int2: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def calcEffectiveDiffusionCoefficients(self) -> None: ... + def clone(self) -> 'Diffusivity': ... + def getEffectiveDiffusionCoefficient(self, int: int) -> float: ... + def getFickBinaryDiffusionCoefficient(self, int: int, int2: int) -> float: ... + def getMaxwellStefanBinaryDiffusionCoefficient(self, int: int, int2: int) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.solidphysicalproperties.diffusivity")``. + + Diffusivity: typing.Type[Diffusivity] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/viscosity/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/viscosity/__init__.pyi new file mode 100644 index 00000000..05e66fcd --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/viscosity/__init__.pyi @@ -0,0 +1,28 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.methods.solidphysicalproperties +import jneqsim.physicalproperties.system +import typing + + + +class Viscosity(jneqsim.physicalproperties.methods.solidphysicalproperties.SolidPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.ViscosityInterface): + pureComponentViscosity: typing.MutableSequence[float] = ... + def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def calcPureComponentViscosity(self) -> None: ... + def calcViscosity(self) -> float: ... + def clone(self) -> 'Viscosity': ... + def getPureComponentViscosity(self, int: int) -> float: ... + def getViscosityPressureCorrection(self, int: int) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.solidphysicalproperties.viscosity")``. + + Viscosity: typing.Type[Viscosity] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/mixingrule/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/mixingrule/__init__.pyi new file mode 100644 index 00000000..47abd115 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/mixingrule/__init__.pyi @@ -0,0 +1,35 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.thermo +import jneqsim.thermo.phase +import typing + + + +class PhysicalPropertyMixingRuleInterface(java.lang.Cloneable): + def clone(self) -> 'PhysicalPropertyMixingRuleInterface': ... + def getViscosityGij(self, int: int, int2: int) -> float: ... + def initMixingRules(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def setViscosityGij(self, double: float, int: int, int2: int) -> None: ... + +class PhysicalPropertyMixingRule(PhysicalPropertyMixingRuleInterface, jneqsim.thermo.ThermodynamicConstantsInterface): + Gij: typing.MutableSequence[typing.MutableSequence[float]] = ... + def __init__(self): ... + def clone(self) -> 'PhysicalPropertyMixingRule': ... + def getPhysicalPropertyMixingRule(self) -> PhysicalPropertyMixingRuleInterface: ... + def getViscosityGij(self, int: int, int2: int) -> float: ... + def initMixingRules(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def setViscosityGij(self, double: float, int: int, int2: int) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.mixingrule")``. + + PhysicalPropertyMixingRule: typing.Type[PhysicalPropertyMixingRule] + PhysicalPropertyMixingRuleInterface: typing.Type[PhysicalPropertyMixingRuleInterface] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/__init__.pyi new file mode 100644 index 00000000..714df8bc --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/__init__.pyi @@ -0,0 +1,116 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.physicalproperties +import jneqsim.physicalproperties.methods.methodinterface +import jneqsim.physicalproperties.mixingrule +import jneqsim.physicalproperties.system.commonphasephysicalproperties +import jneqsim.physicalproperties.system.gasphysicalproperties +import jneqsim.physicalproperties.system.liquidphysicalproperties +import jneqsim.physicalproperties.system.solidphysicalproperties +import jneqsim.thermo +import jneqsim.thermo.phase +import typing + + + +class PhysicalProperties(java.lang.Cloneable, jneqsim.thermo.ThermodynamicConstantsInterface): + conductivityCalc: jneqsim.physicalproperties.methods.methodinterface.ConductivityInterface = ... + viscosityCalc: jneqsim.physicalproperties.methods.methodinterface.ViscosityInterface = ... + diffusivityCalc: jneqsim.physicalproperties.methods.methodinterface.DiffusivityInterface = ... + densityCalc: jneqsim.physicalproperties.methods.methodinterface.DensityInterface = ... + kinematicViscosity: float = ... + density: float = ... + viscosity: float = ... + conductivity: float = ... + @typing.overload + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface): ... + @typing.overload + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int): ... + def calcDensity(self) -> float: ... + def calcEffectiveDiffusionCoefficients(self) -> None: ... + def calcKinematicViscosity(self) -> float: ... + def clone(self) -> 'PhysicalProperties': ... + def getConductivity(self) -> float: ... + def getConductivityModel(self) -> jneqsim.physicalproperties.methods.methodinterface.ConductivityInterface: ... + def getDensity(self) -> float: ... + @typing.overload + def getDiffusionCoefficient(self, int: int, int2: int) -> float: ... + @typing.overload + def getDiffusionCoefficient(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEffectiveDiffusionCoefficient(self, int: int) -> float: ... + @typing.overload + def getEffectiveDiffusionCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getEffectiveSchmidtNumber(self, int: int) -> float: ... + def getFickDiffusionCoefficient(self, int: int, int2: int) -> float: ... + def getKinematicViscosity(self) -> float: ... + def getMixingRule(self) -> jneqsim.physicalproperties.mixingrule.PhysicalPropertyMixingRuleInterface: ... + def getPhase(self) -> jneqsim.thermo.phase.PhaseInterface: ... + def getPureComponentViscosity(self, int: int) -> float: ... + def getViscosity(self) -> float: ... + def getViscosityModel(self) -> jneqsim.physicalproperties.methods.methodinterface.ViscosityInterface: ... + def getViscosityOfWaxyOil(self, double: float, double2: float) -> float: ... + def getWaxViscosityParameter(self) -> typing.MutableSequence[float]: ... + @typing.overload + def init(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + @typing.overload + def init(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def init(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, physicalPropertyType: jneqsim.physicalproperties.PhysicalPropertyType) -> None: ... + def setBinaryDiffusionCoefficientMethod(self, int: int) -> None: ... + def setConductivityModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setDensityModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setDiffusionCoefficientModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setLbcParameter(self, int: int, double: float) -> None: ... + def setLbcParameters(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setMixingRule(self, physicalPropertyMixingRuleInterface: jneqsim.physicalproperties.mixingrule.PhysicalPropertyMixingRuleInterface) -> None: ... + def setMixingRuleNull(self) -> None: ... + def setMulticomponentDiffusionMethod(self, int: int) -> None: ... + def setPhase(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def setPhases(self) -> None: ... + def setViscosityModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setWaxViscosityParameter(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setWaxViscosityParameter(self, int: int, double: float) -> None: ... + +class PhysicalPropertyModel(java.lang.Enum['PhysicalPropertyModel']): + DEFAULT: typing.ClassVar['PhysicalPropertyModel'] = ... + WATER: typing.ClassVar['PhysicalPropertyModel'] = ... + GLYCOL: typing.ClassVar['PhysicalPropertyModel'] = ... + AMINE: typing.ClassVar['PhysicalPropertyModel'] = ... + CO2WATER: typing.ClassVar['PhysicalPropertyModel'] = ... + BASIC: typing.ClassVar['PhysicalPropertyModel'] = ... + SALT_WATER: typing.ClassVar['PhysicalPropertyModel'] = ... + @staticmethod + def byName(string: typing.Union[java.lang.String, str]) -> 'PhysicalPropertyModel': ... + @staticmethod + def byValue(int: int) -> 'PhysicalPropertyModel': ... + def getValue(self) -> int: ... + _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]) -> 'PhysicalPropertyModel': ... + @staticmethod + def values() -> typing.MutableSequence['PhysicalPropertyModel']: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.system")``. + + PhysicalProperties: typing.Type[PhysicalProperties] + PhysicalPropertyModel: typing.Type[PhysicalPropertyModel] + commonphasephysicalproperties: jneqsim.physicalproperties.system.commonphasephysicalproperties.__module_protocol__ + gasphysicalproperties: jneqsim.physicalproperties.system.gasphysicalproperties.__module_protocol__ + liquidphysicalproperties: jneqsim.physicalproperties.system.liquidphysicalproperties.__module_protocol__ + solidphysicalproperties: jneqsim.physicalproperties.system.solidphysicalproperties.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/commonphasephysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/commonphasephysicalproperties/__init__.pyi new file mode 100644 index 00000000..2eef4c1f --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/commonphasephysicalproperties/__init__.pyi @@ -0,0 +1,21 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.system +import jneqsim.thermo.phase +import typing + + + +class DefaultPhysicalProperties(jneqsim.physicalproperties.system.PhysicalProperties): + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.system.commonphasephysicalproperties")``. + + DefaultPhysicalProperties: typing.Type[DefaultPhysicalProperties] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/gasphysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/gasphysicalproperties/__init__.pyi new file mode 100644 index 00000000..06ed955d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/gasphysicalproperties/__init__.pyi @@ -0,0 +1,30 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.system +import jneqsim.thermo.phase +import typing + + + +class GasPhysicalProperties(jneqsim.physicalproperties.system.PhysicalProperties): + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int): ... + def clone(self) -> 'GasPhysicalProperties': ... + +class AirPhysicalProperties(GasPhysicalProperties): + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int): ... + +class NaturalGasPhysicalProperties(GasPhysicalProperties): + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.system.gasphysicalproperties")``. + + AirPhysicalProperties: typing.Type[AirPhysicalProperties] + GasPhysicalProperties: typing.Type[GasPhysicalProperties] + NaturalGasPhysicalProperties: typing.Type[NaturalGasPhysicalProperties] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/liquidphysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/liquidphysicalproperties/__init__.pyi new file mode 100644 index 00000000..01620630 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/liquidphysicalproperties/__init__.pyi @@ -0,0 +1,43 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.system +import jneqsim.thermo.phase +import typing + + + +class CO2waterPhysicalProperties(jneqsim.physicalproperties.system.PhysicalProperties): + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int): ... + def clone(self) -> 'CO2waterPhysicalProperties': ... + +class LiquidPhysicalProperties(jneqsim.physicalproperties.system.PhysicalProperties): + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int): ... + def clone(self) -> 'LiquidPhysicalProperties': ... + +class AminePhysicalProperties(LiquidPhysicalProperties): + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int): ... + +class GlycolPhysicalProperties(LiquidPhysicalProperties): + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int): ... + +class WaterPhysicalProperties(LiquidPhysicalProperties): + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int): ... + +class SaltWaterPhysicalProperties(WaterPhysicalProperties): + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.system.liquidphysicalproperties")``. + + AminePhysicalProperties: typing.Type[AminePhysicalProperties] + CO2waterPhysicalProperties: typing.Type[CO2waterPhysicalProperties] + GlycolPhysicalProperties: typing.Type[GlycolPhysicalProperties] + LiquidPhysicalProperties: typing.Type[LiquidPhysicalProperties] + SaltWaterPhysicalProperties: typing.Type[SaltWaterPhysicalProperties] + WaterPhysicalProperties: typing.Type[WaterPhysicalProperties] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/solidphysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/solidphysicalproperties/__init__.pyi new file mode 100644 index 00000000..15663403 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/solidphysicalproperties/__init__.pyi @@ -0,0 +1,21 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.system +import jneqsim.thermo.phase +import typing + + + +class SolidPhysicalProperties(jneqsim.physicalproperties.system.PhysicalProperties): + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.system.solidphysicalproperties")``. + + SolidPhysicalProperties: typing.Type[SolidPhysicalProperties] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/__init__.pyi new file mode 100644 index 00000000..b370d2ff --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/__init__.pyi @@ -0,0 +1,15 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.util.parameterfitting +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.util")``. + + parameterfitting: jneqsim.physicalproperties.util.parameterfitting.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/__init__.pyi new file mode 100644 index 00000000..8472550e --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/__init__.pyi @@ -0,0 +1,15 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.util.parameterfitting")``. + + purecomponentparameterfitting: jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/__init__.pyi new file mode 100644 index 00000000..02780107 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/__init__.pyi @@ -0,0 +1,17 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting.purecompinterfacetension +import jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting.purecompviscosity +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting")``. + + purecompinterfacetension: jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting.purecompinterfacetension.__module_protocol__ + purecompviscosity: jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting.purecompviscosity.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/purecompinterfacetension/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/purecompinterfacetension/__init__.pyi new file mode 100644 index 00000000..83490b4a --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/purecompinterfacetension/__init__.pyi @@ -0,0 +1,33 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.statistics.parameterfitting.nonlinearparameterfitting +import typing + + + +class ParachorFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): + def __init__(self): ... + def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + @typing.overload + def setFittingParams(self, int: int, double: float) -> None: ... + @typing.overload + def setFittingParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class TestParachorFit: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting.purecompinterfacetension")``. + + ParachorFunction: typing.Type[ParachorFunction] + TestParachorFit: typing.Type[TestParachorFit] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/purecompviscosity/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/purecompviscosity/__init__.pyi new file mode 100644 index 00000000..cb694af1 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/purecompviscosity/__init__.pyi @@ -0,0 +1,17 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting.purecompviscosity.chungmethod +import jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting.purecompviscosity.linearliquidmodel +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting.purecompviscosity")``. + + chungmethod: jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting.purecompviscosity.chungmethod.__module_protocol__ + linearliquidmodel: jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting.purecompviscosity.linearliquidmodel.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/purecompviscosity/chungmethod/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/purecompviscosity/chungmethod/__init__.pyi new file mode 100644 index 00000000..353c3046 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/purecompviscosity/chungmethod/__init__.pyi @@ -0,0 +1,33 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.statistics.parameterfitting.nonlinearparameterfitting +import typing + + + +class ChungFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): + def __init__(self): ... + def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + @typing.overload + def setFittingParams(self, int: int, double: float) -> None: ... + @typing.overload + def setFittingParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class TestChungFit: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting.purecompviscosity.chungmethod")``. + + ChungFunction: typing.Type[ChungFunction] + TestChungFit: typing.Type[TestChungFit] diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/purecompviscosity/linearliquidmodel/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/purecompviscosity/linearliquidmodel/__init__.pyi new file mode 100644 index 00000000..abde4dda --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/purecompviscosity/linearliquidmodel/__init__.pyi @@ -0,0 +1,33 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.statistics.parameterfitting.nonlinearparameterfitting +import typing + + + +class TestViscosityFit: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class ViscosityFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): + def __init__(self): ... + def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + @typing.overload + def setFittingParams(self, int: int, double: float) -> None: ... + @typing.overload + def setFittingParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfitting.purecompviscosity.linearliquidmodel")``. + + TestViscosityFit: typing.Type[TestViscosityFit] + ViscosityFunction: typing.Type[ViscosityFunction] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/__init__.pyi new file mode 100644 index 00000000..ca2b2795 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/__init__.pyi @@ -0,0 +1,80 @@ + +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 jneqsim.process.alarm +import jneqsim.process.conditionmonitor +import jneqsim.process.controllerdevice +import jneqsim.process.costestimation +import jneqsim.process.equipment +import jneqsim.process.logic +import jneqsim.process.measurementdevice +import jneqsim.process.mechanicaldesign +import jneqsim.process.processmodel +import jneqsim.process.safety +import jneqsim.process.util +import jneqsim.util +import typing + + + +class SimulationInterface(jneqsim.util.NamedInterface, java.lang.Runnable, java.io.Serializable): + def getCalculateSteadyState(self) -> bool: ... + def getCalculationIdentifier(self) -> java.util.UUID: ... + def getReport_json(self) -> java.lang.String: ... + def getTime(self) -> float: ... + def increaseTime(self, double: float) -> None: ... + def isRunInSteps(self) -> bool: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def runTransient(self, double: float) -> None: ... + @typing.overload + def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... + @typing.overload + def run_step(self, uUID: java.util.UUID) -> None: ... + @typing.overload + def run_step(self) -> None: ... + def setCalculateSteadyState(self, boolean: bool) -> None: ... + def setCalculationIdentifier(self, uUID: java.util.UUID) -> None: ... + def setRunInSteps(self, boolean: bool) -> None: ... + def setTime(self, double: float) -> None: ... + def solved(self) -> bool: ... + +class SimulationBaseClass(jneqsim.util.NamedBaseClass, SimulationInterface): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def getCalculateSteadyState(self) -> bool: ... + def getCalculationIdentifier(self) -> java.util.UUID: ... + def getTime(self) -> float: ... + def increaseTime(self, double: float) -> None: ... + def isRunInSteps(self) -> bool: ... + def setCalculateSteadyState(self, boolean: bool) -> None: ... + def setCalculationIdentifier(self, uUID: java.util.UUID) -> None: ... + def setRunInSteps(self, boolean: bool) -> None: ... + def setTime(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process")``. + + SimulationBaseClass: typing.Type[SimulationBaseClass] + SimulationInterface: typing.Type[SimulationInterface] + alarm: jneqsim.process.alarm.__module_protocol__ + conditionmonitor: jneqsim.process.conditionmonitor.__module_protocol__ + controllerdevice: jneqsim.process.controllerdevice.__module_protocol__ + costestimation: jneqsim.process.costestimation.__module_protocol__ + equipment: jneqsim.process.equipment.__module_protocol__ + logic: jneqsim.process.logic.__module_protocol__ + measurementdevice: jneqsim.process.measurementdevice.__module_protocol__ + mechanicaldesign: jneqsim.process.mechanicaldesign.__module_protocol__ + processmodel: jneqsim.process.processmodel.__module_protocol__ + safety: jneqsim.process.safety.__module_protocol__ + util: jneqsim.process.util.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/alarm/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/alarm/__init__.pyi new file mode 100644 index 00000000..6bf354d9 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/alarm/__init__.pyi @@ -0,0 +1,187 @@ + +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 jneqsim.process.logic +import jneqsim.process.measurementdevice +import jneqsim.process.processmodel +import typing + + + +class AlarmActionHandler(java.io.Serializable): + @staticmethod + def activateLogic(string: typing.Union[java.lang.String, str], alarmLevel: 'AlarmLevel', alarmEventType: 'AlarmEventType', processLogic: jneqsim.process.logic.ProcessLogic) -> 'AlarmActionHandler': ... + @staticmethod + def activateLogicOnHIHI(string: typing.Union[java.lang.String, str], processLogic: jneqsim.process.logic.ProcessLogic) -> 'AlarmActionHandler': ... + @staticmethod + def activateLogicOnLOLO(string: typing.Union[java.lang.String, str], processLogic: jneqsim.process.logic.ProcessLogic) -> 'AlarmActionHandler': ... + @staticmethod + def composite(list: java.util.List[typing.Union['AlarmActionHandler', typing.Callable]]) -> 'AlarmActionHandler': ... + def getActionDescription(self) -> java.lang.String: ... + def getPriority(self) -> int: ... + def handle(self, alarmEvent: 'AlarmEvent') -> bool: ... + +class AlarmConfig(java.io.Serializable): + @staticmethod + def builder() -> 'AlarmConfig.Builder': ... + def getDeadband(self) -> float: ... + def getDelay(self) -> float: ... + def getHighHighLimit(self) -> float: ... + def getHighLimit(self) -> float: ... + def getLimit(self, alarmLevel: 'AlarmLevel') -> float: ... + def getLowLimit(self) -> float: ... + def getLowLowLimit(self) -> float: ... + def getUnit(self) -> java.lang.String: ... + def hasLimit(self, alarmLevel: 'AlarmLevel') -> bool: ... + class Builder: + def build(self) -> 'AlarmConfig': ... + def deadband(self, double: float) -> 'AlarmConfig.Builder': ... + def delay(self, double: float) -> 'AlarmConfig.Builder': ... + def highHighLimit(self, double: float) -> 'AlarmConfig.Builder': ... + def highLimit(self, double: float) -> 'AlarmConfig.Builder': ... + def lowLimit(self, double: float) -> 'AlarmConfig.Builder': ... + def lowLowLimit(self, double: float) -> 'AlarmConfig.Builder': ... + def unit(self, string: typing.Union[java.lang.String, str]) -> 'AlarmConfig.Builder': ... + +class AlarmEvaluator: + @staticmethod + def evaluateAll(processAlarmManager: 'ProcessAlarmManager', processSystem: jneqsim.process.processmodel.ProcessSystem, double: float, double2: float) -> java.util.List['AlarmEvent']: ... + @staticmethod + def evaluateAndDisplay(processAlarmManager: 'ProcessAlarmManager', list: java.util.List[jneqsim.process.measurementdevice.MeasurementDeviceInterface], double: float, double2: float) -> java.util.List['AlarmEvent']: ... + @staticmethod + def evaluateDevices(processAlarmManager: 'ProcessAlarmManager', list: java.util.List[jneqsim.process.measurementdevice.MeasurementDeviceInterface], double: float, double2: float) -> java.util.List['AlarmEvent']: ... + +class AlarmEvent(java.io.Serializable): + @staticmethod + def acknowledged(string: typing.Union[java.lang.String, str], alarmLevel: 'AlarmLevel', double: float, double2: float) -> 'AlarmEvent': ... + @staticmethod + def activated(string: typing.Union[java.lang.String, str], alarmLevel: 'AlarmLevel', double: float, double2: float) -> 'AlarmEvent': ... + @staticmethod + def cleared(string: typing.Union[java.lang.String, str], alarmLevel: 'AlarmLevel', double: float, double2: float) -> 'AlarmEvent': ... + def getLevel(self) -> 'AlarmLevel': ... + def getSource(self) -> java.lang.String: ... + def getTimestamp(self) -> float: ... + def getType(self) -> 'AlarmEventType': ... + def getValue(self) -> float: ... + def toString(self) -> java.lang.String: ... + +class AlarmEventType(java.lang.Enum['AlarmEventType']): + ACTIVATED: typing.ClassVar['AlarmEventType'] = ... + CLEARED: typing.ClassVar['AlarmEventType'] = ... + ACKNOWLEDGED: typing.ClassVar['AlarmEventType'] = ... + _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]) -> 'AlarmEventType': ... + @staticmethod + def values() -> typing.MutableSequence['AlarmEventType']: ... + +class AlarmLevel(java.lang.Enum['AlarmLevel'], java.io.Serializable): + LOLO: typing.ClassVar['AlarmLevel'] = ... + LO: typing.ClassVar['AlarmLevel'] = ... + HI: typing.ClassVar['AlarmLevel'] = ... + HIHI: typing.ClassVar['AlarmLevel'] = ... + def getDirection(self) -> 'AlarmLevel.Direction': ... + def getPriority(self) -> int: ... + _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]) -> 'AlarmLevel': ... + @staticmethod + def values() -> typing.MutableSequence['AlarmLevel']: ... + class Direction(java.lang.Enum['AlarmLevel.Direction']): + LOW: typing.ClassVar['AlarmLevel.Direction'] = ... + HIGH: typing.ClassVar['AlarmLevel.Direction'] = ... + _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]) -> 'AlarmLevel.Direction': ... + @staticmethod + def values() -> typing.MutableSequence['AlarmLevel.Direction']: ... + +class AlarmReporter: + @staticmethod + def displayAlarmEvents(list: java.util.List[AlarmEvent]) -> None: ... + @typing.overload + @staticmethod + def displayAlarmHistory(processAlarmManager: 'ProcessAlarmManager') -> None: ... + @typing.overload + @staticmethod + def displayAlarmHistory(processAlarmManager: 'ProcessAlarmManager', int: int) -> None: ... + @staticmethod + def displayAlarmStatistics(processAlarmManager: 'ProcessAlarmManager') -> None: ... + @staticmethod + def displayAlarmStatus(processAlarmManager: 'ProcessAlarmManager', string: typing.Union[java.lang.String, str]) -> None: ... + @staticmethod + def formatAlarmEvent(alarmEvent: AlarmEvent) -> java.lang.String: ... + @staticmethod + def formatAlarmEventCompact(alarmEvent: AlarmEvent) -> java.lang.String: ... + @staticmethod + def printScenarioHeader(string: typing.Union[java.lang.String, str]) -> None: ... + +class AlarmState(java.io.Serializable): + def __init__(self): ... + def acknowledge(self, string: typing.Union[java.lang.String, str], double: float) -> AlarmEvent: ... + def evaluate(self, alarmConfig: AlarmConfig, double: float, double2: float, double3: float, string: typing.Union[java.lang.String, str]) -> java.util.List[AlarmEvent]: ... + def getActiveLevel(self) -> AlarmLevel: ... + def getLastUpdateTime(self) -> float: ... + def getLastValue(self) -> float: ... + def isAcknowledged(self) -> bool: ... + def isActive(self) -> bool: ... + def reset(self) -> None: ... + def snapshot(self, string: typing.Union[java.lang.String, str]) -> 'AlarmStatusSnapshot': ... + +class AlarmStatusSnapshot(java.io.Serializable): + def __init__(self, string: typing.Union[java.lang.String, str], alarmLevel: AlarmLevel, boolean: bool, double: float, double2: float): ... + def getLevel(self) -> AlarmLevel: ... + def getSource(self) -> java.lang.String: ... + def getTimestamp(self) -> float: ... + def getValue(self) -> float: ... + def isAcknowledged(self) -> bool: ... + +class ProcessAlarmManager(java.io.Serializable): + def __init__(self): ... + def acknowledgeAll(self, double: float) -> java.util.List[AlarmEvent]: ... + def applyFrom(self, processAlarmManager: 'ProcessAlarmManager', list: java.util.List[jneqsim.process.measurementdevice.MeasurementDeviceInterface]) -> None: ... + def clearHistory(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def evaluateMeasurement(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface, double: float, double2: float, double3: float) -> java.util.List[AlarmEvent]: ... + def getActionHandlers(self) -> java.util.List[AlarmActionHandler]: ... + def getActiveAlarms(self) -> java.util.List[AlarmStatusSnapshot]: ... + def getHistory(self) -> java.util.List[AlarmEvent]: ... + def hashCode(self) -> int: ... + def register(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface) -> None: ... + def registerActionHandler(self, alarmActionHandler: typing.Union[AlarmActionHandler, typing.Callable]) -> None: ... + def registerAll(self, list: java.util.List[jneqsim.process.measurementdevice.MeasurementDeviceInterface]) -> None: ... + def removeActionHandler(self, alarmActionHandler: typing.Union[AlarmActionHandler, typing.Callable]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.alarm")``. + + AlarmActionHandler: typing.Type[AlarmActionHandler] + AlarmConfig: typing.Type[AlarmConfig] + AlarmEvaluator: typing.Type[AlarmEvaluator] + AlarmEvent: typing.Type[AlarmEvent] + AlarmEventType: typing.Type[AlarmEventType] + AlarmLevel: typing.Type[AlarmLevel] + AlarmReporter: typing.Type[AlarmReporter] + AlarmState: typing.Type[AlarmState] + AlarmStatusSnapshot: typing.Type[AlarmStatusSnapshot] + ProcessAlarmManager: typing.Type[ProcessAlarmManager] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/conditionmonitor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/conditionmonitor/__init__.pyi new file mode 100644 index 00000000..e2024f0f --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/conditionmonitor/__init__.pyi @@ -0,0 +1,37 @@ + +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 jneqsim.process.processmodel +import typing + + + +class ConditionMonitor(java.io.Serializable, java.lang.Runnable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem): ... + @typing.overload + def conditionAnalysis(self) -> None: ... + @typing.overload + def conditionAnalysis(self, string: typing.Union[java.lang.String, str]) -> None: ... + def getProcess(self) -> jneqsim.process.processmodel.ProcessSystem: ... + def getReport(self) -> java.lang.String: ... + def run(self) -> None: ... + +class ConditionMonitorSpecifications(java.io.Serializable): + HXmaxDeltaT: typing.ClassVar[float] = ... + HXmaxDeltaT_ErrorMsg: typing.ClassVar[java.lang.String] = ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.conditionmonitor")``. + + ConditionMonitor: typing.Type[ConditionMonitor] + ConditionMonitorSpecifications: typing.Type[ConditionMonitorSpecifications] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/__init__.pyi new file mode 100644 index 00000000..da900342 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/__init__.pyi @@ -0,0 +1,308 @@ + +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 jneqsim.process.controllerdevice.structure +import jneqsim.process.measurementdevice +import jneqsim.util +import typing + + + +class ControllerDeviceInterface(java.io.Serializable): + def addGainSchedulePoint(self, double: float, double2: float, double3: float, double4: float) -> None: ... + @typing.overload + def autoTune(self, double: float, double2: float) -> None: ... + @typing.overload + def autoTune(self, double: float, double2: float, boolean: bool) -> None: ... + @typing.overload + def autoTuneFromEventLog(self) -> bool: ... + @typing.overload + def autoTuneFromEventLog(self, boolean: bool) -> bool: ... + @typing.overload + def autoTuneStepResponse(self, double: float, double2: float, double3: float) -> None: ... + @typing.overload + def autoTuneStepResponse(self, double: float, double2: float, double3: float, boolean: bool) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getControllerSetPoint(self) -> float: ... + def getEventLog(self) -> java.util.List['ControllerEvent']: ... + def getIntegralAbsoluteError(self) -> float: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getResponse(self) -> float: ... + def getSettlingTime(self) -> float: ... + def getStepResponseTuningMethod(self) -> 'ControllerDeviceInterface.StepResponseTuningMethod': ... + def getUnit(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def isActive(self) -> bool: ... + def isReverseActing(self) -> bool: ... + def resetEventLog(self) -> None: ... + def resetPerformanceMetrics(self) -> None: ... + @typing.overload + def runTransient(self, double: float, double2: float, uUID: java.util.UUID) -> None: ... + @typing.overload + def runTransient(self, double: float, double2: float) -> None: ... + def setActive(self, boolean: bool) -> None: ... + def setControllerParameters(self, double: float, double2: float, double3: float) -> None: ... + @typing.overload + def setControllerSetPoint(self, double: float) -> None: ... + @typing.overload + def setControllerSetPoint(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setDerivativeFilterTime(self, double: float) -> None: ... + def setOutputLimits(self, double: float, double2: float) -> None: ... + def setReverseActing(self, boolean: bool) -> None: ... + def setStepResponseTuningMethod(self, stepResponseTuningMethod: 'ControllerDeviceInterface.StepResponseTuningMethod') -> None: ... + def setTransmitter(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface) -> None: ... + def setUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + class StepResponseTuningMethod(java.lang.Enum['ControllerDeviceInterface.StepResponseTuningMethod']): + CLASSIC: typing.ClassVar['ControllerDeviceInterface.StepResponseTuningMethod'] = ... + SIMC: typing.ClassVar['ControllerDeviceInterface.StepResponseTuningMethod'] = ... + _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]) -> 'ControllerDeviceInterface.StepResponseTuningMethod': ... + @staticmethod + def values() -> typing.MutableSequence['ControllerDeviceInterface.StepResponseTuningMethod']: ... + +class ControllerEvent(java.io.Serializable): + def __init__(self, double: float, double2: float, double3: float, double4: float, double5: float): ... + def getError(self) -> float: ... + def getMeasuredValue(self) -> float: ... + def getResponse(self) -> float: ... + def getSetPoint(self) -> float: ... + def getTime(self) -> float: ... + +class ControllerDeviceBaseClass(jneqsim.util.NamedBaseClass, ControllerDeviceInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addGainSchedulePoint(self, double: float, double2: float, double3: float, double4: float) -> None: ... + @typing.overload + def autoTune(self, double: float, double2: float) -> None: ... + @typing.overload + def autoTune(self, double: float, double2: float, boolean: bool) -> None: ... + @typing.overload + def autoTuneFromEventLog(self) -> bool: ... + @typing.overload + def autoTuneFromEventLog(self, boolean: bool) -> bool: ... + @typing.overload + def autoTuneStepResponse(self, double: float, double2: float, double3: float) -> None: ... + @typing.overload + def autoTuneStepResponse(self, double: float, double2: float, double3: float, boolean: bool) -> None: ... + def getControllerSetPoint(self) -> float: ... + def getEventLog(self) -> java.util.List[ControllerEvent]: ... + def getIntegralAbsoluteError(self) -> float: ... + def getKp(self) -> float: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getResponse(self) -> float: ... + def getSettlingTime(self) -> float: ... + def getStepResponseTuningMethod(self) -> ControllerDeviceInterface.StepResponseTuningMethod: ... + def getTd(self) -> float: ... + def getTi(self) -> float: ... + def getUnit(self) -> java.lang.String: ... + def isActive(self) -> bool: ... + def isReverseActing(self) -> bool: ... + def resetEventLog(self) -> None: ... + def resetPerformanceMetrics(self) -> None: ... + @typing.overload + def runTransient(self, double: float, double2: float) -> None: ... + @typing.overload + def runTransient(self, double: float, double2: float, uUID: java.util.UUID) -> None: ... + def setActive(self, boolean: bool) -> None: ... + def setControllerParameters(self, double: float, double2: float, double3: float) -> None: ... + @typing.overload + def setControllerSetPoint(self, double: float) -> None: ... + @typing.overload + def setControllerSetPoint(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setDerivativeFilterTime(self, double: float) -> None: ... + def setKp(self, double: float) -> None: ... + def setOutputLimits(self, double: float, double2: float) -> None: ... + def setReverseActing(self, boolean: bool) -> None: ... + def setStepResponseTuningMethod(self, stepResponseTuningMethod: ControllerDeviceInterface.StepResponseTuningMethod) -> None: ... + def setTd(self, double: float) -> None: ... + def setTi(self, double: float) -> None: ... + def setTransmitter(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface) -> None: ... + def setUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class ModelPredictiveController(jneqsim.util.NamedBaseClass, ControllerDeviceInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addQualityConstraint(self, qualityConstraint: 'ModelPredictiveController.QualityConstraint') -> None: ... + @typing.overload + def autoTune(self, double: float, double2: float) -> None: ... + @typing.overload + def autoTune(self, double: float, double2: float, boolean: bool) -> None: ... + @typing.overload + def autoTune(self) -> 'ModelPredictiveController.AutoTuneResult': ... + @typing.overload + def autoTune(self, list: java.util.List[float], list2: java.util.List[float], list3: java.util.List[float], autoTuneConfiguration: 'ModelPredictiveController.AutoTuneConfiguration') -> 'ModelPredictiveController.AutoTuneResult': ... + @typing.overload + def autoTune(self, autoTuneConfiguration: 'ModelPredictiveController.AutoTuneConfiguration') -> 'ModelPredictiveController.AutoTuneResult': ... + def clearMovingHorizonHistory(self) -> None: ... + def clearQualityConstraints(self) -> None: ... + def configureControls(self, *string: typing.Union[java.lang.String, str]) -> None: ... + def disableMovingHorizonEstimation(self) -> None: ... + def enableMovingHorizonEstimation(self, int: int) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getCalcIdentifier(self) -> java.util.UUID: ... + def getControlNames(self) -> java.util.List[java.lang.String]: ... + @typing.overload + def getControlValue(self, int: int) -> float: ... + @typing.overload + def getControlValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getControlVector(self) -> typing.MutableSequence[float]: ... + def getControlWeight(self) -> float: ... + def getControllerSetPoint(self) -> float: ... + def getLastAppliedControl(self) -> float: ... + def getLastMovingHorizonEstimate(self) -> 'ModelPredictiveController.MovingHorizonEstimate': ... + def getLastSampleTime(self) -> float: ... + def getLastSampledValue(self) -> float: ... + def getMaxResponse(self) -> float: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMinResponse(self) -> float: ... + def getMoveWeight(self) -> float: ... + def getMovingHorizonEstimationWindow(self) -> int: ... + def getOutputWeight(self) -> float: ... + def getPredictedQuality(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getPredictedTrajectory(self, int: int, double: float) -> typing.MutableSequence[float]: ... + def getPredictionHorizon(self) -> int: ... + def getProcessBias(self) -> float: ... + def getProcessGain(self) -> float: ... + def getResponse(self) -> float: ... + def getTimeConstant(self) -> float: ... + def getUnit(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + @typing.overload + def ingestPlantSample(self, double: float, double2: float) -> None: ... + @typing.overload + def ingestPlantSample(self, double: float, double2: float, double3: float) -> None: ... + def isActive(self) -> bool: ... + def isMovingHorizonEstimationEnabled(self) -> bool: ... + def isReverseActing(self) -> bool: ... + @typing.overload + def runTransient(self, double: float, double2: float) -> None: ... + @typing.overload + def runTransient(self, double: float, double2: float, uUID: java.util.UUID) -> None: ... + def setActive(self, boolean: bool) -> None: ... + @typing.overload + def setControlLimits(self, int: int, double: float, double2: float) -> None: ... + @typing.overload + def setControlLimits(self, string: typing.Union[java.lang.String, str], double: float, double2: float) -> None: ... + @typing.overload + def setControlMoveLimits(self, int: int, double: float, double2: float) -> None: ... + @typing.overload + def setControlMoveLimits(self, string: typing.Union[java.lang.String, str], double: float, double2: float) -> None: ... + def setControlWeights(self, *double: float) -> None: ... + def setControllerParameters(self, double: float, double2: float, double3: float) -> None: ... + @typing.overload + def setControllerSetPoint(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setControllerSetPoint(self, double: float) -> None: ... + def setEnergyReference(self, double: float) -> None: ... + def setEnergyReferenceVector(self, *double: float) -> None: ... + def setInitialControlValues(self, *double: float) -> None: ... + def setMoveLimits(self, double: float, double2: float) -> None: ... + def setMoveWeights(self, *double: float) -> None: ... + def setOutputLimits(self, double: float, double2: float) -> None: ... + def setPredictionHorizon(self, int: int) -> None: ... + def setPreferredControlValue(self, double: float) -> None: ... + def setPreferredControlVector(self, *double: float) -> None: ... + def setPrimaryControlIndex(self, int: int) -> None: ... + def setProcessBias(self, double: float) -> None: ... + @typing.overload + def setProcessModel(self, double: float, double2: float) -> None: ... + @typing.overload + def setProcessModel(self, double: float, double2: float, double3: float) -> None: ... + def setReverseActing(self, boolean: bool) -> None: ... + def setTransmitter(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface) -> None: ... + def setUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setWeights(self, double: float, double2: float, double3: float) -> None: ... + def updateFeedConditions(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 updateQualityMeasurement(self, string: typing.Union[java.lang.String, str], double: float) -> bool: ... + def updateQualityMeasurements(self, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]]) -> None: ... + class AutoTuneConfiguration: + @staticmethod + def builder() -> 'ModelPredictiveController.AutoTuneConfiguration.Builder': ... + def getClosedLoopTimeConstantRatio(self) -> float: ... + def getControlWeightFactor(self) -> float: ... + def getMaximumHorizon(self) -> int: ... + def getMinimumHorizon(self) -> int: ... + def getMoveWeightFactor(self) -> float: ... + def getOutputWeight(self) -> float: ... + def getPredictionHorizonMultiple(self) -> float: ... + def getSampleTimeOverride(self) -> float: ... + def isApplyImmediately(self) -> bool: ... + class Builder: + def applyImmediately(self, boolean: bool) -> 'ModelPredictiveController.AutoTuneConfiguration.Builder': ... + def build(self) -> 'ModelPredictiveController.AutoTuneConfiguration': ... + def closedLoopTimeConstantRatio(self, double: float) -> 'ModelPredictiveController.AutoTuneConfiguration.Builder': ... + def controlWeightFactor(self, double: float) -> 'ModelPredictiveController.AutoTuneConfiguration.Builder': ... + def defaults(self) -> 'ModelPredictiveController.AutoTuneConfiguration.Builder': ... + def maximumHorizon(self, int: int) -> 'ModelPredictiveController.AutoTuneConfiguration.Builder': ... + def minimumHorizon(self, int: int) -> 'ModelPredictiveController.AutoTuneConfiguration.Builder': ... + def moveWeightFactor(self, double: float) -> 'ModelPredictiveController.AutoTuneConfiguration.Builder': ... + def outputWeight(self, double: float) -> 'ModelPredictiveController.AutoTuneConfiguration.Builder': ... + def predictionHorizonMultiple(self, double: float) -> 'ModelPredictiveController.AutoTuneConfiguration.Builder': ... + def sampleTimeOverride(self, double: float) -> 'ModelPredictiveController.AutoTuneConfiguration.Builder': ... + class AutoTuneResult: + def getClosedLoopTimeConstant(self) -> float: ... + def getControlWeight(self) -> float: ... + def getMeanSquaredError(self) -> float: ... + def getMoveWeight(self) -> float: ... + def getOutputWeight(self) -> float: ... + def getPredictionHorizon(self) -> int: ... + def getProcessBias(self) -> float: ... + def getProcessGain(self) -> float: ... + def getSampleCount(self) -> int: ... + def getSampleTime(self) -> float: ... + def getTimeConstant(self) -> float: ... + def isApplied(self) -> bool: ... + class MovingHorizonEstimate: + def getMeanSquaredError(self) -> float: ... + def getProcessBias(self) -> float: ... + def getProcessGain(self) -> float: ... + def getSampleCount(self) -> int: ... + def getTimeConstant(self) -> float: ... + class QualityConstraint: + @staticmethod + def builder(string: typing.Union[java.lang.String, str]) -> 'ModelPredictiveController.QualityConstraint.Builder': ... + class Builder: + def build(self) -> 'ModelPredictiveController.QualityConstraint': ... + def compositionSensitivities(self, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]]) -> 'ModelPredictiveController.QualityConstraint.Builder': ... + def compositionSensitivity(self, string: typing.Union[java.lang.String, str], double: float) -> 'ModelPredictiveController.QualityConstraint.Builder': ... + def controlSensitivity(self, *double: float) -> 'ModelPredictiveController.QualityConstraint.Builder': ... + def limit(self, double: float) -> 'ModelPredictiveController.QualityConstraint.Builder': ... + def margin(self, double: float) -> 'ModelPredictiveController.QualityConstraint.Builder': ... + def measurement(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface) -> 'ModelPredictiveController.QualityConstraint.Builder': ... + def rateSensitivity(self, double: float) -> 'ModelPredictiveController.QualityConstraint.Builder': ... + def unit(self, string: typing.Union[java.lang.String, str]) -> 'ModelPredictiveController.QualityConstraint.Builder': ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.controllerdevice")``. + + ControllerDeviceBaseClass: typing.Type[ControllerDeviceBaseClass] + ControllerDeviceInterface: typing.Type[ControllerDeviceInterface] + ControllerEvent: typing.Type[ControllerEvent] + ModelPredictiveController: typing.Type[ModelPredictiveController] + structure: jneqsim.process.controllerdevice.structure.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/structure/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/structure/__init__.pyi new file mode 100644 index 00000000..f4fe6803 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/structure/__init__.pyi @@ -0,0 +1,51 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.io +import jneqsim.process.controllerdevice +import jneqsim.process.measurementdevice +import typing + + + +class ControlStructureInterface(java.io.Serializable): + def getOutput(self) -> float: ... + def isActive(self) -> bool: ... + def runTransient(self, double: float) -> None: ... + def setActive(self, boolean: bool) -> None: ... + +class CascadeControllerStructure(ControlStructureInterface): + def __init__(self, controllerDeviceInterface: jneqsim.process.controllerdevice.ControllerDeviceInterface, controllerDeviceInterface2: jneqsim.process.controllerdevice.ControllerDeviceInterface): ... + def getOutput(self) -> float: ... + def isActive(self) -> bool: ... + def runTransient(self, double: float) -> None: ... + def setActive(self, boolean: bool) -> None: ... + +class FeedForwardControllerStructure(ControlStructureInterface): + def __init__(self, controllerDeviceInterface: jneqsim.process.controllerdevice.ControllerDeviceInterface, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface): ... + def getOutput(self) -> float: ... + def isActive(self) -> bool: ... + def runTransient(self, double: float) -> None: ... + def setActive(self, boolean: bool) -> None: ... + def setFeedForwardGain(self, double: float) -> None: ... + +class RatioControllerStructure(ControlStructureInterface): + def __init__(self, controllerDeviceInterface: jneqsim.process.controllerdevice.ControllerDeviceInterface, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface): ... + def getOutput(self) -> float: ... + def isActive(self) -> bool: ... + def runTransient(self, double: float) -> None: ... + def setActive(self, boolean: bool) -> None: ... + def setRatio(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.controllerdevice.structure")``. + + CascadeControllerStructure: typing.Type[CascadeControllerStructure] + ControlStructureInterface: typing.Type[ControlStructureInterface] + FeedForwardControllerStructure: typing.Type[FeedForwardControllerStructure] + RatioControllerStructure: typing.Type[RatioControllerStructure] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/__init__.pyi new file mode 100644 index 00000000..7b03c873 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/__init__.pyi @@ -0,0 +1,45 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.io +import jneqsim.process.costestimation.compressor +import jneqsim.process.costestimation.separator +import jneqsim.process.costestimation.valve +import jneqsim.process.mechanicaldesign +import typing + + + +class CostEstimateBaseClass(java.io.Serializable): + @typing.overload + def __init__(self, systemMechanicalDesign: jneqsim.process.mechanicaldesign.SystemMechanicalDesign): ... + @typing.overload + def __init__(self, systemMechanicalDesign: jneqsim.process.mechanicaldesign.SystemMechanicalDesign, double: float): ... + def equals(self, object: typing.Any) -> bool: ... + def getCAPEXestimate(self) -> float: ... + def getWeightBasedCAPEXEstimate(self) -> float: ... + def hashCode(self) -> int: ... + +class UnitCostEstimateBaseClass(java.io.Serializable): + mechanicalEquipment: jneqsim.process.mechanicaldesign.MechanicalDesign = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def equals(self, object: typing.Any) -> bool: ... + def getTotalCost(self) -> float: ... + def hashCode(self) -> int: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.costestimation")``. + + CostEstimateBaseClass: typing.Type[CostEstimateBaseClass] + UnitCostEstimateBaseClass: typing.Type[UnitCostEstimateBaseClass] + compressor: jneqsim.process.costestimation.compressor.__module_protocol__ + separator: jneqsim.process.costestimation.separator.__module_protocol__ + valve: jneqsim.process.costestimation.valve.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/compressor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/compressor/__init__.pyi new file mode 100644 index 00000000..919a5424 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/compressor/__init__.pyi @@ -0,0 +1,22 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.process.costestimation +import jneqsim.process.mechanicaldesign.compressor +import typing + + + +class CompressorCostEstimate(jneqsim.process.costestimation.UnitCostEstimateBaseClass): + def __init__(self, compressorMechanicalDesign: jneqsim.process.mechanicaldesign.compressor.CompressorMechanicalDesign): ... + def getTotalCost(self) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.costestimation.compressor")``. + + CompressorCostEstimate: typing.Type[CompressorCostEstimate] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/separator/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/separator/__init__.pyi new file mode 100644 index 00000000..35af7c89 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/separator/__init__.pyi @@ -0,0 +1,22 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.process.costestimation +import jneqsim.process.mechanicaldesign.separator +import typing + + + +class SeparatorCostEstimate(jneqsim.process.costestimation.UnitCostEstimateBaseClass): + def __init__(self, separatorMechanicalDesign: jneqsim.process.mechanicaldesign.separator.SeparatorMechanicalDesign): ... + def getTotalCost(self) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.costestimation.separator")``. + + SeparatorCostEstimate: typing.Type[SeparatorCostEstimate] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/valve/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/valve/__init__.pyi new file mode 100644 index 00000000..e3d93149 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/valve/__init__.pyi @@ -0,0 +1,22 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.process.costestimation +import jneqsim.process.mechanicaldesign.valve +import typing + + + +class ValveCostEstimate(jneqsim.process.costestimation.UnitCostEstimateBaseClass): + def __init__(self, valveMechanicalDesign: jneqsim.process.mechanicaldesign.valve.ValveMechanicalDesign): ... + def getTotalCost(self) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.costestimation.valve")``. + + ValveCostEstimate: typing.Type[ValveCostEstimate] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/__init__.pyi new file mode 100644 index 00000000..94d553a0 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/__init__.pyi @@ -0,0 +1,309 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process +import jneqsim.process.controllerdevice +import jneqsim.process.equipment.absorber +import jneqsim.process.equipment.adsorber +import jneqsim.process.equipment.battery +import jneqsim.process.equipment.blackoil +import jneqsim.process.equipment.compressor +import jneqsim.process.equipment.diffpressure +import jneqsim.process.equipment.distillation +import jneqsim.process.equipment.ejector +import jneqsim.process.equipment.electrolyzer +import jneqsim.process.equipment.expander +import jneqsim.process.equipment.filter +import jneqsim.process.equipment.flare +import jneqsim.process.equipment.heatexchanger +import jneqsim.process.equipment.manifold +import jneqsim.process.equipment.membrane +import jneqsim.process.equipment.mixer +import jneqsim.process.equipment.network +import jneqsim.process.equipment.pipeline +import jneqsim.process.equipment.powergeneration +import jneqsim.process.equipment.pump +import jneqsim.process.equipment.reactor +import jneqsim.process.equipment.reservoir +import jneqsim.process.equipment.separator +import jneqsim.process.equipment.splitter +import jneqsim.process.equipment.stream +import jneqsim.process.equipment.subsea +import jneqsim.process.equipment.tank +import jneqsim.process.equipment.util +import jneqsim.process.equipment.valve +import jneqsim.process.mechanicaldesign +import jneqsim.process.util.report +import jneqsim.thermo.system +import typing + + + +class EquipmentEnum(java.lang.Enum['EquipmentEnum']): + Stream: typing.ClassVar['EquipmentEnum'] = ... + ThrottlingValve: typing.ClassVar['EquipmentEnum'] = ... + Compressor: typing.ClassVar['EquipmentEnum'] = ... + Pump: typing.ClassVar['EquipmentEnum'] = ... + Separator: typing.ClassVar['EquipmentEnum'] = ... + HeatExchanger: typing.ClassVar['EquipmentEnum'] = ... + Cooler: typing.ClassVar['EquipmentEnum'] = ... + Heater: typing.ClassVar['EquipmentEnum'] = ... + Mixer: typing.ClassVar['EquipmentEnum'] = ... + Splitter: typing.ClassVar['EquipmentEnum'] = ... + Reactor: typing.ClassVar['EquipmentEnum'] = ... + Column: typing.ClassVar['EquipmentEnum'] = ... + ThreePhaseSeparator: typing.ClassVar['EquipmentEnum'] = ... + Recycle: typing.ClassVar['EquipmentEnum'] = ... + Ejector: typing.ClassVar['EquipmentEnum'] = ... + GORfitter: typing.ClassVar['EquipmentEnum'] = ... + Adjuster: typing.ClassVar['EquipmentEnum'] = ... + SetPoint: typing.ClassVar['EquipmentEnum'] = ... + FlowRateAdjuster: typing.ClassVar['EquipmentEnum'] = ... + Calculator: typing.ClassVar['EquipmentEnum'] = ... + Expander: typing.ClassVar['EquipmentEnum'] = ... + SimpleTEGAbsorber: typing.ClassVar['EquipmentEnum'] = ... + Tank: typing.ClassVar['EquipmentEnum'] = ... + ComponentSplitter: typing.ClassVar['EquipmentEnum'] = ... + ReservoirCVDsim: typing.ClassVar['EquipmentEnum'] = ... + ReservoirDiffLibsim: typing.ClassVar['EquipmentEnum'] = ... + VirtualStream: typing.ClassVar['EquipmentEnum'] = ... + ReservoirTPsim: typing.ClassVar['EquipmentEnum'] = ... + SimpleReservoir: typing.ClassVar['EquipmentEnum'] = ... + Manifold: typing.ClassVar['EquipmentEnum'] = ... + Flare: typing.ClassVar['EquipmentEnum'] = ... + FlareStack: typing.ClassVar['EquipmentEnum'] = ... + FuelCell: typing.ClassVar['EquipmentEnum'] = ... + CO2Electrolyzer: typing.ClassVar['EquipmentEnum'] = ... + Electrolyzer: typing.ClassVar['EquipmentEnum'] = ... + WindTurbine: typing.ClassVar['EquipmentEnum'] = ... + BatteryStorage: typing.ClassVar['EquipmentEnum'] = ... + SolarPanel: typing.ClassVar['EquipmentEnum'] = ... + def toString(self) -> java.lang.String: ... + _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]) -> 'EquipmentEnum': ... + @staticmethod + def values() -> typing.MutableSequence['EquipmentEnum']: ... + +class EquipmentFactory: + @staticmethod + def createEjector(string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> jneqsim.process.equipment.ejector.Ejector: ... + @typing.overload + @staticmethod + def createEquipment(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> 'ProcessEquipmentInterface': ... + @typing.overload + @staticmethod + def createEquipment(string: typing.Union[java.lang.String, str], equipmentEnum: EquipmentEnum) -> 'ProcessEquipmentInterface': ... + @staticmethod + def createGORfitter(string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> jneqsim.process.equipment.util.GORfitter: ... + @staticmethod + def createReservoirCVDsim(string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface) -> jneqsim.process.equipment.reservoir.ReservoirCVDsim: ... + @staticmethod + def createReservoirDiffLibsim(string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface) -> jneqsim.process.equipment.reservoir.ReservoirDiffLibsim: ... + @staticmethod + def createReservoirTPsim(string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface) -> jneqsim.process.equipment.reservoir.ReservoirTPsim: ... + +class ProcessEquipmentInterface(jneqsim.process.SimulationInterface): + def displayResult(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getCapacityDuty(self) -> float: ... + def getCapacityMax(self) -> float: ... + def getConditionAnalysisMessage(self) -> java.lang.String: ... + def getController(self) -> jneqsim.process.controllerdevice.ControllerDeviceInterface: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str], double: float) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getFluid(self) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.MechanicalDesign: ... + @typing.overload + def getPressure(self) -> float: ... + @typing.overload + def getPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getReport_json(self) -> java.lang.String: ... + def getRestCapacity(self) -> float: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getSpecification(self) -> java.lang.String: ... + @typing.overload + def getTemperature(self) -> float: ... + @typing.overload + def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def hashCode(self) -> int: ... + def initMechanicalDesign(self) -> None: ... + def needRecalculation(self) -> bool: ... + def reportResults(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def runConditionAnalysis(self, processEquipmentInterface: 'ProcessEquipmentInterface') -> None: ... + def setController(self, controllerDeviceInterface: jneqsim.process.controllerdevice.ControllerDeviceInterface) -> None: ... + def setPressure(self, double: float) -> None: ... + def setRegulatorOutSignal(self, double: float) -> None: ... + def setSpecification(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setTemperature(self, double: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class TwoPortInterface: + def getInStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getInletPressure(self) -> float: ... + def getInletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getInletTemperature(self) -> float: ... + def getOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOutletPressure(self) -> float: ... + def getOutletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOutletTemperature(self) -> float: ... + def setInletPressure(self, double: float) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setInletTemperature(self, double: float) -> None: ... + def setOutletPressure(self, double: float) -> None: ... + def setOutletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setOutletTemperature(self, double: float) -> None: ... + +class ProcessEquipmentBaseClass(jneqsim.process.SimulationBaseClass, ProcessEquipmentInterface): + hasController: bool = ... + report: typing.MutableSequence[typing.MutableSequence[java.lang.String]] = ... + properties: java.util.HashMap = ... + energyStream: jneqsim.process.equipment.stream.EnergyStream = ... + conditionAnalysisMessage: java.lang.String = ... + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def copy(self) -> ProcessEquipmentInterface: ... + def displayResult(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getConditionAnalysisMessage(self) -> java.lang.String: ... + def getController(self) -> jneqsim.process.controllerdevice.ControllerDeviceInterface: ... + def getEnergyStream(self) -> jneqsim.process.equipment.stream.EnergyStream: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str], double: float) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.MechanicalDesign: ... + def getMinimumFlow(self) -> float: ... + @typing.overload + def getPressure(self) -> float: ... + @typing.overload + def getPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getProperty(self, string: typing.Union[java.lang.String, str]) -> typing.Any: ... + def getReport_json(self) -> java.lang.String: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getSpecification(self) -> java.lang.String: ... + @typing.overload + def getTemperature(self) -> float: ... + @typing.overload + def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def hashCode(self) -> int: ... + def initMechanicalDesign(self) -> None: ... + @typing.overload + def isActive(self) -> bool: ... + @typing.overload + def isActive(self, boolean: bool) -> None: ... + def isSetEnergyStream(self) -> bool: ... + def reportResults(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def runConditionAnalysis(self, processEquipmentInterface: ProcessEquipmentInterface) -> None: ... + @typing.overload + def run_step(self) -> None: ... + @typing.overload + def run_step(self, uUID: java.util.UUID) -> None: ... + def setController(self, controllerDeviceInterface: jneqsim.process.controllerdevice.ControllerDeviceInterface) -> None: ... + @typing.overload + def setEnergyStream(self, boolean: bool) -> None: ... + @typing.overload + def setEnergyStream(self, energyStream: jneqsim.process.equipment.stream.EnergyStream) -> None: ... + def setFlowValveController(self, controllerDeviceInterface: jneqsim.process.controllerdevice.ControllerDeviceInterface) -> None: ... + def setMinimumFlow(self, double: float) -> None: ... + def setPressure(self, double: float) -> None: ... + def setRegulatorOutSignal(self, double: float) -> None: ... + def setSpecification(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setTemperature(self, double: float) -> None: ... + def solved(self) -> bool: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class TwoPortEquipment(ProcessEquipmentBaseClass, TwoPortInterface): + @typing.overload + 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 getInletPressure(self) -> float: ... + def getInletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getInletTemperature(self) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getOutletPressure(self) -> float: ... + def getOutletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOutletTemperature(self) -> float: ... + def setInletPressure(self, double: float) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setInletTemperature(self, double: float) -> None: ... + def setOutletPressure(self, double: float) -> None: ... + def setOutletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setOutletTemperature(self, double: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment")``. + + EquipmentEnum: typing.Type[EquipmentEnum] + EquipmentFactory: typing.Type[EquipmentFactory] + ProcessEquipmentBaseClass: typing.Type[ProcessEquipmentBaseClass] + ProcessEquipmentInterface: typing.Type[ProcessEquipmentInterface] + TwoPortEquipment: typing.Type[TwoPortEquipment] + TwoPortInterface: typing.Type[TwoPortInterface] + absorber: jneqsim.process.equipment.absorber.__module_protocol__ + adsorber: jneqsim.process.equipment.adsorber.__module_protocol__ + battery: jneqsim.process.equipment.battery.__module_protocol__ + blackoil: jneqsim.process.equipment.blackoil.__module_protocol__ + compressor: jneqsim.process.equipment.compressor.__module_protocol__ + diffpressure: jneqsim.process.equipment.diffpressure.__module_protocol__ + distillation: jneqsim.process.equipment.distillation.__module_protocol__ + ejector: jneqsim.process.equipment.ejector.__module_protocol__ + electrolyzer: jneqsim.process.equipment.electrolyzer.__module_protocol__ + expander: jneqsim.process.equipment.expander.__module_protocol__ + filter: jneqsim.process.equipment.filter.__module_protocol__ + flare: jneqsim.process.equipment.flare.__module_protocol__ + heatexchanger: jneqsim.process.equipment.heatexchanger.__module_protocol__ + manifold: jneqsim.process.equipment.manifold.__module_protocol__ + membrane: jneqsim.process.equipment.membrane.__module_protocol__ + mixer: jneqsim.process.equipment.mixer.__module_protocol__ + network: jneqsim.process.equipment.network.__module_protocol__ + pipeline: jneqsim.process.equipment.pipeline.__module_protocol__ + powergeneration: jneqsim.process.equipment.powergeneration.__module_protocol__ + pump: jneqsim.process.equipment.pump.__module_protocol__ + reactor: jneqsim.process.equipment.reactor.__module_protocol__ + reservoir: jneqsim.process.equipment.reservoir.__module_protocol__ + separator: jneqsim.process.equipment.separator.__module_protocol__ + splitter: jneqsim.process.equipment.splitter.__module_protocol__ + stream: jneqsim.process.equipment.stream.__module_protocol__ + subsea: jneqsim.process.equipment.subsea.__module_protocol__ + tank: jneqsim.process.equipment.tank.__module_protocol__ + util: jneqsim.process.equipment.util.__module_protocol__ + valve: jneqsim.process.equipment.valve.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/absorber/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/absorber/__init__.pyi new file mode 100644 index 00000000..4bf26175 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/absorber/__init__.pyi @@ -0,0 +1,144 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.separator +import jneqsim.process.equipment.stream +import jneqsim.process.mechanicaldesign.absorber +import typing + + + +class AbsorberInterface(jneqsim.process.equipment.ProcessEquipmentInterface): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def setAproachToEquilibrium(self, double: float) -> None: ... + +class SimpleAbsorber(jneqsim.process.equipment.separator.Separator, AbsorberInterface): + @typing.overload + 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 displayResult(self) -> None: ... + def getFsFactor(self) -> float: ... + def getHTU(self) -> float: ... + def getInStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getInTemperature(self, int: int) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.absorber.AbsorberMechanicalDesign: ... + def getNTU(self) -> float: ... + def getNumberOfStages(self) -> int: ... + def getNumberOfTheoreticalStages(self) -> float: ... + @typing.overload + def getOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getOutStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOutTemperature(self, int: int) -> float: ... + def getSolventInStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getStageEfficiency(self) -> float: ... + def getWettingRate(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setAproachToEquilibrium(self, double: float) -> None: ... + def setHTU(self, double: float) -> None: ... + def setNTU(self, double: float) -> None: ... + def setName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setNumberOfStages(self, int: int) -> None: ... + def setNumberOfTheoreticalStages(self, double: float) -> None: ... + def setOutTemperature(self, double: float) -> None: ... + def setStageEfficiency(self, double: float) -> None: ... + def setdT(self, double: float) -> None: ... + +class SimpleTEGAbsorber(SimpleAbsorber): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addGasInStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def addSolventInStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def addStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcEa(self) -> float: ... + def calcMixStreamEnthalpy(self) -> float: ... + def calcNTU(self, double: float, double2: float, double3: float, double4: float) -> float: ... + def calcNumberOfTheoreticalStages(self) -> float: ... + def calcY0(self) -> float: ... + def displayResult(self) -> None: ... + def getGasInStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getGasLoadFactor(self) -> float: ... + @typing.overload + def getGasLoadFactor(self, int: int) -> float: ... + def getGasOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getInStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getInStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquidOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getOutStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getSolventInStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getSolventOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def guessTemperature(self) -> float: ... + def isSetWaterInDryGas(self, boolean: bool) -> None: ... + def mixStream(self) -> None: ... + def replaceSolventInStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def runConditionAnalysis(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + def setGasOutStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setPressure(self, double: float) -> None: ... + def setSolventOutStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setWaterInDryGas(self, double: float) -> None: ... + +class WaterStripperColumn(SimpleAbsorber): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addGasInStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def addSolventInStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def addStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcEa(self) -> float: ... + def calcMixStreamEnthalpy(self) -> float: ... + def calcNTU(self, double: float, double2: float, double3: float, double4: float) -> float: ... + def calcNumberOfTheoreticalStages(self) -> float: ... + def calcX0(self) -> float: ... + def displayResult(self) -> None: ... + def getGasOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getInStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getInStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquidOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getOutStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getSolventInStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getSolventOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getWaterDewPointTemperature(self) -> float: ... + def guessTemperature(self) -> float: ... + def mixStream(self) -> None: ... + def replaceSolventInStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setGasOutStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setPressure(self, double: float) -> None: ... + def setSolventOutStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setWaterDewPointTemperature(self, double: float, double2: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.absorber")``. + + AbsorberInterface: typing.Type[AbsorberInterface] + SimpleAbsorber: typing.Type[SimpleAbsorber] + SimpleTEGAbsorber: typing.Type[SimpleTEGAbsorber] + WaterStripperColumn: typing.Type[WaterStripperColumn] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/adsorber/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/adsorber/__init__.pyi new file mode 100644 index 00000000..b63e2a2d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/adsorber/__init__.pyi @@ -0,0 +1,54 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.mechanicaldesign.adsorber +import typing + + + +class SimpleAdsorber(jneqsim.process.equipment.ProcessEquipmentBaseClass): + @typing.overload + 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 displayResult(self) -> None: ... + def getHTU(self) -> float: ... + def getInTemperature(self, int: int) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.adsorber.AdsorberMechanicalDesign: ... + def getNTU(self) -> float: ... + def getNumberOfStages(self) -> int: ... + def getNumberOfTheoreticalStages(self) -> float: ... + def getOutStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOutTemperature(self, int: int) -> float: ... + def getStageEfficiency(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setAproachToEquilibrium(self, double: float) -> None: ... + def setHTU(self, double: float) -> None: ... + def setNTU(self, double: float) -> None: ... + def setName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setNumberOfStages(self, int: int) -> None: ... + def setNumberOfTheoreticalStages(self, double: float) -> None: ... + def setOutTemperature(self, double: float) -> None: ... + def setStageEfficiency(self, double: float) -> None: ... + def setdT(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.adsorber")``. + + SimpleAdsorber: typing.Type[SimpleAdsorber] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/battery/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/battery/__init__.pyi new file mode 100644 index 00000000..11d61d4c --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/battery/__init__.pyi @@ -0,0 +1,38 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import typing + + + +class BatteryStorage(jneqsim.process.equipment.ProcessEquipmentBaseClass): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float): ... + def charge(self, double: float, double2: float) -> None: ... + def discharge(self, double: float, double2: float) -> float: ... + def getCapacity(self) -> float: ... + def getStateOfCharge(self) -> float: ... + def getStateOfChargeFraction(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setCapacity(self, double: float) -> None: ... + def setStateOfCharge(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.battery")``. + + BatteryStorage: typing.Type[BatteryStorage] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/blackoil/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/blackoil/__init__.pyi new file mode 100644 index 00000000..7fb003db --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/blackoil/__init__.pyi @@ -0,0 +1,28 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.blackoil +import typing + + + +class BlackOilSeparator: + def __init__(self, string: typing.Union[java.lang.String, str], systemBlackOil: jneqsim.blackoil.SystemBlackOil, double: float, double2: float): ... + def getGasOut(self) -> jneqsim.blackoil.SystemBlackOil: ... + def getInlet(self) -> jneqsim.blackoil.SystemBlackOil: ... + def getName(self) -> java.lang.String: ... + def getOilOut(self) -> jneqsim.blackoil.SystemBlackOil: ... + def getWaterOut(self) -> jneqsim.blackoil.SystemBlackOil: ... + def run(self) -> None: ... + def setInlet(self, systemBlackOil: jneqsim.blackoil.SystemBlackOil) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.blackoil")``. + + BlackOilSeparator: typing.Type[BlackOilSeparator] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/compressor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/compressor/__init__.pyi new file mode 100644 index 00000000..763b06df --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/compressor/__init__.pyi @@ -0,0 +1,498 @@ + +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.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.mechanicaldesign.compressor +import jneqsim.process.util.report +import jneqsim.thermo.system +import typing + + + +class AntiSurge(java.io.Serializable): + def __init__(self): ... + def equals(self, object: typing.Any) -> bool: ... + def getCurrentSurgeFraction(self) -> float: ... + def getSurgeControlFactor(self) -> float: ... + def hashCode(self) -> int: ... + def isActive(self) -> bool: ... + def isSurge(self) -> bool: ... + def setActive(self, boolean: bool) -> None: ... + def setCurrentSurgeFraction(self, double: float) -> None: ... + def setSurge(self, boolean: bool) -> None: ... + def setSurgeControlFactor(self, double: float) -> None: ... + +class BoundaryCurveInterface(java.io.Serializable): + def getFlow(self, double: float) -> float: ... + def isActive(self) -> bool: ... + def isLimit(self, double: float, double2: float) -> bool: ... + def setActive(self, boolean: bool) -> None: ... + def setCurve(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]) -> None: ... + +class CompressorChartGenerator: + def __init__(self, compressor: 'Compressor'): ... + def generateCompressorChart(self, string: typing.Union[java.lang.String, str]) -> 'CompressorChart': ... + +class CompressorChartInterface(java.lang.Cloneable): + @typing.overload + def addCurve(self, double: 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]) -> None: ... + @typing.overload + def addCurve(self, double: 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], doubleArray4: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def generateStoneWallCurve(self) -> None: ... + def generateSurgeCurve(self) -> None: ... + def getFlow(self, double: float, double2: float, double3: float) -> float: ... + def getHeadUnit(self) -> java.lang.String: ... + def getMinSpeedCurve(self) -> float: ... + def getPolytropicEfficiency(self, double: float, double2: float) -> float: ... + def getPolytropicHead(self, double: float, double2: float) -> float: ... + def getSpeed(self, double: float, double2: float) -> int: ... + def getStoneWallCurve(self) -> 'StoneWallCurve': ... + def getStoneWallFlowAtSpeed(self, double: float) -> float: ... + def getStoneWallHeadAtSpeed(self, double: float) -> float: ... + def getSurgeCurve(self) -> 'SafeSplineSurgeCurve': ... + def getSurgeFlowAtSpeed(self, double: float) -> float: ... + def getSurgeHeadAtSpeed(self, double: float) -> float: ... + def hashCode(self) -> int: ... + def isUseCompressorChart(self) -> bool: ... + def plot(self) -> None: ... + @typing.overload + def setCurves(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray5: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setCurves(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray5: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray6: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setHeadUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setReferenceConditions(self, double: float, double2: float, double3: float, double4: float) -> None: ... + def setStoneWallCurve(self, stoneWallCurve: 'StoneWallCurve') -> None: ... + def setSurgeCurve(self, safeSplineSurgeCurve: 'SafeSplineSurgeCurve') -> None: ... + def setUseCompressorChart(self, boolean: bool) -> None: ... + def setUseRealKappa(self, boolean: bool) -> None: ... + def useRealKappa(self) -> bool: ... + +class CompressorChartReader: + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def getChokeFlow(self) -> typing.MutableSequence[float]: ... + def getChokeHead(self) -> typing.MutableSequence[float]: ... + def getFlowLines(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getHeadLines(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getPolyEffLines(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getSpeeds(self) -> typing.MutableSequence[float]: ... + def getStonewallCurve(self) -> typing.MutableSequence[float]: ... + def getSurgeCurve(self) -> typing.MutableSequence[float]: ... + def getSurgeFlow(self) -> typing.MutableSequence[float]: ... + def getSurgeHead(self) -> typing.MutableSequence[float]: ... + def setCurvesToCompressor(self, compressor: 'Compressor') -> None: ... + def setHeadUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class CompressorCurve(java.io.Serializable): + flow: typing.MutableSequence[float] = ... + flowPolytropicEfficiency: typing.MutableSequence[float] = ... + head: typing.MutableSequence[float] = ... + polytropicEfficiency: typing.MutableSequence[float] = ... + speed: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: 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]): ... + @typing.overload + def __init__(self, double: 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], doubleArray4: typing.Union[typing.List[float], jpype.JArray]): ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + +class CompressorInterface(jneqsim.process.equipment.ProcessEquipmentInterface, jneqsim.process.equipment.TwoPortInterface): + def equals(self, object: typing.Any) -> bool: ... + def getAntiSurge(self) -> AntiSurge: ... + def getDistanceToSurge(self) -> float: ... + def getEnergy(self) -> float: ... + def getIsentropicEfficiency(self) -> float: ... + def getMaximumSpeed(self) -> float: ... + def getMinimumSpeed(self) -> float: ... + def getPolytropicEfficiency(self) -> float: ... + def getSurgeFlowRate(self) -> float: ... + def getSurgeFlowRateMargin(self) -> float: ... + def getSurgeFlowRateStd(self) -> float: ... + def hashCode(self) -> int: ... + def isStoneWall(self) -> bool: ... + def isSurge(self) -> bool: ... + def setCompressorChartType(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setIsentropicEfficiency(self, double: float) -> None: ... + def setMaximumSpeed(self, double: float) -> None: ... + def setMinimumSpeed(self, double: float) -> None: ... + def setPolytropicEfficiency(self, double: float) -> None: ... + +class CompressorPropertyProfile(java.io.Serializable): + def __init__(self): ... + def addFluid(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def getFluid(self) -> java.util.ArrayList[jneqsim.thermo.system.SystemInterface]: ... + def isActive(self) -> bool: ... + def setActive(self, boolean: bool) -> None: ... + def setFluid(self, arrayList: java.util.ArrayList[jneqsim.thermo.system.SystemInterface]) -> None: ... + +class BoundaryCurve(BoundaryCurveInterface): + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def getFlow(self, double: float) -> float: ... + @typing.overload + def getFlow(self) -> typing.MutableSequence[float]: ... + def getHead(self) -> typing.MutableSequence[float]: ... + def hashCode(self) -> int: ... + def isActive(self) -> bool: ... + def setActive(self, boolean: bool) -> None: ... + def setCurve(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]) -> None: ... + +class Compressor(jneqsim.process.equipment.TwoPortEquipment, CompressorInterface): + thermoSystem: jneqsim.thermo.system.SystemInterface = ... + dH: float = ... + inletEnthalpy: float = ... + pressure: float = ... + isentropicEfficiency: float = ... + polytropicEfficiency: float = ... + usePolytropicCalc: bool = ... + powerSet: bool = ... + calcPressureOut: bool = ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], boolean: bool): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def copy(self) -> 'Compressor': ... + def displayResult(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def findOutPressure(self, double: float, double2: float, double3: float) -> float: ... + def generateCompressorCurves(self) -> None: ... + def getActualCompressionRatio(self) -> float: ... + def getAntiSurge(self) -> AntiSurge: ... + def getCapacityDuty(self) -> float: ... + def getCapacityMax(self) -> float: ... + def getCompressionRatio(self) -> float: ... + def getCompressorChart(self) -> CompressorChartInterface: ... + def getDistanceToStoneWall(self) -> float: ... + def getDistanceToSurge(self) -> float: ... + def getEnergy(self) -> float: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str], double: float) -> float: ... + def getIsentropicEfficiency(self) -> float: ... + def getMaxOutletPressure(self) -> float: ... + def getMaximumSpeed(self) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.compressor.CompressorMechanicalDesign: ... + def getMinimumSpeed(self) -> float: ... + def getNumberOfCompressorCalcSteps(self) -> int: ... + def getOutTemperature(self) -> float: ... + def getOutletPressure(self) -> float: ... + def getPolytropicEfficiency(self) -> float: ... + def getPolytropicExponent(self) -> float: ... + def getPolytropicFluidHead(self) -> float: ... + @typing.overload + def getPolytropicHead(self) -> float: ... + @typing.overload + def getPolytropicHead(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getPolytropicHeadMeter(self) -> float: ... + def getPolytropicMethod(self) -> java.lang.String: ... + @typing.overload + def getPower(self) -> float: ... + @typing.overload + def getPower(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getPropertyProfile(self) -> CompressorPropertyProfile: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getSafetyFactorCorrectedFlowHeadAtCurrentSpeed(self) -> typing.MutableSequence[float]: ... + def getSpeed(self) -> float: ... + def getSurgeFlowRate(self) -> float: ... + def getSurgeFlowRateMargin(self) -> float: ... + def getSurgeFlowRateStd(self) -> float: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getTotalWork(self) -> float: ... + def hashCode(self) -> int: ... + def initMechanicalDesign(self) -> None: ... + def isCalcPressureOut(self) -> bool: ... + def isLimitSpeed(self) -> bool: ... + def isSetMaxOutletPressure(self) -> bool: ... + def isSolveSpeed(self) -> bool: ... + @typing.overload + def isStoneWall(self) -> bool: ... + @typing.overload + def isStoneWall(self, double: float, double2: float) -> bool: ... + @typing.overload + def isSurge(self, double: float, double2: float) -> bool: ... + @typing.overload + def isSurge(self) -> bool: ... + def isUseGERG2008(self) -> bool: ... + def isUseLeachman(self) -> bool: ... + def isUseRigorousPolytropicMethod(self) -> bool: ... + def isUseVega(self) -> bool: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def runController(self, double: float, 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 setAntiSurge(self, antiSurge: AntiSurge) -> None: ... + def setCalcPressureOut(self, boolean: bool) -> None: ... + def setCompressionRatio(self, double: float) -> None: ... + def setCompressorChart(self, compressorChartInterface: CompressorChartInterface) -> None: ... + def setCompressorChartType(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setIsSetMaxOutletPressure(self, boolean: bool) -> None: ... + def setIsentropicEfficiency(self, double: float) -> None: ... + def setLimitSpeed(self, boolean: bool) -> None: ... + def setMaxOutletPressure(self, double: float) -> None: ... + def setMaximumSpeed(self, double: float) -> None: ... + def setMinimumSpeed(self, double: float) -> None: ... + def setNumberOfCompressorCalcSteps(self, int: int) -> None: ... + def setOutTemperature(self, double: float) -> None: ... + @typing.overload + def setOutletPressure(self, double: float) -> None: ... + @typing.overload + def setOutletPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setPolytropicEfficiency(self, double: float) -> None: ... + def setPolytropicHeadMeter(self, double: float) -> None: ... + def setPolytropicMethod(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPower(self, double: float) -> None: ... + @typing.overload + def setPressure(self, double: float) -> None: ... + @typing.overload + def setPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setPropertyProfile(self, compressorPropertyProfile: CompressorPropertyProfile) -> None: ... + def setSolveSpeed(self, boolean: bool) -> None: ... + def setSpeed(self, double: float) -> None: ... + def setUseEnergyEfficiencyChart(self, boolean: bool) -> None: ... + def setUseGERG2008(self, boolean: bool) -> None: ... + def setUseLeachman(self, boolean: bool) -> None: ... + def setUsePolytropicCalc(self, boolean: bool) -> None: ... + def setUseRigorousPolytropicMethod(self, boolean: bool) -> None: ... + def setUseVega(self, boolean: bool) -> None: ... + def solveAntiSurge(self) -> None: ... + def solveEfficiency(self, double: float) -> float: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + def useOutTemperature(self, boolean: bool) -> None: ... + def usePolytropicCalc(self) -> bool: ... + +class CompressorChart(CompressorChartInterface, java.io.Serializable): + def __init__(self): ... + @typing.overload + def addCurve(self, double: 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]) -> None: ... + @typing.overload + def addCurve(self, double: 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], doubleArray4: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def addSurgeCurve(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def checkStoneWall(self, double: float, double2: float) -> bool: ... + def checkSurge1(self, double: float, double2: float) -> bool: ... + def checkSurge2(self, double: float, double2: float) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def fitReducedCurve(self) -> None: ... + def generateStoneWallCurve(self) -> None: ... + def generateSurgeCurve(self) -> None: ... + def getFlow(self, double: float, double2: float, double3: float) -> float: ... + def getHeadUnit(self) -> java.lang.String: ... + def getMaxSpeedCurve(self) -> float: ... + def getMinSpeedCurve(self) -> float: ... + def getPolytropicEfficiency(self, double: float, double2: float) -> float: ... + def getPolytropicHead(self, double: float, double2: float) -> float: ... + def getSpeed(self, double: float, double2: float) -> int: ... + def getStoneWallCurve(self) -> 'StoneWallCurve': ... + def getStoneWallFlowAtSpeed(self, double: float) -> float: ... + def getStoneWallHeadAtSpeed(self, double: float) -> float: ... + def getSurgeCurve(self) -> 'SafeSplineSurgeCurve': ... + def getSurgeFlowAtSpeed(self, double: float) -> float: ... + def getSurgeHeadAtSpeed(self, double: float) -> float: ... + def hashCode(self) -> int: ... + def isUseCompressorChart(self) -> bool: ... + def plot(self) -> None: ... + def polytropicEfficiency(self, double: float, double2: float) -> float: ... + @typing.overload + def setCurves(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray5: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setCurves(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray5: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray6: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setHeadUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setMaxSpeedCurve(self, double: float) -> None: ... + def setMinSpeedCurve(self, double: float) -> None: ... + def setReferenceConditions(self, double: float, double2: float, double3: float, double4: float) -> None: ... + def setStoneWallCurve(self, stoneWallCurve: 'StoneWallCurve') -> None: ... + def setSurgeCurve(self, safeSplineSurgeCurve: 'SafeSplineSurgeCurve') -> None: ... + def setUseCompressorChart(self, boolean: bool) -> None: ... + def setUseRealKappa(self, boolean: bool) -> None: ... + def useRealKappa(self) -> bool: ... + +class CompressorChartAlternativeMapLookup(CompressorChart, CompressorChartInterface, java.io.Serializable): + def __init__(self): ... + @typing.overload + def addCurve(self, double: 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]) -> None: ... + @typing.overload + def addCurve(self, double: 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], doubleArray4: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def addSurgeCurve(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + @staticmethod + def bisect_left(doubleArray: typing.Union[typing.List[float], jpype.JArray], double2: float) -> int: ... + @typing.overload + @staticmethod + def bisect_left(doubleArray: typing.Union[typing.List[float], jpype.JArray], double2: float, int: int, int2: int) -> int: ... + def checkStoneWall(self, double: float, double2: float) -> bool: ... + def checkSurge1(self, double: float, double2: float) -> bool: ... + def checkSurge2(self, double: float, double2: float) -> bool: ... + def getChartValues(self) -> java.util.ArrayList[CompressorCurve]: ... + def getClosestRefSpeeds(self, double: float) -> java.util.ArrayList[float]: ... + def getCurveAtRefSpeed(self, double: float) -> CompressorCurve: ... + def getFlow(self, double: float, double2: float, double3: float) -> float: ... + def getGearRatio(self) -> float: ... + def getHeadUnit(self) -> java.lang.String: ... + def getMinSpeedCurve(self) -> float: ... + def getPolytropicEfficiency(self, double: float, double2: float) -> float: ... + def getPolytropicHead(self, double: float, double2: float) -> float: ... + def getSpeed(self, double: float, double2: float) -> int: ... + def getStoneWallCurve(self) -> 'StoneWallCurve': ... + def getSurgeCurve(self) -> 'SafeSplineSurgeCurve': ... + def isUseCompressorChart(self) -> bool: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def plot(self) -> None: ... + def polytropicEfficiency(self, double: float, double2: float) -> float: ... + def prettyPrintChartValues(self) -> None: ... + @typing.overload + def setCurves(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray5: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setCurves(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray5: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray6: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setGearRatio(self, double: float) -> None: ... + def setHeadUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setReferenceConditions(self, double: float, double2: float, double3: float, double4: float) -> None: ... + def setStoneWallCurve(self, stoneWallCurve: 'StoneWallCurve') -> None: ... + def setSurgeCurve(self, safeSplineSurgeCurve: 'SafeSplineSurgeCurve') -> None: ... + def setUseCompressorChart(self, boolean: bool) -> None: ... + def setUseRealKappa(self, boolean: bool) -> None: ... + def useRealKappa(self) -> bool: ... + +class StoneWallCurve(BoundaryCurve): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]): ... + def getStoneWallFlow(self, double: float) -> float: ... + def isLimit(self, double: float, double2: float) -> bool: ... + def isStoneWall(self, double: float, double2: float) -> bool: ... + +class SurgeCurve(BoundaryCurve): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]): ... + def getSurgeFlow(self, double: float) -> float: ... + def isLimit(self, double: float, double2: float) -> bool: ... + def isSurge(self, double: float, double2: float) -> bool: ... + +class CompressorChartAlternativeMapLookupExtrapolate(CompressorChartAlternativeMapLookup): + def __init__(self): ... + def getClosestRefSpeeds(self, double: float) -> java.util.ArrayList[float]: ... + def getPolytropicEfficiency(self, double: float, double2: float) -> float: ... + def getPolytropicHead(self, double: float, double2: float) -> float: ... + +class SafeSplineStoneWallCurve(StoneWallCurve): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]): ... + @typing.overload + def getFlow(self, double: float) -> float: ... + @typing.overload + def getFlow(self) -> typing.MutableSequence[float]: ... + def getSortedFlow(self) -> typing.MutableSequence[float]: ... + def getSortedHead(self) -> typing.MutableSequence[float]: ... + def getStoneWallFlow(self, double: float) -> float: ... + def getStoneWallHead(self, double: float) -> float: ... + def isStoneWall(self, double: float, double2: float) -> bool: ... + def setCurve(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]) -> None: ... + +class SafeSplineSurgeCurve(SurgeCurve): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]): ... + @typing.overload + def getFlow(self, double: float) -> float: ... + @typing.overload + def getFlow(self) -> typing.MutableSequence[float]: ... + def getSortedFlow(self) -> typing.MutableSequence[float]: ... + def getSortedHead(self) -> typing.MutableSequence[float]: ... + def getSurgeFlow(self, double: float) -> float: ... + def getSurgeHead(self, double: float) -> float: ... + def isSurge(self, double: float, double2: float) -> bool: ... + def setCurve(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]) -> None: ... + +class CompressorChartKhader2015(CompressorChartAlternativeMapLookupExtrapolate): + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface, double: float): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface, double: float): ... + def generateRealCurvesForFluid(self) -> None: ... + def generateStoneWallCurve(self) -> None: ... + def generateSurgeCurve(self) -> None: ... + def getCorrectedCurves(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray5: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray6: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> java.util.List['CompressorChartKhader2015.CorrectedCurve']: ... + def getImpellerOuterDiameter(self) -> float: ... + def getPolytropicEfficiency(self, double: float, double2: float) -> float: ... + def getPolytropicHead(self, double: float, double2: float) -> float: ... + def getRealCurves(self) -> java.util.List['CompressorChartKhader2015.RealCurve']: ... + def getReferenceFluid(self) -> jneqsim.thermo.system.SystemInterface: ... + def getStoneWallFlowAtSpeed(self, double: float) -> float: ... + def getStoneWallHeadAtSpeed(self, double: float) -> float: ... + def getSurgeFlowAtSpeed(self, double: float) -> float: ... + def getSurgeHeadAtSpeed(self, double: float) -> float: ... + def prettyPrintRealCurvesForFluid(self) -> None: ... + @typing.overload + def setCurves(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray5: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setCurves(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray5: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray6: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setImpellerOuterDiameter(self, double: float) -> None: ... + def setReferenceFluid(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + class CorrectedCurve: + machineMachNumber: float = ... + correctedFlowFactor: typing.MutableSequence[float] = ... + correctedHeadFactor: typing.MutableSequence[float] = ... + correctedFlowFactorEfficiency: typing.MutableSequence[float] = ... + polytropicEfficiency: typing.MutableSequence[float] = ... + def __init__(self, double: 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], doubleArray4: typing.Union[typing.List[float], jpype.JArray]): ... + class RealCurve: + speed: float = ... + flow: typing.MutableSequence[float] = ... + head: typing.MutableSequence[float] = ... + flowPolyEff: typing.MutableSequence[float] = ... + polytropicEfficiency: typing.MutableSequence[float] = ... + def __init__(self, double: 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], doubleArray4: typing.Union[typing.List[float], jpype.JArray]): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.compressor")``. + + AntiSurge: typing.Type[AntiSurge] + BoundaryCurve: typing.Type[BoundaryCurve] + BoundaryCurveInterface: typing.Type[BoundaryCurveInterface] + Compressor: typing.Type[Compressor] + CompressorChart: typing.Type[CompressorChart] + CompressorChartAlternativeMapLookup: typing.Type[CompressorChartAlternativeMapLookup] + CompressorChartAlternativeMapLookupExtrapolate: typing.Type[CompressorChartAlternativeMapLookupExtrapolate] + CompressorChartGenerator: typing.Type[CompressorChartGenerator] + CompressorChartInterface: typing.Type[CompressorChartInterface] + CompressorChartKhader2015: typing.Type[CompressorChartKhader2015] + CompressorChartReader: typing.Type[CompressorChartReader] + CompressorCurve: typing.Type[CompressorCurve] + CompressorInterface: typing.Type[CompressorInterface] + CompressorPropertyProfile: typing.Type[CompressorPropertyProfile] + SafeSplineStoneWallCurve: typing.Type[SafeSplineStoneWallCurve] + SafeSplineSurgeCurve: typing.Type[SafeSplineSurgeCurve] + StoneWallCurve: typing.Type[StoneWallCurve] + SurgeCurve: typing.Type[SurgeCurve] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/diffpressure/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/diffpressure/__init__.pyi new file mode 100644 index 00000000..535ace92 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/diffpressure/__init__.pyi @@ -0,0 +1,63 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.process.equipment +import typing + + + +class DifferentialPressureFlowCalculator: + @typing.overload + @staticmethod + def calculate(doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[float], jpype.JArray], string: typing.Union[java.lang.String, str]) -> 'DifferentialPressureFlowCalculator.FlowCalculationResult': ... + @typing.overload + @staticmethod + def calculate(doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[float], jpype.JArray], string: typing.Union[java.lang.String, str], doubleArray4: typing.Union[typing.List[float], jpype.JArray]) -> 'DifferentialPressureFlowCalculator.FlowCalculationResult': ... + @typing.overload + @staticmethod + def calculate(doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[float], jpype.JArray], string: typing.Union[java.lang.String, str], doubleArray4: typing.Union[typing.List[float], jpype.JArray], list: java.util.List[typing.Union[java.lang.String, str]], doubleArray5: typing.Union[typing.List[float], jpype.JArray], boolean: bool) -> 'DifferentialPressureFlowCalculator.FlowCalculationResult': ... + class FlowCalculationResult: + def getMassFlowKgPerHour(self) -> typing.MutableSequence[float]: ... + def getMolecularWeightGPerMol(self) -> typing.MutableSequence[float]: ... + def getStandardFlowMSm3PerDay(self) -> typing.MutableSequence[float]: ... + def getVolumetricFlowM3PerHour(self) -> typing.MutableSequence[float]: ... + +class Orifice(jneqsim.process.equipment.TwoPortEquipment): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float, double5: float): ... + def calc_dp(self) -> float: ... + @staticmethod + def calculateBetaRatio(double: float, double2: float) -> float: ... + @staticmethod + def calculateDischargeCoefficient(double: float, double2: float, double3: float, double4: float, double5: float, string: typing.Union[java.lang.String, str]) -> float: ... + @staticmethod + def calculateExpansibility(double: float, double2: float, double3: float, double4: float, double5: float) -> float: ... + @staticmethod + def calculateMassFlowRate(double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, string: typing.Union[java.lang.String, str]) -> float: ... + @staticmethod + def calculatePressureDrop(double: float, double2: float, double3: float, double4: float, double5: float) -> float: ... + @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 setOrificeParameters(self, double: float, double2: float, double3: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.diffpressure")``. + + DifferentialPressureFlowCalculator: typing.Type[DifferentialPressureFlowCalculator] + Orifice: typing.Type[Orifice] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/distillation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/distillation/__init__.pyi new file mode 100644 index 00000000..445a56e9 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/distillation/__init__.pyi @@ -0,0 +1,205 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.process.equipment +import jneqsim.process.equipment.mixer +import jneqsim.process.equipment.stream +import jneqsim.process.util.report +import typing + + + +class DistillationColumnMatrixSolver: + def __init__(self, distillationColumn: 'DistillationColumn'): ... + def solve(self, uUID: java.util.UUID) -> None: ... + +class DistillationInterface(jneqsim.process.equipment.ProcessEquipmentInterface): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def setNumberOfTrays(self, int: int) -> None: ... + +class TrayInterface(jneqsim.process.equipment.ProcessEquipmentInterface): + def addStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def setHeatInput(self, double: float) -> None: ... + +class DistillationColumn(jneqsim.process.equipment.ProcessEquipmentBaseClass, DistillationInterface): + def __init__(self, string: typing.Union[java.lang.String, str], int: int, boolean: bool, boolean2: bool): ... + @typing.overload + def addFeedStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + @typing.overload + def addFeedStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface, int: int) -> None: ... + def componentMassBalanceCheck(self, string: typing.Union[java.lang.String, str]) -> bool: ... + def displayResult(self) -> None: ... + def energyBalanceCheck(self) -> None: ... + def findOptimalNumberOfTrays(self, double: float, string: typing.Union[java.lang.String, str], boolean: bool, int: int) -> int: ... + def getCondenser(self) -> 'Condenser': ... + def getCondenserTemperature(self) -> float: ... + def getEnergyBalanceError(self) -> float: ... + def getEnthalpyBalanceTolerance(self) -> float: ... + def getFeedStreams(self, int: int) -> java.util.List[jneqsim.process.equipment.stream.StreamInterface]: ... + def getFsFactor(self) -> float: ... + def getGasOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getInternalDiameter(self) -> float: ... + def getLastEnergyResidual(self) -> float: ... + def getLastIterationCount(self) -> int: ... + def getLastMassResidual(self) -> float: ... + def getLastSolveTimeSeconds(self) -> float: ... + def getLastTemperatureResidual(self) -> float: ... + def getLiquidOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMassBalanceError(self) -> float: ... + def getMassBalanceTolerance(self) -> float: ... + def getNumerOfTrays(self) -> int: ... + def getReboiler(self) -> 'Reboiler': ... + def getReboilerTemperature(self) -> float: ... + def getTemperatureTolerance(self) -> float: ... + def getTray(self, int: int) -> 'SimpleTray': ... + def getTrays(self) -> java.util.ArrayList['SimpleTray']: ... + def init(self) -> None: ... + def isDoInitializion(self) -> bool: ... + def isDoMultiPhaseCheck(self) -> bool: ... + def isEnforceEnergyBalanceTolerance(self) -> bool: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def massBalanceCheck(self) -> bool: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def runBroyden(self, uUID: java.util.UUID) -> None: ... + def setBottomPressure(self, double: float) -> None: ... + def setCondenserTemperature(self, double: float) -> None: ... + def setDoInitializion(self, boolean: bool) -> None: ... + def setEnforceEnergyBalanceTolerance(self, boolean: bool) -> None: ... + def setEnthalpyBalanceTolerance(self, double: float) -> None: ... + def setInternalDiameter(self, double: float) -> None: ... + def setMassBalanceTolerance(self, double: float) -> None: ... + def setMaxNumberOfIterations(self, int: int) -> None: ... + def setMultiPhaseCheck(self, boolean: bool) -> None: ... + def setNumberOfTrays(self, int: int) -> None: ... + def setReboilerTemperature(self, double: float) -> None: ... + def setRelaxationFactor(self, double: float) -> None: ... + def setSolverType(self, solverType: 'DistillationColumn.SolverType') -> None: ... + def setTemperatureTolerance(self, double: float) -> None: ... + def setTopCondenserDuty(self, double: float) -> None: ... + def setTopPressure(self, double: float) -> None: ... + def solved(self) -> bool: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + class SolverType(java.lang.Enum['DistillationColumn.SolverType']): + DIRECT_SUBSTITUTION: typing.ClassVar['DistillationColumn.SolverType'] = ... + DAMPED_SUBSTITUTION: typing.ClassVar['DistillationColumn.SolverType'] = ... + INSIDE_OUT: typing.ClassVar['DistillationColumn.SolverType'] = ... + MATRIX_SOLVER: typing.ClassVar['DistillationColumn.SolverType'] = ... + _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]) -> 'DistillationColumn.SolverType': ... + @staticmethod + def values() -> typing.MutableSequence['DistillationColumn.SolverType']: ... + +class SimpleTray(jneqsim.process.equipment.mixer.Mixer, TrayInterface): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def TPflash(self) -> None: ... + def calcMixStreamEnthalpy(self) -> float: ... + def calcMixStreamEnthalpy0(self) -> float: ... + def getFeedRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getGasOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquidFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getLiquidOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getTemperature(self) -> float: ... + def getVaporFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def guessTemperature(self) -> float: ... + def init(self) -> None: ... + def massBalance(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def run2(self) -> None: ... + def setHeatInput(self, double: float) -> None: ... + def setPressure(self, double: float) -> None: ... + def setTemperature(self, double: float) -> None: ... + +class Condenser(SimpleTray): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def getDuty(self) -> float: ... + @typing.overload + def getDuty(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getGasOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquidOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquidProductStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getProductOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getRefluxRatio(self) -> float: ... + def isSeparation_with_liquid_reflux(self) -> bool: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setRefluxRatio(self, double: float) -> None: ... + def setSeparation_with_liquid_reflux(self, boolean: bool, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTotalCondenser(self, boolean: bool) -> None: ... + +class Reboiler(SimpleTray): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def getDuty(self) -> float: ... + @typing.overload + def getDuty(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getRefluxRatio(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setRefluxRatio(self, double: float) -> None: ... + +class VLSolidTray(SimpleTray): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def calcMixStreamEnthalpy(self) -> float: ... + def getGasOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquidOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getTemperature(self) -> float: ... + def init(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setHeatInput(self, double: float) -> None: ... + def setTemperature(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.distillation")``. + + Condenser: typing.Type[Condenser] + DistillationColumn: typing.Type[DistillationColumn] + DistillationColumnMatrixSolver: typing.Type[DistillationColumnMatrixSolver] + DistillationInterface: typing.Type[DistillationInterface] + Reboiler: typing.Type[Reboiler] + SimpleTray: typing.Type[SimpleTray] + TrayInterface: typing.Type[TrayInterface] + VLSolidTray: typing.Type[VLSolidTray] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/ejector/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/ejector/__init__.pyi new file mode 100644 index 00000000..46b04dff --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/ejector/__init__.pyi @@ -0,0 +1,75 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.mechanicaldesign.ejector +import typing + + + +class Ejector(jneqsim.process.equipment.ProcessEquipmentBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface): ... + def getDesignResult(self) -> jneqsim.process.mechanicaldesign.ejector.EjectorMechanicalDesign: ... + def getEntrainmentRatio(self) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.ejector.EjectorMechanicalDesign: ... + def getOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def initMechanicalDesign(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setDesignDiffuserOutletVelocity(self, double: float) -> None: ... + def setDesignSuctionVelocity(self, double: float) -> None: ... + def setDiffuserEfficiency(self, double: float) -> None: ... + def setDischargeConnectionLength(self, double: float) -> None: ... + def setDischargePressure(self, double: float) -> None: ... + def setEfficiencyIsentropic(self, double: float) -> None: ... + def setMixingPressure(self, double: float) -> None: ... + def setSuctionConnectionLength(self, double: float) -> None: ... + def setThroatArea(self, double: float) -> None: ... + +class EjectorDesignResult: + 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): ... + @staticmethod + def empty() -> 'EjectorDesignResult': ... + def getBodyVolume(self) -> float: ... + def getConnectedPipingVolume(self) -> float: ... + def getDiffuserOutletArea(self) -> float: ... + def getDiffuserOutletDiameter(self) -> float: ... + def getDiffuserOutletLength(self) -> float: ... + def getDiffuserOutletVelocity(self) -> float: ... + def getDischargeConnectionLength(self) -> float: ... + def getEntrainmentRatio(self) -> float: ... + def getMixingChamberArea(self) -> float: ... + def getMixingChamberDiameter(self) -> float: ... + def getMixingChamberLength(self) -> float: ... + def getMixingChamberVelocity(self) -> float: ... + def getMixingPressure(self) -> float: ... + def getMotiveNozzleDiameter(self) -> float: ... + def getMotiveNozzleEffectiveLength(self) -> float: ... + def getMotiveNozzleExitVelocity(self) -> float: ... + def getMotiveNozzleThroatArea(self) -> float: ... + def getSuctionConnectionLength(self) -> float: ... + def getSuctionInletArea(self) -> float: ... + def getSuctionInletDiameter(self) -> float: ... + def getSuctionInletLength(self) -> float: ... + def getSuctionInletVelocity(self) -> float: ... + def getTotalVolume(self) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.ejector")``. + + Ejector: typing.Type[Ejector] + EjectorDesignResult: typing.Type[EjectorDesignResult] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/electrolyzer/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/electrolyzer/__init__.pyi new file mode 100644 index 00000000..e3b36e50 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/electrolyzer/__init__.pyi @@ -0,0 +1,64 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import typing + + + +class CO2Electrolyzer(jneqsim.process.equipment.ProcessEquipmentBaseClass): + @typing.overload + 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 getGasProductStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquidProductStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setCO2Conversion(self, double: float) -> None: ... + def setCellVoltage(self, double: float) -> None: ... + def setCo2ComponentName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setCurrentEfficiency(self, double: float) -> None: ... + def setElectronsPerMoleProduct(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def setGasProductSelectivity(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setLiquidProductSelectivity(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def setProductFaradaicEfficiency(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def setUseSelectivityModel(self, boolean: bool) -> None: ... + +class Electrolyzer(jneqsim.process.equipment.ProcessEquipmentBaseClass): + @typing.overload + 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 getHydrogenOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getOxygenOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @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: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.electrolyzer")``. + + CO2Electrolyzer: typing.Type[CO2Electrolyzer] + Electrolyzer: typing.Type[Electrolyzer] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/expander/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/expander/__init__.pyi new file mode 100644 index 00000000..4f3c1c3f --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/expander/__init__.pyi @@ -0,0 +1,152 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.process.equipment +import jneqsim.process.equipment.compressor +import jneqsim.process.equipment.stream +import jneqsim.process.util.report +import typing + + + +class ExpanderInterface(jneqsim.process.equipment.ProcessEquipmentInterface, jneqsim.process.equipment.TwoPortInterface): + def equals(self, object: typing.Any) -> bool: ... + def getEnergy(self) -> float: ... + def hashCode(self) -> int: ... + +class Expander(jneqsim.process.equipment.compressor.Compressor, ExpanderInterface): + @typing.overload + 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): ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + +class ExpanderOld(jneqsim.process.equipment.TwoPortEquipment, ExpanderInterface): + @typing.overload + 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 displayResult(self) -> None: ... + def getEnergy(self) -> float: ... + @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 setOutletPressure(self, double: float) -> None: ... + +class TurboExpanderCompressor(Expander): + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def calcIGVOpenArea(self) -> float: ... + def calcIGVOpening(self) -> float: ... + def calcIGVOpeningFromFlow(self) -> float: ... + def getBearingLossPower(self) -> float: ... + def getCompressorDesignPolytropicEfficiency(self) -> float: ... + def getCompressorDesignPolytropicHead(self) -> float: ... + def getCompressorDesingPolytropicHead(self) -> float: ... + def getCompressorFeedStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getCompressorOutletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getCompressorPolytropicEfficiency(self) -> float: ... + def getCompressorPolytropicEfficieny(self) -> float: ... + def getCompressorPolytropicHead(self) -> float: ... + def getCompressorSpeed(self) -> float: ... + def getCurrentIGVArea(self) -> float: ... + def getDesignCompressorPolytropicEfficiency(self) -> float: ... + def getDesignExpanderQn(self) -> float: ... + def getDesignQn(self) -> float: ... + def getDesignSpeed(self) -> float: ... + def getDesignUC(self) -> float: ... + def getEfficiencyFromQN(self, double: float) -> float: ... + def getEfficiencyFromUC(self, double: float) -> float: ... + def getExpanderDesignIsentropicEfficiency(self) -> float: ... + def getExpanderFeedStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getExpanderIsentropicEfficiency(self) -> float: ... + def getExpanderOutPressure(self) -> float: ... + def getExpanderOutletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getExpanderSpeed(self) -> float: ... + def getGearRatio(self) -> float: ... + def getHeadFromQN(self, double: float) -> float: ... + def getIGVopening(self) -> float: ... + def getIgvAreaIncreaseFactor(self) -> float: ... + def getImpellerDiameter(self) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMaximumIGVArea(self) -> float: ... + def getOutletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getPowerCompressor(self) -> float: ... + @typing.overload + def getPowerCompressor(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getPowerExpander(self) -> float: ... + @typing.overload + def getPowerExpander(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getQNratiocompressor(self) -> float: ... + def getQNratioexpander(self) -> float: ... + def getQn(self) -> float: ... + def getQnCurveA(self) -> float: ... + def getQnCurveH(self) -> float: ... + def getQnCurveK(self) -> float: ... + def getQnHeadCurveA(self) -> float: ... + def getQnHeadCurveH(self) -> float: ... + def getQnHeadCurveK(self) -> float: ... + @staticmethod + def getSerialversionuid() -> int: ... + def getSpeed(self) -> float: ... + def getUCratiocompressor(self) -> float: ... + def getUCratioexpander(self) -> float: ... + def getUcCurveA(self) -> float: ... + def getUcCurveH(self) -> float: ... + def getUcCurveK(self) -> float: ... + def isUsingExpandedIGVArea(self) -> bool: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setCompressorDesignPolytropicEfficiency(self, double: float) -> None: ... + def setCompressorDesignPolytropicHead(self, double: float) -> None: ... + def setCompressorFeedStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setDesignExpanderQn(self, double: float) -> None: ... + def setDesignQn(self, double: float) -> None: ... + def setDesignSpeed(self, double: float) -> None: ... + def setDesignUC(self, double: float) -> None: ... + def setExpanderDesignIsentropicEfficiency(self, double: float) -> None: ... + def setExpanderIsentropicEfficiency(self, double: float) -> None: ... + def setExpanderOutPressure(self, double: float) -> None: ... + def setIGVopening(self, double: float) -> None: ... + def setIgvAreaIncreaseFactor(self, double: float) -> None: ... + def setImpellerDiameter(self, double: float) -> None: ... + def setMaximumIGVArea(self, double: float) -> None: ... + def setQNEfficiencycurve(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setQNHeadcurve(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setQNratiocompressor(self, double: float) -> None: ... + def setQNratioexpander(self, double: float) -> None: ... + def setQn(self, double: float) -> None: ... + def setUCcurve(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setUCratiocompressor(self, double: float) -> None: ... + def setUCratioexpander(self, double: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.expander")``. + + Expander: typing.Type[Expander] + ExpanderInterface: typing.Type[ExpanderInterface] + ExpanderOld: typing.Type[ExpanderOld] + TurboExpanderCompressor: typing.Type[TurboExpanderCompressor] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/filter/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/filter/__init__.pyi new file mode 100644 index 00000000..9d8d0b0d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/filter/__init__.pyi @@ -0,0 +1,39 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import typing + + + +class Filter(jneqsim.process.equipment.TwoPortEquipment): + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def getCvFactor(self) -> float: ... + def getDeltaP(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def runConditionAnalysis(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + def setCvFactor(self, double: float) -> None: ... + @typing.overload + def setDeltaP(self, double: float) -> None: ... + @typing.overload + def setDeltaP(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + +class CharCoalFilter(Filter): + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.filter")``. + + CharCoalFilter: typing.Type[CharCoalFilter] + Filter: typing.Type[Filter] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/flare/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/flare/__init__.pyi new file mode 100644 index 00000000..6e2849ab --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/flare/__init__.pyi @@ -0,0 +1,138 @@ + +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 jneqsim.process.equipment +import jneqsim.process.equipment.flare.dto +import jneqsim.process.equipment.stream +import typing + + + +class Flare(jneqsim.process.equipment.TwoPortEquipment): + @typing.overload + 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): ... + @typing.overload + def estimateRadiationHeatFlux(self, double: float) -> float: ... + @typing.overload + def estimateRadiationHeatFlux(self, double: float, double2: float) -> float: ... + @typing.overload + def evaluateCapacity(self) -> 'Flare.CapacityCheckResult': ... + @typing.overload + def evaluateCapacity(self, double: float, double2: float, double3: float) -> 'Flare.CapacityCheckResult': ... + @typing.overload + def getCO2Emission(self) -> float: ... + @typing.overload + def getCO2Emission(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getCumulativeCO2Emission(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getCumulativeGasBurned(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getCumulativeHeatReleased(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getDispersionSurrogate(self) -> jneqsim.process.equipment.flare.dto.FlareDispersionSurrogateDTO: ... + @typing.overload + def getDispersionSurrogate(self, double: float, double2: float) -> jneqsim.process.equipment.flare.dto.FlareDispersionSurrogateDTO: ... + @typing.overload + def getHeatDuty(self) -> float: ... + @typing.overload + def getHeatDuty(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getLastCapacityCheck(self) -> 'Flare.CapacityCheckResult': ... + @typing.overload + def getPerformanceSummary(self) -> jneqsim.process.equipment.flare.dto.FlarePerformanceDTO: ... + @typing.overload + def getPerformanceSummary(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float) -> jneqsim.process.equipment.flare.dto.FlarePerformanceDTO: ... + def getTransientTime(self) -> float: ... + @typing.overload + def radiationDistanceForFlux(self, double: float) -> float: ... + @typing.overload + def radiationDistanceForFlux(self, double: float, double2: float) -> float: ... + def reset(self) -> None: ... + def resetCumulative(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setDesignHeatDutyCapacity(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setDesignMassFlowCapacity(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setDesignMolarFlowCapacity(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setFlameHeight(self, double: float) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setRadiantFraction(self, double: float) -> None: ... + def setTipDiameter(self, double: float) -> None: ... + def updateCumulative(self, double: float) -> None: ... + class CapacityCheckResult(java.io.Serializable): + def getDesignHeatDutyW(self) -> float: ... + def getDesignMassRateKgS(self) -> float: ... + def getDesignMolarRateMoleS(self) -> float: ... + def getHeatDutyW(self) -> float: ... + def getHeatUtilization(self) -> float: ... + def getMassRateKgS(self) -> float: ... + def getMassUtilization(self) -> float: ... + def getMolarRateMoleS(self) -> float: ... + def getMolarUtilization(self) -> float: ... + def isOverloaded(self) -> bool: ... + def toDTO(self) -> jneqsim.process.equipment.flare.dto.FlareCapacityDTO: ... + +class FlareStack(jneqsim.process.equipment.ProcessEquipmentBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def chamberlainHeatFlux(self, double: float) -> float: ... + def getEmissionsKgPerHr(self) -> java.util.Map[java.lang.String, float]: ... + def getHeatReleaseMW(self) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getTipBackpressureBar(self) -> float: ... + def heatFlux_W_m2(self, double: float) -> float: ... + def pointSourceHeatFlux(self, double: float) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setAirAssist(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setAmbient(self, double: float, double2: float) -> None: ... + def setBurningEfficiency(self, double: float) -> None: ... + def setCOFraction(self, double: float) -> None: ... + def setChamberlainAttenuation(self, double: float) -> None: ... + def setChamberlainEmissivePower(self, double: float, double2: float) -> None: ... + def setChamberlainFlameLength(self, double: float, double2: float, double3: float) -> None: ... + def setChamberlainSegments(self, int: int) -> None: ... + def setChamberlainTilt(self, double: float) -> None: ... + def setExcessAirFrac(self, double: float) -> None: ... + def setRadiantFraction(self, double: float) -> None: ... + def setRadiationModel(self, radiationModel: 'FlareStack.RadiationModel') -> None: ... + def setReliefInlet(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setSO2Conversion(self, double: float) -> None: ... + def setSteamAssist(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setTipDiameter(self, double: float) -> None: ... + def setTipElevation(self, double: float) -> None: ... + def setTipLossK(self, double: float) -> None: ... + def setUnburnedTHCFraction(self, double: float) -> None: ... + def setWindSpeed10m(self, double: float) -> None: ... + class RadiationModel(java.lang.Enum['FlareStack.RadiationModel']): + POINT_SOURCE: typing.ClassVar['FlareStack.RadiationModel'] = ... + CHAMBERLAIN: typing.ClassVar['FlareStack.RadiationModel'] = ... + _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]) -> 'FlareStack.RadiationModel': ... + @staticmethod + def values() -> typing.MutableSequence['FlareStack.RadiationModel']: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.flare")``. + + Flare: typing.Type[Flare] + FlareStack: typing.Type[FlareStack] + dto: jneqsim.process.equipment.flare.dto.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/flare/dto/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/flare/dto/__init__.pyi new file mode 100644 index 00000000..78d20c59 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/flare/dto/__init__.pyi @@ -0,0 +1,59 @@ + +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 typing + + + +class FlareCapacityDTO(java.io.Serializable): + def __init__(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, double9: float, boolean: bool): ... + def getDesignHeatDutyW(self) -> float: ... + def getDesignMassRateKgS(self) -> float: ... + def getDesignMolarRateMoleS(self) -> float: ... + def getHeatDutyW(self) -> float: ... + def getHeatUtilization(self) -> float: ... + def getMassRateKgS(self) -> float: ... + def getMassUtilization(self) -> float: ... + def getMolarRateMoleS(self) -> float: ... + def getMolarUtilization(self) -> float: ... + def isOverloaded(self) -> bool: ... + +class FlareDispersionSurrogateDTO(java.io.Serializable): + def __init__(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float): ... + def getExitVelocityMs(self) -> float: ... + def getMassRateKgS(self) -> float: ... + def getMolarRateMoleS(self) -> float: ... + def getMomentumFlux(self) -> float: ... + def getMomentumPerMass(self) -> float: ... + def getStandardVolumeSm3PerSec(self) -> float: ... + +class FlarePerformanceDTO(java.io.Serializable): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float, double5: float, double6: float, flareDispersionSurrogateDTO: FlareDispersionSurrogateDTO, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]], flareCapacityDTO: FlareCapacityDTO): ... + def getCapacity(self) -> FlareCapacityDTO: ... + def getCo2EmissionKgS(self) -> float: ... + def getCo2EmissionTonPerDay(self) -> float: ... + def getDispersion(self) -> FlareDispersionSurrogateDTO: ... + def getDistanceTo4kWm2(self) -> float: ... + def getEmissions(self) -> java.util.Map[java.lang.String, float]: ... + def getHeatDutyMW(self) -> float: ... + def getHeatDutyW(self) -> float: ... + def getHeatFluxAt30mWm2(self) -> float: ... + def getLabel(self) -> java.lang.String: ... + def getMassRateKgS(self) -> float: ... + def getMolarRateMoleS(self) -> float: ... + def isOverloaded(self) -> bool: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.flare.dto")``. + + FlareCapacityDTO: typing.Type[FlareCapacityDTO] + FlareDispersionSurrogateDTO: typing.Type[FlareDispersionSurrogateDTO] + FlarePerformanceDTO: typing.Type[FlarePerformanceDTO] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/heatexchanger/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/heatexchanger/__init__.pyi new file mode 100644 index 00000000..42423d91 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/heatexchanger/__init__.pyi @@ -0,0 +1,464 @@ + +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 jneqsim.process +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.mechanicaldesign.heatexchanger +import jneqsim.process.util.report +import typing + + + +class HeaterInterface(jneqsim.process.SimulationInterface): + def setOutPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setOutTP(self, double: float, double2: float) -> None: ... + def setOutTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setdT(self, double: float) -> None: ... + +class MultiStreamHeatExchangerInterface(jneqsim.process.equipment.ProcessEquipmentInterface): + def addInStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcThermalEffectiveness(self, double: float, double2: float) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + def getDeltaT(self) -> float: ... + def getDuty(self) -> float: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getFlowArrangement(self) -> java.lang.String: ... + def getGuessOutTemperature(self) -> float: ... + def getHotColdDutyBalance(self) -> float: ... + def getInStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getInTemperature(self, int: int) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getOutStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOutTemperature(self, int: int) -> float: ... + def getThermalEffectiveness(self) -> float: ... + def getUAvalue(self) -> float: ... + def hashCode(self) -> int: ... + @typing.overload + def runConditionAnalysis(self) -> None: ... + @typing.overload + def runConditionAnalysis(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + def setDeltaT(self, double: float) -> None: ... + def setFeedStream(self, int: int, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setFlowArrangement(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setGuessOutTemperature(self, double: float) -> None: ... + @typing.overload + def setGuessOutTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setHotColdDutyBalance(self, double: float) -> None: ... + def setOutTemperature(self, double: float) -> None: ... + def setThermalEffectiveness(self, double: float) -> None: ... + def setUAvalue(self, double: float) -> None: ... + def setUseDeltaT(self, boolean: bool) -> None: ... + def setdT(self, double: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class ReBoiler(jneqsim.process.equipment.TwoPortEquipment): + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def displayResult(self) -> None: ... + def getReboilerDuty(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setReboilerDuty(self, double: float) -> None: ... + +class UtilityStreamSpecification(java.io.Serializable): + def __init__(self): ... + def getApproachTemperature(self) -> float: ... + def getHeatCapacityRate(self) -> float: ... + def getOverallHeatTransferCoefficient(self) -> float: ... + def getReturnTemperature(self) -> float: ... + def getSupplyTemperature(self) -> float: ... + def hasApproachTemperature(self) -> bool: ... + def hasHeatCapacityRate(self) -> bool: ... + def hasOverallHeatTransferCoefficient(self) -> bool: ... + def hasReturnTemperature(self) -> bool: ... + def hasSupplyTemperature(self) -> bool: ... + @typing.overload + def setApproachTemperature(self, double: float) -> None: ... + @typing.overload + def setApproachTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setHeatCapacityRate(self, double: float) -> None: ... + def setOverallHeatTransferCoefficient(self, double: float) -> None: ... + @typing.overload + def setReturnTemperature(self, double: float) -> None: ... + @typing.overload + def setReturnTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setSupplyTemperature(self, double: float) -> None: ... + @typing.overload + def setSupplyTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + +class HeatExchangerInterface(HeaterInterface): + def getOutStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + +class Heater(jneqsim.process.equipment.TwoPortEquipment, HeaterInterface): + @typing.overload + 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 displayResult(self) -> None: ... + def getCapacityDuty(self) -> float: ... + def getCapacityMax(self) -> float: ... + @typing.overload + def getDuty(self) -> float: ... + @typing.overload + def getDuty(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getEnergyInput(self) -> float: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str], double: float) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.heatexchanger.HeatExchangerMechanicalDesign: ... + def getPressureDrop(self) -> float: ... + def getUtilitySpecification(self) -> UtilityStreamSpecification: ... + def initMechanicalDesign(self) -> None: ... + def isSetEnergyInput(self) -> bool: ... + def needRecalculation(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 setDuty(self, double: float) -> None: ... + def setEnergyInput(self, double: float) -> None: ... + @typing.overload + def setOutPressure(self, double: float) -> None: ... + @typing.overload + def setOutPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setOutStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setOutTP(self, double: float, double2: float) -> None: ... + @typing.overload + def setOutTemperature(self, double: float) -> None: ... + @typing.overload + def setOutTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setPressureDrop(self, double: float) -> None: ... + def setSetEnergyInput(self, boolean: bool) -> None: ... + def setUtilityApproachTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setUtilityHeatCapacityRate(self, double: float) -> None: ... + def setUtilityOverallHeatTransferCoefficient(self, double: float) -> None: ... + def setUtilityReturnTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setUtilitySpecification(self, utilityStreamSpecification: UtilityStreamSpecification) -> None: ... + def setUtilitySupplyTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setdT(self, double: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class Cooler(Heater): + @typing.overload + 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 getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.heatexchanger.HeatExchangerMechanicalDesign: ... + def initMechanicalDesign(self) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class HeatExchanger(Heater, HeatExchangerInterface): + guessOutTemperature: float = ... + guessOutTemperatureUnit: java.lang.String = ... + thermalEffectiveness: float = ... + @typing.overload + 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): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface): ... + def addInStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcThermalEffectivenes(self, double: float, double2: float) -> float: ... + def displayResult(self) -> None: ... + def getDeltaT(self) -> float: ... + @typing.overload + def getDuty(self) -> float: ... + @typing.overload + def getDuty(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getFlowArrangement(self) -> java.lang.String: ... + def getGuessOutTemperature(self) -> float: ... + def getHotColdDutyBalance(self) -> float: ... + @typing.overload + def getInStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getInStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getInTemperature(self, int: int) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.heatexchanger.HeatExchangerMechanicalDesign: ... + @typing.overload + def getOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getOutStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOutTemperature(self, int: int) -> float: ... + def getThermalEffectiveness(self) -> float: ... + def getUAvalue(self) -> float: ... + def initMechanicalDesign(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + @typing.overload + def runConditionAnalysis(self) -> None: ... + @typing.overload + def runConditionAnalysis(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + def runDeltaT(self, uUID: java.util.UUID) -> None: ... + def runSpecifiedStream(self, uUID: java.util.UUID) -> None: ... + def setDeltaT(self, double: float) -> None: ... + def setFeedStream(self, int: int, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setFlowArrangement(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setGuessOutTemperature(self, double: float) -> None: ... + @typing.overload + def setGuessOutTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setHotColdDutyBalance(self, double: float) -> None: ... + def setName(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setOutStream(self, int: int, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + @typing.overload + def setOutStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + @typing.overload + def setOutTemperature(self, double: float) -> None: ... + @typing.overload + def setOutTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setThermalEffectiveness(self, double: float) -> None: ... + def setUAvalue(self, double: float) -> None: ... + def setUseDeltaT(self, boolean: bool) -> None: ... + def setdT(self, double: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class MultiStreamHeatExchanger(Heater, MultiStreamHeatExchangerInterface): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], list: java.util.List[jneqsim.process.equipment.stream.StreamInterface]): ... + def addInStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcThermalEffectiveness(self, double: float, double2: float) -> float: ... + def displayResult(self) -> None: ... + def getDeltaT(self) -> float: ... + @typing.overload + def getDuty(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getDuty(self) -> float: ... + @typing.overload + def getDuty(self, int: int) -> float: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getFlowArrangement(self) -> java.lang.String: ... + def getGuessOutTemperature(self) -> float: ... + def getHotColdDutyBalance(self) -> float: ... + @typing.overload + def getInStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getInStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getInTemperature(self, int: int) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getOutStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOutTemperature(self, int: int) -> float: ... + def getTemperatureApproach(self) -> float: ... + def getThermalEffectiveness(self) -> float: ... + def getUAvalue(self) -> float: ... + def numerOfFeedStreams(self) -> int: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + @typing.overload + def runConditionAnalysis(self) -> None: ... + @typing.overload + def runConditionAnalysis(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + def runSpecifiedStream(self, uUID: java.util.UUID) -> None: ... + def setDeltaT(self, double: float) -> None: ... + def setFeedStream(self, int: int, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setFlowArrangement(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setGuessOutTemperature(self, double: float) -> None: ... + @typing.overload + def setGuessOutTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setHotColdDutyBalance(self, double: float) -> None: ... + def setName(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setOutTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setOutTemperature(self, double: float) -> None: ... + def setTemperatureApproach(self, double: float) -> None: ... + def setThermalEffectiveness(self, double: float) -> None: ... + def setUAvalue(self, double: float) -> None: ... + def setUseDeltaT(self, boolean: bool) -> None: ... + def setdT(self, double: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class MultiStreamHeatExchanger2(Heater, MultiStreamHeatExchangerInterface): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addInStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def addInStreamMSHE(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def calcThermalEffectiveness(self, double: float, double2: float) -> float: ... + def calculateUA(self) -> float: ... + def compositeCurve(self) -> java.util.Map[java.lang.String, java.util.List[java.util.Map[java.lang.String, typing.Any]]]: ... + def displayResult(self) -> None: ... + def energyDiff(self) -> float: ... + def getCompositeCurve(self) -> java.util.Map[java.lang.String, java.util.List[java.util.Map[java.lang.String, typing.Any]]]: ... + def getDeltaT(self) -> float: ... + @typing.overload + def getDuty(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getDuty(self) -> float: ... + def getFlowArrangement(self) -> java.lang.String: ... + def getGuessOutTemperature(self) -> float: ... + def getHotColdDutyBalance(self) -> float: ... + @typing.overload + def getInStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getInStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getInTemperature(self, int: int) -> float: ... + @typing.overload + def getOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getOutStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOutTemperature(self, int: int) -> float: ... + def getTemperatureApproach(self) -> float: ... + def getThermalEffectiveness(self) -> float: ... + def getUA(self) -> float: ... + def getUAvalue(self) -> float: ... + def oneUnknown(self) -> None: ... + def pinch(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + @typing.overload + def runConditionAnalysis(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + @typing.overload + def runConditionAnalysis(self) -> None: ... + def setDeltaT(self, double: float) -> None: ... + def setFeedStream(self, int: int, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setFlowArrangement(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setGuessOutTemperature(self, double: float) -> None: ... + @typing.overload + def setGuessOutTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setHotColdDutyBalance(self, double: float) -> None: ... + def setTemperatureApproach(self, double: float) -> None: ... + def setThermalEffectiveness(self, double: float) -> None: ... + def setUAvalue(self, double: float) -> None: ... + def setUseDeltaT(self, boolean: bool) -> None: ... + def threeUnknowns(self) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + def twoUnknowns(self) -> None: ... + +class NeqHeater(Heater): + @typing.overload + 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 displayResult(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + @typing.overload + def setOutTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setOutTemperature(self, double: float) -> None: ... + +class SteamHeater(Heater): + @typing.overload + 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 getSteamFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + @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 setSteamInletTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setSteamOutletTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setSteamPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + +class AirCooler(Cooler): + @typing.overload + 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 getAirMassFlow(self) -> float: ... + def getAirVolumeFlow(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setAirInletTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setAirOutletTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setPressure(self, double: float) -> None: ... + def setRelativeHumidity(self, double: float) -> None: ... + +class WaterCooler(Cooler): + @typing.overload + 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 getCoolingWaterFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + @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 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: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.heatexchanger")``. + + AirCooler: typing.Type[AirCooler] + Cooler: typing.Type[Cooler] + HeatExchanger: typing.Type[HeatExchanger] + HeatExchangerInterface: typing.Type[HeatExchangerInterface] + Heater: typing.Type[Heater] + HeaterInterface: typing.Type[HeaterInterface] + MultiStreamHeatExchanger: typing.Type[MultiStreamHeatExchanger] + MultiStreamHeatExchanger2: typing.Type[MultiStreamHeatExchanger2] + MultiStreamHeatExchangerInterface: typing.Type[MultiStreamHeatExchangerInterface] + NeqHeater: typing.Type[NeqHeater] + ReBoiler: typing.Type[ReBoiler] + SteamHeater: typing.Type[SteamHeater] + UtilityStreamSpecification: typing.Type[UtilityStreamSpecification] + WaterCooler: typing.Type[WaterCooler] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/manifold/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/manifold/__init__.pyi new file mode 100644 index 00000000..b88090b4 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/manifold/__init__.pyi @@ -0,0 +1,43 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.util.report +import typing + + + +class Manifold(jneqsim.process.equipment.ProcessEquipmentBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMixedStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getNumberOfOutputStreams(self) -> int: ... + def getSplitStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setSplitFactors(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.manifold")``. + + Manifold: typing.Type[Manifold] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/membrane/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/membrane/__init__.pyi new file mode 100644 index 00000000..346a1535 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/membrane/__init__.pyi @@ -0,0 +1,47 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import typing + + + +class MembraneSeparator(jneqsim.process.equipment.ProcessEquipmentBaseClass): + @typing.overload + 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 clearPermeateFractions(self) -> None: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getPermeateStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getRetentateStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def needRecalculation(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 setDefaultPermeateFraction(self, double: float) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setMembraneArea(self, double: float) -> None: ... + def setPermeability(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def setPermeateFraction(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.membrane")``. + + MembraneSeparator: typing.Type[MembraneSeparator] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/mixer/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/mixer/__init__.pyi new file mode 100644 index 00000000..1b4efe85 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/mixer/__init__.pyi @@ -0,0 +1,107 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.util.report +import jneqsim.thermo.system +import typing + + + +class MixerInterface(jneqsim.process.equipment.ProcessEquipmentInterface): + def addStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOutletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def hashCode(self) -> int: ... + def removeInputStream(self, int: int) -> None: ... + def replaceStream(self, int: int, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + +class Mixer(jneqsim.process.equipment.ProcessEquipmentBaseClass, MixerInterface): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcMixStreamEnthalpy(self) -> float: ... + def displayResult(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMixedSalinity(self) -> float: ... + def getMixedStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getNumberOfInputStreams(self) -> int: ... + def getOutTemperature(self) -> float: ... + def getOutletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def guessTemperature(self) -> float: ... + def hashCode(self) -> int: ... + def isDoMultiPhaseCheck(self) -> bool: ... + @typing.overload + def isSetOutTemperature(self) -> bool: ... + @typing.overload + def isSetOutTemperature(self, boolean: bool) -> None: ... + def mixStream(self) -> None: ... + def removeInputStream(self, int: int) -> None: ... + def replaceStream(self, int: int, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setMultiPhaseCheck(self, boolean: bool) -> None: ... + def setOutTemperature(self, double: float) -> None: ... + def setPressure(self, double: float) -> None: ... + def setTemperature(self, double: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class StaticMixer(Mixer): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def calcMixStreamEnthalpy(self) -> float: ... + def guessTemperature(self) -> float: ... + def mixStream(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class StaticNeqMixer(StaticMixer): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def mixStream(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + +class StaticPhaseMixer(StaticMixer): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def mixStream(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.mixer")``. + + Mixer: typing.Type[Mixer] + MixerInterface: typing.Type[MixerInterface] + StaticMixer: typing.Type[StaticMixer] + StaticNeqMixer: typing.Type[StaticNeqMixer] + StaticPhaseMixer: typing.Type[StaticPhaseMixer] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/network/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/network/__init__.pyi new file mode 100644 index 00000000..c0c9d598 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/network/__init__.pyi @@ -0,0 +1,75 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.mixer +import jneqsim.process.equipment.pipeline +import jneqsim.process.equipment.reservoir +import jneqsim.process.equipment.stream +import jneqsim.process.equipment.valve +import jneqsim.process.util.report +import typing + + + +class WellFlowlineNetwork(jneqsim.process.equipment.ProcessEquipmentBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def addBranch(self, string: typing.Union[java.lang.String, str], wellFlow: jneqsim.process.equipment.reservoir.WellFlow, pipeBeggsAndBrills: jneqsim.process.equipment.pipeline.PipeBeggsAndBrills) -> 'WellFlowlineNetwork.Branch': ... + @typing.overload + def addBranch(self, string: typing.Union[java.lang.String, str], wellFlow: jneqsim.process.equipment.reservoir.WellFlow, pipeBeggsAndBrills: jneqsim.process.equipment.pipeline.PipeBeggsAndBrills, manifoldNode: 'WellFlowlineNetwork.ManifoldNode') -> 'WellFlowlineNetwork.Branch': ... + @typing.overload + def addBranch(self, string: typing.Union[java.lang.String, str], wellFlow: jneqsim.process.equipment.reservoir.WellFlow, pipeBeggsAndBrills: jneqsim.process.equipment.pipeline.PipeBeggsAndBrills, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve, manifoldNode: 'WellFlowlineNetwork.ManifoldNode') -> 'WellFlowlineNetwork.Branch': ... + @typing.overload + def addBranch(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> 'WellFlowlineNetwork.Branch': ... + @typing.overload + def addBranch(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface, manifoldNode: 'WellFlowlineNetwork.ManifoldNode') -> 'WellFlowlineNetwork.Branch': ... + def addManifold(self, string: typing.Union[java.lang.String, str], pipeBeggsAndBrills: jneqsim.process.equipment.pipeline.PipeBeggsAndBrills) -> 'WellFlowlineNetwork.ManifoldNode': ... + def connectManifolds(self, manifoldNode: 'WellFlowlineNetwork.ManifoldNode', manifoldNode2: 'WellFlowlineNetwork.ManifoldNode', pipeBeggsAndBrills: jneqsim.process.equipment.pipeline.PipeBeggsAndBrills) -> None: ... + def createManifold(self, string: typing.Union[java.lang.String, str]) -> 'WellFlowlineNetwork.ManifoldNode': ... + def getArrivalMixer(self) -> jneqsim.process.equipment.mixer.Mixer: ... + def getArrivalStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getBranches(self) -> java.util.List['WellFlowlineNetwork.Branch']: ... + def getManifolds(self) -> java.util.List['WellFlowlineNetwork.ManifoldNode']: ... + def getTerminalManifoldPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + @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 setFacilityPipeline(self, pipeBeggsAndBrills: jneqsim.process.equipment.pipeline.PipeBeggsAndBrills) -> None: ... + def setForceFlowFromPressureSolve(self, boolean: bool) -> None: ... + def setIterationTolerance(self, double: float) -> None: ... + def setMaxIterations(self, int: int) -> None: ... + def setName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPropagateArrivalPressureToWells(self, boolean: bool) -> None: ... + def setTargetEndpointPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + class Branch: + def getChoke(self) -> jneqsim.process.equipment.valve.ThrottlingValve: ... + def getName(self) -> java.lang.String: ... + def getPipeline(self) -> jneqsim.process.equipment.pipeline.PipeBeggsAndBrills: ... + def getWell(self) -> jneqsim.process.equipment.reservoir.WellFlow: ... + def setChoke(self, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve) -> None: ... + class ManifoldNode: + def getBranches(self) -> java.util.List['WellFlowlineNetwork.Branch']: ... + def getMixer(self) -> jneqsim.process.equipment.mixer.Mixer: ... + def getName(self) -> java.lang.String: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.network")``. + + WellFlowlineNetwork: typing.Type[WellFlowlineNetwork] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/__init__.pyi new file mode 100644 index 00000000..0600173d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/__init__.pyi @@ -0,0 +1,634 @@ + +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.fluidmechanics.flowsystem +import jneqsim.process +import jneqsim.process.equipment +import jneqsim.process.equipment.pipeline.twophasepipe +import jneqsim.process.equipment.stream +import jneqsim.process.mechanicaldesign.pipeline +import jneqsim.process.util.report +import jneqsim.thermo.system +import jneqsim.thermodynamicoperations +import typing + + + +class Fittings(java.io.Serializable): + def __init__(self): ... + @typing.overload + def add(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def add(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def getFittingsList(self) -> java.util.ArrayList['Fittings.Fitting']: ... + class Fitting(java.io.Serializable): + @typing.overload + def __init__(self, fittings: 'Fittings', string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, fittings: 'Fittings', string: typing.Union[java.lang.String, str], double: float): ... + def getFittingName(self) -> java.lang.String: ... + def getLtoD(self) -> float: ... + def setFittingName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setLtoD(self, double: float) -> None: ... + +class PipeLineInterface(jneqsim.process.SimulationInterface, jneqsim.process.equipment.TwoPortInterface): + def getPipe(self) -> jneqsim.fluidmechanics.flowsystem.FlowSystemInterface: ... + def setHeightProfile(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setInitialFlowPattern(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setLegPositions(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setNumberOfLegs(self, int: int) -> None: ... + def setNumberOfNodesInLeg(self, int: int) -> None: ... + def setOuterTemperatures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setOutputFileName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPipeDiameters(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setPipeWallRoughness(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class Pipeline(jneqsim.process.equipment.TwoPortEquipment, PipeLineInterface): + @typing.overload + 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 displayResult(self) -> None: ... + def getCapacityDuty(self) -> float: ... + def getCapacityMax(self) -> float: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.pipeline.PipelineMechanicalDesign: ... + @typing.overload + def getOutletPressure(self) -> float: ... + @typing.overload + def getOutletPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getPipe(self) -> jneqsim.fluidmechanics.flowsystem.FlowSystemInterface: ... + def getSuperficialVelocity(self, int: int, int2: int) -> float: ... + def getTimes(self) -> typing.MutableSequence[float]: ... + def initMechanicalDesign(self) -> None: ... + @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 setEquilibriumHeatTransfer(self, boolean: bool) -> None: ... + def setEquilibriumMassTransfer(self, boolean: bool) -> None: ... + def setHeightProfile(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setInitialFlowPattern(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setLegPositions(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setNumberOfLegs(self, int: int) -> None: ... + def setNumberOfNodesInLeg(self, int: int) -> None: ... + def setOuterTemperatures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setOutputFileName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPipeDiameters(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setPipeOuterHeatTransferCoefficients(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setPipeWallHeatTransferCoefficients(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setPipeWallRoughness(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setTimeSeries(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], systemInterfaceArray: typing.Union[typing.List[jneqsim.thermo.system.SystemInterface], jpype.JArray], int: int) -> None: ... + +class AdiabaticPipe(Pipeline): + @typing.overload + 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 calcFlow(self) -> float: ... + def calcPressureOut(self) -> float: ... + def calcWallFrictionFactor(self, double: float) -> float: ... + def displayResult(self) -> None: ... + def getDiameter(self) -> float: ... + def getInletElevation(self) -> float: ... + def getLength(self) -> float: ... + def getOutletElevation(self) -> float: ... + def getPipe(self) -> jneqsim.fluidmechanics.flowsystem.FlowSystemInterface: ... + def getPipeWallRoughness(self) -> float: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setDiameter(self, double: float) -> None: ... + def setInitialFlowPattern(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setInletElevation(self, double: float) -> None: ... + def setLength(self, double: float) -> None: ... + def setOutPressure(self, double: float) -> None: ... + def setOutTemperature(self, double: float) -> None: ... + def setOutletElevation(self, double: float) -> None: ... + def setPipeSpecification(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setPipeWallRoughness(self, double: float) -> None: ... + @typing.overload + def setPipeWallRoughness(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class AdiabaticTwoPhasePipe(Pipeline): + @typing.overload + 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 calcFlow(self, double: float) -> float: ... + def calcPressureOut(self) -> float: ... + def calcWallFrictionFactor(self, double: float) -> float: ... + def displayResult(self) -> None: ... + def getDiameter(self) -> float: ... + def getInletElevation(self) -> float: ... + def getLength(self) -> float: ... + def getOutletElevation(self) -> float: ... + def getPipe(self) -> jneqsim.fluidmechanics.flowsystem.FlowSystemInterface: ... + def getPipeWallRoughness(self) -> float: ... + def getPressureOutLimit(self) -> float: ... + @typing.overload + def getSuperficialVelocity(self) -> float: ... + @typing.overload + def getSuperficialVelocity(self, int: int, int2: int) -> float: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setDiameter(self, double: float) -> None: ... + def setFlowLimit(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setInitialFlowPattern(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setInletElevation(self, double: float) -> None: ... + def setLength(self, double: float) -> None: ... + def setOutPressure(self, double: float) -> None: ... + def setOutTemperature(self, double: float) -> None: ... + def setOutletElevation(self, double: float) -> None: ... + def setPipeSpecification(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setPipeWallRoughness(self, double: float) -> None: ... + @typing.overload + def setPipeWallRoughness(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setPressureOutLimit(self, double: float) -> None: ... + +class OnePhasePipeLine(Pipeline): + @typing.overload + 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): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def createSystem(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + +class PipeBeggsAndBrills(Pipeline): + @typing.overload + 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 calcFlowRegime(self) -> 'PipeBeggsAndBrills.FlowRegime': ... + def calcFrictionPressureLoss(self) -> float: ... + def calcHeatBalance(self, double: float, systemInterface: jneqsim.thermo.system.SystemInterface, thermodynamicOperations: jneqsim.thermodynamicoperations.ThermodynamicOperations) -> float: ... + def calcHydrostaticPressureDifference(self) -> float: ... + def calcPressureDrop(self) -> float: ... + def calcTemperatureDifference(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> float: ... + def calculateMissingValue(self) -> None: ... + def convertSystemUnitToImperial(self) -> None: ... + def convertSystemUnitToMetric(self) -> None: ... + def displayResult(self) -> None: ... + def estimateHeatTransferCoefficent(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> float: ... + def getAngle(self) -> float: ... + def getCalculationMode(self) -> 'PipeBeggsAndBrills.CalculationMode': ... + def getDiameter(self) -> float: ... + def getElevation(self) -> float: ... + def getElevationProfile(self) -> java.util.List[float]: ... + def getFlowRegime(self) -> 'PipeBeggsAndBrills.FlowRegime': ... + def getFlowRegimeProfile(self) -> java.util.List['PipeBeggsAndBrills.FlowRegime']: ... + def getGasSuperficialVelocityProfile(self) -> java.util.List[float]: ... + def getHeatTransferCoefficient(self) -> float: ... + def getIncrementsProfile(self) -> java.util.List[int]: ... + def getInletSuperficialVelocity(self) -> float: ... + def getLastSegmentPressureDrop(self) -> float: ... + def getLength(self) -> float: ... + def getLengthProfile(self) -> java.util.List[float]: ... + def getLiquidDensityProfile(self) -> java.util.List[float]: ... + def getLiquidHoldupProfile(self) -> java.util.List[float]: ... + def getLiquidSuperficialVelocityProfile(self) -> java.util.List[float]: ... + def getMixtureDensityProfile(self) -> java.util.List[float]: ... + def getMixtureReynoldsNumber(self) -> java.util.List[float]: ... + def getMixtureSuperficialVelocityProfile(self) -> java.util.List[float]: ... + def getMixtureViscosityProfile(self) -> java.util.List[float]: ... + def getNumberOfIncrements(self) -> int: ... + def getOutletSuperficialVelocity(self) -> float: ... + def getPressureDrop(self) -> float: ... + def getPressureDropProfile(self) -> java.util.List[float]: ... + def getPressureProfile(self) -> java.util.List[float]: ... + def getSegmentElevation(self, int: int) -> float: ... + def getSegmentFlowRegime(self, int: int) -> 'PipeBeggsAndBrills.FlowRegime': ... + def getSegmentGasSuperficialVelocity(self, int: int) -> float: ... + def getSegmentLength(self, int: int) -> float: ... + def getSegmentLiquidDensity(self, int: int) -> float: ... + def getSegmentLiquidHoldup(self, int: int) -> float: ... + def getSegmentLiquidSuperficialVelocity(self, int: int) -> float: ... + def getSegmentMixtureDensity(self, int: int) -> float: ... + def getSegmentMixtureReynoldsNumber(self, int: int) -> float: ... + def getSegmentMixtureSuperficialVelocity(self, int: int) -> float: ... + def getSegmentMixtureViscosity(self, int: int) -> float: ... + def getSegmentPressure(self, int: int) -> float: ... + def getSegmentPressureDrop(self, int: int) -> float: ... + def getSegmentTemperature(self, int: int) -> float: ... + def getSpecifiedOutletPressure(self) -> float: ... + def getSpecifiedOutletPressureUnit(self) -> java.lang.String: ... + def getTemperatureProfile(self) -> java.util.List[float]: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getThickness(self) -> float: ... + def isIncludeFrictionHeating(self) -> bool: ... + def isIncludeJouleThomsonEffect(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 setAngle(self, double: float) -> None: ... + def setCalculationMode(self, calculationMode: 'PipeBeggsAndBrills.CalculationMode') -> None: ... + def setConstantSurfaceTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setDiameter(self, double: float) -> None: ... + def setElevation(self, double: float) -> None: ... + def setFlowConvergenceTolerance(self, double: float) -> None: ... + def setHeatTransferCoefficient(self, double: float) -> None: ... + def setIncludeFrictionHeating(self, boolean: bool) -> None: ... + def setIncludeJouleThomsonEffect(self, boolean: bool) -> None: ... + def setLength(self, double: float) -> None: ... + def setMaxFlowIterations(self, int: int) -> None: ... + def setNumberOfIncrements(self, int: int) -> None: ... + @typing.overload + def setOutletPressure(self, double: float) -> None: ... + @typing.overload + def setOutletPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setPipeSpecification(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setPipeWallRoughness(self, double: float) -> None: ... + @typing.overload + def setPipeWallRoughness(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setRunIsothermal(self, boolean: bool) -> None: ... + def setThickness(self, double: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + class CalculationMode(java.lang.Enum['PipeBeggsAndBrills.CalculationMode']): + CALCULATE_OUTLET_PRESSURE: typing.ClassVar['PipeBeggsAndBrills.CalculationMode'] = ... + CALCULATE_FLOW_RATE: typing.ClassVar['PipeBeggsAndBrills.CalculationMode'] = ... + _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]) -> 'PipeBeggsAndBrills.CalculationMode': ... + @staticmethod + def values() -> typing.MutableSequence['PipeBeggsAndBrills.CalculationMode']: ... + class FlowRegime(java.lang.Enum['PipeBeggsAndBrills.FlowRegime']): + SEGREGATED: typing.ClassVar['PipeBeggsAndBrills.FlowRegime'] = ... + INTERMITTENT: typing.ClassVar['PipeBeggsAndBrills.FlowRegime'] = ... + DISTRIBUTED: typing.ClassVar['PipeBeggsAndBrills.FlowRegime'] = ... + TRANSITION: typing.ClassVar['PipeBeggsAndBrills.FlowRegime'] = ... + SINGLE_PHASE: typing.ClassVar['PipeBeggsAndBrills.FlowRegime'] = ... + UNKNOWN: typing.ClassVar['PipeBeggsAndBrills.FlowRegime'] = ... + _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]) -> 'PipeBeggsAndBrills.FlowRegime': ... + @staticmethod + def values() -> typing.MutableSequence['PipeBeggsAndBrills.FlowRegime']: ... + +class SimpleTPoutPipeline(Pipeline): + @typing.overload + 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 displayResult(self) -> None: ... + def getPipe(self) -> jneqsim.fluidmechanics.flowsystem.FlowSystemInterface: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setInitialFlowPattern(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setOutPressure(self, double: float) -> None: ... + def setOutTemperature(self, double: float) -> None: ... + +class TubingPerformance(Pipeline): + @typing.overload + 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 generateVLPCurve(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getCorrelationType(self) -> 'TubingPerformance.CorrelationType': ... + def getDiameter(self) -> float: ... + def getInclination(self) -> float: ... + def getLength(self) -> float: ... + def getPressureDrop(self) -> float: ... + def getRoughness(self) -> float: ... + def getTemperatureModel(self) -> 'TubingPerformance.TemperatureModel': ... + def getWellheadPressure(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setBottomholeTemperature(self, double: float) -> None: ... + def setCorrelationType(self, correlationType: 'TubingPerformance.CorrelationType') -> None: ... + def setDiameter(self, double: float) -> None: ... + def setFormationThermalConductivity(self, double: float) -> None: ... + def setGeothermalGradient(self, double: float) -> None: ... + def setInclination(self, double: float) -> None: ... + def setLength(self, double: float) -> None: ... + def setNumberOfSegments(self, int: int) -> None: ... + def setOverallHeatTransferCoefficient(self, double: float) -> None: ... + def setProductionTime(self, double: float) -> None: ... + def setRoughness(self, double: float) -> None: ... + def setSurfaceTemperature(self, double: float) -> None: ... + def setTemperatureModel(self, temperatureModel: 'TubingPerformance.TemperatureModel') -> None: ... + def setWellheadPressure(self, double: float) -> None: ... + class CorrelationType(java.lang.Enum['TubingPerformance.CorrelationType']): + BEGGS_BRILL: typing.ClassVar['TubingPerformance.CorrelationType'] = ... + HAGEDORN_BROWN: typing.ClassVar['TubingPerformance.CorrelationType'] = ... + GRAY: typing.ClassVar['TubingPerformance.CorrelationType'] = ... + HASAN_KABIR: typing.ClassVar['TubingPerformance.CorrelationType'] = ... + DUNS_ROS: typing.ClassVar['TubingPerformance.CorrelationType'] = ... + _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]) -> 'TubingPerformance.CorrelationType': ... + @staticmethod + def values() -> typing.MutableSequence['TubingPerformance.CorrelationType']: ... + class TemperatureModel(java.lang.Enum['TubingPerformance.TemperatureModel']): + ISOTHERMAL: typing.ClassVar['TubingPerformance.TemperatureModel'] = ... + LINEAR_GRADIENT: typing.ClassVar['TubingPerformance.TemperatureModel'] = ... + RAMEY: typing.ClassVar['TubingPerformance.TemperatureModel'] = ... + HASAN_KABIR: typing.ClassVar['TubingPerformance.TemperatureModel'] = ... + _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]) -> 'TubingPerformance.TemperatureModel': ... + @staticmethod + def values() -> typing.MutableSequence['TubingPerformance.TemperatureModel']: ... + +class TwoFluidPipe(Pipeline): + @typing.overload + 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 getAccumulationTracker(self) -> jneqsim.process.equipment.pipeline.twophasepipe.LiquidAccumulationTracker: ... + def getDiameter(self) -> float: ... + def getDistanceToHydrateRisk(self) -> float: ... + def getFirstHydrateRiskSection(self) -> int: ... + def getFlowRegimeProfile(self) -> typing.MutableSequence[jneqsim.process.equipment.pipeline.twophasepipe.PipeSection.FlowRegime]: ... + def getGasVelocityProfile(self) -> typing.MutableSequence[float]: ... + def getHeatTransferCoefficient(self) -> float: ... + def getHeatTransferProfile(self) -> typing.MutableSequence[float]: ... + def getHydrateFormationTemperature(self) -> float: ... + def getHydrateRiskSectionCount(self) -> int: ... + def getHydrateRiskSections(self) -> typing.MutableSequence[bool]: ... + def getInsulationType(self) -> 'TwoFluidPipe.InsulationType': ... + def getLastSlugArrivalTime(self) -> float: ... + def getLength(self) -> float: ... + def getLiquidHoldupProfile(self) -> typing.MutableSequence[float]: ... + def getLiquidInventory(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getLiquidVelocityProfile(self) -> typing.MutableSequence[float]: ... + def getMaxSimulationTime(self) -> float: ... + def getMaxSlugLengthAtOutlet(self) -> float: ... + def getMaxSlugVolumeAtOutlet(self) -> float: ... + def getNumberOfSections(self) -> int: ... + def getOilHoldupProfile(self) -> typing.MutableSequence[float]: ... + def getOilVelocityProfile(self) -> typing.MutableSequence[float]: ... + def getOilWaterSlipProfile(self) -> typing.MutableSequence[float]: ... + def getOutletSlugCount(self) -> int: ... + def getPositionProfile(self) -> typing.MutableSequence[float]: ... + def getPressureProfile(self) -> typing.MutableSequence[float]: ... + def getRoughness(self) -> float: ... + def getSimulationTime(self) -> float: ... + def getSlugStatisticsSummary(self) -> java.lang.String: ... + def getSlugTracker(self) -> jneqsim.process.equipment.pipeline.twophasepipe.SlugTracker: ... + def getSoilThermalResistance(self) -> float: ... + def getSurfaceTemperature(self) -> float: ... + def getSurfaceTemperatureProfile(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getTemperatureProfile(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getTemperatureProfile(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getTotalSlugVolumeAtOutlet(self) -> float: ... + def getWallTemperatureProfile(self) -> typing.MutableSequence[float]: ... + def getWallThickness(self) -> float: ... + def getWaterCutProfile(self) -> typing.MutableSequence[float]: ... + def getWaterHoldupProfile(self) -> typing.MutableSequence[float]: ... + def getWaterVelocityProfile(self) -> typing.MutableSequence[float]: ... + def getWaxAppearanceTemperature(self) -> float: ... + def getWaxRiskSections(self) -> typing.MutableSequence[bool]: ... + def hasHydrateRisk(self) -> bool: ... + def hasWaxRisk(self) -> bool: ... + def isHeatTransferEnabled(self) -> bool: ... + def isJouleThomsonEnabled(self) -> bool: ... + def isWaterOilSlipEnabled(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 setCflNumber(self, double: float) -> None: ... + def setDiameter(self, double: float) -> None: ... + def setElevationProfile(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setEnableJouleThomson(self, boolean: bool) -> None: ... + def setEnableSlugTracking(self, boolean: bool) -> None: ... + def setEnableWaterOilSlip(self, boolean: bool) -> None: ... + def setHeatTransferCoefficient(self, double: float) -> None: ... + def setHeatTransferProfile(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setHydrateFormationTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setIncludeEnergyEquation(self, boolean: bool) -> None: ... + def setIncludeMassTransfer(self, boolean: bool) -> None: ... + def setInsulationType(self, insulationType: 'TwoFluidPipe.InsulationType') -> None: ... + def setLength(self, double: float) -> None: ... + def setMaxSimulationTime(self, double: float) -> None: ... + def setNumberOfSections(self, int: int) -> None: ... + @typing.overload + def setOutletPressure(self, double: float) -> None: ... + @typing.overload + def setOutletPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setRoughness(self, double: float) -> None: ... + def setSoilThermalResistance(self, double: float) -> None: ... + def setSurfaceTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setSurfaceTemperatureProfile(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setThermodynamicUpdateInterval(self, int: int) -> None: ... + def setWallProperties(self, double: float, double2: float, double3: float) -> None: ... + def setWaxAppearanceTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + class BoundaryCondition(java.lang.Enum['TwoFluidPipe.BoundaryCondition']): + CONSTANT_PRESSURE: typing.ClassVar['TwoFluidPipe.BoundaryCondition'] = ... + CONSTANT_FLOW: typing.ClassVar['TwoFluidPipe.BoundaryCondition'] = ... + STREAM_CONNECTED: typing.ClassVar['TwoFluidPipe.BoundaryCondition'] = ... + _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]) -> 'TwoFluidPipe.BoundaryCondition': ... + @staticmethod + def values() -> typing.MutableSequence['TwoFluidPipe.BoundaryCondition']: ... + class InsulationType(java.lang.Enum['TwoFluidPipe.InsulationType']): + NONE: typing.ClassVar['TwoFluidPipe.InsulationType'] = ... + UNINSULATED_SUBSEA: typing.ClassVar['TwoFluidPipe.InsulationType'] = ... + PU_FOAM: typing.ClassVar['TwoFluidPipe.InsulationType'] = ... + MULTI_LAYER: typing.ClassVar['TwoFluidPipe.InsulationType'] = ... + PIPE_IN_PIPE: typing.ClassVar['TwoFluidPipe.InsulationType'] = ... + VIT: typing.ClassVar['TwoFluidPipe.InsulationType'] = ... + BURIED_ONSHORE: typing.ClassVar['TwoFluidPipe.InsulationType'] = ... + EXPOSED_ONSHORE: typing.ClassVar['TwoFluidPipe.InsulationType'] = ... + def getUValue(self) -> float: ... + _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]) -> 'TwoFluidPipe.InsulationType': ... + @staticmethod + def values() -> typing.MutableSequence['TwoFluidPipe.InsulationType']: ... + +class TwoPhasePipeLine(Pipeline): + @typing.overload + 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 createSystem(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + +class WaterHammerPipe(Pipeline): + @typing.overload + 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 calcEffectiveWaveSpeed(self) -> float: ... + @typing.overload + def calcJoukowskyPressureSurge(self, double: float) -> float: ... + @typing.overload + def calcJoukowskyPressureSurge(self, double: float, string: typing.Union[java.lang.String, str]) -> float: ... + def getCurrentTime(self) -> float: ... + def getDiameter(self) -> float: ... + def getFlowProfile(self) -> typing.MutableSequence[float]: ... + def getHeadProfile(self) -> typing.MutableSequence[float]: ... + def getLength(self) -> float: ... + @typing.overload + def getMaxPressure(self) -> float: ... + @typing.overload + def getMaxPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMaxPressureEnvelope(self) -> typing.MutableSequence[float]: ... + def getMaxStableTimeStep(self) -> float: ... + @typing.overload + def getMinPressure(self) -> float: ... + @typing.overload + def getMinPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMinPressureEnvelope(self) -> typing.MutableSequence[float]: ... + def getNumberOfNodes(self) -> int: ... + def getPressureHistory(self) -> java.util.List[float]: ... + @typing.overload + def getPressureProfile(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getPressureProfile(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getTimeHistory(self) -> java.util.List[float]: ... + def getValveOpening(self) -> float: ... + def getVelocityProfile(self) -> typing.MutableSequence[float]: ... + def getWaveRoundTripTime(self) -> float: ... + def getWaveSpeed(self) -> float: ... + def reset(self) -> None: ... + def resetEnvelopes(self) -> None: ... + @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 setCourantNumber(self, double: float) -> None: ... + @typing.overload + def setDiameter(self, double: float) -> None: ... + @typing.overload + def setDiameter(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setDownstreamBoundary(self, boundaryType: 'WaterHammerPipe.BoundaryType') -> None: ... + def setElevationChange(self, double: float) -> None: ... + @typing.overload + def setLength(self, double: float) -> None: ... + @typing.overload + def setLength(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setNumberOfNodes(self, int: int) -> None: ... + def setPipeElasticModulus(self, double: float) -> None: ... + def setRoughness(self, double: float) -> None: ... + def setUpstreamBoundary(self, boundaryType: 'WaterHammerPipe.BoundaryType') -> None: ... + def setValveOpening(self, double: float) -> None: ... + def setWallThickness(self, double: float) -> None: ... + def setWaveSpeed(self, double: float) -> None: ... + class BoundaryType(java.lang.Enum['WaterHammerPipe.BoundaryType']): + RESERVOIR: typing.ClassVar['WaterHammerPipe.BoundaryType'] = ... + VALVE: typing.ClassVar['WaterHammerPipe.BoundaryType'] = ... + CLOSED_END: typing.ClassVar['WaterHammerPipe.BoundaryType'] = ... + CONSTANT_FLOW: typing.ClassVar['WaterHammerPipe.BoundaryType'] = ... + _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]) -> 'WaterHammerPipe.BoundaryType': ... + @staticmethod + def values() -> typing.MutableSequence['WaterHammerPipe.BoundaryType']: ... + +class IncompressiblePipeFlow(AdiabaticPipe): + @typing.overload + 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 addFitting(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def addFittingFromDatabase(self, string: typing.Union[java.lang.String, str]) -> None: ... + def calcPressureOut(self) -> float: ... + def getTotalEqLenth(self) -> float: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setTotalEqLenth(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.pipeline")``. + + AdiabaticPipe: typing.Type[AdiabaticPipe] + AdiabaticTwoPhasePipe: typing.Type[AdiabaticTwoPhasePipe] + Fittings: typing.Type[Fittings] + IncompressiblePipeFlow: typing.Type[IncompressiblePipeFlow] + OnePhasePipeLine: typing.Type[OnePhasePipeLine] + PipeBeggsAndBrills: typing.Type[PipeBeggsAndBrills] + PipeLineInterface: typing.Type[PipeLineInterface] + Pipeline: typing.Type[Pipeline] + SimpleTPoutPipeline: typing.Type[SimpleTPoutPipeline] + TubingPerformance: typing.Type[TubingPerformance] + TwoFluidPipe: typing.Type[TwoFluidPipe] + TwoPhasePipeLine: typing.Type[TwoPhasePipeLine] + WaterHammerPipe: typing.Type[WaterHammerPipe] + twophasepipe: jneqsim.process.equipment.pipeline.twophasepipe.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/twophasepipe/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/twophasepipe/__init__.pyi new file mode 100644 index 00000000..3b90303b --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/twophasepipe/__init__.pyi @@ -0,0 +1,696 @@ + +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.fluidmechanics.flowsystem +import jneqsim.process.equipment +import jneqsim.process.equipment.pipeline +import jneqsim.process.equipment.pipeline.twophasepipe.closure +import jneqsim.process.equipment.pipeline.twophasepipe.numerics +import jneqsim.process.equipment.stream +import jneqsim.thermo.system +import typing + + + +class DriftFluxModel(java.io.Serializable): + def __init__(self): ... + def calculateDriftFlux(self, pipeSection: 'PipeSection') -> 'DriftFluxModel.DriftFluxParameters': ... + def calculateEnergyEquation(self, pipeSection: 'PipeSection', driftFluxParameters: 'DriftFluxModel.DriftFluxParameters', double: float, double2: float, double3: float, double4: float, double5: float) -> 'DriftFluxModel.EnergyEquationResult': ... + def calculateMixtureHeatCapacity(self, pipeSection: 'PipeSection', driftFluxParameters: 'DriftFluxModel.DriftFluxParameters', double: float, double2: float) -> float: ... + def calculatePressureGradient(self, pipeSection: 'PipeSection', driftFluxParameters: 'DriftFluxModel.DriftFluxParameters') -> float: ... + def calculateSteadyStateTemperature(self, pipeSection: 'PipeSection', double: float, double2: float, double3: float, double4: float, double5: float, double6: float) -> float: ... + def estimateJouleThomsonCoefficient(self, double: float, double2: float, double3: float) -> float: ... + class DriftFluxParameters(java.io.Serializable): + C0: float = ... + driftVelocity: float = ... + gasVelocity: float = ... + liquidVelocity: float = ... + slipRatio: float = ... + voidFraction: float = ... + liquidHoldup: float = ... + def __init__(self): ... + class EnergyEquationResult(java.io.Serializable): + newTemperature: float = ... + jouleThomsonDeltaT: float = ... + heatTransferDeltaT: float = ... + frictionHeatingDeltaT: float = ... + elevationWorkDeltaT: float = ... + heatTransferRate: float = ... + frictionHeatingPower: float = ... + def __init__(self): ... + +class EntrainmentDeposition(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, entrainmentModel: 'EntrainmentDeposition.EntrainmentModel', depositionModel: 'EntrainmentDeposition.DepositionModel'): ... + def calculate(self, flowRegime: 'PipeSection.FlowRegime', double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, double9: float) -> 'EntrainmentDeposition.EntrainmentResult': ... + def getCriticalReFilm(self) -> float: ... + def getCriticalWeber(self) -> float: ... + def getDepositionModel(self) -> 'EntrainmentDeposition.DepositionModel': ... + def getEntrainmentModel(self) -> 'EntrainmentDeposition.EntrainmentModel': ... + def setCriticalReFilm(self, double: float) -> None: ... + def setCriticalWeber(self, double: float) -> None: ... + def setDepositionModel(self, depositionModel: 'EntrainmentDeposition.DepositionModel') -> None: ... + def setEntrainmentModel(self, entrainmentModel: 'EntrainmentDeposition.EntrainmentModel') -> None: ... + class DepositionModel(java.lang.Enum['EntrainmentDeposition.DepositionModel']): + MCCOY_HANRATTY: typing.ClassVar['EntrainmentDeposition.DepositionModel'] = ... + RELAXATION: typing.ClassVar['EntrainmentDeposition.DepositionModel'] = ... + COUSINS: typing.ClassVar['EntrainmentDeposition.DepositionModel'] = ... + _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]) -> 'EntrainmentDeposition.DepositionModel': ... + @staticmethod + def values() -> typing.MutableSequence['EntrainmentDeposition.DepositionModel']: ... + class EntrainmentModel(java.lang.Enum['EntrainmentDeposition.EntrainmentModel']): + ISHII_MISHIMA: typing.ClassVar['EntrainmentDeposition.EntrainmentModel'] = ... + PAN_HANRATTY: typing.ClassVar['EntrainmentDeposition.EntrainmentModel'] = ... + OLIEMANS: typing.ClassVar['EntrainmentDeposition.EntrainmentModel'] = ... + _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]) -> 'EntrainmentDeposition.EntrainmentModel': ... + @staticmethod + def values() -> typing.MutableSequence['EntrainmentDeposition.EntrainmentModel']: ... + class EntrainmentResult(java.io.Serializable): + entrainmentRate: float = ... + depositionRate: float = ... + netTransferRate: float = ... + entrainmentFraction: float = ... + dropletDiameter: float = ... + dropletConcentration: float = ... + filmReynoldsNumber: float = ... + isEntraining: bool = ... + def __init__(self): ... + +class FlashTable(java.io.Serializable): + def __init__(self): ... + def build(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float, int: int, double3: float, double4: float, int2: int) -> None: ... + def clear(self) -> None: ... + def estimateMemoryUsage(self) -> int: ... + def getMaxPressure(self) -> float: ... + def getMaxTemperature(self) -> float: ... + def getMinPressure(self) -> float: ... + def getMinTemperature(self) -> float: ... + def getNumPressurePoints(self) -> int: ... + def getNumTemperaturePoints(self) -> int: ... + def getPressures(self) -> typing.MutableSequence[float]: ... + def getProperty(self, string: typing.Union[java.lang.String, str], double: float, double2: float) -> float: ... + def getTemperatures(self) -> typing.MutableSequence[float]: ... + def getTotalGridPoints(self) -> int: ... + def interpolate(self, double: float, double2: float) -> 'ThermodynamicCoupling.ThermoProperties': ... + def isBuilt(self) -> bool: ... + +class FlowRegimeDetector(java.io.Serializable): + def __init__(self): ... + def detectFlowRegime(self, pipeSection: 'PipeSection') -> 'PipeSection.FlowRegime': ... + def getDetectionMethod(self) -> 'FlowRegimeDetector.DetectionMethod': ... + def getFlowRegimeMap(self, pipeSection: 'PipeSection', double: float, double2: float, int: int) -> typing.MutableSequence[typing.MutableSequence['PipeSection.FlowRegime']]: ... + def isUseMinimumSlipCriterion(self) -> bool: ... + def setDetectionMethod(self, detectionMethod: 'FlowRegimeDetector.DetectionMethod') -> None: ... + def setUseMinimumSlipCriterion(self, boolean: bool) -> None: ... + class DetectionMethod(java.lang.Enum['FlowRegimeDetector.DetectionMethod']): + MECHANISTIC: typing.ClassVar['FlowRegimeDetector.DetectionMethod'] = ... + MINIMUM_SLIP: typing.ClassVar['FlowRegimeDetector.DetectionMethod'] = ... + _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]) -> 'FlowRegimeDetector.DetectionMethod': ... + @staticmethod + def values() -> typing.MutableSequence['FlowRegimeDetector.DetectionMethod']: ... + +class LiquidAccumulationTracker(java.io.Serializable): + def __init__(self): ... + def calculateDrainageRate(self, accumulationZone: 'LiquidAccumulationTracker.AccumulationZone', pipeSectionArray: typing.Union[typing.List['PipeSection'], jpype.JArray], double: float) -> float: ... + def checkForSlugRelease(self, accumulationZone: 'LiquidAccumulationTracker.AccumulationZone', pipeSectionArray: typing.Union[typing.List['PipeSection'], jpype.JArray]) -> 'LiquidAccumulationTracker.SlugCharacteristics': ... + def getAccumulationZones(self) -> java.util.List['LiquidAccumulationTracker.AccumulationZone']: ... + def getCriticalHoldup(self) -> float: ... + def getOverflowingZones(self) -> java.util.List['LiquidAccumulationTracker.AccumulationZone']: ... + def getTotalAccumulatedVolume(self) -> float: ... + def identifyAccumulationZones(self, pipeSectionArray: typing.Union[typing.List['PipeSection'], jpype.JArray]) -> None: ... + def setCriticalHoldup(self, double: float) -> None: ... + def setDrainageCoefficient(self, double: float) -> None: ... + def updateAccumulation(self, pipeSectionArray: typing.Union[typing.List['PipeSection'], jpype.JArray], double: float) -> None: ... + class AccumulationZone(java.io.Serializable): + startPosition: float = ... + endPosition: float = ... + liquidVolume: float = ... + maxVolume: float = ... + liquidLevel: float = ... + isActive: bool = ... + isOverflowing: bool = ... + netInflowRate: float = ... + outflowRate: float = ... + timeSinceSlug: float = ... + sectionIndices: java.util.List = ... + def __init__(self): ... + class SlugCharacteristics(java.io.Serializable): + frontPosition: float = ... + tailPosition: float = ... + length: float = ... + holdup: float = ... + velocity: float = ... + volume: float = ... + isTerrainInduced: bool = ... + def __init__(self): ... + def toString(self) -> java.lang.String: ... + +class PipeSection(java.lang.Cloneable, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float, double3: float, double4: float): ... + def clone(self) -> 'PipeSection': ... + def getAccumulatedLiquidVolume(self) -> float: ... + def getArea(self) -> float: ... + def getConservativeVariables(self) -> typing.MutableSequence[float]: ... + def getDiameter(self) -> float: ... + def getEffectiveLiquidHoldup(self) -> float: ... + def getEffectiveMixtureDensity(self) -> float: ... + def getElevation(self) -> float: ... + def getFlowRegime(self) -> 'PipeSection.FlowRegime': ... + def getFrictionPressureGradient(self) -> float: ... + def getGasDensity(self) -> float: ... + def getGasEnthalpy(self) -> float: ... + def getGasHoldup(self) -> float: ... + def getGasSoundSpeed(self) -> float: ... + def getGasVelocity(self) -> float: ... + def getGasViscosity(self) -> float: ... + def getGravityPressureGradient(self) -> float: ... + def getInclination(self) -> float: ... + def getLength(self) -> float: ... + def getLiquidDensity(self) -> float: ... + def getLiquidEnthalpy(self) -> float: ... + def getLiquidHoldup(self) -> float: ... + def getLiquidLevel(self) -> float: ... + def getLiquidSoundSpeed(self) -> float: ... + def getLiquidVelocity(self) -> float: ... + def getLiquidViscosity(self) -> float: ... + def getMassTransferRate(self) -> float: ... + def getMixtureDensity(self) -> float: ... + def getMixtureHeatCapacity(self) -> float: ... + def getMixtureVelocity(self) -> float: ... + def getPosition(self) -> float: ... + def getPressure(self) -> float: ... + def getRoughness(self) -> float: ... + def getSlugHoldup(self) -> float: ... + def getSuperficialGasVelocity(self) -> float: ... + def getSuperficialLiquidVelocity(self) -> float: ... + def getSurfaceTension(self) -> float: ... + def getTemperature(self) -> float: ... + def getWallisSoundSpeed(self) -> float: ... + def isHighPoint(self) -> bool: ... + def isInSlugBody(self) -> bool: ... + def isInSlugBubble(self) -> bool: ... + def isLowPoint(self) -> bool: ... + def setAccumulatedLiquidVolume(self, double: float) -> None: ... + def setDiameter(self, double: float) -> None: ... + def setElevation(self, double: float) -> None: ... + def setFlowRegime(self, flowRegime: 'PipeSection.FlowRegime') -> None: ... + def setFrictionPressureGradient(self, double: float) -> None: ... + def setFromConservativeVariables(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]) -> None: ... + def setGasDensity(self, double: float) -> None: ... + def setGasEnthalpy(self, double: float) -> None: ... + def setGasHoldup(self, double: float) -> None: ... + def setGasSoundSpeed(self, double: float) -> None: ... + def setGasVelocity(self, double: float) -> None: ... + def setGasViscosity(self, double: float) -> None: ... + def setGravityPressureGradient(self, double: float) -> None: ... + def setHighPoint(self, boolean: bool) -> None: ... + def setInSlugBody(self, boolean: bool) -> None: ... + def setInSlugBubble(self, boolean: bool) -> None: ... + def setInclination(self, double: float) -> None: ... + def setLength(self, double: float) -> None: ... + def setLiquidDensity(self, double: float) -> None: ... + def setLiquidEnthalpy(self, double: float) -> None: ... + def setLiquidHoldup(self, double: float) -> None: ... + def setLiquidSoundSpeed(self, double: float) -> None: ... + def setLiquidVelocity(self, double: float) -> None: ... + def setLiquidViscosity(self, double: float) -> None: ... + def setLowPoint(self, boolean: bool) -> None: ... + def setMassTransferRate(self, double: float) -> None: ... + def setMixtureHeatCapacity(self, double: float) -> None: ... + def setPosition(self, double: float) -> None: ... + def setPressure(self, double: float) -> None: ... + def setRoughness(self, double: float) -> None: ... + def setSlugHoldup(self, double: float) -> None: ... + def setSurfaceTension(self, double: float) -> None: ... + def setTemperature(self, double: float) -> None: ... + def updateDerivedQuantities(self) -> None: ... + class FlowRegime(java.lang.Enum['PipeSection.FlowRegime']): + STRATIFIED_SMOOTH: typing.ClassVar['PipeSection.FlowRegime'] = ... + STRATIFIED_WAVY: typing.ClassVar['PipeSection.FlowRegime'] = ... + SLUG: typing.ClassVar['PipeSection.FlowRegime'] = ... + ANNULAR: typing.ClassVar['PipeSection.FlowRegime'] = ... + DISPERSED_BUBBLE: typing.ClassVar['PipeSection.FlowRegime'] = ... + BUBBLE: typing.ClassVar['PipeSection.FlowRegime'] = ... + CHURN: typing.ClassVar['PipeSection.FlowRegime'] = ... + MIST: typing.ClassVar['PipeSection.FlowRegime'] = ... + SINGLE_PHASE_GAS: typing.ClassVar['PipeSection.FlowRegime'] = ... + SINGLE_PHASE_LIQUID: typing.ClassVar['PipeSection.FlowRegime'] = ... + _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]) -> 'PipeSection.FlowRegime': ... + @staticmethod + def values() -> typing.MutableSequence['PipeSection.FlowRegime']: ... + +class SlugTracker(java.io.Serializable): + def __init__(self): ... + def advanceSlugs(self, pipeSectionArray: typing.Union[typing.List[PipeSection], jpype.JArray], double: float) -> None: ... + def generateInletSlug(self, pipeSection: PipeSection, double: float) -> 'SlugTracker.SlugUnit': ... + def getAverageSlugLength(self) -> float: ... + def getMassConservationError(self) -> float: ... + def getMaxSlugLength(self) -> float: ... + def getSlugBodyHoldup(self) -> float: ... + def getSlugCount(self) -> int: ... + def getSlugFrequency(self) -> float: ... + def getSlugs(self) -> java.util.List['SlugTracker.SlugUnit']: ... + def getStatisticsString(self) -> java.lang.String: ... + def getTotalMassBorrowedFromEulerian(self) -> float: ... + def getTotalMassReturnedToEulerian(self) -> float: ... + def getTotalSlugsGenerated(self) -> int: ... + def getTotalSlugsMerged(self) -> int: ... + def initializeTerrainSlug(self, slugCharacteristics: LiquidAccumulationTracker.SlugCharacteristics, pipeSectionArray: typing.Union[typing.List[PipeSection], jpype.JArray]) -> 'SlugTracker.SlugUnit': ... + def reset(self) -> None: ... + def setFilmHoldup(self, double: float) -> None: ... + def setMinimumSlugLength(self, double: float) -> None: ... + def setReferenceVelocity(self, double: float) -> None: ... + def setSlugBodyHoldup(self, double: float) -> None: ... + class SlugUnit(java.io.Serializable): + id: int = ... + frontPosition: float = ... + tailPosition: float = ... + slugBodyLength: float = ... + bubbleLength: float = ... + frontVelocity: float = ... + tailVelocity: float = ... + bodyHoldup: float = ... + filmHoldup: float = ... + liquidVolume: float = ... + isGrowing: bool = ... + isDecaying: bool = ... + isTerrainInduced: bool = ... + age: float = ... + localInclination: float = ... + borrowedLiquidMass: float = ... + borrowedFromSections: typing.MutableSequence[int] = ... + def __init__(self): ... + def getTotalLength(self) -> float: ... + def toString(self) -> java.lang.String: ... + +class ThermodynamicCoupling(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcMassTransferRate(self, twoFluidSection: 'TwoFluidSection', double: float) -> float: ... + def calcMixtureSoundSpeed(self, twoFluidSection: 'TwoFluidSection') -> float: ... + def flashPH(self, double: float, double2: float) -> 'ThermodynamicCoupling.ThermoProperties': ... + def flashPT(self, double: float, double2: float) -> 'ThermodynamicCoupling.ThermoProperties': ... + def getFlashTable(self) -> FlashTable: ... + def getFlashTolerance(self) -> float: ... + def getMaxFlashIterations(self) -> int: ... + def getReferenceFluid(self) -> jneqsim.thermo.system.SystemInterface: ... + def isUsingFlashTable(self) -> bool: ... + def setFlashTable(self, flashTable: FlashTable) -> None: ... + def setFlashTolerance(self, double: float) -> None: ... + def setMaxFlashIterations(self, int: int) -> None: ... + def setPressureRange(self, double: float, double2: float) -> None: ... + def setReferenceFluid(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setTemperatureRange(self, double: float, double2: float) -> None: ... + def updateAllSections(self, twoFluidSectionArray: typing.Union[typing.List['TwoFluidSection'], jpype.JArray]) -> None: ... + def updateSectionProperties(self, twoFluidSection: 'TwoFluidSection') -> None: ... + class ThermoProperties(java.io.Serializable): + gasVaporFraction: float = ... + liquidFraction: float = ... + gasDensity: float = ... + liquidDensity: float = ... + gasViscosity: float = ... + liquidViscosity: float = ... + gasEnthalpy: float = ... + liquidEnthalpy: float = ... + gasSoundSpeed: float = ... + liquidSoundSpeed: float = ... + surfaceTension: float = ... + gasMolarMass: float = ... + liquidMolarMass: float = ... + gasCompressibility: float = ... + liquidCompressibility: float = ... + gasCp: float = ... + liquidCp: float = ... + gasThermalConductivity: float = ... + liquidThermalConductivity: float = ... + converged: bool = ... + errorMessage: java.lang.String = ... + def __init__(self): ... + +class ThreeFluidConservationEquations(java.io.Serializable): + def __init__(self): ... + def calcRHS(self, threeFluidSection: 'ThreeFluidSection', double: float, threeFluidSection2: 'ThreeFluidSection', threeFluidSection3: 'ThreeFluidSection') -> 'ThreeFluidConservationEquations.ThreeFluidRHS': ... + def getHeatTransferCoefficient(self) -> float: ... + def getStateVector(self, threeFluidSection: 'ThreeFluidSection') -> typing.MutableSequence[float]: ... + def getSurfaceTemperature(self) -> float: ... + def isEnableHeatTransfer(self) -> bool: ... + def setEnableHeatTransfer(self, boolean: bool) -> None: ... + def setHeatTransferCoefficient(self, double: float) -> None: ... + def setStateVector(self, threeFluidSection: 'ThreeFluidSection', doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setSurfaceTemperature(self, double: float) -> None: ... + class ThreeFluidRHS(java.io.Serializable): + gasMass: float = ... + oilMass: float = ... + waterMass: float = ... + gasMomentum: float = ... + oilMomentum: float = ... + waterMomentum: float = ... + energy: float = ... + gasWallShear: float = ... + oilWallShear: float = ... + waterWallShear: float = ... + gasOilInterfacialShear: float = ... + oilWaterInterfacialShear: float = ... + def __init__(self): ... + +class TransientPipe(jneqsim.process.equipment.TwoPortEquipment, jneqsim.process.equipment.pipeline.PipeLineInterface): + @typing.overload + def __init__(self): ... + @typing.overload + 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 getAccumulationTracker(self) -> LiquidAccumulationTracker: ... + def getAmbientTemperature(self) -> float: ... + def getCalculationIdentifier(self) -> java.util.UUID: ... + def getDiameter(self) -> float: ... + def getEnergyResidual(self) -> float: ... + def getGasVelocityProfile(self) -> typing.MutableSequence[float]: ... + def getInletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getJouleThomsonCoeff(self) -> float: ... + def getLength(self) -> float: ... + def getLiquidHoldupProfile(self) -> typing.MutableSequence[float]: ... + def getLiquidVelocityProfile(self) -> typing.MutableSequence[float]: ... + def getMassResidual(self) -> float: ... + def getName(self) -> java.lang.String: ... + def getOutletMassFlow(self) -> float: ... + def getOutletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOverallHeatTransferCoeff(self) -> float: ... + def getPipe(self) -> jneqsim.fluidmechanics.flowsystem.FlowSystemInterface: ... + def getPipeElasticity(self) -> float: ... + def getPressureHistory(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getPressureProfile(self) -> typing.MutableSequence[float]: ... + def getRoughness(self) -> float: ... + def getSections(self) -> typing.MutableSequence[PipeSection]: ... + def getSimulationTime(self) -> float: ... + def getSlugTracker(self) -> SlugTracker: ... + def getTemperatureProfile(self) -> typing.MutableSequence[float]: ... + def getTotalTimeSteps(self) -> int: ... + def getWallThickness(self) -> float: ... + def initializePipe(self) -> None: ... + def isConverged(self) -> bool: ... + def isIncludeHeatTransfer(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 setAmbientTemperature(self, double: float) -> None: ... + def setCalculationIdentifier(self, uUID: java.util.UUID) -> None: ... + def setCflNumber(self, double: float) -> None: ... + def setDiameter(self, double: float) -> None: ... + def setElevationProfile(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setHeightProfile(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setInclinationProfile(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setIncludeHeatTransfer(self, boolean: bool) -> None: ... + def setInitialFlowPattern(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setInletBoundaryCondition(self, boundaryCondition: 'TransientPipe.BoundaryCondition') -> None: ... + def setInletMassFlow(self, double: float) -> None: ... + def setInletPressure(self, double: float) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setLegPositions(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setLength(self, double: float) -> None: ... + def setMaxSimulationTime(self, double: float) -> None: ... + def setName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setNumberOfLegs(self, int: int) -> None: ... + def setNumberOfNodesInLeg(self, int: int) -> None: ... + def setNumberOfSections(self, int: int) -> None: ... + def setOuterTemperatures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setOutletBoundaryCondition(self, boundaryCondition: 'TransientPipe.BoundaryCondition') -> None: ... + def setOutletMassFlow(self, double: float) -> None: ... + def setOutletPressure(self, double: float) -> None: ... + def setOutletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setOutputFileName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setOverallHeatTransferCoeff(self, double: float) -> None: ... + def setPipeDiameters(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setPipeWallRoughness(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setRoughness(self, double: float) -> None: ... + def setThermodynamicUpdateInterval(self, int: int) -> None: ... + def setUpdateThermodynamics(self, boolean: bool) -> None: ... + def setinletPressureValue(self, double: float) -> None: ... + def setoutletPressureValue(self, double: float) -> None: ... + class BoundaryCondition(java.lang.Enum['TransientPipe.BoundaryCondition']): + CONSTANT_PRESSURE: typing.ClassVar['TransientPipe.BoundaryCondition'] = ... + CONSTANT_FLOW: typing.ClassVar['TransientPipe.BoundaryCondition'] = ... + CONSTANT_VELOCITY: typing.ClassVar['TransientPipe.BoundaryCondition'] = ... + CLOSED: typing.ClassVar['TransientPipe.BoundaryCondition'] = ... + TRANSIENT_PRESSURE: typing.ClassVar['TransientPipe.BoundaryCondition'] = ... + TRANSIENT_FLOW: typing.ClassVar['TransientPipe.BoundaryCondition'] = ... + _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]) -> 'TransientPipe.BoundaryCondition': ... + @staticmethod + def values() -> typing.MutableSequence['TransientPipe.BoundaryCondition']: ... + +class TwoFluidConservationEquations(java.io.Serializable): + NUM_EQUATIONS: typing.ClassVar[int] = ... + IDX_GAS_MASS: typing.ClassVar[int] = ... + IDX_OIL_MASS: typing.ClassVar[int] = ... + IDX_WATER_MASS: typing.ClassVar[int] = ... + IDX_GAS_MOMENTUM: typing.ClassVar[int] = ... + IDX_OIL_MOMENTUM: typing.ClassVar[int] = ... + IDX_WATER_MOMENTUM: typing.ClassVar[int] = ... + IDX_ENERGY: typing.ClassVar[int] = ... + IDX_LIQUID_MOMENTUM: typing.ClassVar[int] = ... + def __init__(self): ... + def applyPressureGradient(self, twoFluidSectionArray: typing.Union[typing.List['TwoFluidSection'], jpype.JArray], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], double2: float) -> None: ... + def applyState(self, twoFluidSectionArray: typing.Union[typing.List['TwoFluidSection'], jpype.JArray], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def calcRHS(self, twoFluidSectionArray: typing.Union[typing.List['TwoFluidSection'], jpype.JArray], double: float) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def extractState(self, twoFluidSectionArray: typing.Union[typing.List['TwoFluidSection'], jpype.JArray]) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getFlowRegimeDetector(self) -> FlowRegimeDetector: ... + def getFluxCalculator(self) -> jneqsim.process.equipment.pipeline.twophasepipe.numerics.AUSMPlusFluxCalculator: ... + def getHeatTransferCoefficient(self) -> float: ... + def getInterfacialFriction(self) -> jneqsim.process.equipment.pipeline.twophasepipe.closure.InterfacialFriction: ... + def getMassTransferCoefficient(self) -> float: ... + def getReconstructor(self) -> jneqsim.process.equipment.pipeline.twophasepipe.numerics.MUSCLReconstructor: ... + def getSurfaceTemperature(self) -> float: ... + def getWallFriction(self) -> jneqsim.process.equipment.pipeline.twophasepipe.closure.WallFriction: ... + def isEnableWaterOilSlip(self) -> bool: ... + def isHeatTransferEnabled(self) -> bool: ... + def isIncludeEnergyEquation(self) -> bool: ... + def isIncludeMassTransfer(self) -> bool: ... + def setEnableHeatTransfer(self, boolean: bool) -> None: ... + def setEnableWaterOilSlip(self, boolean: bool) -> None: ... + def setHeatTransferCoefficient(self, double: float) -> None: ... + def setIncludeEnergyEquation(self, boolean: bool) -> None: ... + def setIncludeMassTransfer(self, boolean: bool) -> None: ... + def setMassTransferCoefficient(self, double: float) -> None: ... + def setSurfaceTemperature(self, double: float) -> None: ... + +class TwoFluidSection(PipeSection): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float, double3: float, double4: float): ... + def calcGravityForces(self) -> typing.MutableSequence[float]: ... + def calcOilWaterInterfacialShear(self) -> float: ... + def clone(self) -> 'TwoFluidSection': ... + def extractPrimitiveVariables(self) -> None: ... + @staticmethod + def fromPipeSection(pipeSection: PipeSection) -> 'TwoFluidSection': ... + def getEnergyPerLength(self) -> float: ... + def getEnergySource(self) -> float: ... + def getGasHydraulicDiameter(self) -> float: ... + def getGasMassPerLength(self) -> float: ... + def getGasMassSource(self) -> float: ... + def getGasMomentumPerLength(self) -> float: ... + def getGasMomentumSource(self) -> float: ... + def getGasWallShear(self) -> float: ... + def getGasWettedPerimeter(self) -> float: ... + def getInterfacialShear(self) -> float: ... + def getInterfacialWidth(self) -> float: ... + def getLiquidHoldup(self) -> float: ... + def getLiquidHydraulicDiameter(self) -> float: ... + def getLiquidMassPerLength(self) -> float: ... + def getLiquidMassSource(self) -> float: ... + def getLiquidMomentumPerLength(self) -> float: ... + def getLiquidMomentumSource(self) -> float: ... + def getLiquidWallShear(self) -> float: ... + def getLiquidWettedPerimeter(self) -> float: ... + def getOilDensity(self) -> float: ... + def getOilFractionInLiquid(self) -> float: ... + def getOilHoldup(self) -> float: ... + def getOilMassPerLength(self) -> float: ... + def getOilMomentumPerLength(self) -> float: ... + def getOilVelocity(self) -> float: ... + def getOilViscosity(self) -> float: ... + def getStateVector(self) -> typing.MutableSequence[float]: ... + def getStratifiedLiquidLevel(self) -> float: ... + def getWaterCut(self) -> float: ... + def getWaterDensity(self) -> float: ... + def getWaterHoldup(self) -> float: ... + def getWaterMassPerLength(self) -> float: ... + def getWaterMomentumPerLength(self) -> float: ... + def getWaterVelocity(self) -> float: ... + def getWaterViscosity(self) -> float: ... + def setEnergyPerLength(self, double: float) -> None: ... + def setEnergySource(self, double: float) -> None: ... + def setGasHydraulicDiameter(self, double: float) -> None: ... + def setGasMassPerLength(self, double: float) -> None: ... + def setGasMassSource(self, double: float) -> None: ... + def setGasMomentumPerLength(self, double: float) -> None: ... + def setGasMomentumSource(self, double: float) -> None: ... + def setGasWallShear(self, double: float) -> None: ... + def setGasWettedPerimeter(self, double: float) -> None: ... + def setInterfacialShear(self, double: float) -> None: ... + def setInterfacialWidth(self, double: float) -> None: ... + def setLiquidHoldup(self, double: float) -> None: ... + def setLiquidHydraulicDiameter(self, double: float) -> None: ... + def setLiquidMassPerLength(self, double: float) -> None: ... + def setLiquidMassSource(self, double: float) -> None: ... + def setLiquidMomentumPerLength(self, double: float) -> None: ... + def setLiquidMomentumSource(self, double: float) -> None: ... + def setLiquidWallShear(self, double: float) -> None: ... + def setLiquidWettedPerimeter(self, double: float) -> None: ... + def setOilDensity(self, double: float) -> None: ... + def setOilFractionInLiquid(self, double: float) -> None: ... + def setOilHoldup(self, double: float) -> None: ... + def setOilMassPerLength(self, double: float) -> None: ... + def setOilMomentumPerLength(self, double: float) -> None: ... + def setOilVelocity(self, double: float) -> None: ... + def setOilViscosity(self, double: float) -> None: ... + def setStateVector(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setStratifiedLiquidLevel(self, double: float) -> None: ... + def setWaterCut(self, double: float) -> None: ... + def setWaterDensity(self, double: float) -> None: ... + def setWaterHoldup(self, double: float) -> None: ... + def setWaterMassPerLength(self, double: float) -> None: ... + def setWaterMomentumPerLength(self, double: float) -> None: ... + def setWaterVelocity(self, double: float) -> None: ... + def setWaterViscosity(self, double: float) -> None: ... + def updateConservativeVariables(self) -> None: ... + def updateStratifiedGeometry(self) -> None: ... + def updateThreePhaseProperties(self) -> None: ... + def updateWaterOilConservativeVariables(self) -> None: ... + def updateWaterOilHoldups(self) -> None: ... + +class ThreeFluidSection(TwoFluidSection, java.lang.Cloneable, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float, double3: float): ... + @typing.overload + def __init__(self, double: float, double2: float, double3: float, double4: float): ... + def clone(self) -> 'ThreeFluidSection': ... + def extractPrimitiveVariables(self) -> None: ... + def getGasOilInterfacialWidth(self) -> float: ... + def getGasOilSurfaceTension(self) -> float: ... + def getGasWaterSurfaceTension(self) -> float: ... + def getMixtureLiquidDensity(self) -> float: ... + def getMixtureLiquidVelocity(self) -> float: ... + def getMixtureLiquidViscosity(self) -> float: ... + def getOilArea(self) -> float: ... + def getOilDensity(self) -> float: ... + def getOilEnthalpy(self) -> float: ... + def getOilEvaporationRate(self) -> float: ... + def getOilHoldup(self) -> float: ... + def getOilLevel(self) -> float: ... + def getOilMassPerLength(self) -> float: ... + def getOilMomentumPerLength(self) -> float: ... + def getOilVelocity(self) -> float: ... + def getOilViscosity(self) -> float: ... + def getOilWaterInterfacialWidth(self) -> float: ... + def getOilWaterSurfaceTension(self) -> float: ... + def getOilWettedPerimeter(self) -> float: ... + def getTotalLiquidHoldup(self) -> float: ... + def getWaterArea(self) -> float: ... + def getWaterCut(self) -> float: ... + def getWaterDensity(self) -> float: ... + def getWaterEnthalpy(self) -> float: ... + def getWaterEvaporationRate(self) -> float: ... + def getWaterHoldup(self) -> float: ... + def getWaterLevel(self) -> float: ... + def getWaterMassPerLength(self) -> float: ... + def getWaterMomentumPerLength(self) -> float: ... + def getWaterVelocity(self) -> float: ... + def getWaterViscosity(self) -> float: ... + def getWaterWettedPerimeter(self) -> float: ... + def setGasOilSurfaceTension(self, double: float) -> None: ... + def setGasWaterSurfaceTension(self, double: float) -> None: ... + def setHoldups(self, double: float, double2: float, double3: float) -> None: ... + def setOilDensity(self, double: float) -> None: ... + def setOilEnthalpy(self, double: float) -> None: ... + def setOilEvaporationRate(self, double: float) -> None: ... + def setOilHoldup(self, double: float) -> None: ... + def setOilMassPerLength(self, double: float) -> None: ... + def setOilMomentumPerLength(self, double: float) -> None: ... + def setOilVelocity(self, double: float) -> None: ... + def setOilViscosity(self, double: float) -> None: ... + def setOilWaterSurfaceTension(self, double: float) -> None: ... + def setWaterCut(self, double: float) -> None: ... + def setWaterDensity(self, double: float) -> None: ... + def setWaterEnthalpy(self, double: float) -> None: ... + def setWaterEvaporationRate(self, double: float) -> None: ... + def setWaterHoldup(self, double: float) -> None: ... + def setWaterMassPerLength(self, double: float) -> None: ... + def setWaterMomentumPerLength(self, double: float) -> None: ... + def setWaterVelocity(self, double: float) -> None: ... + def setWaterViscosity(self, double: float) -> None: ... + def updateConservativeVariables(self) -> None: ... + def updateThreeLayerGeometry(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.pipeline.twophasepipe")``. + + DriftFluxModel: typing.Type[DriftFluxModel] + EntrainmentDeposition: typing.Type[EntrainmentDeposition] + FlashTable: typing.Type[FlashTable] + FlowRegimeDetector: typing.Type[FlowRegimeDetector] + LiquidAccumulationTracker: typing.Type[LiquidAccumulationTracker] + PipeSection: typing.Type[PipeSection] + SlugTracker: typing.Type[SlugTracker] + ThermodynamicCoupling: typing.Type[ThermodynamicCoupling] + ThreeFluidConservationEquations: typing.Type[ThreeFluidConservationEquations] + ThreeFluidSection: typing.Type[ThreeFluidSection] + TransientPipe: typing.Type[TransientPipe] + TwoFluidConservationEquations: typing.Type[TwoFluidConservationEquations] + TwoFluidSection: typing.Type[TwoFluidSection] + closure: jneqsim.process.equipment.pipeline.twophasepipe.closure.__module_protocol__ + numerics: jneqsim.process.equipment.pipeline.twophasepipe.numerics.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/twophasepipe/closure/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/twophasepipe/closure/__init__.pyi new file mode 100644 index 00000000..2c162846 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/twophasepipe/closure/__init__.pyi @@ -0,0 +1,69 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.io +import jneqsim.process.equipment.pipeline.twophasepipe +import typing + + + +class GeometryCalculator(java.io.Serializable): + def __init__(self): ... + def approximateLiquidLevel(self, double: float, double2: float) -> float: ... + def calcAnnularFilmThickness(self, double: float, double2: float) -> float: ... + def calcAnnularGasPerimeter(self, double: float, double2: float) -> float: ... + def calcAreaDerivative(self, double: float, double2: float) -> float: ... + def calculateFromHoldup(self, double: float, double2: float) -> 'GeometryCalculator.StratifiedGeometry': ... + def calculateFromLiquidLevel(self, double: float, double2: float) -> 'GeometryCalculator.StratifiedGeometry': ... + def isStratifiedStable(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float) -> bool: ... + class StratifiedGeometry(java.io.Serializable): + liquidArea: float = ... + gasArea: float = ... + liquidWettedPerimeter: float = ... + gasWettedPerimeter: float = ... + interfacialWidth: float = ... + liquidHydraulicDiameter: float = ... + gasHydraulicDiameter: float = ... + liquidAngle: float = ... + liquidLevel: float = ... + liquidHoldup: float = ... + def __init__(self): ... + +class InterfacialFriction(java.io.Serializable): + def __init__(self): ... + def calcInterfacialForce(self, flowRegime: jneqsim.process.equipment.pipeline.twophasepipe.PipeSection.FlowRegime, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, double9: float) -> float: ... + def calculate(self, flowRegime: jneqsim.process.equipment.pipeline.twophasepipe.PipeSection.FlowRegime, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, double9: float) -> 'InterfacialFriction.InterfacialFrictionResult': ... + class InterfacialFrictionResult(java.io.Serializable): + interfacialShear: float = ... + frictionFactor: float = ... + slipVelocity: float = ... + interfacialAreaPerLength: float = ... + def __init__(self): ... + +class WallFriction(java.io.Serializable): + def __init__(self): ... + def calcColebrookFanning(self, double: float, double2: float, double3: float) -> float: ... + def calcFanningFrictionFactor(self, double: float, double2: float, double3: float) -> float: ... + def calculate(self, flowRegime: jneqsim.process.equipment.pipeline.twophasepipe.PipeSection.FlowRegime, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, double9: float) -> 'WallFriction.WallFrictionResult': ... + def getDefaultRoughness(self) -> float: ... + def setDefaultRoughness(self, double: float) -> None: ... + class WallFrictionResult(java.io.Serializable): + gasWallShear: float = ... + liquidWallShear: float = ... + gasFrictionFactor: float = ... + liquidFrictionFactor: float = ... + gasReynolds: float = ... + liquidReynolds: float = ... + def __init__(self): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.pipeline.twophasepipe.closure")``. + + GeometryCalculator: typing.Type[GeometryCalculator] + InterfacialFriction: typing.Type[InterfacialFriction] + WallFriction: typing.Type[WallFriction] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/twophasepipe/numerics/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/twophasepipe/numerics/__init__.pyi new file mode 100644 index 00000000..079f096a --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/twophasepipe/numerics/__init__.pyi @@ -0,0 +1,141 @@ + +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 jpype +import typing + + + +class AUSMPlusFluxCalculator(java.io.Serializable): + def __init__(self): ... + def calcMachMinus(self, double: float) -> float: ... + def calcMachPlus(self, double: float) -> float: ... + def calcPhaseFlux(self, phaseState: 'AUSMPlusFluxCalculator.PhaseState', phaseState2: 'AUSMPlusFluxCalculator.PhaseState', double: float) -> 'AUSMPlusFluxCalculator.PhaseFlux': ... + def calcPressureMinus(self, double: float) -> float: ... + def calcPressurePlus(self, double: float) -> float: ... + def calcRusanovFlux(self, phaseState: 'AUSMPlusFluxCalculator.PhaseState', phaseState2: 'AUSMPlusFluxCalculator.PhaseState', double: float) -> 'AUSMPlusFluxCalculator.PhaseFlux': ... + def calcTwoFluidFlux(self, phaseState: 'AUSMPlusFluxCalculator.PhaseState', phaseState2: 'AUSMPlusFluxCalculator.PhaseState', phaseState3: 'AUSMPlusFluxCalculator.PhaseState', phaseState4: 'AUSMPlusFluxCalculator.PhaseState', double: float) -> 'AUSMPlusFluxCalculator.TwoFluidFlux': ... + def calcUpwindFlux(self, phaseState: 'AUSMPlusFluxCalculator.PhaseState', phaseState2: 'AUSMPlusFluxCalculator.PhaseState', double: float) -> 'AUSMPlusFluxCalculator.PhaseFlux': ... + def getAlpha(self) -> float: ... + def getBeta(self) -> float: ... + def getMinSoundSpeed(self) -> float: ... + def setAlpha(self, double: float) -> None: ... + def setBeta(self, double: float) -> None: ... + def setMinSoundSpeed(self, double: float) -> None: ... + class PhaseFlux(java.io.Serializable): + massFlux: float = ... + momentumFlux: float = ... + energyFlux: float = ... + holdupFlux: float = ... + def __init__(self): ... + class PhaseState(java.io.Serializable): + density: float = ... + velocity: float = ... + pressure: float = ... + soundSpeed: float = ... + enthalpy: float = ... + holdup: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float): ... + class TwoFluidFlux(java.io.Serializable): + gasFlux: 'AUSMPlusFluxCalculator.PhaseFlux' = ... + liquidFlux: 'AUSMPlusFluxCalculator.PhaseFlux' = ... + interfaceMach: float = ... + def __init__(self): ... + +class MUSCLReconstructor(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, slopeLimiter: 'MUSCLReconstructor.SlopeLimiter'): ... + def calcLimitedSlope(self, double: float, double2: float) -> float: ... + def calcLimiter(self, double: float) -> float: ... + def getLimiterType(self) -> 'MUSCLReconstructor.SlopeLimiter': ... + def isSecondOrder(self) -> bool: ... + def mc(self, double: float) -> float: ... + def minmod(self, double: float) -> float: ... + def minmod3(self, double: float, double2: float, double3: float) -> float: ... + def reconstruct(self, double: float, double2: float, double3: float, double4: float) -> 'MUSCLReconstructor.ReconstructedPair': ... + def reconstructArray(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence['MUSCLReconstructor.ReconstructedPair']: ... + def setLimiterType(self, slopeLimiter: 'MUSCLReconstructor.SlopeLimiter') -> None: ... + def superbee(self, double: float) -> float: ... + def vanAlbada(self, double: float) -> float: ... + def vanLeer(self, double: float) -> float: ... + class ReconstructedPair(java.io.Serializable): + left: float = ... + right: float = ... + def __init__(self): ... + class SlopeLimiter(java.lang.Enum['MUSCLReconstructor.SlopeLimiter']): + MINMOD: typing.ClassVar['MUSCLReconstructor.SlopeLimiter'] = ... + VAN_LEER: typing.ClassVar['MUSCLReconstructor.SlopeLimiter'] = ... + VAN_ALBADA: typing.ClassVar['MUSCLReconstructor.SlopeLimiter'] = ... + SUPERBEE: typing.ClassVar['MUSCLReconstructor.SlopeLimiter'] = ... + MC: typing.ClassVar['MUSCLReconstructor.SlopeLimiter'] = ... + NONE: typing.ClassVar['MUSCLReconstructor.SlopeLimiter'] = ... + _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]) -> 'MUSCLReconstructor.SlopeLimiter': ... + @staticmethod + def values() -> typing.MutableSequence['MUSCLReconstructor.SlopeLimiter']: ... + +class TimeIntegrator(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, method: 'TimeIntegrator.Method'): ... + def advanceTime(self, double: float) -> None: ... + def calcStableTimeStep(self, double: float, double2: float) -> float: ... + def calcTwoFluidTimeStep(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], double5: float) -> float: ... + def getCflNumber(self) -> float: ... + def getCurrentDt(self) -> float: ... + def getCurrentTime(self) -> float: ... + def getMaxTimeStep(self) -> float: ... + def getMethod(self) -> 'TimeIntegrator.Method': ... + def getMinTimeStep(self) -> float: ... + def reset(self) -> None: ... + def setCflNumber(self, double: float) -> None: ... + def setCurrentTime(self, double: float) -> None: ... + def setMaxTimeStep(self, double: float) -> None: ... + def setMethod(self, method: 'TimeIntegrator.Method') -> None: ... + def setMinTimeStep(self, double: float) -> None: ... + def step(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], rHSFunction: typing.Union['TimeIntegrator.RHSFunction', typing.Callable], double2: float) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def stepEuler(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], rHSFunction: typing.Union['TimeIntegrator.RHSFunction', typing.Callable], double2: float) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def stepRK2(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], rHSFunction: typing.Union['TimeIntegrator.RHSFunction', typing.Callable], double2: float) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def stepRK4(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], rHSFunction: typing.Union['TimeIntegrator.RHSFunction', typing.Callable], double2: float) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def stepSSPRK3(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], rHSFunction: typing.Union['TimeIntegrator.RHSFunction', typing.Callable], double2: float) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + class Method(java.lang.Enum['TimeIntegrator.Method']): + EULER: typing.ClassVar['TimeIntegrator.Method'] = ... + RK2: typing.ClassVar['TimeIntegrator.Method'] = ... + RK4: typing.ClassVar['TimeIntegrator.Method'] = ... + SSP_RK3: typing.ClassVar['TimeIntegrator.Method'] = ... + _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]) -> 'TimeIntegrator.Method': ... + @staticmethod + def values() -> typing.MutableSequence['TimeIntegrator.Method']: ... + class RHSFunction: + def evaluate(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], double2: float) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.pipeline.twophasepipe.numerics")``. + + AUSMPlusFluxCalculator: typing.Type[AUSMPlusFluxCalculator] + MUSCLReconstructor: typing.Type[MUSCLReconstructor] + TimeIntegrator: typing.Type[TimeIntegrator] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/powergeneration/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/powergeneration/__init__.pyi new file mode 100644 index 00000000..d7545e9d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/powergeneration/__init__.pyi @@ -0,0 +1,101 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.compressor +import jneqsim.process.equipment.stream +import jneqsim.process.mechanicaldesign.compressor +import jneqsim.thermo.system +import typing + + + +class FuelCell(jneqsim.process.equipment.TwoPortEquipment): + @typing.overload + def __init__(self): ... + @typing.overload + 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, streamInterface2: jneqsim.process.equipment.stream.StreamInterface): ... + def getEfficiency(self) -> float: ... + def getHeatLoss(self) -> float: ... + def getOxidantStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getPower(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setEfficiency(self, double: float) -> None: ... + def setOxidantStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + +class GasTurbine(jneqsim.process.equipment.TwoPortEquipment): + thermoSystem: jneqsim.thermo.system.SystemInterface = ... + airStream: jneqsim.process.equipment.stream.StreamInterface = ... + airCompressor: jneqsim.process.equipment.compressor.Compressor = ... + combustionpressure: float = ... + power: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + 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 calcIdealAirFuelRatio(self) -> float: ... + def getHeat(self) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.compressor.CompressorMechanicalDesign: ... + def getPower(self) -> float: ... + @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: ... + +class SolarPanel(jneqsim.process.equipment.ProcessEquipmentBaseClass): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float): ... + def getPower(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setEfficiency(self, double: float) -> None: ... + def setIrradiance(self, double: float) -> None: ... + def setPanelArea(self, double: float) -> None: ... + +class WindTurbine(jneqsim.process.equipment.ProcessEquipmentBaseClass): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def getAirDensity(self) -> float: ... + def getPower(self) -> float: ... + def getPowerCoefficient(self) -> float: ... + def getRotorArea(self) -> float: ... + def getWindSpeed(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setAirDensity(self, double: float) -> None: ... + def setPowerCoefficient(self, double: float) -> None: ... + def setRotorArea(self, double: float) -> None: ... + def setWindSpeed(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.powergeneration")``. + + FuelCell: typing.Type[FuelCell] + GasTurbine: typing.Type[GasTurbine] + SolarPanel: typing.Type[SolarPanel] + WindTurbine: typing.Type[WindTurbine] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pump/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pump/__init__.pyi new file mode 100644 index 00000000..50ae033f --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pump/__init__.pyi @@ -0,0 +1,171 @@ + +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.process.equipment +import jneqsim.process.equipment.compressor +import jneqsim.process.equipment.stream +import jneqsim.process.util.report +import jneqsim.thermo.system +import typing + + + +class PumpChartInterface(java.lang.Cloneable): + def addCurve(self, double: 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]) -> None: ... + def getBestEfficiencyFlowRate(self) -> float: ... + def getEfficiency(self, double: float, double2: float) -> float: ... + def getHead(self, double: float, double2: float) -> float: ... + def getHeadUnit(self) -> java.lang.String: ... + def getNPSHRequired(self, double: float, double2: float) -> float: ... + def getOperatingStatus(self, double: float, double2: float) -> java.lang.String: ... + def getSpecificSpeed(self) -> float: ... + def getSpeed(self, double: float, double2: float) -> int: ... + def hasNPSHCurve(self) -> bool: ... + def isUsePumpChart(self) -> bool: ... + def plot(self) -> None: ... + def setCurves(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray5: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setHeadUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setNPSHCurve(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setReferenceConditions(self, double: float, double2: float, double3: float, double4: float) -> None: ... + def setUsePumpChart(self, boolean: bool) -> None: ... + def setUseRealKappa(self, boolean: bool) -> None: ... + def useRealKappa(self) -> bool: ... + +class PumpCurve(java.io.Serializable): + flow: typing.MutableSequence[float] = ... + head: typing.MutableSequence[float] = ... + efficiency: typing.MutableSequence[float] = ... + speed: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: 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]): ... + +class PumpInterface(jneqsim.process.equipment.ProcessEquipmentInterface, jneqsim.process.equipment.TwoPortInterface): + def equals(self, object: typing.Any) -> bool: ... + def getEnergy(self) -> float: ... + def getMinimumFlow(self) -> float: ... + def getNPSHAvailable(self) -> float: ... + def getNPSHRequired(self) -> float: ... + def getPower(self) -> float: ... + def hashCode(self) -> int: ... + def isCavitating(self) -> bool: ... + def setCheckNPSH(self, boolean: bool) -> None: ... + def setMinimumFlow(self, double: float) -> None: ... + def setPumpChartType(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class Pump(jneqsim.process.equipment.TwoPortEquipment, PumpInterface): + isentropicEfficiency: float = ... + powerSet: bool = ... + @typing.overload + 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 calculateAsCompressor(self, boolean: bool) -> None: ... + def displayResult(self) -> None: ... + def getCapacityDuty(self) -> float: ... + def getCapacityMax(self) -> float: ... + def getDuty(self) -> float: ... + def getEnergy(self) -> float: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getIsentropicEfficiency(self) -> float: ... + def getMinimumFlow(self) -> float: ... + def getMolarFlow(self) -> float: ... + def getNPSHAvailable(self) -> float: ... + def getNPSHMargin(self) -> float: ... + def getNPSHRequired(self) -> float: ... + def getOutTemperature(self) -> float: ... + @typing.overload + def getPower(self) -> float: ... + @typing.overload + def getPower(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getPumpChart(self) -> PumpChartInterface: ... + def getSpeed(self) -> float: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def isCavitating(self) -> bool: ... + def isCheckNPSH(self) -> bool: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setCheckNPSH(self, boolean: bool) -> None: ... + def setIsentropicEfficiency(self, double: float) -> None: ... + def setMinimumFlow(self, double: float) -> None: ... + def setMolarFlow(self, double: float) -> None: ... + def setNPSHMargin(self, double: float) -> None: ... + def setOutTemperature(self, double: float) -> None: ... + @typing.overload + def setOutletPressure(self, double: float) -> None: ... + @typing.overload + def setOutletPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setPressure(self, double: float) -> None: ... + @typing.overload + def setPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setPumpChartType(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setSpeed(self, double: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class PumpChart(PumpChartInterface, java.io.Serializable): + def __init__(self): ... + def addCurve(self, double: 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]) -> None: ... + def checkStoneWall(self, double: float, double2: float) -> bool: ... + def checkSurge1(self, double: float, double2: float) -> bool: ... + def checkSurge2(self, double: float, double2: float) -> bool: ... + def efficiency(self, double: float, double2: float) -> float: ... + def fitReducedCurve(self) -> None: ... + def getBestEfficiencyFlowRate(self) -> float: ... + def getEfficiency(self, double: float, double2: float) -> float: ... + def getHead(self, double: float, double2: float) -> float: ... + def getHeadUnit(self) -> java.lang.String: ... + def getNPSHRequired(self, double: float, double2: float) -> float: ... + def getOperatingStatus(self, double: float, double2: float) -> java.lang.String: ... + def getSpecificSpeed(self) -> float: ... + def getSpeed(self, double: float, double2: float) -> int: ... + def hasNPSHCurve(self) -> bool: ... + def isUsePumpChart(self) -> bool: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def plot(self) -> None: ... + def setCurves(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray5: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setHeadUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setNPSHCurve(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setReferenceConditions(self, double: float, double2: float, double3: float, double4: float) -> None: ... + def setUsePumpChart(self, boolean: bool) -> None: ... + def setUseRealKappa(self, boolean: bool) -> None: ... + def useRealKappa(self) -> bool: ... + +class PumpChartAlternativeMapLookupExtrapolate(jneqsim.process.equipment.compressor.CompressorChartAlternativeMapLookupExtrapolate, PumpChartInterface): + def __init__(self): ... + def getBestEfficiencyFlowRate(self) -> float: ... + def getEfficiency(self, double: float, double2: float) -> float: ... + def getHead(self, double: float, double2: float) -> float: ... + def getNPSHRequired(self, double: float, double2: float) -> float: ... + def getOperatingStatus(self, double: float, double2: float) -> java.lang.String: ... + def getSpecificSpeed(self) -> float: ... + def hasNPSHCurve(self) -> bool: ... + def isUsePumpChart(self) -> bool: ... + def setNPSHCurve(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setUsePumpChart(self, boolean: bool) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.pump")``. + + Pump: typing.Type[Pump] + PumpChart: typing.Type[PumpChart] + PumpChartAlternativeMapLookupExtrapolate: typing.Type[PumpChartAlternativeMapLookupExtrapolate] + PumpChartInterface: typing.Type[PumpChartInterface] + PumpCurve: typing.Type[PumpCurve] + PumpInterface: typing.Type[PumpInterface] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/reactor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/reactor/__init__.pyi new file mode 100644 index 00000000..65ea127c --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/reactor/__init__.pyi @@ -0,0 +1,180 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.util.report +import typing + + + +class FurnaceBurner(jneqsim.process.equipment.ProcessEquipmentBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def getAirFuelRatioMass(self) -> float: ... + def getAirInlet(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getEmissionRatesKgPerHr(self) -> java.util.Map[java.lang.String, float]: ... + def getFlameTemperature(self) -> float: ... + def getFuelInlet(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getHeatReleasekW(self) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getOutletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setAirFuelRatioMass(self, double: float) -> None: ... + def setAirInlet(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setBurnerDesign(self, burnerDesign: 'FurnaceBurner.BurnerDesign') -> None: ... + def setCoolingFactor(self, double: float) -> None: ... + def setExcessAirFraction(self, double: float) -> None: ... + def setFuelInlet(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setSurroundingsTemperature(self, double: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + class BurnerDesign(java.lang.Enum['FurnaceBurner.BurnerDesign']): + ADIABATIC: typing.ClassVar['FurnaceBurner.BurnerDesign'] = ... + COOLED: typing.ClassVar['FurnaceBurner.BurnerDesign'] = ... + _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]) -> 'FurnaceBurner.BurnerDesign': ... + @staticmethod + def values() -> typing.MutableSequence['FurnaceBurner.BurnerDesign']: ... + +class GibbsReactor(jneqsim.process.equipment.TwoPortEquipment): + @typing.overload + 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): ... + @typing.overload + def calculateMixtureEnthalpy(self, list: java.util.List[typing.Union[java.lang.String, str]], list2: java.util.List[float], double: float, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], 'GibbsReactor.GibbsComponent'], typing.Mapping[typing.Union[java.lang.String, str], 'GibbsReactor.GibbsComponent']]) -> float: ... + @typing.overload + def calculateMixtureEnthalpy(self, list: java.util.List[typing.Union[java.lang.String, str]], list2: java.util.List[float], map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], 'GibbsReactor.GibbsComponent'], typing.Mapping[typing.Union[java.lang.String, str], 'GibbsReactor.GibbsComponent']], double: float) -> float: ... + def calculateMixtureEnthalpyStandard(self, list: java.util.List[typing.Union[java.lang.String, str]], list2: java.util.List[float], map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], 'GibbsReactor.GibbsComponent'], typing.Mapping[typing.Union[java.lang.String, str], 'GibbsReactor.GibbsComponent']]) -> float: ... + def calculateMixtureGibbsEnergy(self, list: java.util.List[typing.Union[java.lang.String, str]], list2: java.util.List[float], map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], 'GibbsReactor.GibbsComponent'], typing.Mapping[typing.Union[java.lang.String, str], 'GibbsReactor.GibbsComponent']], double: float) -> float: ... + def getActualIterations(self) -> int: ... + def getConvergenceTolerance(self) -> float: ... + def getDampingComposition(self) -> float: ... + def getDetailedMoleBalance(self) -> java.util.Map[java.lang.String, java.util.Map[java.lang.String, float]]: ... + def getElementMoleBalanceDiff(self) -> typing.MutableSequence[float]: ... + def getElementMoleBalanceIn(self) -> typing.MutableSequence[float]: ... + def getElementMoleBalanceOut(self) -> typing.MutableSequence[float]: ... + def getElementNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getEnergyMode(self) -> 'GibbsReactor.EnergyMode': ... + def getEnthalpyOfReactions(self) -> float: ... + def getFinalConvergenceError(self) -> float: ... + def getFugacityCoefficient(self, object: typing.Any) -> typing.MutableSequence[float]: ... + def getInletMole(self) -> java.util.List[float]: ... + def getInletMoles(self) -> java.util.List[float]: ... + def getJacobianColLabels(self) -> java.util.List[java.lang.String]: ... + def getJacobianInverse(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getJacobianMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getJacobianRowLabels(self) -> java.util.List[java.lang.String]: ... + def getLagrangeContributions(self) -> java.util.Map[java.lang.String, float]: ... + def getLagrangeMultiplierContributions(self) -> java.util.Map[java.lang.String, java.util.Map[java.lang.String, float]]: ... + def getLagrangianMultipliers(self) -> typing.MutableSequence[float]: ... + def getMassBalanceConverged(self) -> bool: ... + def getMassBalanceError(self) -> float: ... + def getMaxIterations(self) -> int: ... + def getMethod(self) -> java.lang.String: ... + def getMixtureEnthalpy(self) -> float: ... + def getMixtureGibbsEnergy(self) -> float: ... + def getObjectiveFunctionValues(self) -> java.util.Map[java.lang.String, float]: ... + def getObjectiveMinimizationVector(self) -> typing.MutableSequence[float]: ... + def getObjectiveMinimizationVectorLabels(self) -> java.util.List[java.lang.String]: ... + def getOutletMole(self) -> java.util.List[float]: ... + def getOutletMoles(self) -> java.util.List[float]: ... + @typing.overload + def getPower(self) -> float: ... + @typing.overload + def getPower(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getTemperatureChange(self) -> float: ... + def getUseAllDatabaseSpecies(self) -> bool: ... + def hasConverged(self) -> bool: ... + def isComponentInert(self, string: typing.Union[java.lang.String, str]) -> bool: ... + def performIterationUpdate(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], double2: float) -> bool: ... + def performNewtonRaphsonIteration(self) -> typing.MutableSequence[float]: ... + def printDatabaseComponents(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + @typing.overload + def setComponentAsInert(self, int: int) -> None: ... + @typing.overload + def setComponentAsInert(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setConvergenceTolerance(self, double: float) -> None: ... + def setDampingComposition(self, double: float) -> None: ... + @typing.overload + def setEnergyMode(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setEnergyMode(self, energyMode: 'GibbsReactor.EnergyMode') -> None: ... + def setLagrangeMultiplier(self, int: int, double: float) -> None: ... + def setMaxIterations(self, int: int) -> None: ... + def setMethod(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setUseAllDatabaseSpecies(self, boolean: bool) -> None: ... + @typing.overload + def solveGibbsEquilibrium(self) -> bool: ... + @typing.overload + def solveGibbsEquilibrium(self, double: float) -> bool: ... + def verifyJacobianInverse(self) -> bool: ... + class EnergyMode(java.lang.Enum['GibbsReactor.EnergyMode']): + ISOTHERMAL: typing.ClassVar['GibbsReactor.EnergyMode'] = ... + ADIABATIC: typing.ClassVar['GibbsReactor.EnergyMode'] = ... + _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]) -> 'GibbsReactor.EnergyMode': ... + @staticmethod + def values() -> typing.MutableSequence['GibbsReactor.EnergyMode']: ... + class GibbsComponent: + def __init__(self, gibbsReactor: 'GibbsReactor', string: typing.Union[java.lang.String, str], doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], 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): ... + def calculateCorrectedHeatCapacityCoeffs(self, int: int) -> typing.MutableSequence[float]: ... + def calculateEnthalpy(self, double: float, int: int) -> float: ... + def calculateEntropy(self, double: float, int: int) -> float: ... + def calculateGibbsEnergy(self, double: float, int: int) -> float: ... + def calculateHeatCapacity(self, double: float, int: int) -> float: ... + def calculateI(self, int: int) -> float: ... + def calculateJ(self, int: int) -> float: ... + def getDeltaGf298(self) -> float: ... + def getDeltaHf298(self) -> float: ... + def getDeltaSf298(self) -> float: ... + def getElements(self) -> typing.MutableSequence[float]: ... + def getHeatCapacityCoeffs(self) -> typing.MutableSequence[float]: ... + def getMolecule(self) -> java.lang.String: ... + +class GibbsReactorCO2(jneqsim.process.equipment.TwoPortEquipment): + @typing.overload + 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): ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.reactor")``. + + FurnaceBurner: typing.Type[FurnaceBurner] + GibbsReactor: typing.Type[GibbsReactor] + GibbsReactorCO2: typing.Type[GibbsReactorCO2] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/reservoir/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/reservoir/__init__.pyi new file mode 100644 index 00000000..dceea0d3 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/reservoir/__init__.pyi @@ -0,0 +1,329 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.nio.file +import java.util +import jpype +import jpype.protocol +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.thermo.system +import jneqsim.util +import typing + + + +class ReservoirCVDsim(jneqsim.process.equipment.ProcessEquipmentBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + +class ReservoirDiffLibsim(jneqsim.process.equipment.ProcessEquipmentBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + +class ReservoirTPsim(jneqsim.process.equipment.ProcessEquipmentBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getProdPhaseName(self) -> java.lang.String: ... + def getReserervourFluid(self) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setFlowRate(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setPressure(self, double: float) -> None: ... + @typing.overload + def setPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setProdPhaseName(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setTemperature(self, double: float) -> None: ... + @typing.overload + def setTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + +class SimpleReservoir(jneqsim.process.equipment.ProcessEquipmentBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def GORprodution(self) -> float: ... + def addGasInjector(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def addGasProducer(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def addOilProducer(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def addWaterInjector(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def addWaterProducer(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def displayResult(self) -> None: ... + def getGasInPlace(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getGasInjector(self, int: int) -> 'Well': ... + def getGasProducer(self, int: int) -> 'Well': ... + def getGasProductionTotal(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getGasProdution(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getLowPressureLimit(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getOGIP(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getOOIP(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getOilInPlace(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getOilProducer(self, int: int) -> 'Well': ... + @typing.overload + def getOilProducer(self, string: typing.Union[java.lang.String, str]) -> 'Well': ... + def getOilProductionTotal(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getOilProdution(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getProductionTotal(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getReservoirFluid(self) -> jneqsim.thermo.system.SystemInterface: ... + def getTime(self) -> float: ... + def getWaterInjector(self, int: int) -> 'Well': ... + def getWaterProducer(self, int: int) -> 'Well': ... + def getWaterProdution(self, string: typing.Union[java.lang.String, str]) -> float: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @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 setLowPressureLimit(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setReservoirFluid(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float, double3: float) -> None: ... + +class TubingPerformance(jneqsim.process.equipment.TwoPortEquipment): + @typing.overload + 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 disableTableVLP(self) -> None: ... + def findOperatingPoint(self, wellFlow: 'WellFlow', double: float, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + @typing.overload + def generateVLPCurve(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + def generateVLPCurve(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], double2: float) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def generateVLPFamily(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], string: typing.Union[java.lang.String, str], doubleArray2: typing.Union[typing.List[float], jpype.JArray], string2: typing.Union[java.lang.String, str]) -> java.util.List[typing.MutableSequence[typing.MutableSequence[float]]]: ... + def getBottomHolePressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getDepthProfile(self) -> typing.MutableSequence[float]: ... + def getHoldupProfile(self) -> typing.MutableSequence[float]: ... + def getPressureProfile(self) -> typing.MutableSequence[float]: ... + def getTemperatureProfile(self) -> typing.MutableSequence[float]: ... + def getTotalPressureDrop(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getVLPCurve(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getVLPTableBHP(self) -> typing.MutableSequence[float]: ... + def getVLPTableFlowRates(self) -> typing.MutableSequence[float]: ... + def getVLPTableWellheadPressure(self) -> float: ... + def getWellheadPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def interpolateBHPFromTable(self, double: float) -> float: ... + def isUsingTableVLP(self) -> bool: ... + @typing.overload + def loadVLPFromFile(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + @typing.overload + def loadVLPFromFile(self, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath], double: float) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setBottomHoleTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setGeothermalGradient(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setInclination(self, double: float) -> None: ... + def setNumberOfSegments(self, int: int) -> None: ... + def setOverallHeatTransferCoefficient(self, double: float) -> None: ... + def setPressureDropCorrelation(self, pressureDropCorrelation: 'TubingPerformance.PressureDropCorrelation') -> None: ... + def setProductionTime(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTableVLP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray], double3: float) -> None: ... + def setTemperatureModel(self, temperatureModel: 'TubingPerformance.TemperatureModel') -> None: ... + def setTubingDiameter(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTubingLength(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setWallRoughness(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setWellheadTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + class PressureDropCorrelation(java.lang.Enum['TubingPerformance.PressureDropCorrelation']): + BEGGS_BRILL: typing.ClassVar['TubingPerformance.PressureDropCorrelation'] = ... + HAGEDORN_BROWN: typing.ClassVar['TubingPerformance.PressureDropCorrelation'] = ... + GRAY: typing.ClassVar['TubingPerformance.PressureDropCorrelation'] = ... + HASAN_KABIR: typing.ClassVar['TubingPerformance.PressureDropCorrelation'] = ... + DUNS_ROS: typing.ClassVar['TubingPerformance.PressureDropCorrelation'] = ... + _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]) -> 'TubingPerformance.PressureDropCorrelation': ... + @staticmethod + def values() -> typing.MutableSequence['TubingPerformance.PressureDropCorrelation']: ... + class TemperatureModel(java.lang.Enum['TubingPerformance.TemperatureModel']): + ISOTHERMAL: typing.ClassVar['TubingPerformance.TemperatureModel'] = ... + LINEAR_GRADIENT: typing.ClassVar['TubingPerformance.TemperatureModel'] = ... + RAMEY: typing.ClassVar['TubingPerformance.TemperatureModel'] = ... + HASAN_KABIR_ENERGY: typing.ClassVar['TubingPerformance.TemperatureModel'] = ... + _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]) -> 'TubingPerformance.TemperatureModel': ... + @staticmethod + def values() -> typing.MutableSequence['TubingPerformance.TemperatureModel']: ... + +class Well(jneqsim.util.NamedBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def getGOR(self) -> float: ... + def getStdGasProduction(self) -> float: ... + def getStdOilProduction(self) -> float: ... + def getStdWaterProduction(self) -> float: ... + def getStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def setStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + +class WellFlow(jneqsim.process.equipment.TwoPortEquipment): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addLayer(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface, double: float, double2: float) -> None: ... + def getIPRTablePressures(self) -> typing.MutableSequence[float]: ... + def getIPRTableRates(self) -> typing.MutableSequence[float]: ... + def getLayer(self, int: int) -> 'WellFlow.ReservoirLayer': ... + def getLayerFlowRates(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getNumberOfLayers(self) -> int: ... + def getWellProductionIndex(self) -> float: ... + def isCalculatingOutletPressure(self) -> bool: ... + @typing.overload + def loadIPRFromFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def loadIPRFromFile(self, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]) -> None: ... + @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 setBackpressureParameters(self, double: float, double2: float, double3: float) -> None: ... + def setDarcyLawParameters(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float) -> None: ... + def setFetkovichParameters(self, double: float, double2: float, double3: float) -> None: ... + @typing.overload + def setOutletPressure(self, double: float) -> None: ... + @typing.overload + def setOutletPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTableInflow(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setVogelParameters(self, double: float, double2: float, double3: float) -> None: ... + def setWellProductionIndex(self, double: float) -> None: ... + def solveFlowFromOutletPressure(self, boolean: bool) -> None: ... + class InflowPerformanceModel(java.lang.Enum['WellFlow.InflowPerformanceModel']): + PRODUCTION_INDEX: typing.ClassVar['WellFlow.InflowPerformanceModel'] = ... + VOGEL: typing.ClassVar['WellFlow.InflowPerformanceModel'] = ... + FETKOVICH: typing.ClassVar['WellFlow.InflowPerformanceModel'] = ... + BACKPRESSURE: typing.ClassVar['WellFlow.InflowPerformanceModel'] = ... + TABLE: typing.ClassVar['WellFlow.InflowPerformanceModel'] = ... + _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]) -> 'WellFlow.InflowPerformanceModel': ... + @staticmethod + def values() -> typing.MutableSequence['WellFlow.InflowPerformanceModel']: ... + class ReservoirLayer: + name: java.lang.String = ... + stream: jneqsim.process.equipment.stream.StreamInterface = ... + reservoirPressure: float = ... + productivityIndex: float = ... + calculatedRate: float = ... + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface, double: float, double2: float): ... + +class WellSystem(jneqsim.process.equipment.ProcessEquipmentBaseClass): + @typing.overload + 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 addLayer(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface, double: float, double2: float, double3: float) -> None: ... + def generateIPRCurve(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def generateVLPCurve(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getBottomHolePressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getDrawdown(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getEffectiveProductivityIndex(self) -> float: ... + def getInletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLayerFlowRates(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getOperatingFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getOutletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getReservoirPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getTubingVLP(self) -> TubingPerformance: ... + def getVLPSolverMode(self) -> 'WellSystem.VLPSolverMode': ... + def getWellFlowIPR(self) -> WellFlow: ... + def getWellheadPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setBackpressureParameters(self, double: float, double2: float, double3: float) -> None: ... + def setBottomHoleTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setChokeOpening(self, double: float) -> None: ... + def setFetkovichParameters(self, double: float, double2: float, double3: float) -> None: ... + def setIPRModel(self, iPRModel: 'WellSystem.IPRModel') -> None: ... + def setInclination(self, double: float) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setPressureDropCorrelation(self, pressureDropCorrelation: TubingPerformance.PressureDropCorrelation) -> None: ... + def setProductionIndex(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setReservoirStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setTemperatureModel(self, temperatureModel: TubingPerformance.TemperatureModel) -> None: ... + def setTubingDiameter(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTubingLength(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTubingRoughness(self, double: float) -> None: ... + def setVLPSolverMode(self, vLPSolverMode: 'WellSystem.VLPSolverMode') -> None: ... + def setVogelParameters(self, double: float, double2: float, double3: float) -> None: ... + def setWellheadPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setWellheadTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + class IPRModel(java.lang.Enum['WellSystem.IPRModel']): + PRODUCTION_INDEX: typing.ClassVar['WellSystem.IPRModel'] = ... + VOGEL: typing.ClassVar['WellSystem.IPRModel'] = ... + FETKOVICH: typing.ClassVar['WellSystem.IPRModel'] = ... + BACKPRESSURE: typing.ClassVar['WellSystem.IPRModel'] = ... + JONES_BLOUNT_GLAZE: typing.ClassVar['WellSystem.IPRModel'] = ... + TABLE: typing.ClassVar['WellSystem.IPRModel'] = ... + _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]) -> 'WellSystem.IPRModel': ... + @staticmethod + def values() -> typing.MutableSequence['WellSystem.IPRModel']: ... + class ReservoirLayer: + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface, double: float, double2: float, double3: float): ... + class VLPSolverMode(java.lang.Enum['WellSystem.VLPSolverMode']): + SIMPLIFIED: typing.ClassVar['WellSystem.VLPSolverMode'] = ... + BEGGS_BRILL: typing.ClassVar['WellSystem.VLPSolverMode'] = ... + HAGEDORN_BROWN: typing.ClassVar['WellSystem.VLPSolverMode'] = ... + GRAY: typing.ClassVar['WellSystem.VLPSolverMode'] = ... + HASAN_KABIR: typing.ClassVar['WellSystem.VLPSolverMode'] = ... + DUNS_ROS: typing.ClassVar['WellSystem.VLPSolverMode'] = ... + DRIFT_FLUX: typing.ClassVar['WellSystem.VLPSolverMode'] = ... + TWO_FLUID: typing.ClassVar['WellSystem.VLPSolverMode'] = ... + _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]) -> 'WellSystem.VLPSolverMode': ... + @staticmethod + def values() -> typing.MutableSequence['WellSystem.VLPSolverMode']: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.reservoir")``. + + ReservoirCVDsim: typing.Type[ReservoirCVDsim] + ReservoirDiffLibsim: typing.Type[ReservoirDiffLibsim] + ReservoirTPsim: typing.Type[ReservoirTPsim] + SimpleReservoir: typing.Type[SimpleReservoir] + TubingPerformance: typing.Type[TubingPerformance] + Well: typing.Type[Well] + WellFlow: typing.Type[WellFlow] + WellSystem: typing.Type[WellSystem] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/separator/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/separator/__init__.pyi new file mode 100644 index 00000000..50d51e48 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/separator/__init__.pyi @@ -0,0 +1,271 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process +import jneqsim.process.equipment +import jneqsim.process.equipment.flare +import jneqsim.process.equipment.separator.sectiontype +import jneqsim.process.equipment.stream +import jneqsim.process.mechanicaldesign.separator +import jneqsim.process.util.fire +import jneqsim.process.util.report +import jneqsim.thermo.system +import typing + + + +class SeparatorInterface(jneqsim.process.SimulationInterface): + @typing.overload + def getHeatInput(self) -> float: ... + @typing.overload + def getHeatInput(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def isSetHeatInput(self) -> bool: ... + @typing.overload + def setHeatInput(self, double: float) -> None: ... + @typing.overload + def setHeatInput(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setInternalDiameter(self, double: float) -> None: ... + def setLiquidLevel(self, double: float) -> None: ... + +class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorInterface): + numberOfInputStreams: int = ... + @typing.overload + 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 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 calcLiquidVolume(self) -> float: ... + def displayResult(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def evaluateFireExposure(self, fireScenarioConfig: jneqsim.process.util.fire.SeparatorFireExposure.FireScenarioConfig) -> jneqsim.process.util.fire.SeparatorFireExposure.FireExposureResult: ... + @typing.overload + def evaluateFireExposure(self, fireScenarioConfig: jneqsim.process.util.fire.SeparatorFireExposure.FireScenarioConfig, flare: jneqsim.process.equipment.flare.Flare, double: float) -> jneqsim.process.util.fire.SeparatorFireExposure.FireExposureResult: ... + def getCapacityDuty(self) -> float: ... + def getCapacityMax(self) -> float: ... + @typing.overload + def getDeRatedGasLoadFactor(self) -> float: ... + @typing.overload + def getDeRatedGasLoadFactor(self, int: int) -> float: ... + def getDesignLiquidLevelFraction(self) -> float: ... + def getEfficiency(self) -> float: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str], double: float) -> float: ... + def getFeedStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getGas(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getGasCarryunderFraction(self) -> float: ... + @typing.overload + def getGasLoadFactor(self) -> float: ... + @typing.overload + def getGasLoadFactor(self, int: int) -> float: ... + def getGasOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getGasSuperficialVelocity(self) -> float: ... + @typing.overload + def getHeatDuty(self) -> float: ... + @typing.overload + def getHeatDuty(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getHeatInput(self) -> float: ... + @typing.overload + def getHeatInput(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getInnerSurfaceArea(self) -> float: ... + def getInternalDiameter(self) -> float: ... + def getLiquid(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquidCarryoverFraction(self) -> float: ... + def getLiquidLevel(self) -> float: ... + def getLiquidOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.separator.SeparatorMechanicalDesign: ... + def getOrientation(self) -> java.lang.String: ... + @typing.overload + def getPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getPressure(self) -> float: ... + def getPressureDrop(self) -> float: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getSeparatorLength(self) -> float: ... + @typing.overload + def getSeparatorSection(self, int: int) -> jneqsim.process.equipment.separator.sectiontype.SeparatorSection: ... + @typing.overload + def getSeparatorSection(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.separator.sectiontype.SeparatorSection: ... + def getSeparatorSections(self) -> java.util.ArrayList[jneqsim.process.equipment.separator.sectiontype.SeparatorSection]: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getUnwettedArea(self) -> float: ... + def getWettedArea(self) -> float: ... + def hashCode(self) -> int: ... + def initMechanicalDesign(self) -> None: ... + def initializeTransientCalculation(self) -> None: ... + def isSetHeatInput(self) -> bool: ... + def levelFromVolume(self, double: float) -> float: ... + def liquidArea(self, double: float) -> float: ... + @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 setDesignLiquidLevelFraction(self, double: float) -> None: ... + @typing.overload + def setDuty(self, double: float) -> None: ... + @typing.overload + def setDuty(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setEfficiency(self, double: float) -> None: ... + def setEntrainment(self, double: float, 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]) -> None: ... + def setGasCarryunderFraction(self, double: float) -> None: ... + @typing.overload + def setHeatDuty(self, double: float) -> None: ... + @typing.overload + def setHeatDuty(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setHeatInput(self, double: float) -> None: ... + @typing.overload + def setHeatInput(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setInternalDiameter(self, double: float) -> None: ... + def setLiquidCarryoverFraction(self, double: float) -> None: ... + def setLiquidLevel(self, double: float) -> None: ... + def setOrientation(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPressureDrop(self, double: float) -> None: ... + def setSeparatorLength(self, double: float) -> None: ... + def setTempPres(self, double: float, double2: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class GasScrubber(Separator): + @typing.overload + 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 getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.separator.GasScrubberMechanicalDesign: ... + +class GasScrubberSimple(Separator): + @typing.overload + 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 calcLiquidCarryoverFraction(self) -> float: ... + def getGas(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getGasOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquid(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquidOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.separator.GasScrubberMechanicalDesign: ... + @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: ... + +class Hydrocyclone(Separator): + @typing.overload + 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 displayResult(self) -> None: ... + def getOilOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getWaterOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @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: ... + +class NeqGasScrubber(Separator): + @typing.overload + 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 addScrubberSection(self, string: typing.Union[java.lang.String, str]) -> None: ... + def displayResult(self) -> None: ... + def getGas(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getGasOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquid(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquidOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.separator.GasScrubberMechanicalDesign: ... + @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: ... + +class ThreePhaseSeparator(Separator): + @typing.overload + 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 displayResult(self) -> None: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str], double: float) -> float: ... + def getGasOutletFlowFraction(self) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getOilLevel(self) -> float: ... + def getOilOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOilOutletFlowFraction(self) -> float: ... + def getOilThickness(self) -> float: ... + def getWaterLevel(self) -> float: ... + def getWaterOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getWaterOutletFlowFraction(self) -> float: ... + def initializeTransientCalculation(self) -> None: ... + @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 setEntrainment(self, double: float, 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]) -> None: ... + def setGasOutletFlowFraction(self, double: float) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setOilLevel(self, double: float) -> None: ... + def setOilOutletFlowFraction(self, double: float) -> None: ... + def setTempPres(self, double: float, double2: float) -> None: ... + def setWaterLevel(self, double: float) -> None: ... + def setWaterOutletFlowFraction(self, double: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class TwoPhaseSeparator(Separator): + @typing.overload + 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): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.separator")``. + + GasScrubber: typing.Type[GasScrubber] + GasScrubberSimple: typing.Type[GasScrubberSimple] + Hydrocyclone: typing.Type[Hydrocyclone] + NeqGasScrubber: typing.Type[NeqGasScrubber] + Separator: typing.Type[Separator] + SeparatorInterface: typing.Type[SeparatorInterface] + ThreePhaseSeparator: typing.Type[ThreePhaseSeparator] + TwoPhaseSeparator: typing.Type[TwoPhaseSeparator] + sectiontype: jneqsim.process.equipment.separator.sectiontype.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/separator/sectiontype/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/separator/sectiontype/__init__.pyi new file mode 100644 index 00000000..b43c0620 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/separator/sectiontype/__init__.pyi @@ -0,0 +1,73 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.process.equipment.separator +import jneqsim.process.mechanicaldesign.separator.sectiontype +import jneqsim.util +import typing + + + +class SeparatorSection(jneqsim.util.NamedBaseClass): + separator: jneqsim.process.equipment.separator.Separator = ... + outerDiameter: float = ... + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], separator: jneqsim.process.equipment.separator.Separator): ... + def calcEfficiency(self) -> float: ... + def getEfficiency(self) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.separator.sectiontype.SepDesignSection: ... + def getMinimumLiquidSealHeight(self) -> float: ... + def getOuterDiameter(self) -> float: ... + def getPressureDrop(self) -> float: ... + def getSeparator(self) -> jneqsim.process.equipment.separator.Separator: ... + def isCalcEfficiency(self) -> bool: ... + def setCalcEfficiency(self, boolean: bool) -> None: ... + def setEfficiency(self, double: float) -> None: ... + def setOuterDiameter(self, double: float) -> None: ... + def setPressureDrop(self, double: float) -> None: ... + def setSeparator(self, separator: jneqsim.process.equipment.separator.Separator) -> None: ... + +class ManwaySection(SeparatorSection): + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], separator: jneqsim.process.equipment.separator.Separator): ... + def calcEfficiency(self) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.separator.sectiontype.MechManwaySection: ... + +class MeshSection(SeparatorSection): + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], separator: jneqsim.process.equipment.separator.Separator): ... + def calcEfficiency(self) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.separator.sectiontype.MecMeshSection: ... + +class NozzleSection(SeparatorSection): + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], separator: jneqsim.process.equipment.separator.Separator): ... + def calcEfficiency(self) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.separator.sectiontype.MechNozzleSection: ... + +class PackedSection(SeparatorSection): + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], separator: jneqsim.process.equipment.separator.Separator): ... + def calcEfficiency(self) -> float: ... + +class ValveSection(SeparatorSection): + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], separator: jneqsim.process.equipment.separator.Separator): ... + def calcEfficiency(self) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.separator.sectiontype.DistillationTraySection: ... + +class VaneSection(SeparatorSection): + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], separator: jneqsim.process.equipment.separator.Separator): ... + def calcEfficiency(self) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.separator.sectiontype.MechVaneSection: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.separator.sectiontype")``. + + ManwaySection: typing.Type[ManwaySection] + MeshSection: typing.Type[MeshSection] + NozzleSection: typing.Type[NozzleSection] + PackedSection: typing.Type[PackedSection] + SeparatorSection: typing.Type[SeparatorSection] + ValveSection: typing.Type[ValveSection] + VaneSection: typing.Type[VaneSection] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/splitter/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/splitter/__init__.pyi new file mode 100644 index 00000000..1bb50d07 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/splitter/__init__.pyi @@ -0,0 +1,91 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.util.report +import typing + + + +class ComponentSplitter(jneqsim.process.equipment.ProcessEquipmentBaseClass): + @typing.overload + 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 displayResult(self) -> None: ... + def getInletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getSplitNumber(self) -> int: ... + def getSplitStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + @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 setSplitFactors(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class SplitterInterface(jneqsim.process.equipment.ProcessEquipmentInterface): + def equals(self, object: typing.Any) -> bool: ... + def getSplitStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def hashCode(self) -> int: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setSplitNumber(self, int: int) -> None: ... + +class Splitter(jneqsim.process.equipment.ProcessEquipmentBaseClass, SplitterInterface): + @typing.overload + 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): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface, int: int): ... + def calcSplitFactors(self) -> None: ... + def displayResult(self) -> None: ... + def getInletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getSplitFactor(self, int: int) -> float: ... + def getSplitFactors(self) -> typing.MutableSequence[float]: ... + def getSplitNumber(self) -> int: ... + def getSplitStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def needRecalculation(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 setFlowRates(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], string: typing.Union[java.lang.String, str]) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setSplitFactors(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setSplitNumber(self, int: int) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.splitter")``. + + ComponentSplitter: typing.Type[ComponentSplitter] + Splitter: typing.Type[Splitter] + SplitterInterface: typing.Type[SplitterInterface] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/stream/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/stream/__init__.pyi new file mode 100644 index 00000000..7a439e77 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/stream/__init__.pyi @@ -0,0 +1,259 @@ + +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.process.equipment +import jneqsim.process.util.report +import jneqsim.standards.gasquality +import jneqsim.thermo.system +import typing + + + +class EnergyStream(java.io.Serializable, java.lang.Cloneable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def clone(self) -> 'EnergyStream': ... + def equals(self, object: typing.Any) -> bool: ... + def getDuty(self) -> float: ... + def getName(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def setDuty(self, double: float) -> None: ... + def setName(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class StreamInterface(jneqsim.process.equipment.ProcessEquipmentInterface): + def CCB(self, string: typing.Union[java.lang.String, str]) -> float: ... + def CCT(self, string: typing.Union[java.lang.String, str]) -> float: ... + def GCV(self) -> float: ... + def LCV(self) -> float: ... + def TVP(self, double: float, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def clone(self) -> 'StreamInterface': ... + @typing.overload + def clone(self, string: typing.Union[java.lang.String, str]) -> 'StreamInterface': ... + def equals(self, object: typing.Any) -> bool: ... + def flashStream(self) -> None: ... + def getFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getGCV(self, string: typing.Union[java.lang.String, str], double: float, double2: float) -> float: ... + def getHydrateEquilibriumTemperature(self) -> float: ... + def getHydrocarbonDewPoint(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> float: ... + def getISO6976(self, string: typing.Union[java.lang.String, str], double: float, double2: float) -> jneqsim.standards.gasquality.Standard_ISO6976: ... + def getMolarRate(self) -> float: ... + @typing.overload + def getPressure(self) -> float: ... + @typing.overload + def getPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getRVP(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getRVP(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]) -> float: ... + def getTVP(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getTemperature(self) -> float: ... + @typing.overload + def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getWI(self, string: typing.Union[java.lang.String, str], double: float, double2: float) -> float: ... + def hashCode(self) -> int: ... + def runTPflash(self) -> None: ... + def setEmptyThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setFlowRate(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setFluid(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setName(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setPressure(self, double: float) -> None: ... + @typing.overload + def setPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setTemperature(self, double: float) -> None: ... + @typing.overload + def setTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setThermoSystemFromPhase(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str]) -> None: ... + +class VirtualStream(jneqsim.process.equipment.ProcessEquipmentBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: StreamInterface): ... + def getOutStream(self) -> StreamInterface: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setComposition(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], string: typing.Union[java.lang.String, str]) -> None: ... + def setFlowRate(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setPressure(self, double: float) -> None: ... + @typing.overload + def setPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setReferenceStream(self, streamInterface: StreamInterface) -> None: ... + @typing.overload + def setTemperature(self, double: float) -> None: ... + @typing.overload + def setTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def solved(self) -> bool: ... + +class Stream(jneqsim.process.equipment.ProcessEquipmentBaseClass, StreamInterface, java.lang.Cloneable): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: StreamInterface): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface): ... + def CCB(self, string: typing.Union[java.lang.String, str]) -> float: ... + def CCT(self, string: typing.Union[java.lang.String, str]) -> float: ... + def GCV(self) -> float: ... + def LCV(self) -> float: ... + def TVP(self, double: float, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def clone(self) -> 'Stream': ... + @typing.overload + def clone(self, string: typing.Union[java.lang.String, str]) -> 'Stream': ... + def displayResult(self) -> None: ... + def flashStream(self) -> None: ... + def getFluid(self) -> jneqsim.thermo.system.SystemInterface: ... + def getGCV(self, string: typing.Union[java.lang.String, str], double: float, double2: float) -> float: ... + def getGasQuality(self) -> float: ... + def getHydrateEquilibriumTemperature(self) -> float: ... + def getHydrocarbonDewPoint(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> float: ... + def getISO6976(self, string: typing.Union[java.lang.String, str], double: float, double2: float) -> jneqsim.standards.gasquality.Standard_ISO6976: ... + def getMolarRate(self) -> float: ... + def getOutletStream(self) -> StreamInterface: ... + @typing.overload + def getProperty(self, string: typing.Union[java.lang.String, str]) -> typing.Any: ... + @typing.overload + def getProperty(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]) -> typing.Any: ... + @typing.overload + def getRVP(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getRVP(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]) -> float: ... + def getReport(self) -> java.util.ArrayList[typing.MutableSequence[java.lang.String]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getSolidFormationTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getTVP(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getTemperature(self) -> float: ... + @typing.overload + def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getWI(self, string: typing.Union[java.lang.String, str], double: float, double2: float) -> float: ... + def needRecalculation(self) -> bool: ... + def phaseEnvelope(self) -> None: ... + def reportResults(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def runController(self, double: float, uUID: java.util.UUID) -> None: ... + def runTPflash(self) -> None: ... + @typing.overload + def runTransient(self, double: float) -> None: ... + @typing.overload + def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... + def setEmptyThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setFlowRate(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setFluid(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setGasQuality(self, double: float) -> None: ... + def setInletStream(self, streamInterface: StreamInterface) -> None: ... + @typing.overload + def setPressure(self, double: float) -> None: ... + @typing.overload + def setPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setStream(self, streamInterface: StreamInterface) -> None: ... + @typing.overload + def setTemperature(self, double: float) -> None: ... + @typing.overload + def setTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setThermoSystemFromPhase(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class EquilibriumStream(Stream): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def clone(self) -> 'EquilibriumStream': ... + @typing.overload + def clone(self, string: typing.Union[java.lang.String, str]) -> 'EquilibriumStream': ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + +class IronIonSaturationStream(Stream): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: StreamInterface): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def clone(self) -> 'IronIonSaturationStream': ... + @typing.overload + def clone(self, string: typing.Union[java.lang.String, str]) -> 'IronIonSaturationStream': ... + def displayResult(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + +class NeqStream(Stream): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: StreamInterface): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def clone(self) -> 'NeqStream': ... + @typing.overload + def clone(self, string: typing.Union[java.lang.String, str]) -> 'NeqStream': ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + +class ScalePotentialCheckStream(Stream): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: StreamInterface): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def clone(self) -> 'ScalePotentialCheckStream': ... + @typing.overload + def clone(self, string: typing.Union[java.lang.String, str]) -> 'ScalePotentialCheckStream': ... + def displayResult(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.stream")``. + + EnergyStream: typing.Type[EnergyStream] + EquilibriumStream: typing.Type[EquilibriumStream] + IronIonSaturationStream: typing.Type[IronIonSaturationStream] + NeqStream: typing.Type[NeqStream] + ScalePotentialCheckStream: typing.Type[ScalePotentialCheckStream] + Stream: typing.Type[Stream] + StreamInterface: typing.Type[StreamInterface] + VirtualStream: typing.Type[VirtualStream] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/subsea/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/subsea/__init__.pyi new file mode 100644 index 00000000..ecc2f48a --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/subsea/__init__.pyi @@ -0,0 +1,48 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.process.equipment +import jneqsim.process.equipment.pipeline +import jneqsim.process.equipment.stream +import jneqsim.thermo.system +import typing + + + +class SimpleFlowLine(jneqsim.process.equipment.TwoPortEquipment): + length: float = ... + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def getHeight(self) -> float: ... + def getPipeline(self) -> jneqsim.process.equipment.pipeline.AdiabaticTwoPhasePipe: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setHeight(self, double: float) -> None: ... + +class SubseaWell(jneqsim.process.equipment.TwoPortEquipment): + height: float = ... + length: float = ... + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def getPipeline(self) -> jneqsim.process.equipment.pipeline.AdiabaticTwoPhasePipe: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.subsea")``. + + SimpleFlowLine: typing.Type[SimpleFlowLine] + SubseaWell: typing.Type[SubseaWell] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/tank/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/tank/__init__.pyi new file mode 100644 index 00000000..306cfcc2 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/tank/__init__.pyi @@ -0,0 +1,62 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.util.report +import jneqsim.thermo.system +import typing + + + +class Tank(jneqsim.process.equipment.ProcessEquipmentBaseClass): + @typing.overload + 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 addStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def displayResult(self) -> None: ... + def getEfficiency(self) -> float: ... + def getGas(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getGasCarryunderFraction(self) -> float: ... + def getGasOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquid(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquidCarryoverFraction(self) -> float: ... + def getLiquidLevel(self) -> float: ... + def getLiquidOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getVolume(self) -> float: ... + @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 setEfficiency(self, double: float) -> None: ... + def setGasCarryunderFraction(self, double: float) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setLiquidCarryoverFraction(self, double: float) -> None: ... + def setOutComposition(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setTempPres(self, double: float, double2: float) -> None: ... + def setVolume(self, double: float) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.tank")``. + + Tank: typing.Type[Tank] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/util/__init__.pyi new file mode 100644 index 00000000..818bb960 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/util/__init__.pyi @@ -0,0 +1,440 @@ + +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 java.util.function +import jpype +import jneqsim.process.equipment +import jneqsim.process.equipment.mixer +import jneqsim.process.equipment.stream +import jneqsim.process.equipment.valve +import jneqsim.process.processmodel +import jneqsim.process.util.report +import jneqsim.thermo.system +import typing + + + +class Adjuster(jneqsim.process.equipment.ProcessEquipmentBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def displayResult(self) -> None: ... + def getError(self) -> float: ... + def getMaxAdjustedValue(self) -> float: ... + def getMinAdjustedValue(self) -> float: ... + def getTolerance(self) -> float: ... + def isActivateWhenLess(self) -> bool: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setActivateWhenLess(self, boolean: bool) -> None: ... + def setAdjustedEquipment(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + @typing.overload + def setAdjustedValueGetter(self, function: typing.Union[java.util.function.Function[jneqsim.process.equipment.ProcessEquipmentInterface, float], typing.Callable[[jneqsim.process.equipment.ProcessEquipmentInterface], float]]) -> None: ... + @typing.overload + def setAdjustedValueGetter(self, supplier: typing.Union[java.util.function.Supplier[float], typing.Callable[[], float]]) -> None: ... + @typing.overload + def setAdjustedValueSetter(self, biConsumer: typing.Union[java.util.function.BiConsumer[jneqsim.process.equipment.ProcessEquipmentInterface, float], typing.Callable[[jneqsim.process.equipment.ProcessEquipmentInterface, float], None]]) -> None: ... + @typing.overload + def setAdjustedValueSetter(self, consumer: typing.Union[java.util.function.Consumer[float], typing.Callable[[float], None]]) -> None: ... + @typing.overload + def setAdjustedVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + @typing.overload + def setAdjustedVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setAdjustedVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def setError(self, double: float) -> None: ... + def setMaxAdjustedValue(self, double: float) -> None: ... + def setMinAdjustedValue(self, double: float) -> None: ... + def setTargetEquipment(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + def setTargetValue(self, double: float) -> None: ... + @typing.overload + def setTargetValueCalculator(self, function: typing.Union[java.util.function.Function[jneqsim.process.equipment.ProcessEquipmentInterface, float], typing.Callable[[jneqsim.process.equipment.ProcessEquipmentInterface], float]]) -> None: ... + @typing.overload + def setTargetValueCalculator(self, supplier: typing.Union[java.util.function.Supplier[float], typing.Callable[[], float]]) -> None: ... + @typing.overload + def setTargetVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + @typing.overload + def setTargetVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setTargetVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setTargetVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], string4: typing.Union[java.lang.String, str]) -> None: ... + def setTolerance(self, double: float) -> None: ... + def solved(self) -> bool: ... + +class Calculator(jneqsim.process.equipment.ProcessEquipmentBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def addInputVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + @typing.overload + def addInputVariable(self, *processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + def getInputVariable(self) -> java.util.ArrayList[jneqsim.process.equipment.ProcessEquipmentInterface]: ... + def getOutputVariable(self) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def runAntiSurgeCalc(self, uUID: java.util.UUID) -> None: ... + @typing.overload + def setCalculationMethod(self, runnable: typing.Union[java.lang.Runnable, typing.Callable]) -> None: ... + @typing.overload + def setCalculationMethod(self, biConsumer: typing.Union[java.util.function.BiConsumer[java.util.ArrayList[jneqsim.process.equipment.ProcessEquipmentInterface], jneqsim.process.equipment.ProcessEquipmentInterface], typing.Callable[[java.util.ArrayList[jneqsim.process.equipment.ProcessEquipmentInterface], jneqsim.process.equipment.ProcessEquipmentInterface], None]]) -> None: ... + def setOutputVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + +class CalculatorLibrary: + @staticmethod + def byName(string: typing.Union[java.lang.String, str]) -> java.util.function.BiConsumer[java.util.ArrayList[jneqsim.process.equipment.ProcessEquipmentInterface], jneqsim.process.equipment.ProcessEquipmentInterface]: ... + @typing.overload + @staticmethod + def dewPointTargeting() -> java.util.function.BiConsumer[java.util.ArrayList[jneqsim.process.equipment.ProcessEquipmentInterface], jneqsim.process.equipment.ProcessEquipmentInterface]: ... + @typing.overload + @staticmethod + def dewPointTargeting(double: float) -> java.util.function.BiConsumer[java.util.ArrayList[jneqsim.process.equipment.ProcessEquipmentInterface], jneqsim.process.equipment.ProcessEquipmentInterface]: ... + @staticmethod + def energyBalance() -> java.util.function.BiConsumer[java.util.ArrayList[jneqsim.process.equipment.ProcessEquipmentInterface], jneqsim.process.equipment.ProcessEquipmentInterface]: ... + @staticmethod + def preset(preset: 'CalculatorLibrary.Preset') -> java.util.function.BiConsumer[java.util.ArrayList[jneqsim.process.equipment.ProcessEquipmentInterface], jneqsim.process.equipment.ProcessEquipmentInterface]: ... + class Preset(java.lang.Enum['CalculatorLibrary.Preset']): + ENERGY_BALANCE: typing.ClassVar['CalculatorLibrary.Preset'] = ... + DEW_POINT_TARGETING: typing.ClassVar['CalculatorLibrary.Preset'] = ... + _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]) -> 'CalculatorLibrary.Preset': ... + @staticmethod + def values() -> typing.MutableSequence['CalculatorLibrary.Preset']: ... + +class FlowRateAdjuster(jneqsim.process.equipment.TwoPortEquipment): + desiredGasFlow: float = ... + desiredOilFlow: float = ... + desiredWaterFlow: float = ... + @typing.overload + 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): ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + @typing.overload + def setAdjustedFlowRates(self, double: float, double2: float, double3: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setAdjustedFlowRates(self, double: float, double2: float, string: typing.Union[java.lang.String, str]) -> None: ... + +class FlowSetter(jneqsim.process.equipment.TwoPortEquipment): + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def createReferenceProcess(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> jneqsim.process.processmodel.ProcessSystem: ... + def getGasFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getOilFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getReferenceProcess(self) -> jneqsim.process.processmodel.ProcessSystem: ... + def getWaterFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setGasFlowRate(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setOilFlowRate(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setSeparationPT(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], string: typing.Union[java.lang.String, str], doubleArray2: typing.Union[typing.List[float], jpype.JArray], string2: typing.Union[java.lang.String, str]) -> None: ... + def setWaterFlowRate(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + +class GORfitter(jneqsim.process.equipment.TwoPortEquipment): + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def getGFV(self) -> float: ... + def getGOR(self) -> float: ... + @typing.overload + def getPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getPressure(self) -> float: ... + def getReferenceConditions(self) -> java.lang.String: ... + @typing.overload + def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getTemperature(self) -> float: ... + def isFitAsGVF(self) -> bool: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setFitAsGVF(self, boolean: bool) -> None: ... + def setGOR(self, double: float) -> None: ... + def setGVF(self, double: float) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + @typing.overload + def setPressure(self, double: float) -> None: ... + @typing.overload + def setPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setReferenceConditions(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setTemperature(self, double: float) -> None: ... + @typing.overload + def setTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + +class MPFMfitter(jneqsim.process.equipment.TwoPortEquipment): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def getGFV(self) -> float: ... + def getGOR(self) -> float: ... + @typing.overload + def getPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getPressure(self) -> float: ... + def getReferenceConditions(self) -> java.lang.String: ... + def getReferenceFluidPackage(self) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getTemperature(self) -> float: ... + def isFitAsGVF(self) -> bool: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setFitAsGVF(self, boolean: bool) -> None: ... + def setGOR(self, double: float) -> None: ... + def setGVF(self, double: float) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + @typing.overload + def setPressure(self, double: float) -> None: ... + @typing.overload + def setPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setReferenceConditions(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setReferenceFluidPackage(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + @typing.overload + def setTemperature(self, double: float) -> None: ... + @typing.overload + def setTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + +class MoleFractionControllerUtil(jneqsim.process.equipment.TwoPortEquipment): + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def displayResult(self) -> None: ... + def getMolesChange(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setComponentRate(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setMoleFraction(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def setRelativeMoleFractionReduction(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + +class NeqSimUnit(jneqsim.process.equipment.TwoPortEquipment): + numberOfNodes: int = ... + interfacialArea: float = ... + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + def getEquipment(self) -> java.lang.String: ... + def getID(self) -> float: ... + def getInterfacialArea(self) -> float: ... + def getLength(self) -> float: ... + def getNumberOfNodes(self) -> int: ... + def getOuterTemperature(self) -> float: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def runAnnular(self) -> None: ... + def runDroplet(self) -> None: ... + def runStratified(self) -> None: ... + def setEquipment(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setID(self, double: float) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setLength(self, double: float) -> None: ... + def setNumberOfNodes(self, int: int) -> None: ... + def setOuterTemperature(self, double: float) -> None: ... + +class PressureDrop(jneqsim.process.equipment.valve.ThrottlingValve): + @typing.overload + 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): ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setPressureDrop(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + +class Recycle(jneqsim.process.equipment.ProcessEquipmentBaseClass, jneqsim.process.equipment.mixer.MixerInterface): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcMixStreamEnthalpy(self) -> float: ... + def compositionBalanceCheck(self) -> float: ... + def displayResult(self) -> None: ... + def flowBalanceCheck(self) -> float: ... + def getCompositionTolerance(self) -> float: ... + def getDownstreamProperty(self) -> java.util.ArrayList[java.lang.String]: ... + def getErrorComposition(self) -> float: ... + def getErrorFlow(self) -> float: ... + def getErrorPressure(self) -> float: ... + def getErrorTemperature(self) -> float: ... + def getFlowTolerance(self) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMinimumFlow(self) -> float: ... + def getOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOutletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getPriority(self) -> int: ... + def getStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getTemperatureTolerance(self) -> float: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def guessTemperature(self) -> float: ... + def initiateDownstreamProperties(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def mixStream(self) -> None: ... + def pressureBalanceCheck(self) -> float: ... + def removeInputStream(self, int: int) -> None: ... + def replaceStream(self, int: int, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def resetIterations(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setCompositionTolerance(self, double: float) -> None: ... + def setDownstreamProperties(self) -> None: ... + @typing.overload + def setDownstreamProperty(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setDownstreamProperty(self, arrayList: java.util.ArrayList[typing.Union[java.lang.String, str]]) -> None: ... + def setErrorCompositon(self, double: float) -> None: ... + def setErrorFlow(self, double: float) -> None: ... + def setErrorPressure(self, double: float) -> None: ... + def setErrorTemperature(self, double: float) -> None: ... + def setFlowTolerance(self, double: float) -> None: ... + def setMinimumFlow(self, double: float) -> None: ... + def setOutletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setPressure(self, double: float) -> None: ... + def setPriority(self, int: int) -> None: ... + def setTemperature(self, double: float) -> None: ... + def setTemperatureTolerance(self, double: float) -> None: ... + def setTolerance(self, double: float) -> None: ... + def solved(self) -> bool: ... + def temperatureBalanceCheck(self) -> float: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class RecycleController(java.io.Serializable): + def __init__(self): ... + def addRecycle(self, recycle: Recycle) -> None: ... + def clear(self) -> None: ... + def doSolveRecycle(self, recycle: Recycle) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def getCurrentPriorityLevel(self) -> int: ... + def hasHigherPriorityLevel(self) -> bool: ... + def hasLoverPriorityLevel(self) -> bool: ... + def hashCode(self) -> int: ... + def init(self) -> None: ... + def isHighestPriority(self, recycle: Recycle) -> bool: ... + def nextPriorityLevel(self) -> None: ... + def resetPriorityLevel(self) -> None: ... + def setCurrentPriorityLevel(self, int: int) -> None: ... + def solvedAll(self) -> bool: ... + def solvedCurrentPriorityLevel(self) -> bool: ... + +class SetPoint(jneqsim.process.equipment.ProcessEquipmentBaseClass): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, string2: typing.Union[java.lang.String, str], processEquipmentInterface2: jneqsim.process.equipment.ProcessEquipmentInterface): ... + def displayResult(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setSourceValueCalculator(self, function: typing.Union[java.util.function.Function[jneqsim.process.equipment.ProcessEquipmentInterface, float], typing.Callable[[jneqsim.process.equipment.ProcessEquipmentInterface], float]]) -> None: ... + @typing.overload + def setSourceVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + @typing.overload + def setSourceVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setTargetVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + @typing.overload + def setTargetVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setTargetVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setTargetVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setTargetVariable(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], string4: typing.Union[java.lang.String, str]) -> None: ... + +class Setter(jneqsim.process.equipment.ProcessEquipmentBaseClass): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addParameter(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], double: float) -> None: ... + @typing.overload + def addTargetEquipment(self, list: java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]) -> None: ... + @typing.overload + def addTargetEquipment(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + def getParameters(self) -> java.util.List[java.util.Map[java.lang.String, typing.Any]]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + +class StreamSaturatorUtil(jneqsim.process.equipment.TwoPortEquipment): + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def isMultiPhase(self) -> bool: ... + def needRecalculation(self) -> bool: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setApprachToSaturation(self, double: float) -> None: ... + def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setMultiPhase(self, boolean: bool) -> None: ... + +class StreamTransition(jneqsim.process.equipment.TwoPortEquipment): + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface): ... + def displayResult(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.util")``. + + Adjuster: typing.Type[Adjuster] + Calculator: typing.Type[Calculator] + CalculatorLibrary: typing.Type[CalculatorLibrary] + FlowRateAdjuster: typing.Type[FlowRateAdjuster] + FlowSetter: typing.Type[FlowSetter] + GORfitter: typing.Type[GORfitter] + MPFMfitter: typing.Type[MPFMfitter] + MoleFractionControllerUtil: typing.Type[MoleFractionControllerUtil] + NeqSimUnit: typing.Type[NeqSimUnit] + PressureDrop: typing.Type[PressureDrop] + Recycle: typing.Type[Recycle] + RecycleController: typing.Type[RecycleController] + SetPoint: typing.Type[SetPoint] + Setter: typing.Type[Setter] + StreamSaturatorUtil: typing.Type[StreamSaturatorUtil] + StreamTransition: typing.Type[StreamTransition] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/valve/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/valve/__init__.pyi new file mode 100644 index 00000000..7615fbc3 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/valve/__init__.pyi @@ -0,0 +1,550 @@ + +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 jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.measurementdevice +import jneqsim.process.mechanicaldesign.valve +import jneqsim.process.util.report +import jneqsim.thermo.system +import typing + + + +class ValveInterface(jneqsim.process.equipment.ProcessEquipmentInterface, jneqsim.process.equipment.TwoPortInterface): + def equals(self, object: typing.Any) -> bool: ... + def getCg(self) -> float: ... + def getClosingTravelTime(self) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getKv(self) -> float: ... + def getOpeningTravelTime(self) -> float: ... + def getPercentValveOpening(self) -> float: ... + def getTargetPercentValveOpening(self) -> float: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getTravelModel(self) -> 'ValveTravelModel': ... + def getTravelTime(self) -> float: ... + def getTravelTimeConstant(self) -> float: ... + def hashCode(self) -> int: ... + def isIsoThermal(self) -> bool: ... + def setClosingTravelTime(self, double: float) -> None: ... + @typing.overload + def setCv(self, double: float) -> None: ... + @typing.overload + def setCv(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setIsoThermal(self, boolean: bool) -> None: ... + def setKv(self, double: float) -> None: ... + def setOpeningTravelTime(self, double: float) -> None: ... + def setPercentValveOpening(self, double: float) -> None: ... + def setTargetPercentValveOpening(self, double: float) -> None: ... + def setTravelModel(self, valveTravelModel: 'ValveTravelModel') -> None: ... + def setTravelTime(self, double: float) -> None: ... + def setTravelTimeConstant(self, double: float) -> None: ... + +class ValveTravelModel(java.lang.Enum['ValveTravelModel']): + NONE: typing.ClassVar['ValveTravelModel'] = ... + LINEAR_RATE_LIMIT: typing.ClassVar['ValveTravelModel'] = ... + FIRST_ORDER_LAG: typing.ClassVar['ValveTravelModel'] = ... + _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]) -> 'ValveTravelModel': ... + @staticmethod + def values() -> typing.MutableSequence['ValveTravelModel']: ... + +class ThrottlingValve(jneqsim.process.equipment.TwoPortEquipment, ValveInterface): + @typing.overload + 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 calcKv(self) -> None: ... + def calculateMolarFlow(self) -> float: ... + def calculateOutletPressure(self, double: float) -> float: ... + def displayResult(self) -> None: ... + def getCapacityDuty(self) -> float: ... + def getCapacityMax(self) -> float: ... + def getCg(self) -> float: ... + def getClosingTravelTime(self) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getDeltaPressure(self) -> float: ... + @typing.overload + def getDeltaPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str], double: float) -> float: ... + def getFp(self) -> float: ... + def getInletPressure(self) -> float: ... + def getKv(self) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.valve.ValveMechanicalDesign: ... + def getOpeningTravelTime(self) -> float: ... + def getOutletPressure(self) -> float: ... + def getPercentValveOpening(self) -> float: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getTargetPercentValveOpening(self) -> float: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getTravelModel(self) -> ValveTravelModel: ... + def getTravelTime(self) -> float: ... + def getTravelTimeConstant(self) -> float: ... + def initMechanicalDesign(self) -> None: ... + def isAcceptNegativeDP(self) -> bool: ... + def isAllowChoked(self) -> bool: ... + def isAllowLaminar(self) -> bool: ... + def isGasValve(self) -> bool: ... + def isIsoThermal(self) -> bool: ... + def isValveKvSet(self) -> bool: ... + def needRecalculation(self) -> bool: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def runController(self, double: float, 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 setAcceptNegativeDP(self, boolean: bool) -> None: ... + def setAllowChoked(self, boolean: bool) -> None: ... + def setAllowLaminar(self, boolean: bool) -> None: ... + def setClosingTravelTime(self, double: float) -> None: ... + @typing.overload + def setCv(self, double: float) -> None: ... + @typing.overload + def setCv(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setDeltaPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setFp(self, double: float) -> None: ... + def setGasValve(self, boolean: bool) -> None: ... + def setIsCalcOutPressure(self, boolean: bool) -> None: ... + def setIsoThermal(self, boolean: bool) -> None: ... + def setKv(self, double: float) -> None: ... + def setMaximumValveOpening(self, double: float) -> None: ... + def setMinimumValveOpening(self, double: float) -> None: ... + def setOpeningTravelTime(self, double: float) -> None: ... + @typing.overload + def setOutletPressure(self, double: float) -> None: ... + @typing.overload + def setOutletPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setPercentValveOpening(self, double: float) -> None: ... + @typing.overload + def setPressure(self, double: float) -> None: ... + @typing.overload + def setPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTargetPercentValveOpening(self, double: float) -> None: ... + def setTravelModel(self, valveTravelModel: ValveTravelModel) -> None: ... + def setTravelTime(self, double: float) -> None: ... + def setTravelTimeConstant(self, double: float) -> None: ... + def setValveKvSet(self, boolean: bool) -> None: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + +class BlowdownValve(ThrottlingValve): + @typing.overload + 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 activate(self) -> None: ... + def close(self) -> None: ... + def getOpeningTime(self) -> float: ... + def getTimeElapsed(self) -> float: ... + def isActivated(self) -> bool: ... + def isOpening(self) -> bool: ... + def reset(self) -> None: ... + @typing.overload + def runTransient(self, double: float) -> None: ... + @typing.overload + def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... + def setOpeningTime(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + +class CheckValve(ThrottlingValve): + @typing.overload + 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 getCrackingPressure(self) -> float: ... + def isOpen(self) -> bool: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setCrackingPressure(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + +class ControlValve(ThrottlingValve): + @typing.overload + 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 toString(self) -> java.lang.String: ... + +class ESDValve(ThrottlingValve): + @typing.overload + 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 completePartialStrokeTest(self) -> None: ... + def deEnergize(self) -> None: ... + def energize(self) -> None: ... + def getFailSafePosition(self) -> float: ... + def getStrokeTime(self) -> float: ... + def getTimeElapsedSinceTrip(self) -> float: ... + def hasTripCompleted(self) -> bool: ... + def isClosing(self) -> bool: ... + def isEnergized(self) -> bool: ... + def isPartialStrokeTestActive(self) -> bool: ... + def reset(self) -> None: ... + @typing.overload + def runTransient(self, double: float) -> None: ... + @typing.overload + def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... + def setFailSafePosition(self, double: float) -> None: ... + def setStrokeTime(self, double: float) -> None: ... + def startPartialStrokeTest(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + def trip(self) -> None: ... + +class HIPPSValve(ThrottlingValve): + @typing.overload + 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 addPressureTransmitter(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface) -> None: ... + def getActiveTransmitterCount(self) -> int: ... + def getClosureTime(self) -> float: ... + def getDiagnostics(self) -> java.lang.String: ... + def getLastTripTime(self) -> float: ... + def getPressureTransmitters(self) -> java.util.List[jneqsim.process.measurementdevice.MeasurementDeviceInterface]: ... + def getProofTestInterval(self) -> float: ... + def getSILRating(self) -> int: ... + def getSpuriousTripCount(self) -> int: ... + def getTimeSinceProofTest(self) -> float: ... + def getVotingLogic(self) -> 'HIPPSValve.VotingLogic': ... + def hasTripped(self) -> bool: ... + def isPartialStrokeTestActive(self) -> bool: ... + def isProofTestDue(self) -> bool: ... + def isTripEnabled(self) -> bool: ... + def performPartialStrokeTest(self, double: float) -> None: ... + def performProofTest(self) -> None: ... + def recordSpuriousTrip(self) -> None: ... + def removePressureTransmitter(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface) -> None: ... + def reset(self) -> None: ... + @typing.overload + def runTransient(self, double: float) -> None: ... + @typing.overload + def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... + def setClosureTime(self, double: float) -> None: ... + def setPercentValveOpening(self, double: float) -> None: ... + def setProofTestInterval(self, double: float) -> None: ... + def setSILRating(self, int: int) -> None: ... + def setTripEnabled(self, boolean: bool) -> None: ... + def setVotingLogic(self, votingLogic: 'HIPPSValve.VotingLogic') -> None: ... + def toString(self) -> java.lang.String: ... + class VotingLogic(java.lang.Enum['HIPPSValve.VotingLogic']): + ONE_OUT_OF_ONE: typing.ClassVar['HIPPSValve.VotingLogic'] = ... + ONE_OUT_OF_TWO: typing.ClassVar['HIPPSValve.VotingLogic'] = ... + TWO_OUT_OF_TWO: typing.ClassVar['HIPPSValve.VotingLogic'] = ... + TWO_OUT_OF_THREE: typing.ClassVar['HIPPSValve.VotingLogic'] = ... + TWO_OUT_OF_FOUR: typing.ClassVar['HIPPSValve.VotingLogic'] = ... + def getNotation(self) -> java.lang.String: ... + _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]) -> 'HIPPSValve.VotingLogic': ... + @staticmethod + def values() -> typing.MutableSequence['HIPPSValve.VotingLogic']: ... + +class PSDValve(ThrottlingValve): + @typing.overload + 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 getClosureTime(self) -> float: ... + def getPressureTransmitter(self) -> jneqsim.process.measurementdevice.MeasurementDeviceInterface: ... + def hasTripped(self) -> bool: ... + def isTripEnabled(self) -> bool: ... + def linkToPressureTransmitter(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface) -> None: ... + def reset(self) -> None: ... + @typing.overload + def runTransient(self, double: float) -> None: ... + @typing.overload + def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... + def setClosureTime(self, double: float) -> None: ... + def setPercentValveOpening(self, double: float) -> None: ... + def setTripEnabled(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class RuptureDisk(ThrottlingValve): + @typing.overload + 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 getBurstPressure(self) -> float: ... + def getFullOpenPressure(self) -> float: ... + def hasRuptured(self) -> bool: ... + def reset(self) -> None: ... + @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 setBurstPressure(self, double: float) -> None: ... + def setFullOpenPressure(self, double: float) -> None: ... + +class SafetyReliefValve(ThrottlingValve): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + 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 getKbMax(self) -> float: ... + def getKd(self) -> float: ... + def getMinStableOpenFrac(self) -> float: ... + def getOpenFraction(self) -> float: ... + def getOpeningLaw(self) -> 'SafetyReliefValve.OpeningLaw': ... + def getOverpressureFrac(self) -> float: ... + def getRatedCv(self) -> float: ... + def getRelievingPressureBar(self) -> float: ... + def getReseatPressureBar(self) -> float: ... + def getSetPressureBar(self) -> float: ... + def getValveType(self) -> 'SafetyReliefValve.ValveType': ... + def initMechanicalDesign(self) -> None: ... + @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 setBackpressureSensitivity(self, double: float) -> None: ... + def setBlowdownFrac(self, double: float) -> None: ... + def setKbMax(self, double: float) -> None: ... + def setKd(self, double: float) -> None: ... + def setMaxLiftRatePerSec(self, double: float) -> None: ... + def setMinCloseTimeSec(self, double: float) -> None: ... + def setMinOpenTimeSec(self, double: float) -> None: ... + def setMinStableOpenFrac(self, double: float) -> None: ... + def setOpeningLaw(self, openingLaw: 'SafetyReliefValve.OpeningLaw') -> None: ... + def setOverpressureFrac(self, double: float) -> None: ... + def setRatedCv(self, double: float) -> None: ... + def setSetPressureBar(self, double: float) -> None: ... + def setTauCloseSec(self, double: float) -> None: ... + def setTauOpenSec(self, double: float) -> None: ... + def setValveType(self, valveType: 'SafetyReliefValve.ValveType') -> None: ... + class OpeningLaw(java.lang.Enum['SafetyReliefValve.OpeningLaw']): + SNAP: typing.ClassVar['SafetyReliefValve.OpeningLaw'] = ... + MODULATING: typing.ClassVar['SafetyReliefValve.OpeningLaw'] = ... + _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]) -> 'SafetyReliefValve.OpeningLaw': ... + @staticmethod + def values() -> typing.MutableSequence['SafetyReliefValve.OpeningLaw']: ... + class ValveType(java.lang.Enum['SafetyReliefValve.ValveType']): + CONVENTIONAL: typing.ClassVar['SafetyReliefValve.ValveType'] = ... + BALANCED_BELLOWS: typing.ClassVar['SafetyReliefValve.ValveType'] = ... + PILOT_MODULATING: typing.ClassVar['SafetyReliefValve.ValveType'] = ... + _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]) -> 'SafetyReliefValve.ValveType': ... + @staticmethod + def values() -> typing.MutableSequence['SafetyReliefValve.ValveType']: ... + +class SafetyValve(ThrottlingValve): + @typing.overload + 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 addScenario(self, relievingScenario: 'SafetyValve.RelievingScenario') -> 'SafetyValve': ... + def clearRelievingScenarios(self) -> None: ... + def ensureDefaultScenario(self) -> None: ... + def getActiveScenario(self) -> java.util.Optional['SafetyValve.RelievingScenario']: ... + def getActiveScenarioName(self) -> java.util.Optional[java.lang.String]: ... + def getBlowdownPressure(self) -> float: ... + def getFullOpenPressure(self) -> float: ... + def getPressureSpec(self) -> float: ... + def getRelievingScenarios(self) -> java.util.List['SafetyValve.RelievingScenario']: ... + def initMechanicalDesign(self) -> None: ... + @typing.overload + def runTransient(self, double: float) -> None: ... + @typing.overload + def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... + def setActiveScenario(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setBlowdown(self, double: float) -> None: ... + def setBlowdownPressure(self, double: float) -> None: ... + def setFullOpenPressure(self, double: float) -> None: ... + def setPressureSpec(self, double: float) -> None: ... + def setRelievingScenarios(self, list: java.util.List['SafetyValve.RelievingScenario']) -> None: ... + class FluidService(java.lang.Enum['SafetyValve.FluidService']): + GAS: typing.ClassVar['SafetyValve.FluidService'] = ... + LIQUID: typing.ClassVar['SafetyValve.FluidService'] = ... + MULTIPHASE: typing.ClassVar['SafetyValve.FluidService'] = ... + FIRE: typing.ClassVar['SafetyValve.FluidService'] = ... + _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]) -> 'SafetyValve.FluidService': ... + @staticmethod + def values() -> typing.MutableSequence['SafetyValve.FluidService']: ... + class RelievingScenario(java.io.Serializable): + def getBackPressure(self) -> float: ... + def getBackPressureCorrection(self) -> java.util.Optional[float]: ... + def getDischargeCoefficient(self) -> java.util.Optional[float]: ... + def getFluidService(self) -> 'SafetyValve.FluidService': ... + def getInstallationCorrection(self) -> java.util.Optional[float]: ... + def getName(self) -> java.lang.String: ... + def getOverpressureFraction(self) -> float: ... + def getRelievingStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getSetPressure(self) -> java.util.Optional[float]: ... + def getSizingStandard(self) -> 'SafetyValve.SizingStandard': ... + class Builder: + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def backPressure(self, double: float) -> 'SafetyValve.RelievingScenario.Builder': ... + def backPressureCorrection(self, double: float) -> 'SafetyValve.RelievingScenario.Builder': ... + def build(self) -> 'SafetyValve.RelievingScenario': ... + def dischargeCoefficient(self, double: float) -> 'SafetyValve.RelievingScenario.Builder': ... + def fluidService(self, fluidService: 'SafetyValve.FluidService') -> 'SafetyValve.RelievingScenario.Builder': ... + def installationCorrection(self, double: float) -> 'SafetyValve.RelievingScenario.Builder': ... + def overpressureFraction(self, double: float) -> 'SafetyValve.RelievingScenario.Builder': ... + def relievingStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> 'SafetyValve.RelievingScenario.Builder': ... + def setPressure(self, double: float) -> 'SafetyValve.RelievingScenario.Builder': ... + def sizingStandard(self, sizingStandard: 'SafetyValve.SizingStandard') -> 'SafetyValve.RelievingScenario.Builder': ... + class SizingStandard(java.lang.Enum['SafetyValve.SizingStandard']): + API_520: typing.ClassVar['SafetyValve.SizingStandard'] = ... + ISO_4126: typing.ClassVar['SafetyValve.SizingStandard'] = ... + _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]) -> 'SafetyValve.SizingStandard': ... + @staticmethod + def values() -> typing.MutableSequence['SafetyValve.SizingStandard']: ... + +class LevelControlValve(ControlValve): + @typing.overload + 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 getControlAction(self) -> 'LevelControlValve.ControlAction': ... + def getControlError(self) -> float: ... + def getControllerGain(self) -> float: ... + def getFailSafePosition(self) -> float: ... + def getLevelSetpoint(self) -> float: ... + def getMeasuredLevel(self) -> float: ... + def isAutoMode(self) -> bool: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setAutoMode(self, boolean: bool) -> None: ... + def setControlAction(self, controlAction: 'LevelControlValve.ControlAction') -> None: ... + def setControllerGain(self, double: float) -> None: ... + def setFailSafePosition(self, double: float) -> None: ... + def setLevelSetpoint(self, double: float) -> None: ... + def setMeasuredLevel(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + class ControlAction(java.lang.Enum['LevelControlValve.ControlAction']): + DIRECT: typing.ClassVar['LevelControlValve.ControlAction'] = ... + REVERSE: typing.ClassVar['LevelControlValve.ControlAction'] = ... + _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]) -> 'LevelControlValve.ControlAction': ... + @staticmethod + def values() -> typing.MutableSequence['LevelControlValve.ControlAction']: ... + +class PressureControlValve(ControlValve): + @typing.overload + 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 getControlError(self) -> float: ... + def getControlMode(self) -> 'PressureControlValve.ControlMode': ... + def getControllerGain(self) -> float: ... + def getPressureSetpoint(self) -> float: ... + def getProcessVariable(self) -> float: ... + def isAutoMode(self) -> bool: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setAutoMode(self, boolean: bool) -> None: ... + def setControlMode(self, controlMode: 'PressureControlValve.ControlMode') -> None: ... + def setControllerGain(self, double: float) -> None: ... + def setPressureSetpoint(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + class ControlMode(java.lang.Enum['PressureControlValve.ControlMode']): + DOWNSTREAM: typing.ClassVar['PressureControlValve.ControlMode'] = ... + UPSTREAM: typing.ClassVar['PressureControlValve.ControlMode'] = ... + DIFFERENTIAL: typing.ClassVar['PressureControlValve.ControlMode'] = ... + _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]) -> 'PressureControlValve.ControlMode': ... + @staticmethod + def values() -> typing.MutableSequence['PressureControlValve.ControlMode']: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.valve")``. + + BlowdownValve: typing.Type[BlowdownValve] + CheckValve: typing.Type[CheckValve] + ControlValve: typing.Type[ControlValve] + ESDValve: typing.Type[ESDValve] + HIPPSValve: typing.Type[HIPPSValve] + LevelControlValve: typing.Type[LevelControlValve] + PSDValve: typing.Type[PSDValve] + PressureControlValve: typing.Type[PressureControlValve] + RuptureDisk: typing.Type[RuptureDisk] + SafetyReliefValve: typing.Type[SafetyReliefValve] + SafetyValve: typing.Type[SafetyValve] + ThrottlingValve: typing.Type[ThrottlingValve] + ValveInterface: typing.Type[ValveInterface] + ValveTravelModel: typing.Type[ValveTravelModel] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/__init__.pyi new file mode 100644 index 00000000..f758cca6 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/__init__.pyi @@ -0,0 +1,82 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.logic.action +import jneqsim.process.logic.condition +import jneqsim.process.logic.control +import jneqsim.process.logic.esd +import jneqsim.process.logic.hipps +import jneqsim.process.logic.shutdown +import jneqsim.process.logic.sis +import jneqsim.process.logic.startup +import jneqsim.process.logic.voting +import typing + + + +class LogicAction: + def execute(self) -> None: ... + def getDescription(self) -> java.lang.String: ... + def getTargetName(self) -> java.lang.String: ... + def isComplete(self) -> bool: ... + +class LogicCondition: + def evaluate(self) -> bool: ... + def getCurrentValue(self) -> java.lang.String: ... + def getDescription(self) -> java.lang.String: ... + def getExpectedValue(self) -> java.lang.String: ... + def getTargetEquipment(self) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + +class LogicState(java.lang.Enum['LogicState']): + IDLE: typing.ClassVar['LogicState'] = ... + RUNNING: typing.ClassVar['LogicState'] = ... + PAUSED: typing.ClassVar['LogicState'] = ... + COMPLETED: typing.ClassVar['LogicState'] = ... + FAILED: typing.ClassVar['LogicState'] = ... + WAITING_PERMISSIVES: typing.ClassVar['LogicState'] = ... + _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]) -> 'LogicState': ... + @staticmethod + def values() -> typing.MutableSequence['LogicState']: ... + +class ProcessLogic: + def activate(self) -> None: ... + def deactivate(self) -> None: ... + def execute(self, double: float) -> None: ... + def getName(self) -> java.lang.String: ... + def getState(self) -> LogicState: ... + def getStatusDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... + def isActive(self) -> bool: ... + def isComplete(self) -> bool: ... + def reset(self) -> bool: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.logic")``. + + LogicAction: typing.Type[LogicAction] + LogicCondition: typing.Type[LogicCondition] + LogicState: typing.Type[LogicState] + ProcessLogic: typing.Type[ProcessLogic] + action: jneqsim.process.logic.action.__module_protocol__ + condition: jneqsim.process.logic.condition.__module_protocol__ + control: jneqsim.process.logic.control.__module_protocol__ + esd: jneqsim.process.logic.esd.__module_protocol__ + hipps: jneqsim.process.logic.hipps.__module_protocol__ + shutdown: jneqsim.process.logic.shutdown.__module_protocol__ + sis: jneqsim.process.logic.sis.__module_protocol__ + startup: jneqsim.process.logic.startup.__module_protocol__ + voting: jneqsim.process.logic.voting.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/action/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/action/__init__.pyi new file mode 100644 index 00000000..7a84e6ab --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/action/__init__.pyi @@ -0,0 +1,122 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.process.equipment.separator +import jneqsim.process.equipment.splitter +import jneqsim.process.equipment.valve +import jneqsim.process.logic +import typing + + + +class ActivateBlowdownAction(jneqsim.process.logic.LogicAction): + def __init__(self, blowdownValve: jneqsim.process.equipment.valve.BlowdownValve): ... + def execute(self) -> None: ... + def getDescription(self) -> java.lang.String: ... + def getTargetName(self) -> java.lang.String: ... + def isComplete(self) -> bool: ... + +class CloseValveAction(jneqsim.process.logic.LogicAction): + def __init__(self, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve): ... + def execute(self) -> None: ... + def getDescription(self) -> java.lang.String: ... + def getTargetName(self) -> java.lang.String: ... + def isComplete(self) -> bool: ... + +class ConditionalAction(jneqsim.process.logic.LogicAction): + @typing.overload + def __init__(self, logicCondition: jneqsim.process.logic.LogicCondition, logicAction: jneqsim.process.logic.LogicAction, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, logicCondition: jneqsim.process.logic.LogicCondition, logicAction: jneqsim.process.logic.LogicAction, logicAction2: jneqsim.process.logic.LogicAction, string: typing.Union[java.lang.String, str]): ... + def execute(self) -> None: ... + def getAlternativeAction(self) -> jneqsim.process.logic.LogicAction: ... + def getCondition(self) -> jneqsim.process.logic.LogicCondition: ... + def getDescription(self) -> java.lang.String: ... + def getPrimaryAction(self) -> jneqsim.process.logic.LogicAction: ... + def getSelectedAction(self) -> jneqsim.process.logic.LogicAction: ... + def getTargetName(self) -> java.lang.String: ... + def isComplete(self) -> bool: ... + def isEvaluated(self) -> bool: ... + def reset(self) -> None: ... + +class EnergizeESDValveAction(jneqsim.process.logic.LogicAction): + @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 getTargetName(self) -> java.lang.String: ... + def isComplete(self) -> bool: ... + +class OpenValveAction(jneqsim.process.logic.LogicAction): + def __init__(self, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve): ... + def execute(self) -> None: ... + def getDescription(self) -> java.lang.String: ... + def getTargetName(self) -> java.lang.String: ... + def isComplete(self) -> bool: ... + +class ParallelActionGroup(jneqsim.process.logic.LogicAction): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addAction(self, logicAction: jneqsim.process.logic.LogicAction) -> None: ... + def execute(self) -> None: ... + def getActions(self) -> java.util.List[jneqsim.process.logic.LogicAction]: ... + def getCompletedCount(self) -> int: ... + def getCompletionPercentage(self) -> float: ... + def getDescription(self) -> java.lang.String: ... + def getTargetName(self) -> java.lang.String: ... + def getTotalCount(self) -> int: ... + def isComplete(self) -> bool: ... + def toString(self) -> java.lang.String: ... + +class SetSeparatorModeAction(jneqsim.process.logic.LogicAction): + def __init__(self, separator: jneqsim.process.equipment.separator.Separator, boolean: bool): ... + def execute(self) -> None: ... + def getDescription(self) -> java.lang.String: ... + def getTargetName(self) -> java.lang.String: ... + def isComplete(self) -> bool: ... + def isSteadyState(self) -> bool: ... + +class SetSplitterAction(jneqsim.process.logic.LogicAction): + 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 getTargetName(self) -> java.lang.String: ... + def isComplete(self) -> bool: ... + +class SetValveOpeningAction(jneqsim.process.logic.LogicAction): + def __init__(self, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve, double: float): ... + def execute(self) -> None: ... + def getDescription(self) -> java.lang.String: ... + def getTargetName(self) -> java.lang.String: ... + def getTargetOpening(self) -> float: ... + def isComplete(self) -> bool: ... + +class TripValveAction(jneqsim.process.logic.LogicAction): + def __init__(self, eSDValve: jneqsim.process.equipment.valve.ESDValve): ... + def execute(self) -> None: ... + def getDescription(self) -> java.lang.String: ... + def getTargetName(self) -> java.lang.String: ... + def isComplete(self) -> bool: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.logic.action")``. + + ActivateBlowdownAction: typing.Type[ActivateBlowdownAction] + CloseValveAction: typing.Type[CloseValveAction] + ConditionalAction: typing.Type[ConditionalAction] + EnergizeESDValveAction: typing.Type[EnergizeESDValveAction] + OpenValveAction: typing.Type[OpenValveAction] + ParallelActionGroup: typing.Type[ParallelActionGroup] + SetSeparatorModeAction: typing.Type[SetSeparatorModeAction] + SetSplitterAction: typing.Type[SetSplitterAction] + SetValveOpeningAction: typing.Type[SetValveOpeningAction] + TripValveAction: typing.Type[TripValveAction] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/condition/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/condition/__init__.pyi new file mode 100644 index 00000000..dca059fb --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/condition/__init__.pyi @@ -0,0 +1,69 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.process.equipment +import jneqsim.process.equipment.valve +import jneqsim.process.logic +import typing + + + +class PressureCondition(jneqsim.process.logic.LogicCondition): + @typing.overload + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, double: float, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, double: float, string: typing.Union[java.lang.String, str], double2: float): ... + def evaluate(self) -> bool: ... + def getCurrentValue(self) -> java.lang.String: ... + def getDescription(self) -> java.lang.String: ... + def getExpectedValue(self) -> java.lang.String: ... + def getTargetEquipment(self) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + +class TemperatureCondition(jneqsim.process.logic.LogicCondition): + @typing.overload + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, double: float, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, double: float, string: typing.Union[java.lang.String, str], double2: float): ... + def evaluate(self) -> bool: ... + def getCurrentValue(self) -> java.lang.String: ... + def getDescription(self) -> java.lang.String: ... + def getExpectedValue(self) -> java.lang.String: ... + def getTargetEquipment(self) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + +class TimerCondition(jneqsim.process.logic.LogicCondition): + def __init__(self, double: float): ... + def evaluate(self) -> bool: ... + def getCurrentValue(self) -> java.lang.String: ... + def getDescription(self) -> java.lang.String: ... + def getElapsed(self) -> float: ... + def getExpectedValue(self) -> java.lang.String: ... + def getRemaining(self) -> float: ... + def getTargetEquipment(self) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + def reset(self) -> None: ... + def start(self) -> None: ... + def update(self, double: float) -> None: ... + +class ValvePositionCondition(jneqsim.process.logic.LogicCondition): + @typing.overload + def __init__(self, valveInterface: jneqsim.process.equipment.valve.ValveInterface, string: typing.Union[java.lang.String, str], double: float): ... + @typing.overload + def __init__(self, valveInterface: jneqsim.process.equipment.valve.ValveInterface, string: typing.Union[java.lang.String, str], double: float, double2: float): ... + def evaluate(self) -> bool: ... + def getCurrentValue(self) -> java.lang.String: ... + def getDescription(self) -> java.lang.String: ... + def getExpectedValue(self) -> java.lang.String: ... + def getTargetEquipment(self) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.logic.condition")``. + + PressureCondition: typing.Type[PressureCondition] + TemperatureCondition: typing.Type[TemperatureCondition] + TimerCondition: typing.Type[TimerCondition] + ValvePositionCondition: typing.Type[ValvePositionCondition] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/control/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/control/__init__.pyi new file mode 100644 index 00000000..ae104c9f --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/control/__init__.pyi @@ -0,0 +1,41 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.valve +import jneqsim.process.logic +import jneqsim.process.processmodel +import typing + + + +class PressureControlLogic(jneqsim.process.logic.ProcessLogic): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], controlValve: jneqsim.process.equipment.valve.ControlValve, double: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], controlValve: jneqsim.process.equipment.valve.ControlValve, double: float, processSystem: jneqsim.process.processmodel.ProcessSystem): ... + def activate(self) -> None: ... + def deactivate(self) -> None: ... + def execute(self, double: float) -> None: ... + def getControlValve(self) -> jneqsim.process.equipment.valve.ControlValve: ... + def getName(self) -> java.lang.String: ... + def getState(self) -> jneqsim.process.logic.LogicState: ... + def getStatusDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... + def getTargetOpening(self) -> float: ... + def isActive(self) -> bool: ... + def isComplete(self) -> bool: ... + def reset(self) -> bool: ... + def toString(self) -> java.lang.String: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.logic.control")``. + + PressureControlLogic: typing.Type[PressureControlLogic] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/esd/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/esd/__init__.pyi new file mode 100644 index 00000000..7fa79b3f --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/esd/__init__.pyi @@ -0,0 +1,37 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.logic +import typing + + + +class ESDLogic(jneqsim.process.logic.ProcessLogic): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def activate(self) -> None: ... + def addAction(self, logicAction: jneqsim.process.logic.LogicAction, double: float) -> None: ... + def deactivate(self) -> None: ... + def execute(self, double: float) -> None: ... + def getActionCount(self) -> int: ... + def getCurrentActionIndex(self) -> int: ... + def getElapsedTime(self) -> float: ... + def getName(self) -> java.lang.String: ... + def getState(self) -> jneqsim.process.logic.LogicState: ... + def getStatusDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... + def isActive(self) -> bool: ... + def isComplete(self) -> bool: ... + def reset(self) -> bool: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.logic.esd")``. + + ESDLogic: typing.Type[ESDLogic] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/hipps/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/hipps/__init__.pyi new file mode 100644 index 00000000..d50527b0 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/hipps/__init__.pyi @@ -0,0 +1,46 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.valve +import jneqsim.process.logic +import jneqsim.process.logic.sis +import typing + + + +class HIPPSLogic(jneqsim.process.logic.ProcessLogic): + def __init__(self, string: typing.Union[java.lang.String, str], votingLogic: jneqsim.process.logic.sis.VotingLogic): ... + def activate(self) -> None: ... + def addPressureSensor(self, detector: jneqsim.process.logic.sis.Detector) -> None: ... + def deactivate(self) -> None: ... + def execute(self, double: float) -> None: ... + def getName(self) -> java.lang.String: ... + def getPressureSensor(self, int: int) -> jneqsim.process.logic.sis.Detector: ... + def getState(self) -> jneqsim.process.logic.LogicState: ... + def getStatusDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... + def getTimeSinceTrip(self) -> float: ... + def hasEscalated(self) -> bool: ... + def isActive(self) -> bool: ... + def isComplete(self) -> bool: ... + def isTripped(self) -> bool: ... + def linkToEscalationLogic(self, processLogic: jneqsim.process.logic.ProcessLogic, double: float) -> None: ... + def reset(self) -> bool: ... + def setIsolationValve(self, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve) -> None: ... + def setOverride(self, boolean: bool) -> None: ... + def setValveClosureTime(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + def update(self, *double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.logic.hipps")``. + + HIPPSLogic: typing.Type[HIPPSLogic] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/shutdown/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/shutdown/__init__.pyi new file mode 100644 index 00000000..94e4628f --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/shutdown/__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.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.logic +import typing + + + +class ShutdownLogic(jneqsim.process.logic.ProcessLogic): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def activate(self) -> None: ... + def addAction(self, logicAction: jneqsim.process.logic.LogicAction, double: float) -> None: ... + def deactivate(self) -> None: ... + def execute(self, double: float) -> None: ... + def getActionCount(self) -> int: ... + def getCompletedActionCount(self) -> int: ... + def getEffectiveShutdownTime(self) -> float: ... + def getEmergencyShutdownTime(self) -> float: ... + def getName(self) -> java.lang.String: ... + def getProgress(self) -> float: ... + def getRampDownTime(self) -> float: ... + def getState(self) -> jneqsim.process.logic.LogicState: ... + def getStatusDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... + def isActive(self) -> bool: ... + def isComplete(self) -> bool: ... + def isEmergencyMode(self) -> bool: ... + def reset(self) -> bool: ... + def setEmergencyMode(self, boolean: bool) -> None: ... + def setEmergencyShutdownTime(self, double: float) -> None: ... + def setRampDownTime(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.logic.shutdown")``. + + ShutdownLogic: typing.Type[ShutdownLogic] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/sis/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/sis/__init__.pyi new file mode 100644 index 00000000..a443ae77 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/sis/__init__.pyi @@ -0,0 +1,119 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.logic +import typing + + + +class Detector: + def __init__(self, string: typing.Union[java.lang.String, str], detectorType: 'Detector.DetectorType', alarmLevel: 'Detector.AlarmLevel', double: float, string2: typing.Union[java.lang.String, str]): ... + def getAlarmLevel(self) -> 'Detector.AlarmLevel': ... + def getMeasuredValue(self) -> float: ... + def getName(self) -> java.lang.String: ... + def getSetpoint(self) -> float: ... + def getTripTime(self) -> int: ... + def getType(self) -> 'Detector.DetectorType': ... + def isBypassed(self) -> bool: ... + def isFaulty(self) -> bool: ... + def isTripped(self) -> bool: ... + def reset(self) -> None: ... + def setBypass(self, boolean: bool) -> None: ... + def setFaulty(self, boolean: bool) -> None: ... + def setSetpoint(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + def trip(self) -> None: ... + def update(self, double: float) -> None: ... + class AlarmLevel(java.lang.Enum['Detector.AlarmLevel']): + LOW_LOW: typing.ClassVar['Detector.AlarmLevel'] = ... + LOW: typing.ClassVar['Detector.AlarmLevel'] = ... + HIGH: typing.ClassVar['Detector.AlarmLevel'] = ... + HIGH_HIGH: typing.ClassVar['Detector.AlarmLevel'] = ... + def getNotation(self) -> java.lang.String: ... + _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]) -> 'Detector.AlarmLevel': ... + @staticmethod + def values() -> typing.MutableSequence['Detector.AlarmLevel']: ... + class DetectorType(java.lang.Enum['Detector.DetectorType']): + FIRE: typing.ClassVar['Detector.DetectorType'] = ... + GAS: typing.ClassVar['Detector.DetectorType'] = ... + PRESSURE: typing.ClassVar['Detector.DetectorType'] = ... + TEMPERATURE: typing.ClassVar['Detector.DetectorType'] = ... + LEVEL: typing.ClassVar['Detector.DetectorType'] = ... + FLOW: typing.ClassVar['Detector.DetectorType'] = ... + def getDescription(self) -> java.lang.String: ... + _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]) -> 'Detector.DetectorType': ... + @staticmethod + def values() -> typing.MutableSequence['Detector.DetectorType']: ... + +class SafetyInstrumentedFunction(jneqsim.process.logic.ProcessLogic): + def __init__(self, string: typing.Union[java.lang.String, str], votingLogic: 'VotingLogic'): ... + def activate(self) -> None: ... + def addDetector(self, detector: Detector) -> None: ... + def deactivate(self) -> None: ... + def execute(self, double: float) -> None: ... + def getDetector(self, int: int) -> Detector: ... + def getDetectors(self) -> java.util.List[Detector]: ... + def getName(self) -> java.lang.String: ... + def getState(self) -> jneqsim.process.logic.LogicState: ... + def getStatusDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... + def getVotingLogic(self) -> 'VotingLogic': ... + def isActive(self) -> bool: ... + def isComplete(self) -> bool: ... + def isOverridden(self) -> bool: ... + def isTripped(self) -> bool: ... + def linkToLogic(self, processLogic: jneqsim.process.logic.ProcessLogic) -> None: ... + def reset(self) -> bool: ... + def setMaxBypassedDetectors(self, int: int) -> None: ... + def setOverride(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + def update(self, *double: float) -> None: ... + +class VotingLogic(java.lang.Enum['VotingLogic']): + ONE_OUT_OF_ONE: typing.ClassVar['VotingLogic'] = ... + ONE_OUT_OF_TWO: typing.ClassVar['VotingLogic'] = ... + TWO_OUT_OF_TWO: typing.ClassVar['VotingLogic'] = ... + TWO_OUT_OF_THREE: typing.ClassVar['VotingLogic'] = ... + TWO_OUT_OF_FOUR: typing.ClassVar['VotingLogic'] = ... + THREE_OUT_OF_FOUR: typing.ClassVar['VotingLogic'] = ... + def evaluate(self, int: int) -> bool: ... + def getNotation(self) -> java.lang.String: ... + def getRequiredTrips(self) -> int: ... + def getTotalSensors(self) -> int: ... + def toString(self) -> java.lang.String: ... + _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]) -> 'VotingLogic': ... + @staticmethod + def values() -> typing.MutableSequence['VotingLogic']: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.logic.sis")``. + + Detector: typing.Type[Detector] + SafetyInstrumentedFunction: typing.Type[SafetyInstrumentedFunction] + VotingLogic: typing.Type[VotingLogic] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/startup/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/startup/__init__.pyi new file mode 100644 index 00000000..ecd33252 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/startup/__init__.pyi @@ -0,0 +1,41 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.logic +import typing + + + +class StartupLogic(jneqsim.process.logic.ProcessLogic): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def activate(self) -> None: ... + def addAction(self, logicAction: jneqsim.process.logic.LogicAction, double: float) -> None: ... + def addPermissive(self, logicCondition: jneqsim.process.logic.LogicCondition) -> None: ... + def deactivate(self) -> None: ... + def execute(self, double: float) -> None: ... + def getAbortReason(self) -> java.lang.String: ... + def getActionCount(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getPermissiveWaitTime(self) -> float: ... + def getPermissives(self) -> java.util.List[jneqsim.process.logic.LogicCondition]: ... + def getState(self) -> jneqsim.process.logic.LogicState: ... + def getStatusDescription(self) -> java.lang.String: ... + def getTargetEquipment(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... + def isAborted(self) -> bool: ... + def isActive(self) -> bool: ... + def isComplete(self) -> bool: ... + def reset(self) -> bool: ... + def setPermissiveTimeout(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.logic.startup")``. + + StartupLogic: typing.Type[StartupLogic] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/voting/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/voting/__init__.pyi new file mode 100644 index 00000000..507ad254 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/voting/__init__.pyi @@ -0,0 +1,54 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import typing + + + +_VotingEvaluator__T = typing.TypeVar('_VotingEvaluator__T') # +class VotingEvaluator(typing.Generic[_VotingEvaluator__T]): + def __init__(self, votingPattern: 'VotingPattern'): ... + def addInput(self, t: _VotingEvaluator__T, boolean: bool) -> None: ... + def clearInputs(self) -> None: ... + def evaluateAverage(self) -> float: ... + def evaluateDigital(self) -> bool: ... + def evaluateMedian(self) -> float: ... + def evaluateMidValue(self) -> float: ... + def getFaultyInputCount(self) -> int: ... + def getPattern(self) -> 'VotingPattern': ... + def getTotalInputCount(self) -> int: ... + def getValidInputCount(self) -> int: ... + +class VotingPattern(java.lang.Enum['VotingPattern']): + ONE_OUT_OF_ONE: typing.ClassVar['VotingPattern'] = ... + ONE_OUT_OF_TWO: typing.ClassVar['VotingPattern'] = ... + TWO_OUT_OF_TWO: typing.ClassVar['VotingPattern'] = ... + TWO_OUT_OF_THREE: typing.ClassVar['VotingPattern'] = ... + TWO_OUT_OF_FOUR: typing.ClassVar['VotingPattern'] = ... + THREE_OUT_OF_FOUR: typing.ClassVar['VotingPattern'] = ... + def evaluate(self, int: int) -> bool: ... + def getNotation(self) -> java.lang.String: ... + def getRequiredTrue(self) -> int: ... + def getTotalSensors(self) -> int: ... + def toString(self) -> java.lang.String: ... + _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]) -> 'VotingPattern': ... + @staticmethod + def values() -> typing.MutableSequence['VotingPattern']: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.logic.voting")``. + + VotingEvaluator: typing.Type[VotingEvaluator] + VotingPattern: typing.Type[VotingPattern] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/__init__.pyi new file mode 100644 index 00000000..3b68adc8 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/__init__.pyi @@ -0,0 +1,452 @@ + +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 jneqsim.process.alarm +import jneqsim.process.equipment.compressor +import jneqsim.process.equipment.pipeline +import jneqsim.process.equipment.separator +import jneqsim.process.equipment.stream +import jneqsim.process.equipment.valve +import jneqsim.process.logic +import jneqsim.process.measurementdevice.online +import jneqsim.process.measurementdevice.simpleflowregime +import jneqsim.util +import typing + + + +class MeasurementDeviceInterface(jneqsim.util.NamedInterface, java.io.Serializable): + def acknowledgeAlarm(self, double: float) -> jneqsim.process.alarm.AlarmEvent: ... + def displayResult(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def evaluateAlarm(self, double: float, double2: float, double3: float) -> java.util.List[jneqsim.process.alarm.AlarmEvent]: ... + def getAlarmConfig(self) -> jneqsim.process.alarm.AlarmConfig: ... + def getAlarmState(self) -> jneqsim.process.alarm.AlarmState: ... + def getMaximumValue(self) -> float: ... + def getMeasuredPercentValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + def getMinimumValue(self) -> float: ... + def getOnlineSignal(self) -> jneqsim.process.measurementdevice.online.OnlineSignal: ... + def getOnlineValue(self) -> float: ... + def getUnit(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def isLogging(self) -> bool: ... + def isOnlineSignal(self) -> bool: ... + def setAlarmConfig(self, alarmConfig: jneqsim.process.alarm.AlarmConfig) -> None: ... + def setLogging(self, boolean: bool) -> None: ... + def setMaximumValue(self, double: float) -> None: ... + def setMinimumValue(self, double: float) -> None: ... + def setUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class MeasurementDeviceBaseClass(jneqsim.util.NamedBaseClass, MeasurementDeviceInterface): + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + def acknowledgeAlarm(self, double: float) -> jneqsim.process.alarm.AlarmEvent: ... + def displayResult(self) -> None: ... + def doConditionAnalysis(self) -> bool: ... + def evaluateAlarm(self, double: float, double2: float, double3: float) -> java.util.List[jneqsim.process.alarm.AlarmEvent]: ... + def getAlarmConfig(self) -> jneqsim.process.alarm.AlarmConfig: ... + def getAlarmState(self) -> jneqsim.process.alarm.AlarmState: ... + def getConditionAnalysisMaxDeviation(self) -> float: ... + def getConditionAnalysisMessage(self) -> java.lang.String: ... + def getDelaySteps(self) -> int: ... + def getMaximumValue(self) -> float: ... + def getMeasuredPercentValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMinimumValue(self) -> float: ... + def getNoiseStdDev(self) -> float: ... + def getOnlineMeasurementValue(self) -> float: ... + def getOnlineSignal(self) -> jneqsim.process.measurementdevice.online.OnlineSignal: ... + def getUnit(self) -> java.lang.String: ... + def isLogging(self) -> bool: ... + def isOnlineSignal(self) -> bool: ... + def runConditionAnalysis(self) -> None: ... + def setAlarmConfig(self, alarmConfig: jneqsim.process.alarm.AlarmConfig) -> None: ... + def setConditionAnalysis(self, boolean: bool) -> None: ... + def setConditionAnalysisMaxDeviation(self, double: float) -> None: ... + def setDelaySteps(self, int: int) -> None: ... + def setIsOnlineSignal(self, boolean: bool, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def setLogging(self, boolean: bool) -> None: ... + def setMaximumValue(self, double: float) -> None: ... + def setMinimumValue(self, double: float) -> None: ... + def setNoiseStdDev(self, double: float) -> None: ... + def setOnlineMeasurementValue(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setOnlineSignal(self, onlineSignal: jneqsim.process.measurementdevice.online.OnlineSignal) -> None: ... + def setQualityCheckMessage(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setRandomSeed(self, long: int) -> None: ... + def setUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class CompressorMonitor(MeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], compressor: jneqsim.process.equipment.compressor.Compressor): ... + @typing.overload + def __init__(self, compressor: jneqsim.process.equipment.compressor.Compressor): ... + def displayResult(self) -> None: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class FireDetector(MeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + def detectFire(self) -> None: ... + def displayResult(self) -> None: ... + def getDetectionDelay(self) -> float: ... + def getDetectionThreshold(self) -> float: ... + def getLocation(self) -> java.lang.String: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getSignalLevel(self) -> float: ... + def isFireDetected(self) -> bool: ... + def reset(self) -> None: ... + def setDetectionDelay(self, double: float) -> None: ... + def setDetectionThreshold(self, double: float) -> None: ... + def setLocation(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setSignalLevel(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + +class FlowInducedVibrationAnalyser(MeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], pipeBeggsAndBrills: jneqsim.process.equipment.pipeline.PipeBeggsAndBrills): ... + @typing.overload + def __init__(self, pipeBeggsAndBrills: jneqsim.process.equipment.pipeline.PipeBeggsAndBrills): ... + def displayResult(self) -> None: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMethod(self) -> java.lang.String: ... + def setFRMSConstant(self, double: float) -> None: ... + def setMethod(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setSegment(self, int: int) -> None: ... + def setSupportArrangement(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setSupportDistance(self, double: float) -> None: ... + +class GasDetector(MeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], gasType: 'GasDetector.GasType'): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], gasType: 'GasDetector.GasType', string2: typing.Union[java.lang.String, str]): ... + def convertPercentLELToPpm(self, double: float) -> float: ... + def convertPpmToPercentLEL(self, double: float) -> float: ... + def displayResult(self) -> None: ... + def getGasConcentration(self) -> float: ... + def getGasSpecies(self) -> java.lang.String: ... + def getGasType(self) -> 'GasDetector.GasType': ... + def getLocation(self) -> java.lang.String: ... + def getLowerExplosiveLimit(self) -> float: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getResponseTime(self) -> float: ... + def isGasDetected(self, double: float) -> bool: ... + def isHighAlarm(self, double: float) -> bool: ... + def reset(self) -> None: ... + def setGasConcentration(self, double: float) -> None: ... + def setGasSpecies(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setLocation(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setLowerExplosiveLimit(self, double: float) -> None: ... + def setResponseTime(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + class GasType(java.lang.Enum['GasDetector.GasType']): + COMBUSTIBLE: typing.ClassVar['GasDetector.GasType'] = ... + TOXIC: typing.ClassVar['GasDetector.GasType'] = ... + OXYGEN: typing.ClassVar['GasDetector.GasType'] = ... + def getDefaultUnit(self) -> java.lang.String: ... + _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]) -> 'GasDetector.GasType': ... + @staticmethod + def values() -> typing.MutableSequence['GasDetector.GasType']: ... + +class LevelTransmitter(MeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], separator: jneqsim.process.equipment.separator.Separator): ... + @typing.overload + def __init__(self, separator: jneqsim.process.equipment.separator.Separator): ... + def displayResult(self) -> None: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class OilLevelTransmitter(MeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], threePhaseSeparator: jneqsim.process.equipment.separator.ThreePhaseSeparator): ... + @typing.overload + def __init__(self, threePhaseSeparator: jneqsim.process.equipment.separator.ThreePhaseSeparator): ... + def displayResult(self) -> None: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getOilThickness(self) -> float: ... + +class PushButton(MeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], blowdownValve: jneqsim.process.equipment.valve.BlowdownValve): ... + def displayResult(self) -> None: ... + def getLinkedBlowdownValve(self) -> jneqsim.process.equipment.valve.BlowdownValve: ... + def getLinkedLogics(self) -> java.util.List[jneqsim.process.logic.ProcessLogic]: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def isAutoActivateValve(self) -> bool: ... + def isPushed(self) -> bool: ... + def linkToBlowdownValve(self, blowdownValve: jneqsim.process.equipment.valve.BlowdownValve) -> None: ... + def linkToLogic(self, processLogic: jneqsim.process.logic.ProcessLogic) -> None: ... + def push(self) -> None: ... + def reset(self) -> None: ... + def setAutoActivateValve(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class StreamMeasurementDeviceBaseClass(MeasurementDeviceBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def getStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def setStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + +class WaterLevelTransmitter(MeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], threePhaseSeparator: jneqsim.process.equipment.separator.ThreePhaseSeparator): ... + @typing.overload + def __init__(self, threePhaseSeparator: jneqsim.process.equipment.separator.ThreePhaseSeparator): ... + def displayResult(self) -> None: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class CombustionEmissionsCalculator(StreamMeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @staticmethod + def calculateCO2Emissions(map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]], map2: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]]) -> float: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def setComponents(self) -> None: ... + +class CricondenbarAnalyser(StreamMeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def displayResult(self) -> None: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMeasuredValue2(self, string: typing.Union[java.lang.String, str], double: float) -> float: ... + +class HydrateEquilibriumTemperatureAnalyser(StreamMeasurementDeviceBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def displayResult(self) -> None: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getReferencePressure(self) -> float: ... + def setReferencePressure(self, double: float) -> None: ... + +class HydrocarbonDewPointAnalyser(StreamMeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def displayResult(self) -> None: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMethod(self) -> java.lang.String: ... + def getReferencePressure(self) -> float: ... + def setMethod(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setReferencePressure(self, double: float) -> None: ... + +class MolarMassAnalyser(StreamMeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def displayResult(self) -> None: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class MultiPhaseMeter(StreamMeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def getPressure(self) -> float: ... + def getTemperature(self) -> float: ... + def setPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + +class NMVOCAnalyser(StreamMeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getnmVOCFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class PressureTransmitter(StreamMeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def displayResult(self) -> None: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class TemperatureTransmitter(StreamMeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def displayResult(self) -> None: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class VolumeFlowTransmitter(StreamMeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def displayResult(self) -> None: ... + def getMeasuredPhaseNumber(self) -> int: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def setMeasuredPhaseNumber(self, int: int) -> None: ... + +class WaterContentAnalyser(StreamMeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def displayResult(self) -> None: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class WaterDewPointAnalyser(StreamMeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def displayResult(self) -> None: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMethod(self) -> java.lang.String: ... + def getReferencePressure(self) -> float: ... + def setMethod(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setReferencePressure(self, double: float) -> None: ... + +class WellAllocator(StreamMeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def setExportGasStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def setExportOilStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + +class pHProbe(StreamMeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + @typing.overload + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def getAlkalinity(self) -> float: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def run(self) -> None: ... + def setAlkalinity(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.measurementdevice")``. + + CombustionEmissionsCalculator: typing.Type[CombustionEmissionsCalculator] + CompressorMonitor: typing.Type[CompressorMonitor] + CricondenbarAnalyser: typing.Type[CricondenbarAnalyser] + FireDetector: typing.Type[FireDetector] + FlowInducedVibrationAnalyser: typing.Type[FlowInducedVibrationAnalyser] + GasDetector: typing.Type[GasDetector] + HydrateEquilibriumTemperatureAnalyser: typing.Type[HydrateEquilibriumTemperatureAnalyser] + HydrocarbonDewPointAnalyser: typing.Type[HydrocarbonDewPointAnalyser] + LevelTransmitter: typing.Type[LevelTransmitter] + MeasurementDeviceBaseClass: typing.Type[MeasurementDeviceBaseClass] + MeasurementDeviceInterface: typing.Type[MeasurementDeviceInterface] + MolarMassAnalyser: typing.Type[MolarMassAnalyser] + MultiPhaseMeter: typing.Type[MultiPhaseMeter] + NMVOCAnalyser: typing.Type[NMVOCAnalyser] + OilLevelTransmitter: typing.Type[OilLevelTransmitter] + PressureTransmitter: typing.Type[PressureTransmitter] + PushButton: typing.Type[PushButton] + StreamMeasurementDeviceBaseClass: typing.Type[StreamMeasurementDeviceBaseClass] + TemperatureTransmitter: typing.Type[TemperatureTransmitter] + VolumeFlowTransmitter: typing.Type[VolumeFlowTransmitter] + WaterContentAnalyser: typing.Type[WaterContentAnalyser] + WaterDewPointAnalyser: typing.Type[WaterDewPointAnalyser] + WaterLevelTransmitter: typing.Type[WaterLevelTransmitter] + WellAllocator: typing.Type[WellAllocator] + pHProbe: typing.Type[pHProbe] + online: jneqsim.process.measurementdevice.online.__module_protocol__ + simpleflowregime: jneqsim.process.measurementdevice.simpleflowregime.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/online/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/online/__init__.pyi new file mode 100644 index 00000000..70182b12 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/online/__init__.pyi @@ -0,0 +1,27 @@ + +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 typing + + + +class OnlineSignal(java.io.Serializable): + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + def connect(self) -> bool: ... + def getTimeStamp(self) -> java.util.Date: ... + def getUnit(self) -> java.lang.String: ... + def getValue(self) -> float: ... + def setUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.measurementdevice.online")``. + + OnlineSignal: typing.Type[OnlineSignal] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/simpleflowregime/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/simpleflowregime/__init__.pyi new file mode 100644 index 00000000..be5923a5 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/simpleflowregime/__init__.pyi @@ -0,0 +1,92 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.process.equipment.stream +import jneqsim.process.measurementdevice +import jneqsim.thermo.system +import typing + + + +class FluidSevereSlug: + def getGasConstant(self) -> float: ... + def getLiqDensity(self) -> float: ... + def getMolecularWeight(self) -> float: ... + def getliqVisc(self) -> float: ... + def setLiqDensity(self, double: float) -> None: ... + def setLiqVisc(self, double: float) -> None: ... + def setMolecularWeight(self, double: float) -> None: ... + +class Pipe: + def getAngle(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getArea(self) -> float: ... + def getInternalDiameter(self) -> float: ... + def getLeftLength(self) -> float: ... + def getName(self) -> java.lang.String: ... + def getRightLength(self) -> float: ... + def setAngle(self, double: float) -> None: ... + def setInternalDiameter(self, double: float) -> None: ... + def setLeftLength(self, double: float) -> None: ... + def setName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setRightLength(self, double: float) -> None: ... + +class SevereSlugAnalyser(jneqsim.process.measurementdevice.MeasurementDeviceBaseClass): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, int: int): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], stream: jneqsim.process.equipment.stream.Stream, double: float, double2: float, double3: float, double4: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], stream: jneqsim.process.equipment.stream.Stream, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, int: int): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], stream: jneqsim.process.equipment.stream.Stream, double: float, double2: float, double3: float, double4: float, double5: float, int: int): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface, pipe: Pipe, double: float, double2: float, double3: float, int: int): ... + def checkFlowRegime(self, fluidSevereSlug: FluidSevereSlug, pipe: Pipe, severeSlugAnalyser: 'SevereSlugAnalyser') -> java.lang.String: ... + def gasConst(self, fluidSevereSlug: FluidSevereSlug) -> float: ... + def getFlowPattern(self) -> java.lang.String: ... + @typing.overload + def getMeasuredValue(self) -> float: ... + @typing.overload + def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getMeasuredValue(self, fluidSevereSlug: FluidSevereSlug, pipe: Pipe, severeSlugAnalyser: 'SevereSlugAnalyser') -> float: ... + def getNumberOfTimeSteps(self) -> int: ... + def getOutletPressure(self) -> float: ... + @typing.overload + def getPredictedFlowRegime(self) -> java.lang.String: ... + @typing.overload + def getPredictedFlowRegime(self, fluidSevereSlug: FluidSevereSlug, pipe: Pipe, severeSlugAnalyser: 'SevereSlugAnalyser') -> java.lang.String: ... + def getSimulationTime(self) -> float: ... + def getSlugValue(self) -> float: ... + def getSuperficialGasVelocity(self) -> float: ... + def getSuperficialLiquidVelocity(self) -> float: ... + def getTemperature(self) -> float: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def runSevereSlug(self, fluidSevereSlug: FluidSevereSlug, pipe: Pipe, severeSlugAnalyser: 'SevereSlugAnalyser') -> None: ... + def setNumberOfTimeSteps(self, int: int) -> None: ... + def setOutletPressure(self, double: float) -> None: ... + def setSimulationTime(self, double: float) -> None: ... + def setSuperficialGasVelocity(self, double: float) -> None: ... + def setSuperficialLiquidVelocity(self, double: float) -> None: ... + def setTemperature(self, double: float) -> None: ... + def slugHoldUp(self, pipe: Pipe, severeSlugAnalyser: 'SevereSlugAnalyser') -> float: ... + def stratifiedHoldUp(self, fluidSevereSlug: FluidSevereSlug, pipe: Pipe, severeSlugAnalyser: 'SevereSlugAnalyser') -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.measurementdevice.simpleflowregime")``. + + FluidSevereSlug: typing.Type[FluidSevereSlug] + Pipe: typing.Type[Pipe] + SevereSlugAnalyser: typing.Type[SevereSlugAnalyser] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/__init__.pyi new file mode 100644 index 00000000..59004555 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/__init__.pyi @@ -0,0 +1,238 @@ + +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 jneqsim.process.costestimation +import jneqsim.process.equipment +import jneqsim.process.mechanicaldesign.absorber +import jneqsim.process.mechanicaldesign.adsorber +import jneqsim.process.mechanicaldesign.compressor +import jneqsim.process.mechanicaldesign.data +import jneqsim.process.mechanicaldesign.designstandards +import jneqsim.process.mechanicaldesign.ejector +import jneqsim.process.mechanicaldesign.heatexchanger +import jneqsim.process.mechanicaldesign.pipeline +import jneqsim.process.mechanicaldesign.separator +import jneqsim.process.mechanicaldesign.valve +import jneqsim.process.processmodel +import typing + + + +class DesignLimitData(java.io.Serializable): + EMPTY: typing.ClassVar['DesignLimitData'] = ... + @staticmethod + def builder() -> 'DesignLimitData.Builder': ... + def equals(self, object: typing.Any) -> bool: ... + def getCorrosionAllowance(self) -> float: ... + def getJointEfficiency(self) -> float: ... + def getMaxPressure(self) -> float: ... + def getMaxTemperature(self) -> float: ... + def getMinPressure(self) -> float: ... + def getMinTemperature(self) -> float: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + class Builder: + def build(self) -> 'DesignLimitData': ... + def corrosionAllowance(self, double: float) -> 'DesignLimitData.Builder': ... + def jointEfficiency(self, double: float) -> 'DesignLimitData.Builder': ... + def maxPressure(self, double: float) -> 'DesignLimitData.Builder': ... + def maxTemperature(self, double: float) -> 'DesignLimitData.Builder': ... + def minPressure(self, double: float) -> 'DesignLimitData.Builder': ... + def minTemperature(self, double: float) -> 'DesignLimitData.Builder': ... + +class MechanicalDesign(java.io.Serializable): + maxDesignVolumeFlow: float = ... + minDesignVolumeFLow: float = ... + maxDesignGassVolumeFlow: float = ... + minDesignGassVolumeFLow: float = ... + maxDesignOilVolumeFlow: float = ... + minDesignOilFLow: float = ... + maxDesignWaterVolumeFlow: float = ... + minDesignWaterVolumeFLow: float = ... + maxDesignPower: float = ... + minDesignPower: float = ... + maxDesignDuty: float = ... + minDesignDuty: float = ... + innerDiameter: float = ... + outerDiameter: float = ... + wallThickness: float = ... + tantanLength: float = ... + weigthInternals: float = ... + weightNozzle: float = ... + weightPiping: float = ... + weightElectroInstrument: float = ... + weightStructualSteel: float = ... + weightVessel: float = ... + weigthVesselShell: float = ... + moduleHeight: float = ... + moduleWidth: float = ... + moduleLength: float = ... + designStandard: java.util.Hashtable = ... + costEstimate: jneqsim.process.costestimation.UnitCostEstimateBaseClass = ... + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + def addDesignDataSource(self, mechanicalDesignDataSource: typing.Union[jneqsim.process.mechanicaldesign.data.MechanicalDesignDataSource, typing.Callable]) -> None: ... + def calcDesign(self) -> None: ... + def displayResults(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getCompanySpecificDesignStandards(self) -> java.lang.String: ... + def getConstrutionMaterial(self) -> java.lang.String: ... + def getCorrosionAllowance(self) -> float: ... + def getCostEstimate(self) -> jneqsim.process.costestimation.UnitCostEstimateBaseClass: ... + def getDefaultLiquidDensity(self) -> float: ... + def getDefaultLiquidViscosity(self) -> float: ... + def getDesignCorrosionAllowance(self) -> float: ... + def getDesignDataSources(self) -> java.util.List[jneqsim.process.mechanicaldesign.data.MechanicalDesignDataSource]: ... + def getDesignJointEfficiency(self) -> float: ... + def getDesignLimitData(self) -> DesignLimitData: ... + def getDesignMaxPressureLimit(self) -> float: ... + def getDesignMaxTemperatureLimit(self) -> float: ... + def getDesignMinPressureLimit(self) -> float: ... + def getDesignMinTemperatureLimit(self) -> float: ... + def getDesignStandard(self) -> java.util.Hashtable[java.lang.String, jneqsim.process.mechanicaldesign.designstandards.DesignStandard]: ... + def getInnerDiameter(self) -> float: ... + def getJointEfficiency(self) -> float: ... + def getLastMarginResult(self) -> 'MechanicalDesignMarginResult': ... + def getMaterialDesignStandard(self) -> jneqsim.process.mechanicaldesign.designstandards.MaterialPlateDesignStandard: ... + def getMaterialPipeDesignStandard(self) -> jneqsim.process.mechanicaldesign.designstandards.MaterialPipeDesignStandard: ... + def getMaxAllowableStress(self) -> float: ... + def getMaxDesignGassVolumeFlow(self) -> float: ... + def getMaxDesignOilVolumeFlow(self) -> float: ... + def getMaxDesignPressure(self) -> float: ... + def getMaxDesignVolumeFlow(self) -> float: ... + def getMaxDesignWaterVolumeFlow(self) -> float: ... + def getMaxOperationPressure(self) -> float: ... + def getMaxOperationTemperature(self) -> float: ... + def getMinDesignGassVolumeFLow(self) -> float: ... + def getMinDesignOilFLow(self) -> float: ... + def getMinDesignPressure(self) -> float: ... + def getMinDesignVolumeFLow(self) -> float: ... + def getMinDesignWaterVolumeFLow(self) -> float: ... + def getMinOperationPressure(self) -> float: ... + def getMinOperationTemperature(self) -> float: ... + def getModuleHeight(self) -> float: ... + def getModuleLength(self) -> float: ... + def getModuleWidth(self) -> float: ... + def getOuterDiameter(self) -> float: ... + def getPressureMarginFactor(self) -> float: ... + def getProcessEquipment(self) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + def getTantanLength(self) -> float: ... + def getTensileStrength(self) -> float: ... + def getVolumeTotal(self) -> float: ... + def getWallThickness(self) -> float: ... + def getWeightElectroInstrument(self) -> float: ... + def getWeightNozzle(self) -> float: ... + def getWeightPiping(self) -> float: ... + def getWeightStructualSteel(self) -> float: ... + def getWeightTotal(self) -> float: ... + def getWeightVessel(self) -> float: ... + def getWeigthInternals(self) -> float: ... + def getWeigthVesselShell(self) -> float: ... + def hashCode(self) -> int: ... + def initMechanicalDesign(self) -> None: ... + def isHasSetCompanySpecificDesignStandards(self) -> bool: ... + def readDesignSpecifications(self) -> None: ... + def setCompanySpecificDesignStandards(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setConstrutionMaterial(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setCorrosionAllowance(self, double: float) -> None: ... + def setDefaultLiquidDensity(self, double: float) -> None: ... + def setDefaultLiquidViscosity(self, double: float) -> None: ... + def setDesign(self) -> None: ... + def setDesignDataSource(self, mechanicalDesignDataSource: typing.Union[jneqsim.process.mechanicaldesign.data.MechanicalDesignDataSource, typing.Callable]) -> None: ... + def setDesignDataSources(self, list: java.util.List[typing.Union[jneqsim.process.mechanicaldesign.data.MechanicalDesignDataSource, typing.Callable]]) -> None: ... + def setDesignStandard(self, hashtable: java.util.Hashtable[typing.Union[java.lang.String, str], jneqsim.process.mechanicaldesign.designstandards.DesignStandard]) -> None: ... + def setHasSetCompanySpecificDesignStandards(self, boolean: bool) -> None: ... + def setInnerDiameter(self, double: float) -> None: ... + def setJointEfficiency(self, double: float) -> None: ... + def setMaterialDesignStandard(self, materialPlateDesignStandard: jneqsim.process.mechanicaldesign.designstandards.MaterialPlateDesignStandard) -> None: ... + def setMaterialPipeDesignStandard(self, materialPipeDesignStandard: jneqsim.process.mechanicaldesign.designstandards.MaterialPipeDesignStandard) -> None: ... + def setMaxDesignDuty(self, double: float) -> None: ... + def setMaxDesignGassVolumeFlow(self, double: float) -> None: ... + def setMaxDesignOilVolumeFlow(self, double: float) -> None: ... + def setMaxDesignPower(self, double: float) -> None: ... + def setMaxDesignVolumeFlow(self, double: float) -> None: ... + def setMaxDesignWaterVolumeFlow(self, double: float) -> None: ... + def setMaxOperationPressure(self, double: float) -> None: ... + def setMaxOperationTemperature(self, double: float) -> None: ... + def setMinDesignDuty(self, double: float) -> None: ... + def setMinDesignGassVolumeFLow(self, double: float) -> None: ... + def setMinDesignOilFLow(self, double: float) -> None: ... + def setMinDesignPower(self, double: float) -> None: ... + def setMinDesignVolumeFLow(self, double: float) -> None: ... + def setMinDesignWaterVolumeFLow(self, double: float) -> None: ... + def setMinOperationPressure(self, double: float) -> None: ... + def setMinOperationTemperature(self, double: float) -> None: ... + def setModuleHeight(self, double: float) -> None: ... + def setModuleLength(self, double: float) -> None: ... + def setModuleWidth(self, double: float) -> None: ... + def setOuterDiameter(self, double: float) -> None: ... + def setPressureMarginFactor(self, double: float) -> None: ... + def setProcessEquipment(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + def setTantanLength(self, double: float) -> None: ... + def setTensileStrength(self, double: float) -> None: ... + def setWallThickness(self, double: float) -> None: ... + def setWeightElectroInstrument(self, double: float) -> None: ... + def setWeightNozzle(self, double: float) -> None: ... + def setWeightPiping(self, double: float) -> None: ... + def setWeightStructualSteel(self, double: float) -> None: ... + def setWeightTotal(self, double: float) -> None: ... + def setWeightVessel(self, double: float) -> None: ... + def setWeigthInternals(self, double: float) -> None: ... + def setWeigthVesselShell(self, double: float) -> None: ... + @typing.overload + def validateOperatingEnvelope(self) -> 'MechanicalDesignMarginResult': ... + @typing.overload + def validateOperatingEnvelope(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float) -> 'MechanicalDesignMarginResult': ... + +class MechanicalDesignMarginResult(java.io.Serializable): + EMPTY: typing.ClassVar['MechanicalDesignMarginResult'] = ... + def __init__(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float): ... + def equals(self, object: typing.Any) -> bool: ... + def getCorrosionAllowanceMargin(self) -> float: ... + def getJointEfficiencyMargin(self) -> float: ... + def getMaxPressureMargin(self) -> float: ... + def getMaxTemperatureMargin(self) -> float: ... + def getMinPressureMargin(self) -> float: ... + def getMinTemperatureMargin(self) -> float: ... + def hashCode(self) -> int: ... + def isWithinDesignEnvelope(self) -> bool: ... + def toString(self) -> java.lang.String: ... + +class SystemMechanicalDesign(java.io.Serializable): + def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem): ... + def equals(self, object: typing.Any) -> bool: ... + def getMechanicalWeight(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getProcess(self) -> jneqsim.process.processmodel.ProcessSystem: ... + def getTotalNumberOfModules(self) -> int: ... + def getTotalPlotSpace(self) -> float: ... + def getTotalVolume(self) -> float: ... + def getTotalWeight(self) -> float: ... + def hashCode(self) -> int: ... + def runDesignCalculation(self) -> None: ... + def setCompanySpecificDesignStandards(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setDesign(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.mechanicaldesign")``. + + DesignLimitData: typing.Type[DesignLimitData] + MechanicalDesign: typing.Type[MechanicalDesign] + MechanicalDesignMarginResult: typing.Type[MechanicalDesignMarginResult] + SystemMechanicalDesign: typing.Type[SystemMechanicalDesign] + absorber: jneqsim.process.mechanicaldesign.absorber.__module_protocol__ + adsorber: jneqsim.process.mechanicaldesign.adsorber.__module_protocol__ + compressor: jneqsim.process.mechanicaldesign.compressor.__module_protocol__ + data: jneqsim.process.mechanicaldesign.data.__module_protocol__ + designstandards: jneqsim.process.mechanicaldesign.designstandards.__module_protocol__ + ejector: jneqsim.process.mechanicaldesign.ejector.__module_protocol__ + heatexchanger: jneqsim.process.mechanicaldesign.heatexchanger.__module_protocol__ + pipeline: jneqsim.process.mechanicaldesign.pipeline.__module_protocol__ + separator: jneqsim.process.mechanicaldesign.separator.__module_protocol__ + valve: jneqsim.process.mechanicaldesign.valve.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/absorber/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/absorber/__init__.pyi new file mode 100644 index 00000000..79c9eb65 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/absorber/__init__.pyi @@ -0,0 +1,28 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.process.equipment +import jneqsim.process.mechanicaldesign.separator +import typing + + + +class AbsorberMechanicalDesign(jneqsim.process.mechanicaldesign.separator.SeparatorMechanicalDesign): + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + def calcDesign(self) -> None: ... + def getOuterDiameter(self) -> float: ... + def getWallThickness(self) -> float: ... + def readDesignSpecifications(self) -> None: ... + def setDesign(self) -> None: ... + def setOuterDiameter(self, double: float) -> None: ... + def setWallThickness(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.mechanicaldesign.absorber")``. + + AbsorberMechanicalDesign: typing.Type[AbsorberMechanicalDesign] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/adsorber/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/adsorber/__init__.pyi new file mode 100644 index 00000000..9e19863e --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/adsorber/__init__.pyi @@ -0,0 +1,28 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.process.equipment +import jneqsim.process.mechanicaldesign +import typing + + + +class AdsorberMechanicalDesign(jneqsim.process.mechanicaldesign.MechanicalDesign): + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + def calcDesign(self) -> None: ... + def getOuterDiameter(self) -> float: ... + def getWallThickness(self) -> float: ... + def readDesignSpecifications(self) -> None: ... + def setDesign(self) -> None: ... + def setOuterDiameter(self, double: float) -> None: ... + def setWallThickness(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.mechanicaldesign.adsorber")``. + + AdsorberMechanicalDesign: typing.Type[AdsorberMechanicalDesign] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/compressor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/compressor/__init__.pyi new file mode 100644 index 00000000..a3a481ca --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/compressor/__init__.pyi @@ -0,0 +1,29 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.process.equipment +import jneqsim.process.mechanicaldesign +import typing + + + +class CompressorMechanicalDesign(jneqsim.process.mechanicaldesign.MechanicalDesign): + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + def calcDesign(self) -> None: ... + def displayResults(self) -> None: ... + def getOuterDiameter(self) -> float: ... + def getWallThickness(self) -> float: ... + def readDesignSpecifications(self) -> None: ... + def setDesign(self) -> None: ... + def setOuterDiameter(self, double: float) -> None: ... + def setWallThickness(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.mechanicaldesign.compressor")``. + + CompressorMechanicalDesign: typing.Type[CompressorMechanicalDesign] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/data/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/data/__init__.pyi new file mode 100644 index 00000000..1ac7ea03 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/data/__init__.pyi @@ -0,0 +1,34 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.nio.file +import java.util +import jpype.protocol +import jneqsim.process.mechanicaldesign +import typing + + + +class MechanicalDesignDataSource: + def getDesignLimits(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> java.util.Optional[jneqsim.process.mechanicaldesign.DesignLimitData]: ... + +class CsvMechanicalDesignDataSource(MechanicalDesignDataSource): + def __init__(self, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath]): ... + def getDesignLimits(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> java.util.Optional[jneqsim.process.mechanicaldesign.DesignLimitData]: ... + +class DatabaseMechanicalDesignDataSource(MechanicalDesignDataSource): + def __init__(self): ... + def getDesignLimits(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> java.util.Optional[jneqsim.process.mechanicaldesign.DesignLimitData]: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.mechanicaldesign.data")``. + + CsvMechanicalDesignDataSource: typing.Type[CsvMechanicalDesignDataSource] + DatabaseMechanicalDesignDataSource: typing.Type[DatabaseMechanicalDesignDataSource] + MechanicalDesignDataSource: typing.Type[MechanicalDesignDataSource] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/designstandards/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/designstandards/__init__.pyi new file mode 100644 index 00000000..964e8746 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/designstandards/__init__.pyi @@ -0,0 +1,132 @@ + +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 jneqsim.process.mechanicaldesign +import typing + + + +class DesignStandard(java.io.Serializable): + equipment: jneqsim.process.mechanicaldesign.MechanicalDesign = ... + standardName: java.lang.String = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def computeSafetyMargins(self) -> jneqsim.process.mechanicaldesign.MechanicalDesignMarginResult: ... + def equals(self, object: typing.Any) -> bool: ... + def getEquipment(self) -> jneqsim.process.mechanicaldesign.MechanicalDesign: ... + def getStandardName(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def setDesignStandardName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setEquipment(self, mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign) -> None: ... + def setStandardName(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class AbsorptionColumnDesignStandard(DesignStandard): + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def getMolecularSieveWaterCapacity(self) -> float: ... + def setMolecularSieveWaterCapacity(self, double: float) -> None: ... + +class AdsorptionDehydrationDesignStandard(DesignStandard): + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def getMolecularSieveWaterCapacity(self) -> float: ... + def setMolecularSieveWaterCapacity(self, double: float) -> None: ... + +class CompressorDesignStandard(DesignStandard): + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def getCompressorFactor(self) -> float: ... + def setCompressorFactor(self, double: float) -> None: ... + +class GasScrubberDesignStandard(DesignStandard): + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def getGasLoadFactor(self) -> float: ... + def getVolumetricDesignFactor(self) -> float: ... + +class JointEfficiencyPipelineStandard(DesignStandard): + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def getJEFactor(self) -> float: ... + def readJointEfficiencyStandard(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def setJEFactor(self, double: float) -> None: ... + +class JointEfficiencyPlateStandard(DesignStandard): + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def getJEFactor(self) -> float: ... + def readJointEfficiencyStandard(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def setJEFactor(self, double: float) -> None: ... + +class MaterialPipeDesignStandard(DesignStandard): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def getDesignFactor(self) -> float: ... + def getEfactor(self) -> float: ... + def getMinimumYeildStrength(self) -> float: ... + def getTemperatureDeratingFactor(self) -> float: ... + def readMaterialDesignStandard(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def setDesignFactor(self, double: float) -> None: ... + def setEfactor(self, double: float) -> None: ... + def setMinimumYeildStrength(self, double: float) -> None: ... + def setTemperatureDeratingFactor(self, double: float) -> None: ... + +class MaterialPlateDesignStandard(DesignStandard): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def getDivisionClass(self) -> float: ... + def readMaterialDesignStandard(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], int: int) -> None: ... + def setDivisionClass(self, double: float) -> None: ... + +class PipelineDesignStandard(DesignStandard): + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def calcPipelineWallThickness(self) -> float: ... + def getSafetyMargins(self) -> jneqsim.process.mechanicaldesign.MechanicalDesignMarginResult: ... + +class PipingDesignStandard(DesignStandard): + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + +class PressureVesselDesignStandard(DesignStandard): + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def calcWallThickness(self) -> float: ... + def getSafetyMargins(self) -> jneqsim.process.mechanicaldesign.MechanicalDesignMarginResult: ... + +class SeparatorDesignStandard(DesignStandard): + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def getFg(self) -> float: ... + def getGasLoadFactor(self) -> float: ... + def getLiquidRetentionTime(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign) -> float: ... + def getSafetyMargins(self) -> jneqsim.process.mechanicaldesign.MechanicalDesignMarginResult: ... + def getVolumetricDesignFactor(self) -> float: ... + def setFg(self, double: float) -> None: ... + def setVolumetricDesignFactor(self, double: float) -> None: ... + +class ValveDesignStandard(DesignStandard): + valveCvMax: float = ... + def __init__(self, string: typing.Union[java.lang.String, str], mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + def getValveCvMax(self) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.mechanicaldesign.designstandards")``. + + AbsorptionColumnDesignStandard: typing.Type[AbsorptionColumnDesignStandard] + AdsorptionDehydrationDesignStandard: typing.Type[AdsorptionDehydrationDesignStandard] + CompressorDesignStandard: typing.Type[CompressorDesignStandard] + DesignStandard: typing.Type[DesignStandard] + GasScrubberDesignStandard: typing.Type[GasScrubberDesignStandard] + JointEfficiencyPipelineStandard: typing.Type[JointEfficiencyPipelineStandard] + JointEfficiencyPlateStandard: typing.Type[JointEfficiencyPlateStandard] + MaterialPipeDesignStandard: typing.Type[MaterialPipeDesignStandard] + MaterialPlateDesignStandard: typing.Type[MaterialPlateDesignStandard] + PipelineDesignStandard: typing.Type[PipelineDesignStandard] + PipingDesignStandard: typing.Type[PipingDesignStandard] + PressureVesselDesignStandard: typing.Type[PressureVesselDesignStandard] + SeparatorDesignStandard: typing.Type[SeparatorDesignStandard] + ValveDesignStandard: typing.Type[ValveDesignStandard] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/ejector/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/ejector/__init__.pyi new file mode 100644 index 00000000..19202819 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/ejector/__init__.pyi @@ -0,0 +1,46 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.process.equipment +import jneqsim.process.mechanicaldesign +import typing + + + +class EjectorMechanicalDesign(jneqsim.process.mechanicaldesign.MechanicalDesign): + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + def getBodyVolume(self) -> float: ... + def getConnectedPipingVolume(self) -> float: ... + def getDiffuserOutletArea(self) -> float: ... + def getDiffuserOutletDiameter(self) -> float: ... + def getDiffuserOutletLength(self) -> float: ... + def getDiffuserOutletVelocity(self) -> float: ... + def getDischargeConnectionLength(self) -> float: ... + def getEntrainmentRatio(self) -> float: ... + def getMixingChamberArea(self) -> float: ... + def getMixingChamberDiameter(self) -> float: ... + def getMixingChamberLength(self) -> float: ... + def getMixingChamberVelocity(self) -> float: ... + def getMixingPressure(self) -> float: ... + def getMotiveNozzleDiameter(self) -> float: ... + def getMotiveNozzleEffectiveLength(self) -> float: ... + def getMotiveNozzleExitVelocity(self) -> float: ... + def getMotiveNozzleThroatArea(self) -> float: ... + def getSuctionConnectionLength(self) -> float: ... + def getSuctionInletArea(self) -> float: ... + def getSuctionInletDiameter(self) -> float: ... + def getSuctionInletLength(self) -> float: ... + def getSuctionInletVelocity(self) -> float: ... + def getTotalVolume(self) -> float: ... + def resetDesign(self) -> None: ... + def updateDesign(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) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.mechanicaldesign.ejector")``. + + EjectorMechanicalDesign: typing.Type[EjectorMechanicalDesign] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/heatexchanger/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/heatexchanger/__init__.pyi new file mode 100644 index 00000000..d42124de --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/heatexchanger/__init__.pyi @@ -0,0 +1,118 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.heatexchanger +import jneqsim.process.mechanicaldesign +import typing + + + +class HeatExchangerMechanicalDesign(jneqsim.process.mechanicaldesign.MechanicalDesign): + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + def calcDesign(self) -> None: ... + def getApproachTemperature(self) -> float: ... + def getCalculatedUA(self) -> float: ... + def getCandidateTypes(self) -> java.util.List['HeatExchangerType']: ... + def getLogMeanTemperatureDifference(self) -> float: ... + def getManualSelection(self) -> 'HeatExchangerType': ... + def getSelectedSizingResult(self) -> 'HeatExchangerSizingResult': ... + def getSelectedType(self) -> 'HeatExchangerType': ... + def getSelectionCriterion(self) -> 'HeatExchangerMechanicalDesign.SelectionCriterion': ... + def getSizingResults(self) -> java.util.List['HeatExchangerSizingResult']: ... + def getSizingSummary(self) -> java.lang.String: ... + def getUsedOverallHeatTransferCoefficient(self) -> float: ... + @typing.overload + def setCandidateTypes(self, list: java.util.List['HeatExchangerType']) -> None: ... + @typing.overload + def setCandidateTypes(self, *heatExchangerType: 'HeatExchangerType') -> None: ... + def setManualSelection(self, heatExchangerType: 'HeatExchangerType') -> None: ... + def setSelectionCriterion(self, selectionCriterion: 'HeatExchangerMechanicalDesign.SelectionCriterion') -> None: ... + class SelectionCriterion(java.lang.Enum['HeatExchangerMechanicalDesign.SelectionCriterion']): + MIN_AREA: typing.ClassVar['HeatExchangerMechanicalDesign.SelectionCriterion'] = ... + MIN_WEIGHT: typing.ClassVar['HeatExchangerMechanicalDesign.SelectionCriterion'] = ... + MIN_PRESSURE_DROP: typing.ClassVar['HeatExchangerMechanicalDesign.SelectionCriterion'] = ... + _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]) -> 'HeatExchangerMechanicalDesign.SelectionCriterion': ... + @staticmethod + def values() -> typing.MutableSequence['HeatExchangerMechanicalDesign.SelectionCriterion']: ... + +class HeatExchangerSizingResult: + @staticmethod + def builder() -> 'HeatExchangerSizingResult.Builder': ... + def getApproachTemperature(self) -> float: ... + def getEstimatedLength(self) -> float: ... + def getEstimatedPressureDrop(self) -> float: ... + def getEstimatedWeight(self) -> float: ... + def getFinSurfaceArea(self) -> float: ... + def getInnerDiameter(self) -> float: ... + def getMetric(self, selectionCriterion: HeatExchangerMechanicalDesign.SelectionCriterion) -> float: ... + def getModuleHeight(self) -> float: ... + def getModuleLength(self) -> float: ... + def getModuleWidth(self) -> float: ... + def getOuterDiameter(self) -> float: ... + def getOverallHeatTransferCoefficient(self) -> float: ... + def getRequiredArea(self) -> float: ... + def getRequiredUA(self) -> float: ... + def getTubeCount(self) -> int: ... + def getTubePasses(self) -> int: ... + def getType(self) -> 'HeatExchangerType': ... + def getWallThickness(self) -> float: ... + def toString(self) -> java.lang.String: ... + class Builder: + def approachTemperature(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + def build(self) -> 'HeatExchangerSizingResult': ... + def estimatedLength(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + def estimatedPressureDrop(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + def estimatedWeight(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + def finSurfaceArea(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + def innerDiameter(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + def moduleHeight(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + def moduleLength(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + def moduleWidth(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + def outerDiameter(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + def overallHeatTransferCoefficient(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + def requiredArea(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + def requiredUA(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + def tubeCount(self, int: int) -> 'HeatExchangerSizingResult.Builder': ... + def tubePasses(self, int: int) -> 'HeatExchangerSizingResult.Builder': ... + def type(self, heatExchangerType: 'HeatExchangerType') -> 'HeatExchangerSizingResult.Builder': ... + def wallThickness(self, double: float) -> 'HeatExchangerSizingResult.Builder': ... + +class HeatExchangerType(java.lang.Enum['HeatExchangerType']): + SHELL_AND_TUBE: typing.ClassVar['HeatExchangerType'] = ... + PLATE_AND_FRAME: typing.ClassVar['HeatExchangerType'] = ... + AIR_COOLER: typing.ClassVar['HeatExchangerType'] = ... + DOUBLE_PIPE: typing.ClassVar['HeatExchangerType'] = ... + def createSizingResult(self, heatExchanger: jneqsim.process.equipment.heatexchanger.HeatExchanger, double: float, double2: float, double3: float) -> HeatExchangerSizingResult: ... + def getAllowableApproachTemperature(self) -> float: ... + def getDisplayName(self) -> java.lang.String: ... + def getTypicalOverallHeatTransferCoefficient(self) -> float: ... + _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]) -> 'HeatExchangerType': ... + @staticmethod + def values() -> typing.MutableSequence['HeatExchangerType']: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.mechanicaldesign.heatexchanger")``. + + HeatExchangerMechanicalDesign: typing.Type[HeatExchangerMechanicalDesign] + HeatExchangerSizingResult: typing.Type[HeatExchangerSizingResult] + HeatExchangerType: typing.Type[HeatExchangerType] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/pipeline/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/pipeline/__init__.pyi new file mode 100644 index 00000000..2d02ff25 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/pipeline/__init__.pyi @@ -0,0 +1,123 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.process.equipment +import jneqsim.process.mechanicaldesign +import typing + + + +class PipeDesign: + NPS5: typing.ClassVar[typing.MutableSequence[float]] = ... + S5i: typing.ClassVar[typing.MutableSequence[float]] = ... + S5o: typing.ClassVar[typing.MutableSequence[float]] = ... + S5t: typing.ClassVar[typing.MutableSequence[float]] = ... + NPS10: typing.ClassVar[typing.MutableSequence[float]] = ... + S10i: typing.ClassVar[typing.MutableSequence[float]] = ... + S10o: typing.ClassVar[typing.MutableSequence[float]] = ... + S10t: typing.ClassVar[typing.MutableSequence[float]] = ... + NPS20: typing.ClassVar[typing.MutableSequence[float]] = ... + S20i: typing.ClassVar[typing.MutableSequence[float]] = ... + S20o: typing.ClassVar[typing.MutableSequence[float]] = ... + S20t: typing.ClassVar[typing.MutableSequence[float]] = ... + NPS30: typing.ClassVar[typing.MutableSequence[float]] = ... + S30i: typing.ClassVar[typing.MutableSequence[float]] = ... + S30o: typing.ClassVar[typing.MutableSequence[float]] = ... + S30t: typing.ClassVar[typing.MutableSequence[float]] = ... + NPS40: typing.ClassVar[typing.MutableSequence[float]] = ... + S40i: typing.ClassVar[typing.MutableSequence[float]] = ... + S40o: typing.ClassVar[typing.MutableSequence[float]] = ... + S40t: typing.ClassVar[typing.MutableSequence[float]] = ... + NPS60: typing.ClassVar[typing.MutableSequence[float]] = ... + S60i: typing.ClassVar[typing.MutableSequence[float]] = ... + S60o: typing.ClassVar[typing.MutableSequence[float]] = ... + S60t: typing.ClassVar[typing.MutableSequence[float]] = ... + NPS80: typing.ClassVar[typing.MutableSequence[float]] = ... + S80i: typing.ClassVar[typing.MutableSequence[float]] = ... + S80o: typing.ClassVar[typing.MutableSequence[float]] = ... + S80t: typing.ClassVar[typing.MutableSequence[float]] = ... + NPS100: typing.ClassVar[typing.MutableSequence[float]] = ... + S100i: typing.ClassVar[typing.MutableSequence[float]] = ... + S100o: typing.ClassVar[typing.MutableSequence[float]] = ... + S100t: typing.ClassVar[typing.MutableSequence[float]] = ... + NPS120: typing.ClassVar[typing.MutableSequence[float]] = ... + S120i: typing.ClassVar[typing.MutableSequence[float]] = ... + S120o: typing.ClassVar[typing.MutableSequence[float]] = ... + S120t: typing.ClassVar[typing.MutableSequence[float]] = ... + NPS140: typing.ClassVar[typing.MutableSequence[float]] = ... + S140i: typing.ClassVar[typing.MutableSequence[float]] = ... + S140o: typing.ClassVar[typing.MutableSequence[float]] = ... + S140t: typing.ClassVar[typing.MutableSequence[float]] = ... + NPS160: typing.ClassVar[typing.MutableSequence[float]] = ... + S160i: typing.ClassVar[typing.MutableSequence[float]] = ... + S160o: typing.ClassVar[typing.MutableSequence[float]] = ... + S160t: typing.ClassVar[typing.MutableSequence[float]] = ... + NPSSTD: typing.ClassVar[typing.MutableSequence[float]] = ... + STDi: typing.ClassVar[typing.MutableSequence[float]] = ... + STDo: typing.ClassVar[typing.MutableSequence[float]] = ... + STDt: typing.ClassVar[typing.MutableSequence[float]] = ... + NPSXS: typing.ClassVar[typing.MutableSequence[float]] = ... + XSi: typing.ClassVar[typing.MutableSequence[float]] = ... + XSo: typing.ClassVar[typing.MutableSequence[float]] = ... + XSt: typing.ClassVar[typing.MutableSequence[float]] = ... + NPSXXS: typing.ClassVar[typing.MutableSequence[float]] = ... + XXSi: typing.ClassVar[typing.MutableSequence[float]] = ... + XXSo: typing.ClassVar[typing.MutableSequence[float]] = ... + XXSt: typing.ClassVar[typing.MutableSequence[float]] = ... + NPSS5: typing.ClassVar[typing.MutableSequence[float]] = ... + SS5DN: typing.ClassVar[typing.MutableSequence[float]] = ... + SS5i: typing.ClassVar[typing.MutableSequence[float]] = ... + SS5o: typing.ClassVar[typing.MutableSequence[float]] = ... + SS5t: typing.ClassVar[typing.MutableSequence[float]] = ... + scheduleLookup: typing.ClassVar[java.util.Map] = ... + SSWG_integers: typing.ClassVar[typing.MutableSequence[float]] = ... + SSWG_inch: typing.ClassVar[typing.MutableSequence[float]] = ... + SSWG_SI: typing.ClassVar[typing.MutableSequence[float]] = ... + BWG_integers: typing.ClassVar[typing.MutableSequence[float]] = ... + BWG_inch: typing.ClassVar[typing.MutableSequence[float]] = ... + BWG_SI: typing.ClassVar[typing.MutableSequence[float]] = ... + wireSchedules: typing.ClassVar[java.util.Map] = ... + def __init__(self): ... + @staticmethod + def erosionalVelocity(double: float, double2: float) -> float: ... + @staticmethod + def gaugeFromThickness(double: float, boolean: bool, string: typing.Union[java.lang.String, str]) -> float: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @staticmethod + def nearestPipe(double: float, double2: float, double3: float, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + @staticmethod + def thicknessFromGauge(double: float, boolean: bool, string: typing.Union[java.lang.String, str]) -> float: ... + class ScheduleData: + nps: typing.MutableSequence[float] = ... + dis: typing.MutableSequence[float] = ... + dos: typing.MutableSequence[float] = ... + ts: typing.MutableSequence[float] = ... + 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]): ... + class WireScheduleData: + gaugeNumbers: typing.MutableSequence[float] = ... + thicknessInch: typing.MutableSequence[float] = ... + thicknessM: typing.MutableSequence[float] = ... + something: bool = ... + 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], boolean: bool): ... + +class PipelineMechanicalDesign(jneqsim.process.mechanicaldesign.MechanicalDesign): + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + def calcDesign(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def readDesignSpecifications(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.mechanicaldesign.pipeline")``. + + PipeDesign: typing.Type[PipeDesign] + PipelineMechanicalDesign: typing.Type[PipelineMechanicalDesign] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/separator/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/separator/__init__.pyi new file mode 100644 index 00000000..f85d2fc4 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/separator/__init__.pyi @@ -0,0 +1,34 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.process.equipment +import jneqsim.process.mechanicaldesign +import jneqsim.process.mechanicaldesign.separator.sectiontype +import typing + + + +class SeparatorMechanicalDesign(jneqsim.process.mechanicaldesign.MechanicalDesign): + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + def calcDesign(self) -> None: ... + def displayResults(self) -> None: ... + def readDesignSpecifications(self) -> None: ... + def setDesign(self) -> None: ... + +class GasScrubberMechanicalDesign(SeparatorMechanicalDesign): + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + def calcDesign(self) -> None: ... + def readDesignSpecifications(self) -> None: ... + def setDesign(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.mechanicaldesign.separator")``. + + GasScrubberMechanicalDesign: typing.Type[GasScrubberMechanicalDesign] + SeparatorMechanicalDesign: typing.Type[SeparatorMechanicalDesign] + sectiontype: jneqsim.process.mechanicaldesign.separator.sectiontype.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/separator/sectiontype/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/separator/sectiontype/__init__.pyi new file mode 100644 index 00000000..e976dd2c --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/separator/sectiontype/__init__.pyi @@ -0,0 +1,59 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.process.equipment.separator.sectiontype +import typing + + + +class SepDesignSection: + totalWeight: float = ... + totalHeight: float = ... + ANSIclass: int = ... + nominalSize: java.lang.String = ... + def __init__(self, separatorSection: jneqsim.process.equipment.separator.sectiontype.SeparatorSection): ... + def calcDesign(self) -> None: ... + def getANSIclass(self) -> int: ... + def getNominalSize(self) -> java.lang.String: ... + def getTotalHeight(self) -> float: ... + def getTotalWeight(self) -> float: ... + def setANSIclass(self, int: int) -> None: ... + def setNominalSize(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setTotalHeight(self, double: float) -> None: ... + def setTotalWeight(self, double: float) -> None: ... + +class DistillationTraySection(SepDesignSection): + def __init__(self, separatorSection: jneqsim.process.equipment.separator.sectiontype.SeparatorSection): ... + def calcDesign(self) -> None: ... + +class MecMeshSection(SepDesignSection): + def __init__(self, separatorSection: jneqsim.process.equipment.separator.sectiontype.SeparatorSection): ... + def calcDesign(self) -> None: ... + +class MechManwaySection(SepDesignSection): + def __init__(self, separatorSection: jneqsim.process.equipment.separator.sectiontype.SeparatorSection): ... + def calcDesign(self) -> None: ... + +class MechNozzleSection(SepDesignSection): + def __init__(self, separatorSection: jneqsim.process.equipment.separator.sectiontype.SeparatorSection): ... + def calcDesign(self) -> None: ... + +class MechVaneSection(SepDesignSection): + def __init__(self, separatorSection: jneqsim.process.equipment.separator.sectiontype.SeparatorSection): ... + def calcDesign(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.mechanicaldesign.separator.sectiontype")``. + + DistillationTraySection: typing.Type[DistillationTraySection] + MecMeshSection: typing.Type[MecMeshSection] + MechManwaySection: typing.Type[MechManwaySection] + MechNozzleSection: typing.Type[MechNozzleSection] + MechVaneSection: typing.Type[MechVaneSection] + SepDesignSection: typing.Type[SepDesignSection] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/valve/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/valve/__init__.pyi new file mode 100644 index 00000000..e13a5725 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/valve/__init__.pyi @@ -0,0 +1,221 @@ + +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 jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.equipment.valve +import jneqsim.process.mechanicaldesign +import typing + + + +class ControlValveSizingInterface: + def calcValveSize(self, double: float) -> java.util.Map[java.lang.String, typing.Any]: ... + def calculateFlowRateFromValveOpening(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def calculateValveOpeningFromFlowRate(self, double: float, double2: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def findOutletPressureForFixedKv(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def getxT(self) -> float: ... + def isAllowChoked(self) -> bool: ... + def setAllowChoked(self, boolean: bool) -> None: ... + def setxT(self, double: float) -> None: ... + +class ValveCharacteristic(java.io.Serializable): + def getActualKv(self, double: float, double2: float) -> float: ... + def getOpeningFactor(self, double: float) -> float: ... + +class ValveMechanicalDesign(jneqsim.process.mechanicaldesign.MechanicalDesign): + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + def calcDesign(self) -> None: ... + def calcValveSize(self) -> java.util.Map[java.lang.String, typing.Any]: ... + def displayResults(self) -> None: ... + def getValveCharacterization(self) -> java.lang.String: ... + def getValveCharacterizationMethod(self) -> ValveCharacteristic: ... + def getValveSizingMethod(self) -> ControlValveSizingInterface: ... + def getValveSizingStandard(self) -> java.lang.String: ... + def readDesignSpecifications(self) -> None: ... + def setValveCharacterization(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setValveCharacterizationMethod(self, valveCharacteristic: ValveCharacteristic) -> None: ... + def setValveSizingStandard(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class ControlValveSizing(ControlValveSizingInterface, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, valveMechanicalDesign: ValveMechanicalDesign): ... + def calcKv(self, double: float) -> float: ... + def calcValveSize(self, double: float) -> java.util.Map[java.lang.String, typing.Any]: ... + def calculateFlowRateFromValveOpening(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def calculateMolarFlow(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def calculateOutletPressure(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def calculateValveOpeningFromFlowRate(self, double: float, double2: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def findOutletPressureForFixedKv(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def getValveMechanicalDesign(self) -> ValveMechanicalDesign: ... + def getxT(self) -> float: ... + def isAllowChoked(self) -> bool: ... + def setAllowChoked(self, boolean: bool) -> None: ... + def setxT(self, double: float) -> None: ... + +class LinearCharacteristic(ValveCharacteristic): + def __init__(self): ... + def getActualKv(self, double: float, double2: float) -> float: ... + def getOpeningFactor(self, double: float) -> float: ... + +class SafetyValveMechanicalDesign(ValveMechanicalDesign): + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + def calcDesign(self) -> None: ... + def calcGasOrificeAreaAPI520(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, double9: float) -> float: ... + def getControllingOrificeArea(self) -> float: ... + def getControllingScenarioName(self) -> java.lang.String: ... + def getOrificeArea(self) -> float: ... + def getScenarioReports(self) -> java.util.Map[java.lang.String, 'SafetyValveMechanicalDesign.SafetyValveScenarioReport']: ... + def getScenarioResults(self) -> java.util.Map[java.lang.String, 'SafetyValveMechanicalDesign.SafetyValveScenarioResult']: ... + class SafetyValveScenarioReport: + def getBackPressureBar(self) -> float: ... + def getFluidService(self) -> jneqsim.process.equipment.valve.SafetyValve.FluidService: ... + def getOverpressureMarginBar(self) -> float: ... + def getRelievingPressureBar(self) -> float: ... + def getRequiredOrificeArea(self) -> float: ... + def getScenarioName(self) -> java.lang.String: ... + def getSetPressureBar(self) -> float: ... + def getSizingStandard(self) -> jneqsim.process.equipment.valve.SafetyValve.SizingStandard: ... + def isActiveScenario(self) -> bool: ... + def isControllingScenario(self) -> bool: ... + class SafetyValveScenarioResult: + def getBackPressureBar(self) -> float: ... + def getBackPressurePa(self) -> float: ... + def getFluidService(self) -> jneqsim.process.equipment.valve.SafetyValve.FluidService: ... + def getOverpressureMarginBar(self) -> float: ... + def getOverpressureMarginPa(self) -> float: ... + def getRelievingPressureBar(self) -> float: ... + def getRelievingPressurePa(self) -> float: ... + def getRequiredOrificeArea(self) -> float: ... + def getScenarioName(self) -> java.lang.String: ... + def getSetPressureBar(self) -> float: ... + def getSetPressurePa(self) -> float: ... + def getSizingStandard(self) -> jneqsim.process.equipment.valve.SafetyValve.SizingStandard: ... + def isActiveScenario(self) -> bool: ... + def isControllingScenario(self) -> bool: ... + +class ControlValveSizing_IEC_60534(ControlValveSizing): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, valveMechanicalDesign: ValveMechanicalDesign): ... + def calcValveSize(self, double: float) -> java.util.Map[java.lang.String, typing.Any]: ... + @typing.overload + def calculateFlowRateFromKvAndValveOpeningGas(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, double9: float, double10: float, boolean: bool) -> float: ... + @typing.overload + def calculateFlowRateFromKvAndValveOpeningGas(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def calculateFlowRateFromValveOpening(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def calculateFlowRateFromValveOpeningGas(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + @typing.overload + def calculateFlowRateFromValveOpeningLiquid(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float) -> float: ... + @typing.overload + def calculateFlowRateFromValveOpeningLiquid(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + @typing.overload + def calculateValveOpeningFromFlowRateGas(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, double9: float, double10: float, double11: float, boolean: bool) -> float: ... + @typing.overload + def calculateValveOpeningFromFlowRateGas(self, double: float, double2: float, double3: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + @typing.overload + def calculateValveOpeningFromFlowRateLiquid(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float) -> float: ... + @typing.overload + def calculateValveOpeningFromFlowRateLiquid(self, double: float, double2: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def findOutletPressureForFixedKv(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + @typing.overload + def findOutletPressureForFixedKvGas(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float) -> float: ... + @typing.overload + def findOutletPressureForFixedKvGas(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + @typing.overload + def findOutletPressureForFixedKvLiquid(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, double9: float, boolean: bool, boolean2: bool) -> float: ... + @typing.overload + def findOutletPressureForFixedKvLiquid(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def getD(self) -> float: ... + def getD1(self) -> float: ... + def getD2(self) -> float: ... + def getFL(self) -> float: ... + def getFd(self) -> float: ... + def getValve(self) -> jneqsim.process.equipment.valve.ValveInterface: ... + def isAllowChoked(self) -> bool: ... + def isAllowLaminar(self) -> bool: ... + def isFullOutput(self) -> bool: ... + def setAllowChoked(self, boolean: bool) -> None: ... + def setAllowLaminar(self, boolean: bool) -> None: ... + def setD(self, double: float) -> None: ... + def setD1(self, double: float) -> None: ... + def setD2(self, double: float) -> None: ... + def setFL(self, double: float) -> None: ... + def setFd(self, double: float) -> None: ... + def setFullOutput(self, boolean: bool) -> None: ... + def sizeControlValve(self, fluidType: 'ControlValveSizing_IEC_60534.FluidType', 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, boolean: bool, boolean2: bool, boolean3: bool, double15: float) -> java.util.Map[java.lang.String, typing.Any]: ... + def sizeControlValveGas(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float) -> java.util.Map[java.lang.String, typing.Any]: ... + def sizeControlValveLiquid(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float) -> java.util.Map[java.lang.String, typing.Any]: ... + class FluidType(java.lang.Enum['ControlValveSizing_IEC_60534.FluidType']): + LIQUID: typing.ClassVar['ControlValveSizing_IEC_60534.FluidType'] = ... + GAS: typing.ClassVar['ControlValveSizing_IEC_60534.FluidType'] = ... + _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]) -> 'ControlValveSizing_IEC_60534.FluidType': ... + @staticmethod + def values() -> typing.MutableSequence['ControlValveSizing_IEC_60534.FluidType']: ... + +class ControlValveSizing_simple(ControlValveSizing): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, valveMechanicalDesign: ValveMechanicalDesign): ... + def calcKv(self, double: float) -> float: ... + @typing.overload + def calculateFlowRateFromValveOpening(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + @typing.overload + def calculateFlowRateFromValveOpening(self, double: float, double2: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def calculateMolarFlow(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def calculateOutletPressure(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + @typing.overload + def calculateValveOpeningFromFlowRate(self, double: float, double2: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + @typing.overload + def calculateValveOpeningFromFlowRate(self, double: float, double2: float, double3: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + @typing.overload + def findOutletPressureForFixedKv(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + @typing.overload + def findOutletPressureForFixedKv(self, double: float, double2: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + +class ControlValveSizing_IEC_60534_full(ControlValveSizing_IEC_60534): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, valveMechanicalDesign: ValveMechanicalDesign): ... + def calculateFlowRateFromValveOpening(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + @typing.overload + def calculateValveOpeningFromFlowRate(self, double: float, double2: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + @typing.overload + def calculateValveOpeningFromFlowRate(self, double: float, double2: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface, streamInterface2: jneqsim.process.equipment.stream.StreamInterface, double3: float) -> float: ... + def findOutletPressureForFixedKv(self, double: float, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> float: ... + def isFullTrim(self) -> bool: ... + def setFullTrim(self, boolean: bool) -> None: ... + def sizeControlValveGas(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float) -> java.util.Map[java.lang.String, typing.Any]: ... + def sizeControlValveLiquid(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float) -> java.util.Map[java.lang.String, typing.Any]: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.mechanicaldesign.valve")``. + + ControlValveSizing: typing.Type[ControlValveSizing] + ControlValveSizingInterface: typing.Type[ControlValveSizingInterface] + ControlValveSizing_IEC_60534: typing.Type[ControlValveSizing_IEC_60534] + ControlValveSizing_IEC_60534_full: typing.Type[ControlValveSizing_IEC_60534_full] + ControlValveSizing_simple: typing.Type[ControlValveSizing_simple] + LinearCharacteristic: typing.Type[LinearCharacteristic] + SafetyValveMechanicalDesign: typing.Type[SafetyValveMechanicalDesign] + ValveCharacteristic: typing.Type[ValveCharacteristic] + ValveMechanicalDesign: typing.Type[ValveMechanicalDesign] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/__init__.pyi new file mode 100644 index 00000000..12f32cb4 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/__init__.pyi @@ -0,0 +1,490 @@ + +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 java.util.concurrent +import javax.xml.parsers +import jpype +import jpype.protocol +import jneqsim.process +import jneqsim.process.alarm +import jneqsim.process.conditionmonitor +import jneqsim.process.controllerdevice +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.measurementdevice +import jneqsim.process.mechanicaldesign +import jneqsim.process.processmodel.processmodules +import jneqsim.process.util.report +import jneqsim.thermo.system +import typing + + + +class DexpiMetadata: + TAG_NAME: typing.ClassVar[java.lang.String] = ... + LINE_NUMBER: typing.ClassVar[java.lang.String] = ... + FLUID_CODE: typing.ClassVar[java.lang.String] = ... + SEGMENT_NUMBER: typing.ClassVar[java.lang.String] = ... + OPERATING_PRESSURE_VALUE: typing.ClassVar[java.lang.String] = ... + OPERATING_PRESSURE_UNIT: typing.ClassVar[java.lang.String] = ... + OPERATING_TEMPERATURE_VALUE: typing.ClassVar[java.lang.String] = ... + OPERATING_TEMPERATURE_UNIT: typing.ClassVar[java.lang.String] = ... + OPERATING_FLOW_VALUE: typing.ClassVar[java.lang.String] = ... + OPERATING_FLOW_UNIT: typing.ClassVar[java.lang.String] = ... + DEFAULT_PRESSURE_UNIT: typing.ClassVar[java.lang.String] = ... + DEFAULT_TEMPERATURE_UNIT: typing.ClassVar[java.lang.String] = ... + DEFAULT_FLOW_UNIT: typing.ClassVar[java.lang.String] = ... + @staticmethod + def recommendedEquipmentAttributes() -> java.util.Set[java.lang.String]: ... + @staticmethod + def recommendedStreamAttributes() -> java.util.Set[java.lang.String]: ... + +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: ... + def getFluidCode(self) -> java.lang.String: ... + def getLineNumber(self) -> java.lang.String: ... + def getMappedEquipment(self) -> jneqsim.process.equipment.EquipmentEnum: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + +class DexpiRoundTripProfile: + @staticmethod + def minimalRunnableProfile() -> 'DexpiRoundTripProfile': ... + def validate(self, processSystem: 'ProcessSystem') -> 'DexpiRoundTripProfile.ValidationResult': ... + class ValidationResult: + def getViolations(self) -> java.util.List[java.lang.String]: ... + def isSuccessful(self) -> bool: ... + +class DexpiStream(jneqsim.process.equipment.stream.Stream): + def __init__(self, string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface, string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], string4: typing.Union[java.lang.String, str]): ... + def getDexpiClass(self) -> java.lang.String: ... + def getFluidCode(self) -> java.lang.String: ... + def getLineNumber(self) -> java.lang.String: ... + +class DexpiXmlReader: + @typing.overload + @staticmethod + def load(file: typing.Union[java.io.File, jpype.protocol.SupportsPath], processSystem: 'ProcessSystem') -> None: ... + @typing.overload + @staticmethod + def load(file: typing.Union[java.io.File, jpype.protocol.SupportsPath], processSystem: 'ProcessSystem', stream: jneqsim.process.equipment.stream.Stream) -> None: ... + @typing.overload + @staticmethod + def load(inputStream: java.io.InputStream, processSystem: 'ProcessSystem') -> None: ... + @typing.overload + @staticmethod + def load(inputStream: java.io.InputStream, processSystem: 'ProcessSystem', stream: jneqsim.process.equipment.stream.Stream) -> None: ... + @typing.overload + @staticmethod + def read(file: typing.Union[java.io.File, jpype.protocol.SupportsPath]) -> 'ProcessSystem': ... + @typing.overload + @staticmethod + def read(file: typing.Union[java.io.File, jpype.protocol.SupportsPath], stream: jneqsim.process.equipment.stream.Stream) -> 'ProcessSystem': ... + @typing.overload + @staticmethod + def read(inputStream: java.io.InputStream) -> 'ProcessSystem': ... + @typing.overload + @staticmethod + def read(inputStream: java.io.InputStream, stream: jneqsim.process.equipment.stream.Stream) -> 'ProcessSystem': ... + +class DexpiXmlReaderException(java.lang.Exception): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], throwable: java.lang.Throwable): ... + +class DexpiXmlWriter: + @typing.overload + @staticmethod + def write(processSystem: 'ProcessSystem', file: typing.Union[java.io.File, jpype.protocol.SupportsPath]) -> None: ... + @typing.overload + @staticmethod + def write(processSystem: 'ProcessSystem', outputStream: java.io.OutputStream) -> None: ... + +class ModuleInterface(jneqsim.process.equipment.ProcessEquipmentInterface): + def addInputStream(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getOperations(self) -> 'ProcessSystem': ... + def getOutputStream(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getPreferedThermodynamicModel(self) -> java.lang.String: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> typing.Any: ... + def hashCode(self) -> int: ... + def initializeModule(self) -> None: ... + def initializeStreams(self) -> None: ... + def isCalcDesign(self) -> bool: ... + def setIsCalcDesign(self, boolean: bool) -> None: ... + def setPreferedThermodynamicModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setProperty(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + +class ProcessLoader: + def __init__(self): ... + @typing.overload + @staticmethod + def loadProcessFromYaml(file: typing.Union[java.io.File, jpype.protocol.SupportsPath], string: typing.Union[java.lang.String, str], processSystem: 'ProcessSystem') -> None: ... + @typing.overload + @staticmethod + def loadProcessFromYaml(file: typing.Union[java.io.File, jpype.protocol.SupportsPath], processSystem: 'ProcessSystem') -> None: ... + @typing.overload + @staticmethod + def loadProcessFromYaml(string: typing.Union[java.lang.String, str], processSystem: 'ProcessSystem') -> None: ... + +class ProcessModel(java.lang.Runnable): + def __init__(self): ... + def add(self, string: typing.Union[java.lang.String, str], processSystem: 'ProcessSystem') -> bool: ... + @typing.overload + def checkMassBalance(self) -> java.util.Map[java.lang.String, java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']]: ... + @typing.overload + def checkMassBalance(self, string: typing.Union[java.lang.String, str]) -> java.util.Map[java.lang.String, java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']]: ... + def get(self, string: typing.Union[java.lang.String, str]) -> 'ProcessSystem': ... + def getAllProcesses(self) -> java.util.Collection['ProcessSystem']: ... + @typing.overload + def getFailedMassBalance(self) -> java.util.Map[java.lang.String, java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']]: ... + @typing.overload + def getFailedMassBalance(self, double: float) -> java.util.Map[java.lang.String, java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']]: ... + @typing.overload + def getFailedMassBalance(self, string: typing.Union[java.lang.String, str], double: float) -> java.util.Map[java.lang.String, java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']]: ... + @typing.overload + def getFailedMassBalanceReport(self) -> java.lang.String: ... + @typing.overload + def getFailedMassBalanceReport(self, double: float) -> java.lang.String: ... + @typing.overload + def getFailedMassBalanceReport(self, string: typing.Union[java.lang.String, str], double: float) -> java.lang.String: ... + @typing.overload + def getMassBalanceReport(self) -> java.lang.String: ... + @typing.overload + def getMassBalanceReport(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + def getReport_json(self) -> java.lang.String: ... + def getThreads(self) -> java.util.Map[java.lang.String, java.lang.Thread]: ... + def isFinished(self) -> bool: ... + def isRunStep(self) -> bool: ... + def remove(self, string: typing.Union[java.lang.String, str]) -> bool: ... + def run(self) -> None: ... + def runAsTask(self) -> java.util.concurrent.Future[typing.Any]: ... + def runAsThread(self) -> java.lang.Thread: ... + def runStep(self) -> None: ... + def setRunStep(self, boolean: bool) -> None: ... + +class ProcessModule(jneqsim.process.SimulationBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def add(self, processModule: 'ProcessModule') -> None: ... + @typing.overload + def add(self, processSystem: 'ProcessSystem') -> None: ... + @typing.overload + def checkMassBalance(self) -> java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']: ... + @typing.overload + def checkMassBalance(self, string: typing.Union[java.lang.String, str]) -> java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']: ... + def checkModulesRecycles(self) -> None: ... + def copy(self) -> 'ProcessModule': ... + def getAddedModules(self) -> java.util.List['ProcessModule']: ... + def getAddedUnitOperations(self) -> java.util.List['ProcessSystem']: ... + @typing.overload + def getFailedMassBalance(self) -> java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']: ... + @typing.overload + def getFailedMassBalance(self, double: float) -> java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']: ... + @typing.overload + def getFailedMassBalance(self, string: typing.Union[java.lang.String, str], double: float) -> java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']: ... + def getMeasurementDevice(self, string: typing.Union[java.lang.String, str]) -> typing.Any: ... + def getModulesIndex(self) -> java.util.List[int]: ... + def getOperationsIndex(self) -> java.util.List[int]: ... + def getReport(self) -> java.util.ArrayList[typing.MutableSequence[java.lang.String]]: ... + def getReport_json(self) -> java.lang.String: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> typing.Any: ... + def recyclesSolved(self) -> bool: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def runAsTask(self) -> java.util.concurrent.Future[typing.Any]: ... + def runAsThread(self) -> java.lang.Thread: ... + @typing.overload + def run_step(self) -> None: ... + @typing.overload + def run_step(self, uUID: java.util.UUID) -> None: ... + def solved(self) -> bool: ... + +class ProcessSystem(jneqsim.process.SimulationBaseClass): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def add(self, int: int, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + @typing.overload + def add(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + @typing.overload + def add(self, processEquipmentInterfaceArray: typing.Union[typing.List[jneqsim.process.equipment.ProcessEquipmentInterface], jpype.JArray]) -> None: ... + @typing.overload + def add(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface) -> None: ... + _addUnit_0__T = typing.TypeVar('_addUnit_0__T', bound=jneqsim.process.equipment.ProcessEquipmentInterface) # + _addUnit_1__T = typing.TypeVar('_addUnit_1__T', bound=jneqsim.process.equipment.ProcessEquipmentInterface) # + _addUnit_2__T = typing.TypeVar('_addUnit_2__T', bound=jneqsim.process.equipment.ProcessEquipmentInterface) # + _addUnit_3__T = typing.TypeVar('_addUnit_3__T', bound=jneqsim.process.equipment.ProcessEquipmentInterface) # + _addUnit_5__T = typing.TypeVar('_addUnit_5__T', bound=jneqsim.process.equipment.ProcessEquipmentInterface) # + @typing.overload + def addUnit(self, string: typing.Union[java.lang.String, str]) -> _addUnit_0__T: ... + @typing.overload + def addUnit(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> _addUnit_1__T: ... + @typing.overload + def addUnit(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> _addUnit_2__T: ... + @typing.overload + def addUnit(self, string: typing.Union[java.lang.String, str], equipmentEnum: jneqsim.process.equipment.EquipmentEnum) -> _addUnit_3__T: ... + @typing.overload + def addUnit(self, string: typing.Union[java.lang.String, str], processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + @typing.overload + def addUnit(self, equipmentEnum: jneqsim.process.equipment.EquipmentEnum) -> _addUnit_5__T: ... + @typing.overload + def addUnit(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + @typing.overload + def checkMassBalance(self) -> java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']: ... + @typing.overload + def checkMassBalance(self, string: typing.Union[java.lang.String, str]) -> java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']: ... + def clear(self) -> None: ... + def clearAll(self) -> None: ... + def clearHistory(self) -> None: ... + def copy(self) -> 'ProcessSystem': ... + def displayResult(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def exportToGraphviz(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def exportToGraphviz(self, string: typing.Union[java.lang.String, str], graphvizExportOptions: 'ProcessSystemGraphvizExporter.GraphvizExportOptions') -> None: ... + def getAlarmManager(self) -> jneqsim.process.alarm.ProcessAlarmManager: ... + def getAllUnitNames(self) -> java.util.ArrayList[java.lang.String]: ... + def getBottleneck(self) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + def getConditionMonitor(self) -> jneqsim.process.conditionmonitor.ConditionMonitor: ... + def getCoolerDuty(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getExergyChange(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getFailedMassBalance(self) -> java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']: ... + @typing.overload + def getFailedMassBalance(self, double: float) -> java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']: ... + @typing.overload + def getFailedMassBalance(self, string: typing.Union[java.lang.String, str], double: float) -> java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']: ... + @typing.overload + def getFailedMassBalanceReport(self) -> java.lang.String: ... + @typing.overload + def getFailedMassBalanceReport(self, double: float) -> java.lang.String: ... + @typing.overload + def getFailedMassBalanceReport(self, string: typing.Union[java.lang.String, str], double: float) -> java.lang.String: ... + def getHeaterDuty(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getHistoryCapacity(self) -> int: ... + def getHistorySize(self) -> int: ... + def getHistorySnapshot(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getMassBalanceErrorThreshold(self) -> float: ... + @typing.overload + def getMassBalanceReport(self) -> java.lang.String: ... + @typing.overload + def getMassBalanceReport(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + def getMeasurementDevice(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.measurementdevice.MeasurementDeviceInterface: ... + def getMinimumFlowForMassBalanceError(self) -> float: ... + def getName(self) -> java.lang.String: ... + def getPower(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getReport_json(self) -> java.lang.String: ... + def getSurroundingTemperature(self) -> float: ... + @typing.overload + def getTime(self) -> float: ... + @typing.overload + def getTime(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getTimeStep(self) -> float: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + def getUnitNumber(self, string: typing.Union[java.lang.String, str]) -> int: ... + def getUnitOperations(self) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... + def hasUnitName(self, string: typing.Union[java.lang.String, str]) -> bool: ... + def hashCode(self) -> int: ... + def isRunStep(self) -> bool: ... + def loadProcessFromYaml(self, file: typing.Union[java.io.File, jpype.protocol.SupportsPath]) -> None: ... + @staticmethod + def open(string: typing.Union[java.lang.String, str]) -> 'ProcessSystem': ... + def printLogFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def removeUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + def replaceObject(self, string: typing.Union[java.lang.String, str], processEquipmentBaseClass: jneqsim.process.equipment.ProcessEquipmentBaseClass) -> None: ... + def replaceUnit(self, string: typing.Union[java.lang.String, str], processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> bool: ... + def reportMeasuredValues(self) -> None: ... + def reportResults(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def reset(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def runAsTask(self) -> java.util.concurrent.Future[typing.Any]: ... + def runAsThread(self) -> java.lang.Thread: ... + @typing.overload + def runTransient(self, double: float) -> None: ... + @typing.overload + def runTransient(self) -> None: ... + @typing.overload + def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... + @typing.overload + def run_step(self) -> None: ... + @typing.overload + def run_step(self, uUID: java.util.UUID) -> None: ... + def save(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setFluid(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface) -> None: ... + @typing.overload + def setFluid(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface, boolean: bool) -> None: ... + def setHistoryCapacity(self, int: int) -> None: ... + def setMassBalanceErrorThreshold(self, double: float) -> None: ... + def setMinimumFlowForMassBalanceError(self, double: float) -> None: ... + def setName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setRunStep(self, boolean: bool) -> None: ... + def setSurroundingTemperature(self, double: float) -> None: ... + def setTimeStep(self, double: float) -> None: ... + def size(self) -> int: ... + def solved(self) -> bool: ... + def storeInitialState(self) -> None: ... + def view(self) -> None: ... + class MassBalanceResult: + def __init__(self, double: float, double2: float, string: typing.Union[java.lang.String, str]): ... + def getAbsoluteError(self) -> float: ... + def getPercentError(self) -> float: ... + def getUnit(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class ProcessSystemGraphvizExporter: + def __init__(self): ... + @typing.overload + def export(self, processSystem: ProcessSystem, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def export(self, processSystem: ProcessSystem, string: typing.Union[java.lang.String, str], graphvizExportOptions: 'ProcessSystemGraphvizExporter.GraphvizExportOptions') -> None: ... + class GraphvizExportOptions: + @staticmethod + def builder() -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder': ... + @staticmethod + def defaults() -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions': ... + def getFlowRateUnit(self) -> java.lang.String: ... + def getPressureUnit(self) -> java.lang.String: ... + def getTablePlacement(self) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.TablePlacement': ... + def getTemperatureUnit(self) -> java.lang.String: ... + def includeStreamFlowRates(self) -> bool: ... + def includeStreamPressures(self) -> bool: ... + def includeStreamPropertyTable(self) -> bool: ... + def includeStreamTemperatures(self) -> bool: ... + def includeTableFlowRates(self) -> bool: ... + def includeTablePressures(self) -> bool: ... + def includeTableTemperatures(self) -> bool: ... + class Builder: + def build(self) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions': ... + def flowRateUnit(self, string: typing.Union[java.lang.String, str]) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder': ... + def includeStreamFlowRates(self, boolean: bool) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder': ... + def includeStreamPressures(self, boolean: bool) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder': ... + def includeStreamPropertyTable(self, boolean: bool) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder': ... + def includeStreamTemperatures(self, boolean: bool) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder': ... + def includeTableFlowRates(self, boolean: bool) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder': ... + def includeTablePressures(self, boolean: bool) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder': ... + def includeTableTemperatures(self, boolean: bool) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder': ... + def pressureUnit(self, string: typing.Union[java.lang.String, str]) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder': ... + def tablePlacement(self, tablePlacement: 'ProcessSystemGraphvizExporter.GraphvizExportOptions.TablePlacement') -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder': ... + def temperatureUnit(self, string: typing.Union[java.lang.String, str]) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder': ... + class TablePlacement(java.lang.Enum['ProcessSystemGraphvizExporter.GraphvizExportOptions.TablePlacement']): + ABOVE: typing.ClassVar['ProcessSystemGraphvizExporter.GraphvizExportOptions.TablePlacement'] = ... + BELOW: typing.ClassVar['ProcessSystemGraphvizExporter.GraphvizExportOptions.TablePlacement'] = ... + _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]) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.TablePlacement': ... + @staticmethod + def values() -> typing.MutableSequence['ProcessSystemGraphvizExporter.GraphvizExportOptions.TablePlacement']: ... + +class XmlUtil: + @staticmethod + def createDocumentBuilder() -> javax.xml.parsers.DocumentBuilder: ... + +class ProcessModuleBaseClass(jneqsim.process.SimulationBaseClass, ModuleInterface): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def calcDesign(self) -> None: ... + def displayResult(self) -> None: ... + def getConditionAnalysisMessage(self) -> java.lang.String: ... + def getController(self) -> jneqsim.process.controllerdevice.ControllerDeviceInterface: ... + def getEntropyProduction(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergyChange(self, string: typing.Union[java.lang.String, str], double: float) -> float: ... + @typing.overload + def getMassBalance(self) -> float: ... + @typing.overload + def getMassBalance(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.MechanicalDesign: ... + def getOperations(self) -> ProcessSystem: ... + def getPreferedThermodynamicModel(self) -> java.lang.String: ... + @typing.overload + def getPressure(self) -> float: ... + @typing.overload + def getPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getReport_json(self) -> java.lang.String: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getSpecification(self) -> java.lang.String: ... + @typing.overload + def getTemperature(self) -> float: ... + @typing.overload + def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> typing.Any: ... + def isCalcDesign(self) -> bool: ... + def reportResults(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def runConditionAnalysis(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + @typing.overload + def runTransient(self, double: float) -> None: ... + @typing.overload + def runTransient(self, double: float, uUID: java.util.UUID) -> None: ... + @typing.overload + def run_step(self) -> None: ... + @typing.overload + def run_step(self, uUID: java.util.UUID) -> None: ... + def setController(self, controllerDeviceInterface: jneqsim.process.controllerdevice.ControllerDeviceInterface) -> None: ... + def setDesign(self) -> None: ... + def setIsCalcDesign(self, boolean: bool) -> None: ... + def setPreferedThermodynamicModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPressure(self, double: float) -> None: ... + @typing.overload + def setProperty(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + @typing.overload + def setProperty(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + def setRegulatorOutSignal(self, double: float) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def setTemperature(self, double: float) -> None: ... + def solved(self) -> bool: ... + @typing.overload + def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + @typing.overload + def toJson(self) -> java.lang.String: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.processmodel")``. + + DexpiMetadata: typing.Type[DexpiMetadata] + DexpiProcessUnit: typing.Type[DexpiProcessUnit] + DexpiRoundTripProfile: typing.Type[DexpiRoundTripProfile] + DexpiStream: typing.Type[DexpiStream] + DexpiXmlReader: typing.Type[DexpiXmlReader] + DexpiXmlReaderException: typing.Type[DexpiXmlReaderException] + DexpiXmlWriter: typing.Type[DexpiXmlWriter] + ModuleInterface: typing.Type[ModuleInterface] + ProcessLoader: typing.Type[ProcessLoader] + ProcessModel: typing.Type[ProcessModel] + ProcessModule: typing.Type[ProcessModule] + ProcessModuleBaseClass: typing.Type[ProcessModuleBaseClass] + ProcessSystem: typing.Type[ProcessSystem] + ProcessSystemGraphvizExporter: typing.Type[ProcessSystemGraphvizExporter] + XmlUtil: typing.Type[XmlUtil] + processmodules: jneqsim.process.processmodel.processmodules.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/processmodules/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/processmodules/__init__.pyi new file mode 100644 index 00000000..e087cba1 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/processmodules/__init__.pyi @@ -0,0 +1,222 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.processmodel +import typing + + + +class AdsorptionDehydrationlModule(jneqsim.process.processmodel.ProcessModuleBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addInputStream(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcDesign(self) -> None: ... + def getOutputStream(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + def initializeModule(self) -> None: ... + def initializeStreams(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setDesign(self) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + +class CO2RemovalModule(jneqsim.process.processmodel.ProcessModuleBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addInputStream(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcDesign(self) -> None: ... + def getOutputStream(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def initializeModule(self) -> None: ... + def initializeStreams(self) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setDesign(self) -> None: ... + +class DPCUModule(jneqsim.process.processmodel.ProcessModuleBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addInputStream(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcDesign(self) -> None: ... + def displayResult(self) -> None: ... + def getOutputStream(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def initializeModule(self) -> None: ... + def initializeStreams(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setDesign(self) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + +class GlycolDehydrationlModule(jneqsim.process.processmodel.ProcessModuleBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addInputStream(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcDesign(self) -> None: ... + def calcGlycolConcentration(self, double: float) -> float: ... + def calcKglycol(self) -> float: ... + def displayResult(self) -> None: ... + def getFlashPressure(self) -> float: ... + def getOutputStream(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def initializeModule(self) -> None: ... + def initializeStreams(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setDesign(self) -> None: ... + def setFlashPressure(self, double: float) -> None: ... + @typing.overload + def setProperty(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + @typing.overload + def setProperty(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + def solveAbsorptionFactor(self, double: float) -> float: ... + +class MEGReclaimerModule(jneqsim.process.processmodel.ProcessModuleBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addInputStream(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcDesign(self) -> None: ... + def getOutputStream(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def initializeModule(self) -> None: ... + def initializeStreams(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setDesign(self) -> None: ... + def setOperationPressure(self, double: float) -> None: ... + +class MixerGasProcessingModule(jneqsim.process.processmodel.ProcessModuleBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addInputStream(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcDesign(self) -> None: ... + def getOutputStream(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def initializeModule(self) -> None: ... + def initializeStreams(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setDesign(self) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + +class PropaneCoolingModule(jneqsim.process.processmodel.ProcessModuleBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addInputStream(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcDesign(self) -> None: ... + def getOutputStream(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def initializeModule(self) -> None: ... + def initializeStreams(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setCondenserTemperature(self, double: float) -> None: ... + def setDesign(self) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def setVaporizerTemperature(self, double: float) -> None: ... + +class SeparationTrainModule(jneqsim.process.processmodel.ProcessModuleBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addInputStream(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcDesign(self) -> None: ... + def getOutputStream(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def initializeModule(self) -> None: ... + def initializeStreams(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setDesign(self) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + +class SeparationTrainModuleSimple(jneqsim.process.processmodel.ProcessModuleBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addInputStream(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcDesign(self) -> None: ... + def getOutputStream(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def initializeModule(self) -> None: ... + def initializeStreams(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setDesign(self) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + +class WellFluidModule(jneqsim.process.processmodel.ProcessModuleBaseClass): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addInputStream(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + def calcDesign(self) -> None: ... + def getOutputStream(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.equipment.stream.StreamInterface: ... + def initializeModule(self) -> None: ... + def initializeStreams(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def run(self) -> None: ... + @typing.overload + def run(self, uUID: java.util.UUID) -> None: ... + def setDesign(self) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setSpecification(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.processmodel.processmodules")``. + + AdsorptionDehydrationlModule: typing.Type[AdsorptionDehydrationlModule] + CO2RemovalModule: typing.Type[CO2RemovalModule] + DPCUModule: typing.Type[DPCUModule] + GlycolDehydrationlModule: typing.Type[GlycolDehydrationlModule] + MEGReclaimerModule: typing.Type[MEGReclaimerModule] + MixerGasProcessingModule: typing.Type[MixerGasProcessingModule] + PropaneCoolingModule: typing.Type[PropaneCoolingModule] + SeparationTrainModule: typing.Type[SeparationTrainModule] + SeparationTrainModuleSimple: typing.Type[SeparationTrainModuleSimple] + WellFluidModule: typing.Type[WellFluidModule] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/safety/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/safety/__init__.pyi new file mode 100644 index 00000000..ce1965cb --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/safety/__init__.pyi @@ -0,0 +1,101 @@ + +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 java.util.function +import jneqsim.process.equipment +import jneqsim.process.equipment.flare +import jneqsim.process.processmodel +import jneqsim.process.safety.dto +import typing + + + +class DisposalNetwork(java.io.Serializable): + def __init__(self): ... + def evaluate(self, list: java.util.List['ProcessSafetyLoadCase']) -> jneqsim.process.safety.dto.DisposalNetworkSummaryDTO: ... + def mapSourceToDisposal(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def registerDisposalUnit(self, flare: jneqsim.process.equipment.flare.Flare) -> None: ... + +class ProcessSafetyAnalysisSummary(java.io.Serializable): + def __init__(self, string: typing.Union[java.lang.String, str], set: java.util.Set[typing.Union[java.lang.String, str]], string2: typing.Union[java.lang.String, str], map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Union[java.lang.String, str]], typing.Mapping[typing.Union[java.lang.String, str], typing.Union[java.lang.String, str]]], map2: typing.Union[java.util.Map[typing.Union[java.lang.String, str], 'ProcessSafetyAnalysisSummary.UnitKpiSnapshot'], typing.Mapping[typing.Union[java.lang.String, str], 'ProcessSafetyAnalysisSummary.UnitKpiSnapshot']]): ... + def getAffectedUnits(self) -> java.util.Set[java.lang.String]: ... + def getConditionMessages(self) -> java.util.Map[java.lang.String, java.lang.String]: ... + def getConditionMonitorReport(self) -> java.lang.String: ... + def getScenarioName(self) -> java.lang.String: ... + def getUnitKpis(self) -> java.util.Map[java.lang.String, 'ProcessSafetyAnalysisSummary.UnitKpiSnapshot']: ... + class UnitKpiSnapshot(java.io.Serializable): + def __init__(self, double: float, double2: float, double3: float): ... + def getMassBalance(self) -> float: ... + def getPressure(self) -> float: ... + def getTemperature(self) -> float: ... + +class ProcessSafetyAnalyzer(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem): ... + @typing.overload + def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem, processSafetyResultRepository: typing.Union['ProcessSafetyResultRepository', typing.Callable]): ... + def addLoadCase(self, processSafetyLoadCase: 'ProcessSafetyLoadCase') -> None: ... + @typing.overload + def analyze(self, collection: typing.Union[java.util.Collection['ProcessSafetyScenario'], typing.Sequence['ProcessSafetyScenario'], typing.Set['ProcessSafetyScenario']]) -> java.util.List[ProcessSafetyAnalysisSummary]: ... + @typing.overload + def analyze(self, processSafetyScenario: 'ProcessSafetyScenario') -> ProcessSafetyAnalysisSummary: ... + @typing.overload + def analyze(self) -> jneqsim.process.safety.dto.DisposalNetworkSummaryDTO: ... + def getLoadCases(self) -> java.util.List['ProcessSafetyLoadCase']: ... + def mapSourceToDisposal(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def registerDisposalUnit(self, flare: jneqsim.process.equipment.flare.Flare) -> None: ... + +class ProcessSafetyLoadCase(java.io.Serializable): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addReliefSource(self, string: typing.Union[java.lang.String, str], reliefSourceLoad: 'ProcessSafetyLoadCase.ReliefSourceLoad') -> None: ... + def getName(self) -> java.lang.String: ... + def getReliefLoads(self) -> java.util.Map[java.lang.String, 'ProcessSafetyLoadCase.ReliefSourceLoad']: ... + class ReliefSourceLoad(java.io.Serializable): + def __init__(self, double: float, double2: float, double3: float): ... + def getHeatDutyW(self) -> float: ... + def getMassRateKgS(self) -> float: ... + def getMolarRateMoleS(self) -> float: ... + +class ProcessSafetyResultRepository: + def findAll(self) -> java.util.List[ProcessSafetyAnalysisSummary]: ... + def save(self, processSafetyAnalysisSummary: ProcessSafetyAnalysisSummary) -> None: ... + +class ProcessSafetyScenario(java.io.Serializable): + def applyTo(self, processSystem: jneqsim.process.processmodel.ProcessSystem) -> None: ... + @staticmethod + def builder(string: typing.Union[java.lang.String, str]) -> 'ProcessSafetyScenario.Builder': ... + def getBlockedOutletUnits(self) -> java.util.List[java.lang.String]: ... + def getControllerSetPointOverrides(self) -> java.util.Map[java.lang.String, float]: ... + def getCustomManipulators(self) -> java.util.Map[java.lang.String, java.util.function.Consumer[jneqsim.process.equipment.ProcessEquipmentInterface]]: ... + def getName(self) -> java.lang.String: ... + def getTargetUnits(self) -> java.util.Set[java.lang.String]: ... + def getUtilityLossUnits(self) -> java.util.List[java.lang.String]: ... + class Builder: + def blockOutlet(self, string: typing.Union[java.lang.String, str]) -> 'ProcessSafetyScenario.Builder': ... + def blockOutlets(self, collection: typing.Union[java.util.Collection[typing.Union[java.lang.String, str]], typing.Sequence[typing.Union[java.lang.String, str]], typing.Set[typing.Union[java.lang.String, str]]]) -> 'ProcessSafetyScenario.Builder': ... + def build(self) -> 'ProcessSafetyScenario': ... + def controllerSetPoint(self, string: typing.Union[java.lang.String, str], double: float) -> 'ProcessSafetyScenario.Builder': ... + def customManipulator(self, string: typing.Union[java.lang.String, str], consumer: typing.Union[java.util.function.Consumer[jneqsim.process.equipment.ProcessEquipmentInterface], typing.Callable[[jneqsim.process.equipment.ProcessEquipmentInterface], None]]) -> 'ProcessSafetyScenario.Builder': ... + def utilityLoss(self, string: typing.Union[java.lang.String, str]) -> 'ProcessSafetyScenario.Builder': ... + def utilityLosses(self, collection: typing.Union[java.util.Collection[typing.Union[java.lang.String, str]], typing.Sequence[typing.Union[java.lang.String, str]], typing.Set[typing.Union[java.lang.String, str]]]) -> 'ProcessSafetyScenario.Builder': ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.safety")``. + + DisposalNetwork: typing.Type[DisposalNetwork] + ProcessSafetyAnalysisSummary: typing.Type[ProcessSafetyAnalysisSummary] + ProcessSafetyAnalyzer: typing.Type[ProcessSafetyAnalyzer] + ProcessSafetyLoadCase: typing.Type[ProcessSafetyLoadCase] + ProcessSafetyResultRepository: typing.Type[ProcessSafetyResultRepository] + ProcessSafetyScenario: typing.Type[ProcessSafetyScenario] + dto: jneqsim.process.safety.dto.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/safety/dto/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/safety/dto/__init__.pyi new file mode 100644 index 00000000..27f08fba --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/safety/dto/__init__.pyi @@ -0,0 +1,43 @@ + +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 jneqsim.process.equipment.flare.dto +import typing + + + +class CapacityAlertDTO(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]): ... + def getDisposalUnitName(self) -> java.lang.String: ... + def getLoadCaseName(self) -> java.lang.String: ... + def getMessage(self) -> java.lang.String: ... + +class DisposalLoadCaseResultDTO(java.io.Serializable): + def __init__(self, string: typing.Union[java.lang.String, str], map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], jneqsim.process.equipment.flare.dto.FlarePerformanceDTO], typing.Mapping[typing.Union[java.lang.String, str], jneqsim.process.equipment.flare.dto.FlarePerformanceDTO]], double: float, double2: float, list: java.util.List[CapacityAlertDTO]): ... + def getAlerts(self) -> java.util.List[CapacityAlertDTO]: ... + def getLoadCaseName(self) -> java.lang.String: ... + def getMaxRadiationDistanceM(self) -> float: ... + def getPerformanceByUnit(self) -> java.util.Map[java.lang.String, jneqsim.process.equipment.flare.dto.FlarePerformanceDTO]: ... + def getTotalHeatDutyMW(self) -> float: ... + +class DisposalNetworkSummaryDTO(java.io.Serializable): + def __init__(self, list: java.util.List[DisposalLoadCaseResultDTO], double: float, double2: float, list2: java.util.List[CapacityAlertDTO]): ... + def getAlerts(self) -> java.util.List[CapacityAlertDTO]: ... + def getLoadCaseResults(self) -> java.util.List[DisposalLoadCaseResultDTO]: ... + def getMaxHeatDutyMW(self) -> float: ... + def getMaxRadiationDistanceM(self) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.safety.dto")``. + + CapacityAlertDTO: typing.Type[CapacityAlertDTO] + DisposalLoadCaseResultDTO: typing.Type[DisposalLoadCaseResultDTO] + DisposalNetworkSummaryDTO: typing.Type[DisposalNetworkSummaryDTO] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/__init__.pyi new file mode 100644 index 00000000..501df3fc --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/__init__.pyi @@ -0,0 +1,27 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.process.util.example +import jneqsim.process.util.fielddevelopment +import jneqsim.process.util.fire +import jneqsim.process.util.monitor +import jneqsim.process.util.optimization +import jneqsim.process.util.report +import jneqsim.process.util.scenario +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.util")``. + + example: jneqsim.process.util.example.__module_protocol__ + fielddevelopment: jneqsim.process.util.fielddevelopment.__module_protocol__ + fire: jneqsim.process.util.fire.__module_protocol__ + monitor: jneqsim.process.util.monitor.__module_protocol__ + optimization: jneqsim.process.util.optimization.__module_protocol__ + report: jneqsim.process.util.report.__module_protocol__ + scenario: jneqsim.process.util.scenario.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/example/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/example/__init__.pyi new file mode 100644 index 00000000..82737301 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/example/__init__.pyi @@ -0,0 +1,113 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import typing + + + +class AdvancedProcessLogicExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class ConfigurableLogicExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class DynamicLogicExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class ESDBlowdownSystemExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class ESDLogicExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class ESDValveExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class FireGasSISExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class HIPPSExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class HIPPSWithESDExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class IntegratedSafetySystemExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class IntegratedSafetySystemWithLogicExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class ProcessLogicAlarmIntegratedExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class ProcessLogicIntegratedExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class SelectiveLogicExecutionExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class SeparatorFireDepressurizationExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class SeparatorHeatInputExample: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.util.example")``. + + AdvancedProcessLogicExample: typing.Type[AdvancedProcessLogicExample] + ConfigurableLogicExample: typing.Type[ConfigurableLogicExample] + DynamicLogicExample: typing.Type[DynamicLogicExample] + ESDBlowdownSystemExample: typing.Type[ESDBlowdownSystemExample] + ESDLogicExample: typing.Type[ESDLogicExample] + ESDValveExample: typing.Type[ESDValveExample] + FireGasSISExample: typing.Type[FireGasSISExample] + HIPPSExample: typing.Type[HIPPSExample] + HIPPSWithESDExample: typing.Type[HIPPSWithESDExample] + IntegratedSafetySystemExample: typing.Type[IntegratedSafetySystemExample] + IntegratedSafetySystemWithLogicExample: typing.Type[IntegratedSafetySystemWithLogicExample] + ProcessLogicAlarmIntegratedExample: typing.Type[ProcessLogicAlarmIntegratedExample] + ProcessLogicIntegratedExample: typing.Type[ProcessLogicIntegratedExample] + SelectiveLogicExecutionExample: typing.Type[SelectiveLogicExecutionExample] + SeparatorFireDepressurizationExample: typing.Type[SeparatorFireDepressurizationExample] + SeparatorHeatInputExample: typing.Type[SeparatorHeatInputExample] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/fielddevelopment/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/fielddevelopment/__init__.pyi new file mode 100644 index 00000000..442c8db3 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/fielddevelopment/__init__.pyi @@ -0,0 +1,362 @@ + +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.time +import java.util +import java.util.function +import jneqsim.process.equipment.reservoir +import jneqsim.process.equipment.stream +import jneqsim.process.processmodel +import jneqsim.process.util.optimization +import typing + + + +class FacilityCapacity(java.io.Serializable): + DEFAULT_NEAR_BOTTLENECK_THRESHOLD: typing.ClassVar[float] = ... + DEFAULT_CAPACITY_INCREASE_FACTOR: typing.ClassVar[float] = ... + def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem): ... + def analyzeOverFieldLife(self, productionForecast: 'ProductionProfile.ProductionForecast', streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> java.util.List['FacilityCapacity.CapacityPeriod']: ... + def assess(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface, double: float, double2: float, string: typing.Union[java.lang.String, str]) -> 'FacilityCapacity.CapacityAssessment': ... + def calculateDebottleneckNPV(self, debottleneckOption: 'FacilityCapacity.DebottleneckOption', double: float, double2: float, double3: float, int: int) -> float: ... + def compareDebottleneckScenarios(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface, list: java.util.List['FacilityCapacity.DebottleneckOption'], double: float, double2: float, string: typing.Union[java.lang.String, str]) -> jneqsim.process.util.optimization.ProductionOptimizer.ScenarioComparisonResult: ... + def getFacility(self) -> jneqsim.process.processmodel.ProcessSystem: ... + def getNearBottleneckThreshold(self) -> float: ... + def setCapacityIncreaseFactor(self, double: float) -> None: ... + def setCostFactorForName(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def setCostFactorForType(self, class_: typing.Type[typing.Any], double: float) -> None: ... + def setNearBottleneckThreshold(self, double: float) -> None: ... + class CapacityAssessment(java.io.Serializable): + def __init__(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], double2: float, list: java.util.List[jneqsim.process.util.optimization.ProductionOptimizer.UtilizationRecord], list2: java.util.List[typing.Union[java.lang.String, str]], list3: java.util.List['FacilityCapacity.DebottleneckOption'], map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]], boolean: bool): ... + def getBottleneckUtilization(self) -> float: ... + def getCurrentBottleneck(self) -> java.lang.String: ... + def getCurrentMaxRate(self) -> float: ... + def getDebottleneckOptions(self) -> java.util.List['FacilityCapacity.DebottleneckOption']: ... + def getEquipmentHeadroom(self) -> java.util.Map[java.lang.String, float]: ... + def getNearBottlenecks(self) -> java.util.List[java.lang.String]: ... + def getRateUnit(self) -> java.lang.String: ... + def getTopOptions(self, int: int) -> java.util.List['FacilityCapacity.DebottleneckOption']: ... + def getTotalPotentialGain(self) -> float: ... + def getUtilizationRecords(self) -> java.util.List[jneqsim.process.util.optimization.ProductionOptimizer.UtilizationRecord]: ... + def isFeasible(self) -> bool: ... + def toMarkdown(self) -> java.lang.String: ... + class CapacityPeriod(java.io.Serializable): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], double2: float, string3: typing.Union[java.lang.String, str], string4: typing.Union[java.lang.String, str], double3: float, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]], list: java.util.List[typing.Union[java.lang.String, str]], boolean: bool): ... + def getBottleneckEquipment(self) -> java.lang.String: ... + def getBottleneckUtilization(self) -> float: ... + def getEquipmentUtilizations(self) -> java.util.Map[java.lang.String, float]: ... + def getMaxFacilityRate(self) -> float: ... + def getNearBottlenecks(self) -> java.util.List[java.lang.String]: ... + def getPeriodName(self) -> java.lang.String: ... + def getRateUnit(self) -> java.lang.String: ... + def getTime(self) -> float: ... + def getTimeUnit(self) -> java.lang.String: ... + def isFacilityConstrained(self) -> bool: ... + class DebottleneckOption(java.io.Serializable, java.lang.Comparable['FacilityCapacity.DebottleneckOption']): + def __init__(self, string: typing.Union[java.lang.String, str], class_: typing.Type[typing.Any], string2: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float, string3: typing.Union[java.lang.String, str], double5: float, string4: typing.Union[java.lang.String, str], double6: float, double7: float): ... + def compareTo(self, debottleneckOption: 'FacilityCapacity.DebottleneckOption') -> int: ... + def getCapacityIncreasePercent(self) -> float: ... + def getCapex(self) -> float: ... + def getCurrency(self) -> java.lang.String: ... + def getCurrentCapacity(self) -> float: ... + def getCurrentUtilization(self) -> float: ... + def getDescription(self) -> java.lang.String: ... + def getEquipmentName(self) -> java.lang.String: ... + def getEquipmentType(self) -> typing.Type[typing.Any]: ... + def getIncrementalProduction(self) -> float: ... + def getNpv(self) -> float: ... + def getPaybackYears(self) -> float: ... + def getRateUnit(self) -> java.lang.String: ... + def getUpgradedCapacity(self) -> float: ... + def toString(self) -> java.lang.String: ... + +class ProductionProfile(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem): ... + @staticmethod + def calculateCumulativeProduction(declineParameters: 'ProductionProfile.DeclineParameters', double: float) -> float: ... + @staticmethod + def calculateRate(declineParameters: 'ProductionProfile.DeclineParameters', double: float) -> float: ... + def fitDecline(self, list: java.util.List[float], list2: java.util.List[float], declineType: 'ProductionProfile.DeclineType', string: typing.Union[java.lang.String, str]) -> 'ProductionProfile.DeclineParameters': ... + def forecast(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface, declineParameters: 'ProductionProfile.DeclineParameters', double: float, double2: float, double3: float, double4: float, double5: float) -> 'ProductionProfile.ProductionForecast': ... + def getFacility(self) -> jneqsim.process.processmodel.ProcessSystem: ... + class DeclineParameters(java.io.Serializable): + @typing.overload + def __init__(self, double: float, double2: float, double3: float, declineType: 'ProductionProfile.DeclineType', string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, double: float, double2: float, double3: float, declineType: 'ProductionProfile.DeclineType', string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, double: float, double2: float, declineType: 'ProductionProfile.DeclineType', string: typing.Union[java.lang.String, str]): ... + def getDeclineRate(self) -> float: ... + def getHyperbolicExponent(self) -> float: ... + def getInitialRate(self) -> float: ... + def getRateUnit(self) -> java.lang.String: ... + def getTimeUnit(self) -> java.lang.String: ... + def getType(self) -> 'ProductionProfile.DeclineType': ... + def toString(self) -> java.lang.String: ... + def withInitialRate(self, double: float) -> 'ProductionProfile.DeclineParameters': ... + class DeclineType(java.lang.Enum['ProductionProfile.DeclineType']): + EXPONENTIAL: typing.ClassVar['ProductionProfile.DeclineType'] = ... + HYPERBOLIC: typing.ClassVar['ProductionProfile.DeclineType'] = ... + HARMONIC: typing.ClassVar['ProductionProfile.DeclineType'] = ... + _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]) -> 'ProductionProfile.DeclineType': ... + @staticmethod + def values() -> typing.MutableSequence['ProductionProfile.DeclineType']: ... + class ProductionForecast(java.io.Serializable): + def __init__(self, list: java.util.List['ProductionProfile.ProductionPoint'], double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, declineParameters: 'ProductionProfile.DeclineParameters'): ... + def getActualPlateauDuration(self) -> float: ... + def getActualPlateauRate(self) -> float: ... + def getDeclineParams(self) -> 'ProductionProfile.DeclineParameters': ... + def getEconomicLifeYears(self) -> float: ... + def getEconomicLimit(self) -> float: ... + def getPlateauDuration(self) -> float: ... + def getPlateauRate(self) -> float: ... + def getProfile(self) -> java.util.List['ProductionProfile.ProductionPoint']: ... + def getTotalRecovery(self) -> float: ... + def toCSV(self) -> java.lang.String: ... + def toMarkdownTable(self) -> java.lang.String: ... + class ProductionPoint(java.io.Serializable): + def __init__(self, double: float, string: typing.Union[java.lang.String, str], double2: float, double3: float, string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str], double4: float, boolean: bool, boolean2: bool): ... + def getBottleneckEquipment(self) -> java.lang.String: ... + def getCumulativeProduction(self) -> float: ... + def getFacilityUtilization(self) -> float: ... + def getRate(self) -> float: ... + def getRateUnit(self) -> java.lang.String: ... + def getTime(self) -> float: ... + def getTimeUnit(self) -> java.lang.String: ... + def isAboveEconomicLimit(self) -> bool: ... + def isOnPlateau(self) -> bool: ... + +class SensitivityAnalysis(java.io.Serializable): + DEFAULT_NUMBER_OF_TRIALS: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem): ... + @typing.overload + def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem, random: java.util.Random): ... + def addParameter(self, uncertainParameter: 'SensitivityAnalysis.UncertainParameter') -> 'SensitivityAnalysis': ... + def clearParameters(self) -> 'SensitivityAnalysis': ... + def getBaseProcess(self) -> jneqsim.process.processmodel.ProcessSystem: ... + def getParameters(self) -> java.util.List['SensitivityAnalysis.UncertainParameter']: ... + def runMonteCarloOptimization(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface, double: float, double2: float, string: typing.Union[java.lang.String, str], toDoubleFunction: typing.Union[java.util.function.ToDoubleFunction[jneqsim.process.util.optimization.ProductionOptimizer.OptimizationResult], typing.Callable[[jneqsim.process.util.optimization.ProductionOptimizer.OptimizationResult], float]], sensitivityConfig: 'SensitivityAnalysis.SensitivityConfig') -> 'SensitivityAnalysis.MonteCarloResult': ... + def runSpiderAnalysis(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface, double: float, double2: float, string: typing.Union[java.lang.String, str], int: int, toDoubleFunction: typing.Union[java.util.function.ToDoubleFunction[jneqsim.process.util.optimization.ProductionOptimizer.OptimizationResult], typing.Callable[[jneqsim.process.util.optimization.ProductionOptimizer.OptimizationResult], float]]) -> java.util.Map[java.lang.String, java.util.List['SensitivityAnalysis.SpiderPoint']]: ... + def runTornadoAnalysis(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface, double: float, double2: float, string: typing.Union[java.lang.String, str], toDoubleFunction: typing.Union[java.util.function.ToDoubleFunction[jneqsim.process.util.optimization.ProductionOptimizer.OptimizationResult], typing.Callable[[jneqsim.process.util.optimization.ProductionOptimizer.OptimizationResult], float]]) -> java.util.Map[java.lang.String, float]: ... + def setRng(self, random: java.util.Random) -> None: ... + class DistributionType(java.lang.Enum['SensitivityAnalysis.DistributionType']): + NORMAL: typing.ClassVar['SensitivityAnalysis.DistributionType'] = ... + LOGNORMAL: typing.ClassVar['SensitivityAnalysis.DistributionType'] = ... + TRIANGULAR: typing.ClassVar['SensitivityAnalysis.DistributionType'] = ... + UNIFORM: typing.ClassVar['SensitivityAnalysis.DistributionType'] = ... + _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]) -> 'SensitivityAnalysis.DistributionType': ... + @staticmethod + def values() -> typing.MutableSequence['SensitivityAnalysis.DistributionType']: ... + class MonteCarloResult(java.io.Serializable): + def __init__(self, list: java.util.List['SensitivityAnalysis.TrialResult'], map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]], string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + def getConvergedCount(self) -> int: ... + def getFeasibleCount(self) -> int: ... + def getHistogramData(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getMax(self) -> float: ... + def getMean(self) -> float: ... + def getMin(self) -> float: ... + def getMostSensitiveParameters(self) -> java.util.List[java.lang.String]: ... + def getOutputName(self) -> java.lang.String: ... + def getOutputUnit(self) -> java.lang.String: ... + def getP10(self) -> float: ... + def getP50(self) -> float: ... + def getP90(self) -> float: ... + def getPercentile(self, double: float) -> float: ... + def getStdDev(self) -> float: ... + def getTornadoSensitivities(self) -> java.util.Map[java.lang.String, float]: ... + def getTrials(self) -> java.util.List['SensitivityAnalysis.TrialResult']: ... + def toCSV(self, list: java.util.List[typing.Union[java.lang.String, str]]) -> java.lang.String: ... + def toSummaryMarkdown(self) -> java.lang.String: ... + def toTornadoMarkdown(self) -> java.lang.String: ... + class SensitivityConfig(java.io.Serializable): + def __init__(self): ... + def getNumberOfTrials(self) -> int: ... + def getParallelThreads(self) -> int: ... + def getRandomSeed(self) -> int: ... + def includeBaseCase(self, boolean: bool) -> 'SensitivityAnalysis.SensitivityConfig': ... + def isIncludeBaseCase(self) -> bool: ... + def isParallel(self) -> bool: ... + def isUseFixedSeed(self) -> bool: ... + def numberOfTrials(self, int: int) -> 'SensitivityAnalysis.SensitivityConfig': ... + def parallel(self, boolean: bool) -> 'SensitivityAnalysis.SensitivityConfig': ... + def parallelThreads(self, int: int) -> 'SensitivityAnalysis.SensitivityConfig': ... + def randomSeed(self, long: int) -> 'SensitivityAnalysis.SensitivityConfig': ... + class SpiderPoint(java.io.Serializable): + def __init__(self, double: float, double2: float, double3: float): ... + def getNormalizedParameter(self) -> float: ... + def getOutputValue(self) -> float: ... + def getParameterValue(self) -> float: ... + class TrialResult(java.io.Serializable, java.lang.Comparable['SensitivityAnalysis.TrialResult']): + def __init__(self, int: int, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]], double: float, string: typing.Union[java.lang.String, str], boolean: bool, boolean2: bool): ... + def compareTo(self, trialResult: 'SensitivityAnalysis.TrialResult') -> int: ... + def getBottleneck(self) -> java.lang.String: ... + def getOutputValue(self) -> float: ... + def getSampledParameters(self) -> java.util.Map[java.lang.String, float]: ... + def getTrialNumber(self) -> int: ... + def isConverged(self) -> bool: ... + def isFeasible(self) -> bool: ... + class UncertainParameter(java.io.Serializable): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, distributionType: 'SensitivityAnalysis.DistributionType', string2: typing.Union[java.lang.String, str], biConsumer: typing.Union[java.util.function.BiConsumer[jneqsim.process.processmodel.ProcessSystem, float], typing.Callable[[jneqsim.process.processmodel.ProcessSystem, float], None]]): ... + def apply(self, processSystem: jneqsim.process.processmodel.ProcessSystem, double: float) -> None: ... + def getDistribution(self) -> 'SensitivityAnalysis.DistributionType': ... + def getName(self) -> java.lang.String: ... + def getP10(self) -> float: ... + def getP50(self) -> float: ... + def getP90(self) -> float: ... + def getRange(self) -> float: ... + def getUnit(self) -> java.lang.String: ... + @staticmethod + def lognormal(string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, biConsumer: typing.Union[java.util.function.BiConsumer[jneqsim.process.processmodel.ProcessSystem, float], typing.Callable[[jneqsim.process.processmodel.ProcessSystem, float], None]]) -> 'SensitivityAnalysis.UncertainParameter': ... + @staticmethod + def normal(string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, biConsumer: typing.Union[java.util.function.BiConsumer[jneqsim.process.processmodel.ProcessSystem, float], typing.Callable[[jneqsim.process.processmodel.ProcessSystem, float], None]]) -> 'SensitivityAnalysis.UncertainParameter': ... + def sample(self, random: java.util.Random) -> float: ... + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def triangular(string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, string2: typing.Union[java.lang.String, str], biConsumer: typing.Union[java.util.function.BiConsumer[jneqsim.process.processmodel.ProcessSystem, float], typing.Callable[[jneqsim.process.processmodel.ProcessSystem, float], None]]) -> 'SensitivityAnalysis.UncertainParameter': ... + @typing.overload + @staticmethod + def triangular(string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, biConsumer: typing.Union[java.util.function.BiConsumer[jneqsim.process.processmodel.ProcessSystem, float], typing.Callable[[jneqsim.process.processmodel.ProcessSystem, float], None]]) -> 'SensitivityAnalysis.UncertainParameter': ... + @staticmethod + def uniform(string: typing.Union[java.lang.String, str], double: float, double2: float, biConsumer: typing.Union[java.util.function.BiConsumer[jneqsim.process.processmodel.ProcessSystem, float], typing.Callable[[jneqsim.process.processmodel.ProcessSystem, float], None]]) -> 'SensitivityAnalysis.UncertainParameter': ... + +class WellScheduler(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, simpleReservoir: jneqsim.process.equipment.reservoir.SimpleReservoir, processSystem: jneqsim.process.processmodel.ProcessSystem): ... + def addWell(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> 'WellScheduler.WellRecord': ... + def calculateSystemAvailability(self, localDate: java.time.LocalDate, localDate2: java.time.LocalDate) -> float: ... + def getAllInterventions(self) -> java.util.List['WellScheduler.Intervention']: ... + def getAllWells(self) -> java.util.Collection['WellScheduler.WellRecord']: ... + def getFacility(self) -> jneqsim.process.processmodel.ProcessSystem: ... + def getReservoir(self) -> jneqsim.process.equipment.reservoir.SimpleReservoir: ... + def getTotalPotentialOn(self, localDate: java.time.LocalDate) -> float: ... + def getWell(self, string: typing.Union[java.lang.String, str]) -> 'WellScheduler.WellRecord': ... + def optimizeSchedule(self, localDate: java.time.LocalDate, localDate2: java.time.LocalDate, int: int) -> 'WellScheduler.ScheduleResult': ... + def scheduleIntervention(self, intervention: 'WellScheduler.Intervention') -> None: ... + def setDefaultRateUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + class Intervention(java.io.Serializable, java.lang.Comparable['WellScheduler.Intervention']): + @staticmethod + def builder(string: typing.Union[java.lang.String, str]) -> 'WellScheduler.Intervention.Builder': ... + def compareTo(self, intervention: 'WellScheduler.Intervention') -> int: ... + def getCost(self) -> float: ... + def getCurrency(self) -> java.lang.String: ... + def getDescription(self) -> java.lang.String: ... + def getDurationDays(self) -> int: ... + def getEndDate(self) -> java.time.LocalDate: ... + def getExpectedProductionGain(self) -> float: ... + def getPriority(self) -> int: ... + def getStartDate(self) -> java.time.LocalDate: ... + def getType(self) -> 'WellScheduler.InterventionType': ... + def getWellName(self) -> java.lang.String: ... + def isActiveOn(self, localDate: java.time.LocalDate) -> bool: ... + def overlaps(self, localDate: java.time.LocalDate, localDate2: java.time.LocalDate) -> bool: ... + def toString(self) -> java.lang.String: ... + class Builder: + def build(self) -> 'WellScheduler.Intervention': ... + def cost(self, double: float, string: typing.Union[java.lang.String, str]) -> 'WellScheduler.Intervention.Builder': ... + def description(self, string: typing.Union[java.lang.String, str]) -> 'WellScheduler.Intervention.Builder': ... + def durationDays(self, int: int) -> 'WellScheduler.Intervention.Builder': ... + def expectedGain(self, double: float) -> 'WellScheduler.Intervention.Builder': ... + def priority(self, int: int) -> 'WellScheduler.Intervention.Builder': ... + def startDate(self, localDate: java.time.LocalDate) -> 'WellScheduler.Intervention.Builder': ... + def type(self, interventionType: 'WellScheduler.InterventionType') -> 'WellScheduler.Intervention.Builder': ... + class InterventionType(java.lang.Enum['WellScheduler.InterventionType']): + COILED_TUBING: typing.ClassVar['WellScheduler.InterventionType'] = ... + WIRELINE: typing.ClassVar['WellScheduler.InterventionType'] = ... + HYDRAULIC_WORKOVER: typing.ClassVar['WellScheduler.InterventionType'] = ... + RIG_WORKOVER: typing.ClassVar['WellScheduler.InterventionType'] = ... + STIMULATION: typing.ClassVar['WellScheduler.InterventionType'] = ... + ARTIFICIAL_LIFT_INSTALL: typing.ClassVar['WellScheduler.InterventionType'] = ... + WATER_SHUT_OFF: typing.ClassVar['WellScheduler.InterventionType'] = ... + SCALE_TREATMENT: typing.ClassVar['WellScheduler.InterventionType'] = ... + PLUG_AND_ABANDON: typing.ClassVar['WellScheduler.InterventionType'] = ... + def getDisplayName(self) -> java.lang.String: ... + def getMaxDurationDays(self) -> int: ... + def getMinDurationDays(self) -> int: ... + _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]) -> 'WellScheduler.InterventionType': ... + @staticmethod + def values() -> typing.MutableSequence['WellScheduler.InterventionType']: ... + class ScheduleResult(java.io.Serializable): + def __init__(self, list: java.util.List['WellScheduler.Intervention'], 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, map2: typing.Union[java.util.Map[java.time.LocalDate, float], typing.Mapping[java.time.LocalDate, float]], map3: typing.Union[java.util.Map[java.time.LocalDate, typing.Union[java.lang.String, str]], typing.Mapping[java.time.LocalDate, typing.Union[java.lang.String, str]]], double3: float, string: typing.Union[java.lang.String, str]): ... + def getDailyBottleneck(self) -> java.util.Map[java.time.LocalDate, java.lang.String]: ... + def getDailyFacilityRate(self) -> java.util.Map[java.time.LocalDate, float]: ... + def getNetProductionImpact(self) -> float: ... + def getOptimizedSchedule(self) -> java.util.List['WellScheduler.Intervention']: ... + def getOverallAvailability(self) -> float: ... + def getTotalDeferredProduction(self) -> float: ... + def getTotalProductionGain(self) -> float: ... + def getWellUptime(self) -> java.util.Map[java.lang.String, float]: ... + def toGanttMarkdown(self) -> java.lang.String: ... + def toMarkdownTable(self) -> java.lang.String: ... + class WellRecord(java.io.Serializable): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]): ... + def addIntervention(self, intervention: 'WellScheduler.Intervention') -> None: ... + def calculateAvailability(self, localDate: java.time.LocalDate, localDate2: java.time.LocalDate) -> float: ... + def getCurrentPotential(self) -> float: ... + def getCurrentStatus(self) -> 'WellScheduler.WellStatus': ... + def getInterventionsInRange(self, localDate: java.time.LocalDate, localDate2: java.time.LocalDate) -> java.util.List['WellScheduler.Intervention']: ... + def getOriginalPotential(self) -> float: ... + def getRateUnit(self) -> java.lang.String: ... + def getScheduledInterventions(self) -> java.util.List['WellScheduler.Intervention']: ... + def getStatusOn(self, localDate: java.time.LocalDate) -> 'WellScheduler.WellStatus': ... + def getWellName(self) -> java.lang.String: ... + def recordProduction(self, localDate: java.time.LocalDate, double: float) -> None: ... + def setCurrentPotential(self, double: float) -> None: ... + def setStatus(self, wellStatus: 'WellScheduler.WellStatus', localDate: java.time.LocalDate) -> None: ... + class WellStatus(java.lang.Enum['WellScheduler.WellStatus']): + PRODUCING: typing.ClassVar['WellScheduler.WellStatus'] = ... + SHUT_IN: typing.ClassVar['WellScheduler.WellStatus'] = ... + WORKOVER: typing.ClassVar['WellScheduler.WellStatus'] = ... + WAITING_ON_WEATHER: typing.ClassVar['WellScheduler.WellStatus'] = ... + DRILLING: typing.ClassVar['WellScheduler.WellStatus'] = ... + PLUGGED: typing.ClassVar['WellScheduler.WellStatus'] = ... + def getDisplayName(self) -> java.lang.String: ... + def isProducing(self) -> bool: ... + _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]) -> 'WellScheduler.WellStatus': ... + @staticmethod + def values() -> typing.MutableSequence['WellScheduler.WellStatus']: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.util.fielddevelopment")``. + + FacilityCapacity: typing.Type[FacilityCapacity] + ProductionProfile: typing.Type[ProductionProfile] + SensitivityAnalysis: typing.Type[SensitivityAnalysis] + WellScheduler: typing.Type[WellScheduler] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/fire/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/fire/__init__.pyi new file mode 100644 index 00000000..0e509a64 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/fire/__init__.pyi @@ -0,0 +1,92 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.process.equipment.flare +import jneqsim.process.equipment.separator +import typing + + + +class FireHeatLoadCalculator: + STEFAN_BOLTZMANN: typing.ClassVar[float] = ... + @staticmethod + def api521PoolFireHeatLoad(double: float, double2: float) -> float: ... + @staticmethod + def generalizedStefanBoltzmannHeatFlux(double: float, double2: float, double3: float, double4: float) -> float: ... + +class FireHeatTransferCalculator: + @staticmethod + def calculateWallTemperatures(double: float, double2: float, double3: float, double4: float, double5: float, double6: float) -> 'FireHeatTransferCalculator.SurfaceTemperatureResult': ... + class SurfaceTemperatureResult: + def __init__(self, double: float, double2: float, double3: float): ... + def heatFlux(self) -> float: ... + def innerWallTemperatureK(self) -> float: ... + def outerWallTemperatureK(self) -> float: ... + +class SeparatorFireExposure: + @staticmethod + def applyFireHeating(separator: jneqsim.process.equipment.separator.Separator, fireExposureResult: 'SeparatorFireExposure.FireExposureResult', double: float) -> float: ... + @typing.overload + @staticmethod + def evaluate(separator: jneqsim.process.equipment.separator.Separator, fireScenarioConfig: 'SeparatorFireExposure.FireScenarioConfig') -> 'SeparatorFireExposure.FireExposureResult': ... + @typing.overload + @staticmethod + def evaluate(separator: jneqsim.process.equipment.separator.Separator, fireScenarioConfig: 'SeparatorFireExposure.FireScenarioConfig', flare: jneqsim.process.equipment.flare.Flare, double: float) -> 'SeparatorFireExposure.FireExposureResult': ... + class FireExposureResult: + def __init__(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, surfaceTemperatureResult: FireHeatTransferCalculator.SurfaceTemperatureResult, surfaceTemperatureResult2: FireHeatTransferCalculator.SurfaceTemperatureResult, double9: float, double10: float, boolean: bool): ... + def flareRadiativeFlux(self) -> float: ... + def flareRadiativeHeat(self) -> float: ... + def isRuptureLikely(self) -> bool: ... + def poolFireHeatLoad(self) -> float: ... + def radiativeHeatFlux(self) -> float: ... + def ruptureMarginPa(self) -> float: ... + def totalFireHeat(self) -> float: ... + def unwettedArea(self) -> float: ... + def unwettedRadiativeHeat(self) -> float: ... + def unwettedWall(self) -> FireHeatTransferCalculator.SurfaceTemperatureResult: ... + def vonMisesStressPa(self) -> float: ... + def wettedArea(self) -> float: ... + def wettedWall(self) -> FireHeatTransferCalculator.SurfaceTemperatureResult: ... + class FireScenarioConfig: + def __init__(self): ... + def allowableTensileStrengthPa(self) -> float: ... + def emissivity(self) -> float: ... + def environmentalFactor(self) -> float: ... + def externalFilmCoefficientWPerM2K(self) -> float: ... + def fireTemperatureK(self) -> float: ... + def setAllowableTensileStrengthPa(self, double: float) -> 'SeparatorFireExposure.FireScenarioConfig': ... + def setEmissivity(self, double: float) -> 'SeparatorFireExposure.FireScenarioConfig': ... + def setEnvironmentalFactor(self, double: float) -> 'SeparatorFireExposure.FireScenarioConfig': ... + def setExternalFilmCoefficientWPerM2K(self, double: float) -> 'SeparatorFireExposure.FireScenarioConfig': ... + def setFireTemperatureK(self, double: float) -> 'SeparatorFireExposure.FireScenarioConfig': ... + def setThermalConductivityWPerMPerK(self, double: float) -> 'SeparatorFireExposure.FireScenarioConfig': ... + def setUnwettedInternalFilmCoefficientWPerM2K(self, double: float) -> 'SeparatorFireExposure.FireScenarioConfig': ... + def setViewFactor(self, double: float) -> 'SeparatorFireExposure.FireScenarioConfig': ... + def setWallThicknessM(self, double: float) -> 'SeparatorFireExposure.FireScenarioConfig': ... + def setWettedInternalFilmCoefficientWPerM2K(self, double: float) -> 'SeparatorFireExposure.FireScenarioConfig': ... + def thermalConductivityWPerMPerK(self) -> float: ... + def unwettedInternalFilmCoefficientWPerM2K(self) -> float: ... + def viewFactor(self) -> float: ... + def wallThicknessM(self) -> float: ... + def wettedInternalFilmCoefficientWPerM2K(self) -> float: ... + +class VesselRuptureCalculator: + @staticmethod + def isRuptureLikely(double: float, double2: float) -> bool: ... + @staticmethod + def ruptureMargin(double: float, double2: float) -> float: ... + @staticmethod + def vonMisesStress(double: float, double2: float, double3: float) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.util.fire")``. + + FireHeatLoadCalculator: typing.Type[FireHeatLoadCalculator] + FireHeatTransferCalculator: typing.Type[FireHeatTransferCalculator] + SeparatorFireExposure: typing.Type[SeparatorFireExposure] + VesselRuptureCalculator: typing.Type[VesselRuptureCalculator] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/monitor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/monitor/__init__.pyi new file mode 100644 index 00000000..55d30d86 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/monitor/__init__.pyi @@ -0,0 +1,347 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.equipment +import jneqsim.process.equipment.compressor +import jneqsim.process.equipment.distillation +import jneqsim.process.equipment.expander +import jneqsim.process.equipment.heatexchanger +import jneqsim.process.equipment.manifold +import jneqsim.process.equipment.mixer +import jneqsim.process.equipment.pipeline +import jneqsim.process.equipment.pump +import jneqsim.process.equipment.reactor +import jneqsim.process.equipment.separator +import jneqsim.process.equipment.splitter +import jneqsim.process.equipment.stream +import jneqsim.process.equipment.tank +import jneqsim.process.equipment.util +import jneqsim.process.equipment.valve +import jneqsim.process.measurementdevice +import jneqsim.process.util.report +import jneqsim.thermo.system +import typing + + + +class BaseResponse: + tagName: java.lang.String = ... + name: java.lang.String = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + @typing.overload + def __init__(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface): ... + def applyConfig(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> None: ... + +class FluidComponentResponse: + name: java.lang.String = ... + properties: java.util.HashMap = ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def print_(self) -> None: ... + +class FluidResponse: + name: java.lang.String = ... + properties: java.util.HashMap = ... + composition: java.util.HashMap = ... + conditions: java.util.HashMap = ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def print_(self) -> None: ... + +class KPIDashboard: + def __init__(self): ... + def addScenario(self, string: typing.Union[java.lang.String, str], scenarioKPI: 'ScenarioKPI') -> None: ... + def clear(self) -> None: ... + def getScenarioCount(self) -> int: ... + def printDashboard(self) -> None: ... + +class ScenarioKPI: + def __init__(self): ... + @staticmethod + def builder() -> 'ScenarioKPI.Builder': ... + def calculateEnvironmentalScore(self) -> float: ... + def calculateOverallScore(self) -> float: ... + def calculateProcessScore(self) -> float: ... + def calculateSafetyScore(self) -> float: ... + def getAverageFlowRate(self) -> float: ... + def getCo2Emissions(self) -> float: ... + def getEnergyConsumption(self) -> float: ... + def getErrorCount(self) -> int: ... + def getFinalStatus(self) -> java.lang.String: ... + def getFlareGasVolume(self) -> float: ... + def getFlaringDuration(self) -> float: ... + def getLostProductionValue(self) -> float: ... + def getOperatingCost(self) -> float: ... + def getPeakPressure(self) -> float: ... + def getPeakTemperature(self) -> float: ... + def getProductionLoss(self) -> float: ... + def getRecoveryTime(self) -> float: ... + def getSafetyMarginToMAWP(self) -> float: ... + def getSafetySystemActuations(self) -> int: ... + def getSimulationDuration(self) -> float: ... + def getSteadyStateDeviation(self) -> float: ... + def getTimeToESDActivation(self) -> float: ... + def getVentedMass(self) -> float: ... + def getWarningCount(self) -> int: ... + def isHippsTripped(self) -> bool: ... + def isPsvActivated(self) -> bool: ... + class Builder: + def __init__(self): ... + def averageFlowRate(self, double: float) -> 'ScenarioKPI.Builder': ... + def build(self) -> 'ScenarioKPI': ... + def co2Emissions(self, double: float) -> 'ScenarioKPI.Builder': ... + def energyConsumption(self, double: float) -> 'ScenarioKPI.Builder': ... + def errorCount(self, int: int) -> 'ScenarioKPI.Builder': ... + def finalStatus(self, string: typing.Union[java.lang.String, str]) -> 'ScenarioKPI.Builder': ... + def flareGasVolume(self, double: float) -> 'ScenarioKPI.Builder': ... + def flaringDuration(self, double: float) -> 'ScenarioKPI.Builder': ... + def hippsTripped(self, boolean: bool) -> 'ScenarioKPI.Builder': ... + def lostProductionValue(self, double: float) -> 'ScenarioKPI.Builder': ... + def operatingCost(self, double: float) -> 'ScenarioKPI.Builder': ... + def peakPressure(self, double: float) -> 'ScenarioKPI.Builder': ... + def peakTemperature(self, double: float) -> 'ScenarioKPI.Builder': ... + def productionLoss(self, double: float) -> 'ScenarioKPI.Builder': ... + def psvActivated(self, boolean: bool) -> 'ScenarioKPI.Builder': ... + def recoveryTime(self, double: float) -> 'ScenarioKPI.Builder': ... + def safetyMarginToMAWP(self, double: float) -> 'ScenarioKPI.Builder': ... + def safetySystemActuations(self, int: int) -> 'ScenarioKPI.Builder': ... + def simulationDuration(self, double: float) -> 'ScenarioKPI.Builder': ... + def steadyStateDeviation(self, double: float) -> 'ScenarioKPI.Builder': ... + def timeToESDActivation(self, double: float) -> 'ScenarioKPI.Builder': ... + def ventedMass(self, double: float) -> 'ScenarioKPI.Builder': ... + def warningCount(self, int: int) -> 'ScenarioKPI.Builder': ... + +class Value: + value: java.lang.String = ... + unit: java.lang.String = ... + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + +class WellAllocatorResponse: + name: java.lang.String = ... + data: java.util.HashMap = ... + def __init__(self, wellAllocator: jneqsim.process.measurementdevice.WellAllocator): ... + +class ComponentSplitterResponse(BaseResponse): + data: java.util.HashMap = ... + def __init__(self, componentSplitter: jneqsim.process.equipment.splitter.ComponentSplitter): ... + +class CompressorResponse(BaseResponse): + suctionTemperature: float = ... + dischargeTemperature: float = ... + suctionPressure: float = ... + dischargePressure: float = ... + polytropicHead: float = ... + polytropicEfficiency: float = ... + power: float = ... + suctionVolumeFlow: float = ... + internalVolumeFlow: float = ... + dischargeVolumeFlow: float = ... + molarMass: float = ... + suctionMassDensity: float = ... + dischargeMassDensity: float = ... + massflow: float = ... + stdFlow: float = ... + speed: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, compressor: jneqsim.process.equipment.compressor.Compressor): ... + def applyConfig(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> None: ... + +class DistillationColumnResponse(BaseResponse): + massBalanceError: float = ... + trayTemperature: typing.MutableSequence[float] = ... + trayPressure: typing.MutableSequence[float] = ... + numberOfTrays: int = ... + trayVaporFlowRate: typing.MutableSequence[float] = ... + trayLiquidFlowRate: typing.MutableSequence[float] = ... + trayFeedFlow: typing.MutableSequence[float] = ... + trayMassBalance: typing.MutableSequence[float] = ... + def __init__(self, distillationColumn: jneqsim.process.equipment.distillation.DistillationColumn): ... + +class FurnaceBurnerResponse(BaseResponse): + data: java.util.HashMap = ... + def __init__(self, furnaceBurner: jneqsim.process.equipment.reactor.FurnaceBurner): ... + +class HXResponse(BaseResponse): + feedTemperature1: float = ... + dischargeTemperature1: float = ... + HXthermalEfectiveness: float = ... + feedTemperature2: float = ... + dischargeTemperature2: float = ... + dutyBalance: float = ... + duty: float = ... + UAvalue: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, heatExchanger: jneqsim.process.equipment.heatexchanger.HeatExchanger): ... + +class HeaterResponse(BaseResponse): + data: java.util.HashMap = ... + def __init__(self, heater: jneqsim.process.equipment.heatexchanger.Heater): ... + +class MPMResponse(BaseResponse): + massFLow: float = ... + GOR: float = ... + GOR_std: float = ... + gasDensity: float = ... + oilDensity: float = ... + waterDensity: float = ... + def __init__(self, multiPhaseMeter: jneqsim.process.measurementdevice.MultiPhaseMeter): ... + +class ManifoldResponse(BaseResponse): + data: java.util.HashMap = ... + def __init__(self, manifold: jneqsim.process.equipment.manifold.Manifold): ... + +class MixerResponse(BaseResponse): + data: java.util.HashMap = ... + def __init__(self, mixer: jneqsim.process.equipment.mixer.Mixer): ... + +class MultiStreamHeatExchanger2Response(BaseResponse): + data: java.util.HashMap = ... + temperatureApproach: float = ... + compositeCurveResults: java.util.Map = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, multiStreamHeatExchanger2: jneqsim.process.equipment.heatexchanger.MultiStreamHeatExchanger2): ... + +class MultiStreamHeatExchangerResponse(BaseResponse): + data: java.util.HashMap = ... + feedTemperature: typing.MutableSequence[float] = ... + dischargeTemperature: typing.MutableSequence[float] = ... + duty: typing.MutableSequence[float] = ... + flowRate: typing.MutableSequence[float] = ... + def __init__(self, multiStreamHeatExchanger: jneqsim.process.equipment.heatexchanger.MultiStreamHeatExchanger): ... + +class PipeBeggsBrillsResponse(BaseResponse): + inletPressure: float = ... + outletPressure: float = ... + inletTemperature: float = ... + outletTemperature: float = ... + inletDensity: float = ... + outletDensity: float = ... + inletVolumeFlow: float = ... + outletVolumeFlow: float = ... + inletMassFlow: float = ... + outletMassFlow: float = ... + def __init__(self, pipeBeggsAndBrills: jneqsim.process.equipment.pipeline.PipeBeggsAndBrills): ... + +class PumpResponse(BaseResponse): + data: java.util.HashMap = ... + suctionTemperature: float = ... + dischargeTemperature: float = ... + suctionPressure: float = ... + dischargePressure: float = ... + power: float = ... + duty: float = ... + suctionVolumeFlow: float = ... + internalVolumeFlow: float = ... + dischargeVolumeFlow: float = ... + molarMass: float = ... + suctionMassDensity: float = ... + dischargeMassDensity: float = ... + massflow: float = ... + speed: int = ... + def __init__(self, pump: jneqsim.process.equipment.pump.Pump): ... + +class RecycleResponse(BaseResponse): + data: java.util.HashMap = ... + def __init__(self, recycle: jneqsim.process.equipment.util.Recycle): ... + +class SeparatorResponse(BaseResponse): + gasLoadFactor: float = ... + feed: 'StreamResponse' = ... + gas: 'StreamResponse' = ... + liquid: 'StreamResponse' = ... + oil: 'StreamResponse' = ... + water: 'StreamResponse' = ... + @typing.overload + def __init__(self, separator: jneqsim.process.equipment.separator.Separator): ... + @typing.overload + def __init__(self, threePhaseSeparator: jneqsim.process.equipment.separator.ThreePhaseSeparator): ... + +class SplitterResponse(BaseResponse): + data: java.util.HashMap = ... + def __init__(self, splitter: jneqsim.process.equipment.splitter.Splitter): ... + +class StreamResponse(BaseResponse): + properties: java.util.HashMap = ... + conditions: java.util.HashMap = ... + composition: java.util.HashMap = ... + def __init__(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + def applyConfig(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> None: ... + def print_(self) -> None: ... + +class TankResponse(BaseResponse): + data: java.util.HashMap = ... + def __init__(self, tank: jneqsim.process.equipment.tank.Tank): ... + +class ThreePhaseSeparatorResponse(BaseResponse): + gasLoadFactor: float = ... + massflow: float = ... + gasFluid: FluidResponse = ... + oilFluid: FluidResponse = ... + @typing.overload + def __init__(self, separator: jneqsim.process.equipment.separator.Separator): ... + @typing.overload + def __init__(self, threePhaseSeparator: jneqsim.process.equipment.separator.ThreePhaseSeparator): ... + +class TurboExpanderCompressorResponse(BaseResponse): + def __init__(self, turboExpanderCompressor: jneqsim.process.equipment.expander.TurboExpanderCompressor): ... + +class ValveResponse(BaseResponse): + data: java.util.HashMap = ... + def __init__(self, valveInterface: jneqsim.process.equipment.valve.ValveInterface): ... + def print_(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.util.monitor")``. + + BaseResponse: typing.Type[BaseResponse] + ComponentSplitterResponse: typing.Type[ComponentSplitterResponse] + CompressorResponse: typing.Type[CompressorResponse] + DistillationColumnResponse: typing.Type[DistillationColumnResponse] + FluidComponentResponse: typing.Type[FluidComponentResponse] + FluidResponse: typing.Type[FluidResponse] + FurnaceBurnerResponse: typing.Type[FurnaceBurnerResponse] + HXResponse: typing.Type[HXResponse] + HeaterResponse: typing.Type[HeaterResponse] + KPIDashboard: typing.Type[KPIDashboard] + MPMResponse: typing.Type[MPMResponse] + ManifoldResponse: typing.Type[ManifoldResponse] + MixerResponse: typing.Type[MixerResponse] + MultiStreamHeatExchanger2Response: typing.Type[MultiStreamHeatExchanger2Response] + MultiStreamHeatExchangerResponse: typing.Type[MultiStreamHeatExchangerResponse] + PipeBeggsBrillsResponse: typing.Type[PipeBeggsBrillsResponse] + PumpResponse: typing.Type[PumpResponse] + RecycleResponse: typing.Type[RecycleResponse] + ScenarioKPI: typing.Type[ScenarioKPI] + SeparatorResponse: typing.Type[SeparatorResponse] + SplitterResponse: typing.Type[SplitterResponse] + StreamResponse: typing.Type[StreamResponse] + TankResponse: typing.Type[TankResponse] + ThreePhaseSeparatorResponse: typing.Type[ThreePhaseSeparatorResponse] + TurboExpanderCompressorResponse: typing.Type[TurboExpanderCompressorResponse] + Value: typing.Type[Value] + ValveResponse: typing.Type[ValveResponse] + WellAllocatorResponse: typing.Type[WellAllocatorResponse] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/optimization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/optimization/__init__.pyi new file mode 100644 index 00000000..a0c08531 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/optimization/__init__.pyi @@ -0,0 +1,259 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.nio.file +import java.util +import java.util.function +import jpype.protocol +import jneqsim.process.equipment +import jneqsim.process.equipment.stream +import jneqsim.process.processmodel +import typing + + + +class ProductionOptimizationSpecLoader: + @staticmethod + def load(path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath], map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], jneqsim.process.processmodel.ProcessSystem], typing.Mapping[typing.Union[java.lang.String, str], jneqsim.process.processmodel.ProcessSystem]], map2: typing.Union[java.util.Map[typing.Union[java.lang.String, str], jneqsim.process.equipment.stream.StreamInterface], typing.Mapping[typing.Union[java.lang.String, str], jneqsim.process.equipment.stream.StreamInterface]], map3: typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Union[java.util.function.ToDoubleFunction[jneqsim.process.processmodel.ProcessSystem], typing.Callable[[jneqsim.process.processmodel.ProcessSystem], float]]], typing.Mapping[typing.Union[java.lang.String, str], typing.Union[java.util.function.ToDoubleFunction[jneqsim.process.processmodel.ProcessSystem], typing.Callable[[jneqsim.process.processmodel.ProcessSystem], float]]]]) -> java.util.List['ProductionOptimizer.ScenarioRequest']: ... + +class ProductionOptimizer: + DEFAULT_UTILIZATION_LIMIT: typing.ClassVar[float] = ... + def __init__(self): ... + @staticmethod + def buildUtilizationSeries(list: java.util.List['ProductionOptimizer.IterationRecord']) -> java.util.List['ProductionOptimizer.UtilizationSeries']: ... + def compareScenarios(self, list: java.util.List['ProductionOptimizer.ScenarioRequest'], list2: java.util.List['ProductionOptimizer.ScenarioKpi']) -> 'ProductionOptimizer.ScenarioComparisonResult': ... + @staticmethod + def formatScenarioComparisonTable(scenarioComparisonResult: 'ProductionOptimizer.ScenarioComparisonResult', list: java.util.List['ProductionOptimizer.ScenarioKpi']) -> java.lang.String: ... + @staticmethod + def formatUtilizationTable(list: java.util.List['ProductionOptimizer.UtilizationRecord']) -> java.lang.String: ... + @staticmethod + def formatUtilizationTimeline(list: java.util.List['ProductionOptimizer.IterationRecord']) -> java.lang.String: ... + @typing.overload + def optimize(self, processSystem: jneqsim.process.processmodel.ProcessSystem, list: java.util.List['ProductionOptimizer.ManipulatedVariable'], optimizationConfig: 'ProductionOptimizer.OptimizationConfig', list2: java.util.List['ProductionOptimizer.OptimizationObjective'], list3: java.util.List['ProductionOptimizer.OptimizationConstraint']) -> 'ProductionOptimizer.OptimizationResult': ... + @typing.overload + def optimize(self, processSystem: jneqsim.process.processmodel.ProcessSystem, streamInterface: jneqsim.process.equipment.stream.StreamInterface, optimizationConfig: 'ProductionOptimizer.OptimizationConfig', list: java.util.List['ProductionOptimizer.OptimizationObjective'], list2: java.util.List['ProductionOptimizer.OptimizationConstraint']) -> 'ProductionOptimizer.OptimizationResult': ... + def optimizeScenarios(self, list: java.util.List['ProductionOptimizer.ScenarioRequest']) -> java.util.List['ProductionOptimizer.ScenarioResult']: ... + def optimizeThroughput(self, processSystem: jneqsim.process.processmodel.ProcessSystem, streamInterface: jneqsim.process.equipment.stream.StreamInterface, double: float, double2: float, string: typing.Union[java.lang.String, str], list: java.util.List['ProductionOptimizer.OptimizationConstraint']) -> 'ProductionOptimizer.OptimizationResult': ... + @typing.overload + def quickOptimize(self, processSystem: jneqsim.process.processmodel.ProcessSystem, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> 'ProductionOptimizer.OptimizationSummary': ... + @typing.overload + def quickOptimize(self, processSystem: jneqsim.process.processmodel.ProcessSystem, streamInterface: jneqsim.process.equipment.stream.StreamInterface, string: typing.Union[java.lang.String, str], list: java.util.List['ProductionOptimizer.OptimizationConstraint']) -> 'ProductionOptimizer.OptimizationSummary': ... + class ConstraintDirection(java.lang.Enum['ProductionOptimizer.ConstraintDirection']): + LESS_THAN: typing.ClassVar['ProductionOptimizer.ConstraintDirection'] = ... + GREATER_THAN: typing.ClassVar['ProductionOptimizer.ConstraintDirection'] = ... + _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]) -> 'ProductionOptimizer.ConstraintDirection': ... + @staticmethod + def values() -> typing.MutableSequence['ProductionOptimizer.ConstraintDirection']: ... + class ConstraintSeverity(java.lang.Enum['ProductionOptimizer.ConstraintSeverity']): + HARD: typing.ClassVar['ProductionOptimizer.ConstraintSeverity'] = ... + SOFT: typing.ClassVar['ProductionOptimizer.ConstraintSeverity'] = ... + _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]) -> 'ProductionOptimizer.ConstraintSeverity': ... + @staticmethod + def values() -> typing.MutableSequence['ProductionOptimizer.ConstraintSeverity']: ... + class ConstraintStatus: + def __init__(self, string: typing.Union[java.lang.String, str], constraintSeverity: 'ProductionOptimizer.ConstraintSeverity', double: float, double2: float, string2: typing.Union[java.lang.String, str]): ... + def getDescription(self) -> java.lang.String: ... + def getMargin(self) -> float: ... + def getName(self) -> java.lang.String: ... + def getPenaltyWeight(self) -> float: ... + def getSeverity(self) -> 'ProductionOptimizer.ConstraintSeverity': ... + def violated(self) -> bool: ... + class IterationRecord: + def __init__(self, double: float, 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]], string2: typing.Union[java.lang.String, str], double2: float, boolean: bool, boolean2: bool, boolean3: bool, double3: float, list: java.util.List['ProductionOptimizer.UtilizationRecord']): ... + def getBottleneckName(self) -> java.lang.String: ... + def getBottleneckUtilization(self) -> float: ... + def getDecisionVariables(self) -> java.util.Map[java.lang.String, float]: ... + def getRate(self) -> float: ... + def getRateUnit(self) -> java.lang.String: ... + def getScore(self) -> float: ... + def getUtilizations(self) -> java.util.List['ProductionOptimizer.UtilizationRecord']: ... + def isFeasible(self) -> bool: ... + def isHardConstraintsOk(self) -> bool: ... + def isUtilizationWithinLimits(self) -> bool: ... + class ManipulatedVariable: + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, string2: typing.Union[java.lang.String, str], biConsumer: typing.Union[java.util.function.BiConsumer[jneqsim.process.processmodel.ProcessSystem, float], typing.Callable[[jneqsim.process.processmodel.ProcessSystem, float], None]]): ... + def apply(self, processSystem: jneqsim.process.processmodel.ProcessSystem, double: float) -> None: ... + def getLowerBound(self) -> float: ... + def getName(self) -> java.lang.String: ... + def getUnit(self) -> java.lang.String: ... + def getUpperBound(self) -> float: ... + class ObjectiveType(java.lang.Enum['ProductionOptimizer.ObjectiveType']): + MAXIMIZE: typing.ClassVar['ProductionOptimizer.ObjectiveType'] = ... + MINIMIZE: typing.ClassVar['ProductionOptimizer.ObjectiveType'] = ... + _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]) -> 'ProductionOptimizer.ObjectiveType': ... + @staticmethod + def values() -> typing.MutableSequence['ProductionOptimizer.ObjectiveType']: ... + class OptimizationConfig: + def __init__(self, double: float, double2: float): ... + def capacityPercentile(self, double: float) -> 'ProductionOptimizer.OptimizationConfig': ... + def capacityRangeForName(self, string: typing.Union[java.lang.String, str], capacityRange: 'ProductionOptimizer.CapacityRange') -> 'ProductionOptimizer.OptimizationConfig': ... + def capacityRangeForType(self, class_: typing.Type[typing.Any], capacityRange: 'ProductionOptimizer.CapacityRange') -> 'ProductionOptimizer.OptimizationConfig': ... + def capacityRangeSpreadFraction(self, double: float) -> 'ProductionOptimizer.OptimizationConfig': ... + def capacityRuleForName(self, string: typing.Union[java.lang.String, str], capacityRule: 'ProductionOptimizer.CapacityRule') -> 'ProductionOptimizer.OptimizationConfig': ... + def capacityRuleForType(self, class_: typing.Type[typing.Any], capacityRule: 'ProductionOptimizer.CapacityRule') -> 'ProductionOptimizer.OptimizationConfig': ... + def capacityUncertaintyFraction(self, double: float) -> 'ProductionOptimizer.OptimizationConfig': ... + def cognitiveWeight(self, double: float) -> 'ProductionOptimizer.OptimizationConfig': ... + def columnFsFactorLimit(self, double: float) -> 'ProductionOptimizer.OptimizationConfig': ... + def defaultUtilizationLimit(self, double: float) -> 'ProductionOptimizer.OptimizationConfig': ... + def enableCaching(self, boolean: bool) -> 'ProductionOptimizer.OptimizationConfig': ... + def equipmentConstraintRule(self, equipmentConstraintRule: 'ProductionOptimizer.EquipmentConstraintRule') -> 'ProductionOptimizer.OptimizationConfig': ... + def getCapacityPercentile(self) -> float: ... + def getCapacityRangeSpreadFraction(self) -> float: ... + def getCapacityUncertaintyFraction(self) -> float: ... + def getCognitiveWeight(self) -> float: ... + def getColumnFsFactorLimit(self) -> float: ... + def getInertiaWeight(self) -> float: ... + def getMaxIterations(self) -> int: ... + def getSocialWeight(self) -> float: ... + def getSwarmSize(self) -> int: ... + def getUtilizationMarginFraction(self) -> float: ... + def inertiaWeight(self, double: float) -> 'ProductionOptimizer.OptimizationConfig': ... + def maxIterations(self, int: int) -> 'ProductionOptimizer.OptimizationConfig': ... + def rateUnit(self, string: typing.Union[java.lang.String, str]) -> 'ProductionOptimizer.OptimizationConfig': ... + def searchMode(self, searchMode: 'ProductionOptimizer.SearchMode') -> 'ProductionOptimizer.OptimizationConfig': ... + def socialWeight(self, double: float) -> 'ProductionOptimizer.OptimizationConfig': ... + def swarmSize(self, int: int) -> 'ProductionOptimizer.OptimizationConfig': ... + def tolerance(self, double: float) -> 'ProductionOptimizer.OptimizationConfig': ... + def utilizationLimitForName(self, string: typing.Union[java.lang.String, str], double: float) -> 'ProductionOptimizer.OptimizationConfig': ... + def utilizationLimitForType(self, class_: typing.Type[typing.Any], double: float) -> 'ProductionOptimizer.OptimizationConfig': ... + def utilizationMarginFraction(self, double: float) -> 'ProductionOptimizer.OptimizationConfig': ... + class OptimizationConstraint: + def __init__(self, string: typing.Union[java.lang.String, str], toDoubleFunction: typing.Union[java.util.function.ToDoubleFunction[jneqsim.process.processmodel.ProcessSystem], typing.Callable[[jneqsim.process.processmodel.ProcessSystem], float]], double: float, constraintDirection: 'ProductionOptimizer.ConstraintDirection', constraintSeverity: 'ProductionOptimizer.ConstraintSeverity', double2: float, string2: typing.Union[java.lang.String, str]): ... + def getDescription(self) -> java.lang.String: ... + def getName(self) -> java.lang.String: ... + def getPenaltyWeight(self) -> float: ... + def getSeverity(self) -> 'ProductionOptimizer.ConstraintSeverity': ... + @staticmethod + def greaterThan(string: typing.Union[java.lang.String, str], toDoubleFunction: typing.Union[java.util.function.ToDoubleFunction[jneqsim.process.processmodel.ProcessSystem], typing.Callable[[jneqsim.process.processmodel.ProcessSystem], float]], double: float, constraintSeverity: 'ProductionOptimizer.ConstraintSeverity', double2: float, string2: typing.Union[java.lang.String, str]) -> 'ProductionOptimizer.OptimizationConstraint': ... + def isSatisfied(self, processSystem: jneqsim.process.processmodel.ProcessSystem) -> bool: ... + @staticmethod + def lessThan(string: typing.Union[java.lang.String, str], toDoubleFunction: typing.Union[java.util.function.ToDoubleFunction[jneqsim.process.processmodel.ProcessSystem], typing.Callable[[jneqsim.process.processmodel.ProcessSystem], float]], double: float, constraintSeverity: 'ProductionOptimizer.ConstraintSeverity', double2: float, string2: typing.Union[java.lang.String, str]) -> 'ProductionOptimizer.OptimizationConstraint': ... + def margin(self, processSystem: jneqsim.process.processmodel.ProcessSystem) -> float: ... + class OptimizationObjective: + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], toDoubleFunction: typing.Union[java.util.function.ToDoubleFunction[jneqsim.process.processmodel.ProcessSystem], typing.Callable[[jneqsim.process.processmodel.ProcessSystem], float]], double: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], toDoubleFunction: typing.Union[java.util.function.ToDoubleFunction[jneqsim.process.processmodel.ProcessSystem], typing.Callable[[jneqsim.process.processmodel.ProcessSystem], float]], double: float, objectiveType: 'ProductionOptimizer.ObjectiveType'): ... + def evaluate(self, processSystem: jneqsim.process.processmodel.ProcessSystem) -> float: ... + def getName(self) -> java.lang.String: ... + def getType(self) -> 'ProductionOptimizer.ObjectiveType': ... + def getWeight(self) -> float: ... + class OptimizationResult: + def __init__(self, double: float, 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]], processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, double2: float, list: java.util.List['ProductionOptimizer.UtilizationRecord'], map2: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]], list2: java.util.List['ProductionOptimizer.ConstraintStatus'], boolean: bool, double3: float, int: int, list3: java.util.List['ProductionOptimizer.IterationRecord']): ... + def getBottleneck(self) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + def getBottleneckUtilization(self) -> float: ... + def getConstraintStatuses(self) -> java.util.List['ProductionOptimizer.ConstraintStatus']: ... + def getDecisionVariables(self) -> java.util.Map[java.lang.String, float]: ... + def getIterationHistory(self) -> java.util.List['ProductionOptimizer.IterationRecord']: ... + def getIterations(self) -> int: ... + def getObjectiveValues(self) -> java.util.Map[java.lang.String, float]: ... + def getOptimalRate(self) -> float: ... + def getRateUnit(self) -> java.lang.String: ... + def getScore(self) -> float: ... + def getUtilizationRecords(self) -> java.util.List['ProductionOptimizer.UtilizationRecord']: ... + def isFeasible(self) -> bool: ... + class OptimizationSummary: + def __init__(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], double2: float, double3: float, double4: float, boolean: bool, map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]], list: java.util.List['ProductionOptimizer.UtilizationRecord'], list2: java.util.List['ProductionOptimizer.ConstraintStatus']): ... + def getConstraints(self) -> java.util.List['ProductionOptimizer.ConstraintStatus']: ... + def getDecisionVariables(self) -> java.util.Map[java.lang.String, float]: ... + def getLimitingEquipment(self) -> java.lang.String: ... + def getMaxRate(self) -> float: ... + def getRateUnit(self) -> java.lang.String: ... + def getUtilization(self) -> float: ... + def getUtilizationLimit(self) -> float: ... + def getUtilizationMargin(self) -> float: ... + def getUtilizations(self) -> java.util.List['ProductionOptimizer.UtilizationRecord']: ... + def isFeasible(self) -> bool: ... + class ScenarioComparisonResult: + def __init__(self, string: typing.Union[java.lang.String, str], list: java.util.List['ProductionOptimizer.ScenarioResult'], map: typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]]], typing.Mapping[typing.Union[java.lang.String, str], typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]]]], map2: typing.Union[java.util.Map[typing.Union[java.lang.String, str], typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]]], typing.Mapping[typing.Union[java.lang.String, str], typing.Union[java.util.Map[typing.Union[java.lang.String, str], float], typing.Mapping[typing.Union[java.lang.String, str], float]]]]): ... + def getBaselineScenario(self) -> java.lang.String: ... + def getKpiDeltas(self) -> java.util.Map[java.lang.String, java.util.Map[java.lang.String, float]]: ... + def getKpiValues(self) -> java.util.Map[java.lang.String, java.util.Map[java.lang.String, float]]: ... + def getScenarioResults(self) -> java.util.List['ProductionOptimizer.ScenarioResult']: ... + class ScenarioKpi: + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], toDoubleFunction: typing.Union[java.util.function.ToDoubleFunction['ProductionOptimizer.OptimizationResult'], typing.Callable[['ProductionOptimizer.OptimizationResult'], float]]): ... + def evaluate(self, optimizationResult: 'ProductionOptimizer.OptimizationResult') -> float: ... + def getName(self) -> java.lang.String: ... + def getUnit(self) -> java.lang.String: ... + @staticmethod + def objectiveValue(string: typing.Union[java.lang.String, str]) -> 'ProductionOptimizer.ScenarioKpi': ... + @staticmethod + def optimalRate(string: typing.Union[java.lang.String, str]) -> 'ProductionOptimizer.ScenarioKpi': ... + @staticmethod + def score() -> 'ProductionOptimizer.ScenarioKpi': ... + class ScenarioRequest: + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], processSystem: jneqsim.process.processmodel.ProcessSystem, list: java.util.List['ProductionOptimizer.ManipulatedVariable'], optimizationConfig: 'ProductionOptimizer.OptimizationConfig', list2: java.util.List['ProductionOptimizer.OptimizationObjective'], list3: java.util.List['ProductionOptimizer.OptimizationConstraint']): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], processSystem: jneqsim.process.processmodel.ProcessSystem, streamInterface: jneqsim.process.equipment.stream.StreamInterface, optimizationConfig: 'ProductionOptimizer.OptimizationConfig', list: java.util.List['ProductionOptimizer.OptimizationObjective'], list2: java.util.List['ProductionOptimizer.OptimizationConstraint']): ... + def getConfig(self) -> 'ProductionOptimizer.OptimizationConfig': ... + def getConstraints(self) -> java.util.List['ProductionOptimizer.OptimizationConstraint']: ... + def getFeedStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getName(self) -> java.lang.String: ... + def getObjectives(self) -> java.util.List['ProductionOptimizer.OptimizationObjective']: ... + def getProcess(self) -> jneqsim.process.processmodel.ProcessSystem: ... + def getVariables(self) -> java.util.List['ProductionOptimizer.ManipulatedVariable']: ... + class ScenarioResult: + def __init__(self, string: typing.Union[java.lang.String, str], optimizationResult: 'ProductionOptimizer.OptimizationResult'): ... + def getName(self) -> java.lang.String: ... + def getResult(self) -> 'ProductionOptimizer.OptimizationResult': ... + class SearchMode(java.lang.Enum['ProductionOptimizer.SearchMode']): + BINARY_FEASIBILITY: typing.ClassVar['ProductionOptimizer.SearchMode'] = ... + GOLDEN_SECTION_SCORE: typing.ClassVar['ProductionOptimizer.SearchMode'] = ... + NELDER_MEAD_SCORE: typing.ClassVar['ProductionOptimizer.SearchMode'] = ... + PARTICLE_SWARM_SCORE: typing.ClassVar['ProductionOptimizer.SearchMode'] = ... + _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]) -> 'ProductionOptimizer.SearchMode': ... + @staticmethod + def values() -> typing.MutableSequence['ProductionOptimizer.SearchMode']: ... + class UtilizationRecord: + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float): ... + def getCapacityDuty(self) -> float: ... + def getCapacityMax(self) -> float: ... + def getEquipmentName(self) -> java.lang.String: ... + def getUtilization(self) -> float: ... + def getUtilizationLimit(self) -> float: ... + class UtilizationSeries: + def __init__(self, string: typing.Union[java.lang.String, str], list: java.util.List[float], list2: java.util.List[bool], double: float): ... + def getBottleneckFlags(self) -> java.util.List[bool]: ... + def getEquipmentName(self) -> java.lang.String: ... + def getUtilizationLimit(self) -> float: ... + def getUtilizations(self) -> java.util.List[float]: ... + class CapacityRange: ... + class CapacityRule: ... + class EquipmentConstraintRule: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.util.optimization")``. + + ProductionOptimizationSpecLoader: typing.Type[ProductionOptimizationSpecLoader] + ProductionOptimizer: typing.Type[ProductionOptimizer] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/report/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/report/__init__.pyi new file mode 100644 index 00000000..ab661a59 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/report/__init__.pyi @@ -0,0 +1,64 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.process.equipment +import jneqsim.process.processmodel +import jneqsim.process.util.report.safety +import jneqsim.thermo.system +import typing + + + +class Report: + @typing.overload + def __init__(self, processEquipmentBaseClass: jneqsim.process.equipment.ProcessEquipmentBaseClass): ... + @typing.overload + def __init__(self, processModel: jneqsim.process.processmodel.ProcessModel): ... + @typing.overload + def __init__(self, processModule: jneqsim.process.processmodel.ProcessModule): ... + @typing.overload + def __init__(self, processModuleBaseClass: jneqsim.process.processmodel.ProcessModuleBaseClass): ... + @typing.overload + def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def generateJsonReport(self) -> java.lang.String: ... + @typing.overload + def generateJsonReport(self, reportConfig: 'ReportConfig') -> java.lang.String: ... + +class ReportConfig: + detailLevel: 'ReportConfig.DetailLevel' = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, detailLevel: 'ReportConfig.DetailLevel'): ... + def getDetailLevel(self, string: typing.Union[java.lang.String, str]) -> 'ReportConfig.DetailLevel': ... + def setDetailLevel(self, string: typing.Union[java.lang.String, str], detailLevel: 'ReportConfig.DetailLevel') -> None: ... + class DetailLevel(java.lang.Enum['ReportConfig.DetailLevel']): + MINIMUM: typing.ClassVar['ReportConfig.DetailLevel'] = ... + SUMMARY: typing.ClassVar['ReportConfig.DetailLevel'] = ... + FULL: typing.ClassVar['ReportConfig.DetailLevel'] = ... + HIDE: typing.ClassVar['ReportConfig.DetailLevel'] = ... + _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]) -> 'ReportConfig.DetailLevel': ... + @staticmethod + def values() -> typing.MutableSequence['ReportConfig.DetailLevel']: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.util.report")``. + + Report: typing.Type[Report] + ReportConfig: typing.Type[ReportConfig] + safety: jneqsim.process.util.report.safety.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/report/safety/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/report/safety/__init__.pyi new file mode 100644 index 00000000..d5f7220e --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/report/safety/__init__.pyi @@ -0,0 +1,109 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.conditionmonitor +import jneqsim.process.processmodel +import jneqsim.process.util.report +import typing + + + +class ProcessSafetyReport: + def getConditionFindings(self) -> java.util.List['ProcessSafetyReport.ConditionFinding']: ... + def getEquipmentSnapshotJson(self) -> java.lang.String: ... + def getReliefDeviceAssessments(self) -> java.util.List['ProcessSafetyReport.ReliefDeviceAssessment']: ... + def getSafetyMargins(self) -> java.util.List['ProcessSafetyReport.SafetyMarginAssessment']: ... + def getScenarioLabel(self) -> java.lang.String: ... + def getSystemKpis(self) -> 'ProcessSafetyReport.SystemKpiSnapshot': ... + def getThresholds(self) -> 'ProcessSafetyThresholds': ... + def toCsv(self) -> java.lang.String: ... + def toJson(self) -> java.lang.String: ... + def toUiModel(self) -> java.util.Map[java.lang.String, typing.Any]: ... + class ConditionFinding: + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], severityLevel: 'SeverityLevel'): ... + def getMessage(self) -> java.lang.String: ... + def getSeverity(self) -> 'SeverityLevel': ... + def getUnitName(self) -> java.lang.String: ... + class ReliefDeviceAssessment: + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float, double5: float, severityLevel: 'SeverityLevel'): ... + def getMassFlowRateKgPerHr(self) -> float: ... + def getRelievingPressureBar(self) -> float: ... + def getSetPressureBar(self) -> float: ... + def getSeverity(self) -> 'SeverityLevel': ... + def getUnitName(self) -> java.lang.String: ... + def getUpstreamPressureBar(self) -> float: ... + def getUtilisationFraction(self) -> float: ... + class SafetyMarginAssessment: + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, severityLevel: 'SeverityLevel', string2: typing.Union[java.lang.String, str]): ... + def getDesignPressureBar(self) -> float: ... + def getMarginFraction(self) -> float: ... + def getNotes(self) -> java.lang.String: ... + def getOperatingPressureBar(self) -> float: ... + def getSeverity(self) -> 'SeverityLevel': ... + def getUnitName(self) -> java.lang.String: ... + class SystemKpiSnapshot: + def __init__(self, double: float, double2: float, severityLevel: 'SeverityLevel', severityLevel2: 'SeverityLevel'): ... + def getEntropyChangeKjPerK(self) -> float: ... + def getEntropySeverity(self) -> 'SeverityLevel': ... + def getExergyChangeKj(self) -> float: ... + def getExergySeverity(self) -> 'SeverityLevel': ... + +class ProcessSafetyReportBuilder: + def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem): ... + def build(self) -> ProcessSafetyReport: ... + def withConditionMonitor(self, conditionMonitor: jneqsim.process.conditionmonitor.ConditionMonitor) -> 'ProcessSafetyReportBuilder': ... + def withReportConfig(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> 'ProcessSafetyReportBuilder': ... + def withScenarioLabel(self, string: typing.Union[java.lang.String, str]) -> 'ProcessSafetyReportBuilder': ... + def withThresholds(self, processSafetyThresholds: 'ProcessSafetyThresholds') -> 'ProcessSafetyReportBuilder': ... + +class ProcessSafetyThresholds: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, processSafetyThresholds: 'ProcessSafetyThresholds'): ... + def getEntropyChangeCritical(self) -> float: ... + def getEntropyChangeWarning(self) -> float: ... + def getExergyChangeCritical(self) -> float: ... + def getExergyChangeWarning(self) -> float: ... + def getMinSafetyMarginCritical(self) -> float: ... + def getMinSafetyMarginWarning(self) -> float: ... + def getReliefUtilisationCritical(self) -> float: ... + def getReliefUtilisationWarning(self) -> float: ... + def setEntropyChangeCritical(self, double: float) -> 'ProcessSafetyThresholds': ... + def setEntropyChangeWarning(self, double: float) -> 'ProcessSafetyThresholds': ... + def setExergyChangeCritical(self, double: float) -> 'ProcessSafetyThresholds': ... + def setExergyChangeWarning(self, double: float) -> 'ProcessSafetyThresholds': ... + def setMinSafetyMarginCritical(self, double: float) -> 'ProcessSafetyThresholds': ... + def setMinSafetyMarginWarning(self, double: float) -> 'ProcessSafetyThresholds': ... + def setReliefUtilisationCritical(self, double: float) -> 'ProcessSafetyThresholds': ... + def setReliefUtilisationWarning(self, double: float) -> 'ProcessSafetyThresholds': ... + +class SeverityLevel(java.lang.Enum['SeverityLevel']): + NORMAL: typing.ClassVar['SeverityLevel'] = ... + WARNING: typing.ClassVar['SeverityLevel'] = ... + CRITICAL: typing.ClassVar['SeverityLevel'] = ... + def combine(self, severityLevel: 'SeverityLevel') -> 'SeverityLevel': ... + _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]) -> 'SeverityLevel': ... + @staticmethod + def values() -> typing.MutableSequence['SeverityLevel']: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.util.report.safety")``. + + ProcessSafetyReport: typing.Type[ProcessSafetyReport] + ProcessSafetyReportBuilder: typing.Type[ProcessSafetyReportBuilder] + ProcessSafetyThresholds: typing.Type[ProcessSafetyThresholds] + SeverityLevel: typing.Type[SeverityLevel] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/scenario/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/scenario/__init__.pyi new file mode 100644 index 00000000..542d6bb5 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/scenario/__init__.pyi @@ -0,0 +1,86 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.process.logic +import jneqsim.process.processmodel +import jneqsim.process.safety +import jneqsim.process.util.monitor +import typing + + + +class ProcessScenarioRunner: + def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem): ... + def activateLogic(self, string: typing.Union[java.lang.String, str]) -> bool: ... + def addLogic(self, processLogic: jneqsim.process.logic.ProcessLogic) -> None: ... + def clearAllLogic(self) -> None: ... + def findLogic(self, string: typing.Union[java.lang.String, str]) -> jneqsim.process.logic.ProcessLogic: ... + def getLogicSequences(self) -> java.util.List[jneqsim.process.logic.ProcessLogic]: ... + def getSystem(self) -> jneqsim.process.processmodel.ProcessSystem: ... + def initializeSteadyState(self) -> None: ... + @typing.overload + def removeLogic(self, string: typing.Union[java.lang.String, str]) -> bool: ... + @typing.overload + def removeLogic(self, processLogic: jneqsim.process.logic.ProcessLogic) -> None: ... + def renewSimulationId(self) -> None: ... + def reset(self) -> None: ... + def resetLogic(self) -> None: ... + def runScenario(self, string: typing.Union[java.lang.String, str], processSafetyScenario: jneqsim.process.safety.ProcessSafetyScenario, double: float, double2: float) -> 'ScenarioExecutionSummary': ... + def runScenarioWithLogic(self, string: typing.Union[java.lang.String, str], processSafetyScenario: jneqsim.process.safety.ProcessSafetyScenario, double: float, double2: float, list: java.util.List[typing.Union[java.lang.String, str]]) -> 'ScenarioExecutionSummary': ... + +class ScenarioExecutionSummary: + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def addError(self, string: typing.Union[java.lang.String, str]) -> None: ... + def addLogicResult(self, string: typing.Union[java.lang.String, str], logicState: jneqsim.process.logic.LogicState, string2: typing.Union[java.lang.String, str]) -> None: ... + def addWarning(self, string: typing.Union[java.lang.String, str]) -> None: ... + def getErrors(self) -> java.util.List[java.lang.String]: ... + def getExecutionTime(self) -> int: ... + def getKPI(self) -> jneqsim.process.util.monitor.ScenarioKPI: ... + def getLogicResults(self) -> java.util.Map[java.lang.String, 'ScenarioExecutionSummary.LogicResult']: ... + def getScenario(self) -> jneqsim.process.safety.ProcessSafetyScenario: ... + def getScenarioName(self) -> java.lang.String: ... + def getWarnings(self) -> java.util.List[java.lang.String]: ... + def isSuccessful(self) -> bool: ... + def printResults(self) -> None: ... + def setExecutionTime(self, long: int) -> None: ... + def setKPI(self, scenarioKPI: jneqsim.process.util.monitor.ScenarioKPI) -> None: ... + def setScenario(self, processSafetyScenario: jneqsim.process.safety.ProcessSafetyScenario) -> None: ... + class LogicResult: + def __init__(self, logicState: jneqsim.process.logic.LogicState, string: typing.Union[java.lang.String, str]): ... + def getFinalState(self) -> jneqsim.process.logic.LogicState: ... + def getStatusDescription(self) -> java.lang.String: ... + +class ScenarioTestRunner: + def __init__(self, processScenarioRunner: ProcessScenarioRunner): ... + def batch(self) -> 'ScenarioTestRunner.BatchExecutor': ... + def displayDashboard(self) -> None: ... + @typing.overload + def executeScenario(self, string: typing.Union[java.lang.String, str], processSafetyScenario: jneqsim.process.safety.ProcessSafetyScenario, double: float, double2: float) -> ScenarioExecutionSummary: ... + @typing.overload + def executeScenario(self, string: typing.Union[java.lang.String, str], processSafetyScenario: jneqsim.process.safety.ProcessSafetyScenario, string2: typing.Union[java.lang.String, str], double: float, double2: float) -> ScenarioExecutionSummary: ... + def executeScenarioWithDelayedActivation(self, string: typing.Union[java.lang.String, str], processSafetyScenario: jneqsim.process.safety.ProcessSafetyScenario, string2: typing.Union[java.lang.String, str], long: int, string3: typing.Union[java.lang.String, str], double: float, double2: float) -> ScenarioExecutionSummary: ... + def getDashboard(self) -> jneqsim.process.util.monitor.KPIDashboard: ... + def getRunner(self) -> ProcessScenarioRunner: ... + def getScenarioCount(self) -> int: ... + def printHeader(self) -> None: ... + def resetCounter(self) -> None: ... + class BatchExecutor: + def __init__(self, scenarioTestRunner: 'ScenarioTestRunner'): ... + def add(self, string: typing.Union[java.lang.String, str], processSafetyScenario: jneqsim.process.safety.ProcessSafetyScenario, string2: typing.Union[java.lang.String, str], double: float, double2: float) -> 'ScenarioTestRunner.BatchExecutor': ... + def addDelayed(self, string: typing.Union[java.lang.String, str], processSafetyScenario: jneqsim.process.safety.ProcessSafetyScenario, string2: typing.Union[java.lang.String, str], long: int, string3: typing.Union[java.lang.String, str], double: float, double2: float) -> 'ScenarioTestRunner.BatchExecutor': ... + def execute(self) -> None: ... + def executeWithoutWrapper(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.util.scenario")``. + + ProcessScenarioRunner: typing.Type[ProcessScenarioRunner] + ScenarioExecutionSummary: typing.Type[ScenarioExecutionSummary] + ScenarioTestRunner: typing.Type[ScenarioTestRunner] diff --git a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/__init__.pyi new file mode 100644 index 00000000..4f6e72cb --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/__init__.pyi @@ -0,0 +1,21 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.pvtsimulation.modeltuning +import jneqsim.pvtsimulation.reservoirproperties +import jneqsim.pvtsimulation.simulation +import jneqsim.pvtsimulation.util +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.pvtsimulation")``. + + modeltuning: jneqsim.pvtsimulation.modeltuning.__module_protocol__ + reservoirproperties: jneqsim.pvtsimulation.reservoirproperties.__module_protocol__ + simulation: jneqsim.pvtsimulation.simulation.__module_protocol__ + util: jneqsim.pvtsimulation.util.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/modeltuning/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/modeltuning/__init__.pyi new file mode 100644 index 00000000..8a5364a3 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/modeltuning/__init__.pyi @@ -0,0 +1,40 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.pvtsimulation.simulation +import typing + + + +class TuningInterface: + def getSimulation(self) -> jneqsim.pvtsimulation.simulation.SimulationInterface: ... + def run(self) -> None: ... + def setSaturationConditions(self, double: float, double2: float) -> None: ... + +class BaseTuningClass(TuningInterface): + saturationTemperature: float = ... + saturationPressure: float = ... + def __init__(self, simulationInterface: jneqsim.pvtsimulation.simulation.SimulationInterface): ... + def getSimulation(self) -> jneqsim.pvtsimulation.simulation.SimulationInterface: ... + def isTunePlusMolarMass(self) -> bool: ... + def isTuneVolumeCorrection(self) -> bool: ... + def run(self) -> None: ... + def setSaturationConditions(self, double: float, double2: float) -> None: ... + def setTunePlusMolarMass(self, boolean: bool) -> None: ... + def setTuneVolumeCorrection(self, boolean: bool) -> None: ... + +class TuneToSaturation(BaseTuningClass): + def __init__(self, simulationInterface: jneqsim.pvtsimulation.simulation.SimulationInterface): ... + def run(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.pvtsimulation.modeltuning")``. + + BaseTuningClass: typing.Type[BaseTuningClass] + TuneToSaturation: typing.Type[TuneToSaturation] + TuningInterface: typing.Type[TuningInterface] diff --git a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/reservoirproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/reservoirproperties/__init__.pyi new file mode 100644 index 00000000..b99e8f30 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/reservoirproperties/__init__.pyi @@ -0,0 +1,23 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import typing + + + +class CompositionEstimation: + def __init__(self, double: float, double2: float): ... + @typing.overload + def estimateH2Sconcentration(self) -> float: ... + @typing.overload + def estimateH2Sconcentration(self, double: float) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.pvtsimulation.reservoirproperties")``. + + CompositionEstimation: typing.Type[CompositionEstimation] diff --git a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/simulation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/simulation/__init__.pyi new file mode 100644 index 00000000..2fd456e4 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/simulation/__init__.pyi @@ -0,0 +1,220 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.statistics.parameterfitting.nonlinearparameterfitting +import jneqsim.thermo.system +import jneqsim.thermodynamicoperations +import typing + + + +class SimulationInterface: + def getBaseThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getOptimizer(self) -> jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardt: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def run(self) -> None: ... + def setTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + +class BasePVTsimulation(SimulationInterface): + thermoOps: jneqsim.thermodynamicoperations.ThermodynamicOperations = ... + pressures: typing.MutableSequence[float] = ... + temperature: float = ... + optimizer: jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardt = ... + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getBaseThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getOptimizer(self) -> jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardt: ... + def getPressure(self) -> float: ... + def getPressures(self) -> typing.MutableSequence[float]: ... + def getSaturationPressure(self) -> float: ... + def getSaturationTemperature(self) -> float: ... + def getTemperature(self) -> float: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getZsaturation(self) -> float: ... + def run(self) -> None: ... + def setExperimentalData(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setPressure(self, double: float) -> None: ... + def setPressures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setTemperature(self, double: float) -> None: ... + @typing.overload + def setTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + +class ConstantMassExpansion(BasePVTsimulation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcSaturationConditions(self) -> None: ... + def getBg(self) -> typing.MutableSequence[float]: ... + def getDensity(self) -> typing.MutableSequence[float]: ... + def getIsoThermalCompressibility(self) -> typing.MutableSequence[float]: ... + def getLiquidRelativeVolume(self) -> typing.MutableSequence[float]: ... + def getRelativeVolume(self) -> typing.MutableSequence[float]: ... + def getSaturationIsoThermalCompressibility(self) -> float: ... + def getSaturationPressure(self) -> float: ... + def getViscosity(self) -> typing.MutableSequence[float]: ... + def getYfactor(self) -> typing.MutableSequence[float]: ... + def getZgas(self) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def runCalc(self) -> None: ... + def runTuning(self) -> None: ... + def setTemperaturesAndPressures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class ConstantVolumeDepletion(BasePVTsimulation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcSaturationConditions(self) -> None: ... + def getCummulativeMolePercDepleted(self) -> typing.MutableSequence[float]: ... + def getLiquidRelativeVolume(self) -> typing.MutableSequence[float]: ... + def getRelativeVolume(self) -> typing.MutableSequence[float]: ... + def getSaturationPressure(self) -> float: ... + def getZgas(self) -> typing.MutableSequence[float]: ... + def getZmix(self) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def runCalc(self) -> None: ... + def runTuning(self) -> None: ... + def setTemperaturesAndPressures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class DensitySim(BasePVTsimulation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getAqueousDensity(self) -> typing.MutableSequence[float]: ... + def getGasDensity(self) -> typing.MutableSequence[float]: ... + def getOilDensity(self) -> typing.MutableSequence[float]: ... + def getWaxFraction(self) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def runCalc(self) -> None: ... + def runTuning(self) -> None: ... + def setTemperaturesAndPressures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class DifferentialLiberation(BasePVTsimulation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcSaturationConditions(self) -> None: ... + def getBg(self) -> typing.MutableSequence[float]: ... + def getBo(self) -> typing.MutableSequence[float]: ... + def getGasStandardVolume(self) -> typing.MutableSequence[float]: ... + def getOilDensity(self) -> typing.MutableSequence[float]: ... + def getRelGasGravity(self) -> typing.MutableSequence[float]: ... + def getRelativeVolume(self) -> typing.MutableSequence[float]: ... + def getRs(self) -> typing.MutableSequence[float]: ... + def getSaturationPressure(self) -> float: ... + def getZgas(self) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def runCalc(self) -> None: ... + +class GOR(BasePVTsimulation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getBofactor(self) -> typing.MutableSequence[float]: ... + def getGOR(self) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def runCalc(self) -> None: ... + def setTemperaturesAndPressures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class SaturationPressure(BasePVTsimulation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcSaturationPressure(self) -> float: ... + def getSaturationPressure(self) -> float: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def run(self) -> None: ... + +class SaturationTemperature(BasePVTsimulation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcSaturationTemperature(self) -> float: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def run(self) -> None: ... + +class SeparatorTest(BasePVTsimulation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getBofactor(self) -> typing.MutableSequence[float]: ... + def getGOR(self) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def runCalc(self) -> None: ... + def setSeparatorConditions(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class SlimTubeSim(BasePVTsimulation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface): ... + def getNumberOfSlimTubeNodes(self) -> int: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def run(self) -> None: ... + def setNumberOfSlimTubeNodes(self, int: int) -> None: ... + +class SwellingTest(BasePVTsimulation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getPressures(self) -> typing.MutableSequence[float]: ... + def getRelativeOilVolume(self) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def runCalc(self) -> None: ... + def setCummulativeMolePercentGasInjected(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setInjectionGas(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setPressures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setRelativeOilVolume(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class ViscositySim(BasePVTsimulation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getAqueousViscosity(self) -> typing.MutableSequence[float]: ... + def getGasViscosity(self) -> typing.MutableSequence[float]: ... + def getOilViscosity(self) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def runCalc(self) -> None: ... + def runTuning(self) -> None: ... + def setTemperaturesAndPressures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class ViscosityWaxOilSim(BasePVTsimulation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getAqueousViscosity(self) -> typing.MutableSequence[float]: ... + def getGasViscosity(self) -> typing.MutableSequence[float]: ... + def getOilViscosity(self) -> typing.MutableSequence[float]: ... + def getOilwaxDispersionViscosity(self) -> typing.MutableSequence[float]: ... + def getShareRate(self) -> typing.MutableSequence[float]: ... + def getWaxFraction(self) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def runCalc(self) -> None: ... + def runTuning(self) -> None: ... + def setShareRate(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setTemperaturesAndPressures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class WaxFractionSim(BasePVTsimulation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getBofactor(self) -> typing.MutableSequence[float]: ... + def getGOR(self) -> typing.MutableSequence[float]: ... + def getWaxFraction(self) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def runCalc(self) -> None: ... + def runTuning(self) -> None: ... + def setTemperaturesAndPressures(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.pvtsimulation.simulation")``. + + BasePVTsimulation: typing.Type[BasePVTsimulation] + ConstantMassExpansion: typing.Type[ConstantMassExpansion] + ConstantVolumeDepletion: typing.Type[ConstantVolumeDepletion] + DensitySim: typing.Type[DensitySim] + DifferentialLiberation: typing.Type[DifferentialLiberation] + GOR: typing.Type[GOR] + SaturationPressure: typing.Type[SaturationPressure] + SaturationTemperature: typing.Type[SaturationTemperature] + SeparatorTest: typing.Type[SeparatorTest] + SimulationInterface: typing.Type[SimulationInterface] + SlimTubeSim: typing.Type[SlimTubeSim] + SwellingTest: typing.Type[SwellingTest] + ViscositySim: typing.Type[ViscositySim] + ViscosityWaxOilSim: typing.Type[ViscosityWaxOilSim] + WaxFractionSim: typing.Type[WaxFractionSim] diff --git a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/__init__.pyi new file mode 100644 index 00000000..e277f0bc --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/__init__.pyi @@ -0,0 +1,15 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.pvtsimulation.util.parameterfitting +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.pvtsimulation.util")``. + + parameterfitting: jneqsim.pvtsimulation.util.parameterfitting.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/parameterfitting/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/parameterfitting/__init__.pyi new file mode 100644 index 00000000..e5531a20 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/parameterfitting/__init__.pyi @@ -0,0 +1,105 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.statistics.parameterfitting.nonlinearparameterfitting +import jneqsim.thermo.system +import typing + + + +class CMEFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): + def __init__(self): ... + def calcSaturationConditions(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + @typing.overload + def setFittingParams(self, int: int, double: float) -> None: ... + @typing.overload + def setFittingParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class CVDFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): + def __init__(self): ... + def calcSaturationConditions(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + @typing.overload + def setFittingParams(self, int: int, double: float) -> None: ... + @typing.overload + def setFittingParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class DensityFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): + def __init__(self): ... + def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + @typing.overload + def setFittingParams(self, int: int, double: float) -> None: ... + @typing.overload + def setFittingParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class FunctionJohanSverderup(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): + def __init__(self): ... + def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + @typing.overload + def setFittingParams(self, int: int, double: float) -> None: ... + @typing.overload + def setFittingParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class SaturationPressureFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): + def __init__(self): ... + def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + @typing.overload + def setFittingParams(self, int: int, double: float) -> None: ... + @typing.overload + def setFittingParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class TestFitToOilFieldFluid: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class TestSaturationPresFunction: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class TestWaxTuning: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class ViscosityFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, boolean: bool): ... + def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + @typing.overload + def setFittingParams(self, int: int, double: float) -> None: ... + @typing.overload + def setFittingParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class WaxFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): + def __init__(self): ... + def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + @typing.overload + def setFittingParams(self, int: int, double: float) -> None: ... + @typing.overload + def setFittingParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.pvtsimulation.util.parameterfitting")``. + + CMEFunction: typing.Type[CMEFunction] + CVDFunction: typing.Type[CVDFunction] + DensityFunction: typing.Type[DensityFunction] + FunctionJohanSverderup: typing.Type[FunctionJohanSverderup] + SaturationPressureFunction: typing.Type[SaturationPressureFunction] + TestFitToOilFieldFluid: typing.Type[TestFitToOilFieldFluid] + TestSaturationPresFunction: typing.Type[TestSaturationPresFunction] + TestWaxTuning: typing.Type[TestWaxTuning] + ViscosityFunction: typing.Type[ViscosityFunction] + WaxFunction: typing.Type[WaxFunction] diff --git a/src/jneqsim-stubs/jneqsim-stubs/standards/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/standards/__init__.pyi new file mode 100644 index 00000000..aa81e80f --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/standards/__init__.pyi @@ -0,0 +1,74 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.standards.gasquality +import jneqsim.standards.oilquality +import jneqsim.standards.salescontract +import jneqsim.thermo.system +import jneqsim.util +import typing + + + +class StandardInterface: + def calculate(self) -> None: ... + def createTable(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def display(self, string: typing.Union[java.lang.String, str]) -> None: ... + def getName(self) -> java.lang.String: ... + def getReferencePressure(self) -> float: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getSalesContract(self) -> jneqsim.standards.salescontract.ContractInterface: ... + def getStandardDescription(self) -> java.lang.String: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def isOnSpec(self) -> bool: ... + def setReferencePressure(self, double: float) -> None: ... + def setResultTable(self, stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> None: ... + @typing.overload + def setSalesContract(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setSalesContract(self, contractInterface: jneqsim.standards.salescontract.ContractInterface) -> None: ... + def setThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + +class Standard(jneqsim.util.NamedBaseClass, StandardInterface): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface): ... + def createTable(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def display(self, string: typing.Union[java.lang.String, str]) -> None: ... + def getReferencePressure(self) -> float: ... + def getReferenceState(self) -> java.lang.String: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getSalesContract(self) -> jneqsim.standards.salescontract.ContractInterface: ... + def getStandardDescription(self) -> java.lang.String: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def setReferencePressure(self, double: float) -> None: ... + def setReferenceState(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setResultTable(self, stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> None: ... + @typing.overload + def setSalesContract(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setSalesContract(self, contractInterface: jneqsim.standards.salescontract.ContractInterface) -> None: ... + def setStandardDescription(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.standards")``. + + Standard: typing.Type[Standard] + StandardInterface: typing.Type[StandardInterface] + gasquality: jneqsim.standards.gasquality.__module_protocol__ + oilquality: jneqsim.standards.oilquality.__module_protocol__ + salescontract: jneqsim.standards.salescontract.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/standards/gasquality/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/standards/gasquality/__init__.pyi new file mode 100644 index 00000000..d1bd2c5b --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/standards/gasquality/__init__.pyi @@ -0,0 +1,162 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.standards +import jneqsim.thermo +import jneqsim.thermo.system +import typing + + + +class BestPracticeHydrocarbonDewPoint(jneqsim.standards.Standard): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calculate(self) -> None: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def isOnSpec(self) -> bool: ... + +class Draft_GERG2004(jneqsim.standards.Standard): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calculate(self) -> None: ... + def createTable(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def isOnSpec(self) -> bool: ... + +class Draft_ISO18453(jneqsim.standards.Standard): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calculate(self) -> None: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def isOnSpec(self) -> bool: ... + +class GasChromotograpyhBase(jneqsim.standards.Standard): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calculate(self) -> None: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def isOnSpec(self) -> bool: ... + +class Standard_ISO15403(jneqsim.standards.Standard): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calculate(self) -> None: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def isOnSpec(self) -> bool: ... + +class Standard_ISO6578(jneqsim.standards.Standard): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calculate(self) -> None: ... + def getCorrFactor1(self) -> float: ... + def getCorrFactor2(self) -> float: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def isOnSpec(self) -> bool: ... + def setCorrectionFactors(self) -> None: ... + def useISO6578VolumeCorrectionFacotrs(self, boolean: bool) -> None: ... + +class Standard_ISO6976(jneqsim.standards.Standard, jneqsim.thermo.ThermodynamicConstantsInterface): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float, string: typing.Union[java.lang.String, str]): ... + def calculate(self) -> None: ... + def checkReferenceCondition(self) -> None: ... + def createTable(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getAverageCarbonNumber(self) -> float: ... + def getComponentsNotDefinedByStandard(self) -> java.util.ArrayList[java.lang.String]: ... + def getEnergyRefP(self) -> float: ... + def getEnergyRefT(self) -> float: ... + def getReferenceType(self) -> java.lang.String: ... + def getTotalMolesOfInerts(self) -> float: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def getVolRefT(self) -> float: ... + def isOnSpec(self) -> bool: ... + def removeInertsButNitrogen(self) -> None: ... + def setEnergyRefP(self, double: float) -> None: ... + def setEnergyRefT(self, double: float) -> None: ... + def setReferenceType(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setVolRefT(self, double: float) -> None: ... + +class SulfurSpecificationMethod(jneqsim.standards.Standard): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calculate(self) -> None: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def isOnSpec(self) -> bool: ... + +class UKspecifications_ICF_SI(jneqsim.standards.Standard): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcPropaneNumber(self) -> float: ... + def calcWithNitrogenAsInert(self) -> float: ... + def calculate(self) -> None: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def isOnSpec(self) -> bool: ... + +class Standard_ISO6974(GasChromotograpyhBase): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + +class Standard_ISO6976_2016(Standard_ISO6976): + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float, string: typing.Union[java.lang.String, str]): ... + def calculate(self) -> None: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.standards.gasquality")``. + + BestPracticeHydrocarbonDewPoint: typing.Type[BestPracticeHydrocarbonDewPoint] + Draft_GERG2004: typing.Type[Draft_GERG2004] + Draft_ISO18453: typing.Type[Draft_ISO18453] + GasChromotograpyhBase: typing.Type[GasChromotograpyhBase] + Standard_ISO15403: typing.Type[Standard_ISO15403] + Standard_ISO6578: typing.Type[Standard_ISO6578] + Standard_ISO6974: typing.Type[Standard_ISO6974] + Standard_ISO6976: typing.Type[Standard_ISO6976] + Standard_ISO6976_2016: typing.Type[Standard_ISO6976_2016] + SulfurSpecificationMethod: typing.Type[SulfurSpecificationMethod] + UKspecifications_ICF_SI: typing.Type[UKspecifications_ICF_SI] diff --git a/src/jneqsim-stubs/jneqsim-stubs/standards/oilquality/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/standards/oilquality/__init__.pyi new file mode 100644 index 00000000..263ef45b --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/standards/oilquality/__init__.pyi @@ -0,0 +1,35 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.standards +import jneqsim.thermo.system +import typing + + + +class Standard_ASTM_D6377(jneqsim.standards.Standard): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calculate(self) -> None: ... + def getMethodRVP(self) -> java.lang.String: ... + def getUnit(self, string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + def isOnSpec(self) -> bool: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def setMethodRVP(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setReferenceTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.standards.oilquality")``. + + Standard_ASTM_D6377: typing.Type[Standard_ASTM_D6377] diff --git a/src/jneqsim-stubs/jneqsim-stubs/standards/salescontract/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/standards/salescontract/__init__.pyi new file mode 100644 index 00000000..af7ebe28 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/standards/salescontract/__init__.pyi @@ -0,0 +1,87 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.standards +import jneqsim.thermo.system +import jneqsim.util +import typing + + + +class ContractInterface: + def display(self) -> None: ... + def getContractName(self) -> java.lang.String: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getSpecificationsNumber(self) -> int: ... + def getWaterDewPointSpecPressure(self) -> float: ... + def getWaterDewPointTemperature(self) -> float: ... + def prettyPrint(self) -> None: ... + def runCheck(self) -> None: ... + def setContract(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setContractName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setResultTable(self, stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> None: ... + def setSpecificationsNumber(self, int: int) -> None: ... + def setWaterDewPointSpecPressure(self, double: float) -> None: ... + def setWaterDewPointTemperature(self, double: float) -> None: ... + +class ContractSpecification(jneqsim.util.NamedBaseClass): + 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], standardInterface: jneqsim.standards.StandardInterface, double: float, double2: float, string5: typing.Union[java.lang.String, str], double3: float, double4: float, double5: float, string6: typing.Union[java.lang.String, str]): ... + def getComments(self) -> java.lang.String: ... + def getCountry(self) -> java.lang.String: ... + def getMaxValue(self) -> float: ... + def getMinValue(self) -> float: ... + def getReferencePressure(self) -> float: ... + def getReferenceTemperatureCombustion(self) -> float: ... + def getReferenceTemperatureMeasurement(self) -> float: ... + def getSpecification(self) -> java.lang.String: ... + def getStandard(self) -> jneqsim.standards.StandardInterface: ... + def getTerminal(self) -> java.lang.String: ... + def getUnit(self) -> java.lang.String: ... + def setComments(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setCountry(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setMaxValue(self, double: float) -> None: ... + def setMinValue(self, double: float) -> None: ... + def setReferencePressure(self, double: float) -> None: ... + def setReferenceTemperatureCombustion(self, double: float) -> None: ... + def setReferenceTemperatureMeasurement(self, double: float) -> None: ... + def setSpecification(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setStandard(self, standardInterface: jneqsim.standards.StandardInterface) -> None: ... + def setTerminal(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class BaseContract(ContractInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + def display(self) -> None: ... + def getContractName(self) -> java.lang.String: ... + def getMethod(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str]) -> jneqsim.standards.StandardInterface: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getSpecification(self, standardInterface: jneqsim.standards.StandardInterface, 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], double: float, double2: float, string5: typing.Union[java.lang.String, str], double3: float, double4: float, double5: float, string6: typing.Union[java.lang.String, str]) -> ContractSpecification: ... + def getSpecificationsNumber(self) -> int: ... + def getWaterDewPointSpecPressure(self) -> float: ... + def getWaterDewPointTemperature(self) -> float: ... + def runCheck(self) -> None: ... + def setContract(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setContractName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setResultTable(self, stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> None: ... + def setSpecificationsNumber(self, int: int) -> None: ... + def setWaterDewPointSpecPressure(self, double: float) -> None: ... + def setWaterDewPointTemperature(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.standards.salescontract")``. + + BaseContract: typing.Type[BaseContract] + ContractInterface: typing.Type[ContractInterface] + ContractSpecification: typing.Type[ContractSpecification] diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/__init__.pyi new file mode 100644 index 00000000..4de2aed8 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/__init__.pyi @@ -0,0 +1,23 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.statistics.dataanalysis +import jneqsim.statistics.experimentalequipmentdata +import jneqsim.statistics.experimentalsamplecreation +import jneqsim.statistics.montecarlosimulation +import jneqsim.statistics.parameterfitting +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics")``. + + dataanalysis: jneqsim.statistics.dataanalysis.__module_protocol__ + experimentalequipmentdata: jneqsim.statistics.experimentalequipmentdata.__module_protocol__ + experimentalsamplecreation: jneqsim.statistics.experimentalsamplecreation.__module_protocol__ + montecarlosimulation: jneqsim.statistics.montecarlosimulation.__module_protocol__ + parameterfitting: jneqsim.statistics.parameterfitting.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/dataanalysis/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/dataanalysis/__init__.pyi new file mode 100644 index 00000000..e804dc52 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/dataanalysis/__init__.pyi @@ -0,0 +1,15 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.statistics.dataanalysis.datasmoothing +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.dataanalysis")``. + + datasmoothing: jneqsim.statistics.dataanalysis.datasmoothing.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/dataanalysis/datasmoothing/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/dataanalysis/datasmoothing/__init__.pyi new file mode 100644 index 00000000..8984079f --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/dataanalysis/datasmoothing/__init__.pyi @@ -0,0 +1,24 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jpype +import typing + + + +class DataSmoother: + def __init__(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], int: int, int2: int, int3: int, int4: int): ... + def findCoefs(self) -> None: ... + def getSmoothedNumbers(self) -> typing.MutableSequence[float]: ... + def runSmoothing(self) -> None: ... + def setSmoothedNumbers(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.dataanalysis.datasmoothing")``. + + DataSmoother: typing.Type[DataSmoother] diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalequipmentdata/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalequipmentdata/__init__.pyi new file mode 100644 index 00000000..6651e63b --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalequipmentdata/__init__.pyi @@ -0,0 +1,21 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.statistics.experimentalequipmentdata.wettedwallcolumndata +import typing + + + +class ExperimentalEquipmentData: + def __init__(self): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.experimentalequipmentdata")``. + + ExperimentalEquipmentData: typing.Type[ExperimentalEquipmentData] + wettedwallcolumndata: jneqsim.statistics.experimentalequipmentdata.wettedwallcolumndata.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalequipmentdata/wettedwallcolumndata/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalequipmentdata/wettedwallcolumndata/__init__.pyi new file mode 100644 index 00000000..d585e8f5 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalequipmentdata/wettedwallcolumndata/__init__.pyi @@ -0,0 +1,29 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.statistics.experimentalequipmentdata +import typing + + + +class WettedWallColumnData(jneqsim.statistics.experimentalequipmentdata.ExperimentalEquipmentData): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float, double3: float): ... + def getDiameter(self) -> float: ... + def getLength(self) -> float: ... + def getVolume(self) -> float: ... + def setDiameter(self, double: float) -> None: ... + def setLength(self, double: float) -> None: ... + def setVolume(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.experimentalequipmentdata.wettedwallcolumndata")``. + + WettedWallColumnData: typing.Type[WettedWallColumnData] diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/__init__.pyi new file mode 100644 index 00000000..0b5765ca --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/__init__.pyi @@ -0,0 +1,17 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.statistics.experimentalsamplecreation.readdatafromfile +import jneqsim.statistics.experimentalsamplecreation.samplecreator +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.experimentalsamplecreation")``. + + readdatafromfile: jneqsim.statistics.experimentalsamplecreation.readdatafromfile.__module_protocol__ + samplecreator: jneqsim.statistics.experimentalsamplecreation.samplecreator.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/readdatafromfile/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/readdatafromfile/__init__.pyi new file mode 100644 index 00000000..92703d0b --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/readdatafromfile/__init__.pyi @@ -0,0 +1,42 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.statistics.experimentalsamplecreation.readdatafromfile.wettedwallcolumnreader +import typing + + + +class DataObjectInterface: ... + +class DataReaderInterface: + def readData(self) -> None: ... + +class DataObject(DataObjectInterface): + def __init__(self): ... + +class DataReader(DataReaderInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def getSampleObjectList(self) -> java.util.ArrayList[DataObject]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def readData(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.experimentalsamplecreation.readdatafromfile")``. + + DataObject: typing.Type[DataObject] + DataObjectInterface: typing.Type[DataObjectInterface] + DataReader: typing.Type[DataReader] + DataReaderInterface: typing.Type[DataReaderInterface] + wettedwallcolumnreader: jneqsim.statistics.experimentalsamplecreation.readdatafromfile.wettedwallcolumnreader.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/readdatafromfile/wettedwallcolumnreader/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/readdatafromfile/wettedwallcolumnreader/__init__.pyi new file mode 100644 index 00000000..6ad03530 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/readdatafromfile/wettedwallcolumnreader/__init__.pyi @@ -0,0 +1,52 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.statistics.experimentalsamplecreation.readdatafromfile +import typing + + + +class WettedWallColumnDataObject(jneqsim.statistics.experimentalsamplecreation.readdatafromfile.DataObject): + def __init__(self): ... + def getCo2SupplyFlow(self) -> float: ... + def getColumnWallTemperature(self) -> float: ... + def getInletGasTemperature(self) -> float: ... + def getInletLiquidFlow(self) -> float: ... + def getInletLiquidTemperature(self) -> float: ... + def getInletTotalGasFlow(self) -> float: ... + def getOutletGasTemperature(self) -> float: ... + def getOutletLiquidTemperature(self) -> float: ... + def getPressure(self) -> float: ... + def getTime(self) -> int: ... + def setCo2SupplyFlow(self, double: float) -> None: ... + def setColumnWallTemperature(self, double: float) -> None: ... + def setInletGasTemperature(self, double: float) -> None: ... + def setInletLiquidFlow(self, double: float) -> None: ... + def setInletLiquidTemperature(self, double: float) -> None: ... + def setInletTotalGasFlow(self, double: float) -> None: ... + def setOutletGasTemperature(self, double: float) -> None: ... + def setOutletLiquidTemperature(self, double: float) -> None: ... + def setPressure(self, double: float) -> None: ... + def setTime(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class WettedWallDataReader(jneqsim.statistics.experimentalsamplecreation.readdatafromfile.DataReader): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def readData(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.experimentalsamplecreation.readdatafromfile.wettedwallcolumnreader")``. + + WettedWallColumnDataObject: typing.Type[WettedWallColumnDataObject] + WettedWallDataReader: typing.Type[WettedWallDataReader] diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/samplecreator/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/samplecreator/__init__.pyi new file mode 100644 index 00000000..44b40d9b --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/samplecreator/__init__.pyi @@ -0,0 +1,29 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.statistics.experimentalequipmentdata +import jneqsim.statistics.experimentalsamplecreation.samplecreator.wettedwallcolumnsamplecreator +import jneqsim.thermo.system +import jneqsim.thermodynamicoperations +import typing + + + +class SampleCreator: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, thermodynamicOperations: jneqsim.thermodynamicoperations.ThermodynamicOperations): ... + def setExperimentalEquipment(self, experimentalEquipmentData: jneqsim.statistics.experimentalequipmentdata.ExperimentalEquipmentData) -> None: ... + def setThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.experimentalsamplecreation.samplecreator")``. + + SampleCreator: typing.Type[SampleCreator] + wettedwallcolumnsamplecreator: jneqsim.statistics.experimentalsamplecreation.samplecreator.wettedwallcolumnsamplecreator.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/samplecreator/wettedwallcolumnsamplecreator/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/samplecreator/wettedwallcolumnsamplecreator/__init__.pyi new file mode 100644 index 00000000..e7a3938a --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/samplecreator/wettedwallcolumnsamplecreator/__init__.pyi @@ -0,0 +1,30 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.statistics.experimentalsamplecreation.samplecreator +import typing + + + +class WettedWallColumnSampleCreator(jneqsim.statistics.experimentalsamplecreation.samplecreator.SampleCreator): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def calcdPdt(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def setSampleValues(self) -> None: ... + def smoothData(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.experimentalsamplecreation.samplecreator.wettedwallcolumnsamplecreator")``. + + WettedWallColumnSampleCreator: typing.Type[WettedWallColumnSampleCreator] diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/montecarlosimulation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/montecarlosimulation/__init__.pyi new file mode 100644 index 00000000..16975fdd --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/montecarlosimulation/__init__.pyi @@ -0,0 +1,28 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.statistics.parameterfitting +import typing + + + +class MonteCarloSimulation: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, statisticsBaseClass: jneqsim.statistics.parameterfitting.StatisticsBaseClass, int: int): ... + @typing.overload + def __init__(self, statisticsInterface: jneqsim.statistics.parameterfitting.StatisticsInterface): ... + def createReportMatrix(self) -> None: ... + def runSimulation(self) -> None: ... + def setNumberOfRuns(self, int: int) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.montecarlosimulation")``. + + MonteCarloSimulation: typing.Type[MonteCarloSimulation] diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/parameterfitting/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/parameterfitting/__init__.pyi new file mode 100644 index 00000000..d5fd8de6 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/parameterfitting/__init__.pyi @@ -0,0 +1,173 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import Jama +import java.io +import java.lang +import java.util +import jpype +import jneqsim.statistics.parameterfitting.nonlinearparameterfitting +import jneqsim.thermo.system +import jneqsim.thermodynamicoperations +import typing + + + +class FunctionInterface(java.lang.Cloneable): + def calcTrueValue(self, double: float) -> float: ... + def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + def clone(self) -> 'FunctionInterface': ... + def getBounds(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + def getFittingParams(self, int: int) -> float: ... + @typing.overload + def getFittingParams(self) -> typing.MutableSequence[float]: ... + def getLowerBound(self, int: int) -> float: ... + def getNumberOfFittingParams(self) -> int: ... + def getSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getUpperBound(self, int: int) -> float: ... + def setBounds(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDatabaseParameters(self) -> None: ... + def setFittingParams(self, int: int, double: float) -> None: ... + def setInitialGuess(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setThermodynamicSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + +class NumericalDerivative(java.io.Serializable): + @staticmethod + def calcDerivative(statisticsBaseClass: 'StatisticsBaseClass', int: int, int2: int) -> float: ... + +class SampleSet(java.lang.Cloneable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, arrayList: java.util.ArrayList['SampleValue']): ... + @typing.overload + def __init__(self, sampleValueArray: typing.Union[typing.List['SampleValue'], jpype.JArray]): ... + def add(self, sampleValue: 'SampleValue') -> None: ... + def addSampleSet(self, sampleSet: 'SampleSet') -> None: ... + def clone(self) -> 'SampleSet': ... + def createNewNormalDistributedSet(self) -> 'SampleSet': ... + def getLength(self) -> int: ... + def getSample(self, int: int) -> 'SampleValue': ... + +class SampleValue(java.lang.Cloneable): + system: jneqsim.thermo.system.SystemInterface = ... + thermoOps: jneqsim.thermodynamicoperations.ThermodynamicOperations = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray]): ... + @typing.overload + def __init__(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]): ... + def clone(self) -> 'SampleValue': ... + def getDependentValue(self, int: int) -> float: ... + def getDependentValues(self) -> typing.MutableSequence[float]: ... + def getDescription(self) -> java.lang.String: ... + def getFunction(self) -> FunctionInterface: ... + def getReference(self) -> java.lang.String: ... + def getSampleValue(self) -> float: ... + @typing.overload + def getStandardDeviation(self) -> float: ... + @typing.overload + def getStandardDeviation(self, int: int) -> float: ... + def setDependentValue(self, int: int, double: float) -> None: ... + def setDependentValues(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setDescription(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setFunction(self, baseFunction: 'BaseFunction') -> None: ... + def setReference(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setThermodynamicSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + +class StatisticsInterface: + def createNewRandomClass(self) -> 'StatisticsBaseClass': ... + def displayCurveFit(self) -> None: ... + def displayResult(self) -> None: ... + def getNumberOfTuningParameters(self) -> int: ... + def getSampleSet(self) -> SampleSet: ... + def init(self) -> None: ... + def runMonteCarloSimulation(self, int: int) -> None: ... + def setNumberOfTuningParameters(self, int: int) -> None: ... + def solve(self) -> None: ... + def writeToTextFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class BaseFunction(FunctionInterface): + params: typing.MutableSequence[float] = ... + bounds: typing.MutableSequence[typing.MutableSequence[float]] = ... + system: jneqsim.thermo.system.SystemInterface = ... + thermoOps: jneqsim.thermodynamicoperations.ThermodynamicOperations = ... + def __init__(self): ... + def calcTrueValue(self, double: float) -> float: ... + def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + def clone(self) -> 'BaseFunction': ... + def getBounds(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + def getFittingParams(self, int: int) -> float: ... + @typing.overload + def getFittingParams(self) -> typing.MutableSequence[float]: ... + def getLowerBound(self, int: int) -> float: ... + def getNumberOfFittingParams(self) -> int: ... + def getSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getUpperBound(self, int: int) -> float: ... + def setBounds(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDatabaseParameters(self) -> None: ... + def setFittingParams(self, int: int, double: float) -> None: ... + def setInitialGuess(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setThermodynamicSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + +class StatisticsBaseClass(java.lang.Cloneable, StatisticsInterface): + def __init__(self): ... + def addSampleSet(self, sampleSet: SampleSet) -> None: ... + def calcAbsDev(self) -> None: ... + def calcAlphaMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def calcBetaMatrix(self) -> typing.MutableSequence[float]: ... + def calcChiSquare(self) -> float: ... + def calcCoVarianceMatrix(self) -> None: ... + def calcCorrelationMatrix(self) -> None: ... + def calcDerivatives(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def calcDeviation(self) -> None: ... + def calcParameterStandardDeviation(self) -> None: ... + def calcParameterUncertainty(self) -> None: ... + @typing.overload + def calcTrueValue(self, double: float, sampleValue: SampleValue) -> float: ... + @typing.overload + def calcTrueValue(self, sampleValue: SampleValue) -> float: ... + def calcValue(self, sampleValue: SampleValue) -> float: ... + def checkBounds(self, matrix: Jama.Matrix) -> None: ... + def clone(self) -> 'StatisticsBaseClass': ... + def createNewRandomClass(self) -> 'StatisticsBaseClass': ... + def displayCurveFit(self) -> None: ... + def displayMatrix(self, matrix: Jama.Matrix, string: typing.Union[java.lang.String, str], int: int) -> None: ... + def displayResult(self) -> None: ... + def displayResultWithDeviation(self) -> None: ... + def displaySimple(self) -> None: ... + def displayValues(self) -> None: ... + def getNumberOfTuningParameters(self) -> int: ... + def getSample(self, int: int) -> SampleValue: ... + def getSampleSet(self) -> SampleSet: ... + def init(self) -> None: ... + @typing.overload + def runMonteCarloSimulation(self) -> None: ... + @typing.overload + def runMonteCarloSimulation(self, int: int) -> None: ... + def setFittingParameter(self, int: int, double: float) -> None: ... + def setFittingParameters(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setNumberOfTuningParameters(self, int: int) -> None: ... + def setSampleSet(self, sampleSet: SampleSet) -> None: ... + def solve(self) -> None: ... + def writeToTextFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.parameterfitting")``. + + BaseFunction: typing.Type[BaseFunction] + FunctionInterface: typing.Type[FunctionInterface] + NumericalDerivative: typing.Type[NumericalDerivative] + SampleSet: typing.Type[SampleSet] + SampleValue: typing.Type[SampleValue] + StatisticsBaseClass: typing.Type[StatisticsBaseClass] + StatisticsInterface: typing.Type[StatisticsInterface] + nonlinearparameterfitting: jneqsim.statistics.parameterfitting.nonlinearparameterfitting.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/parameterfitting/nonlinearparameterfitting/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/parameterfitting/nonlinearparameterfitting/__init__.pyi new file mode 100644 index 00000000..9519068c --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/parameterfitting/nonlinearparameterfitting/__init__.pyi @@ -0,0 +1,60 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.statistics.parameterfitting +import typing + + + +class LevenbergMarquardt(jneqsim.statistics.parameterfitting.StatisticsBaseClass): + def __init__(self): ... + def clone(self) -> 'LevenbergMarquardt': ... + def getMaxNumberOfIterations(self) -> int: ... + def init(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def setMaxNumberOfIterations(self, int: int) -> None: ... + def solve(self) -> None: ... + +class LevenbergMarquardtFunction(jneqsim.statistics.parameterfitting.BaseFunction): + def __init__(self): ... + def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + @typing.overload + def getFittingParams(self, int: int) -> float: ... + @typing.overload + def getFittingParams(self) -> typing.MutableSequence[float]: ... + def getNumberOfFittingParams(self) -> int: ... + def setFittingParam(self, int: int, double: float) -> None: ... + @typing.overload + def setFittingParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setFittingParams(self, int: int, double: float) -> None: ... + +class LevenbergMarquardtAbsDev(LevenbergMarquardt): + def __init__(self): ... + def calcAlphaMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def calcBetaMatrix(self) -> typing.MutableSequence[float]: ... + def calcChiSquare(self) -> float: ... + def clone(self) -> 'LevenbergMarquardtAbsDev': ... + +class LevenbergMarquardtBiasDev(LevenbergMarquardt): + def __init__(self): ... + def calcAlphaMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def calcBetaMatrix(self) -> typing.MutableSequence[float]: ... + def calcChiSquare(self) -> float: ... + def clone(self) -> 'LevenbergMarquardtBiasDev': ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.parameterfitting.nonlinearparameterfitting")``. + + LevenbergMarquardt: typing.Type[LevenbergMarquardt] + LevenbergMarquardtAbsDev: typing.Type[LevenbergMarquardtAbsDev] + LevenbergMarquardtBiasDev: typing.Type[LevenbergMarquardtBiasDev] + LevenbergMarquardtFunction: typing.Type[LevenbergMarquardtFunction] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/__init__.pyi new file mode 100644 index 00000000..0dd7ddb9 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/__init__.pyi @@ -0,0 +1,108 @@ + +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 jpype +import jneqsim.thermo.atomelement +import jneqsim.thermo.characterization +import jneqsim.thermo.component +import jneqsim.thermo.mixingrule +import jneqsim.thermo.phase +import jneqsim.thermo.system +import jneqsim.thermo.util +import typing + + + +class Fluid: + def __init__(self): ... + def addComponment(self, string: typing.Union[java.lang.String, str]) -> None: ... + def create(self, string: typing.Union[java.lang.String, str]) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + def create2(self, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + def create2(self, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray], doubleArray: typing.Union[typing.List[float], jpype.JArray], string2: typing.Union[java.lang.String, str]) -> jneqsim.thermo.system.SystemInterface: ... + def createFluid(self, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray], doubleArray: typing.Union[typing.List[float], jpype.JArray], string2: typing.Union[java.lang.String, str]) -> jneqsim.thermo.system.SystemInterface: ... + def getFluid(self) -> jneqsim.thermo.system.SystemInterface: ... + def getThermoMixingRule(self) -> java.lang.String: ... + def getThermoModel(self) -> java.lang.String: ... + def isAutoSelectModel(self) -> bool: ... + def isHasWater(self) -> bool: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def setAutoSelectModel(self, boolean: bool) -> None: ... + def setHasWater(self, boolean: bool) -> None: ... + def setThermoMixingRule(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setThermoModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class FluidCreator: + hasWater: typing.ClassVar[bool] = ... + autoSelectModel: typing.ClassVar[bool] = ... + thermoModel: typing.ClassVar[java.lang.String] = ... + thermoMixingRule: typing.ClassVar[java.lang.String] = ... + @typing.overload + @staticmethod + def create(string: typing.Union[java.lang.String, str]) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + @staticmethod + def create(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + @staticmethod + def create(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray], doubleArray: typing.Union[typing.List[float], jpype.JArray], string2: typing.Union[java.lang.String, str]) -> jneqsim.thermo.system.SystemInterface: ... + +class ThermodynamicConstantsInterface(java.io.Serializable): + R: typing.ClassVar[float] = ... + pi: typing.ClassVar[float] = ... + gravity: typing.ClassVar[float] = ... + avagadroNumber: typing.ClassVar[float] = ... + referenceTemperature: typing.ClassVar[float] = ... + referencePressure: typing.ClassVar[float] = ... + atm: typing.ClassVar[float] = ... + boltzmannConstant: typing.ClassVar[float] = ... + electronCharge: typing.ClassVar[float] = ... + planckConstant: typing.ClassVar[float] = ... + vacumPermittivity: typing.ClassVar[float] = ... + faradayConstant: typing.ClassVar[float] = ... + standardStateTemperature: typing.ClassVar[float] = ... + normalStateTemperature: typing.ClassVar[float] = ... + molarMassAir: typing.ClassVar[float] = ... + +class ThermodynamicModelSettings(java.io.Serializable): + phaseFractionMinimumLimit: typing.ClassVar[float] = ... + MAX_NUMBER_OF_COMPONENTS: typing.ClassVar[int] = ... + +class ThermodynamicModelTest(ThermodynamicConstantsInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def checkFugacityCoefficients(self) -> bool: ... + def checkFugacityCoefficientsDP(self) -> bool: ... + def checkFugacityCoefficientsDT(self) -> bool: ... + def checkFugacityCoefficientsDn(self) -> bool: ... + def checkFugacityCoefficientsDn2(self) -> bool: ... + def checkNumerically(self) -> bool: ... + def runTest(self) -> None: ... + def setMaxError(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo")``. + + Fluid: typing.Type[Fluid] + FluidCreator: typing.Type[FluidCreator] + ThermodynamicConstantsInterface: typing.Type[ThermodynamicConstantsInterface] + ThermodynamicModelSettings: typing.Type[ThermodynamicModelSettings] + ThermodynamicModelTest: typing.Type[ThermodynamicModelTest] + atomelement: jneqsim.thermo.atomelement.__module_protocol__ + characterization: jneqsim.thermo.characterization.__module_protocol__ + component: jneqsim.thermo.component.__module_protocol__ + mixingrule: jneqsim.thermo.mixingrule.__module_protocol__ + phase: jneqsim.thermo.phase.__module_protocol__ + system: jneqsim.thermo.system.__module_protocol__ + util: jneqsim.thermo.util.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/atomelement/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/atomelement/__init__.pyi new file mode 100644 index 00000000..45b62139 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/atomelement/__init__.pyi @@ -0,0 +1,85 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.thermo +import jneqsim.thermo.component +import jneqsim.thermo.phase +import typing + + + +class Element(jneqsim.thermo.ThermodynamicConstantsInterface): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @staticmethod + def getAllElementComponentNames() -> java.util.ArrayList[java.lang.String]: ... + def getElementCoefs(self) -> typing.MutableSequence[float]: ... + def getElementNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getName(self) -> java.lang.String: ... + def getNumberOfElements(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class UNIFACgroup(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.Comparable['UNIFACgroup']): + QMixdN: typing.MutableSequence[float] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + def calcQComp(self, componentGEUnifac: jneqsim.thermo.component.ComponentGEUnifac) -> float: ... + def calcQMix(self, phaseGEUnifac: jneqsim.thermo.phase.PhaseGEUnifac) -> float: ... + def calcQMixdN(self, phaseGEUnifac: jneqsim.thermo.phase.PhaseGEUnifac) -> typing.MutableSequence[float]: ... + def calcXComp(self, componentGEUnifac: jneqsim.thermo.component.ComponentGEUnifac) -> float: ... + def compareTo(self, uNIFACgroup: 'UNIFACgroup') -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def getGroupIndex(self) -> int: ... + def getGroupName(self) -> java.lang.String: ... + def getLnGammaComp(self) -> float: ... + def getLnGammaCompdT(self) -> float: ... + def getLnGammaCompdTdT(self) -> float: ... + def getLnGammaMix(self) -> float: ... + def getLnGammaMixdT(self) -> float: ... + def getLnGammaMixdTdT(self) -> float: ... + def getLnGammaMixdn(self, int: int) -> float: ... + def getMainGroup(self) -> int: ... + def getN(self) -> int: ... + def getQ(self) -> float: ... + def getQComp(self) -> float: ... + def getQMix(self) -> float: ... + @typing.overload + def getQMixdN(self, int: int) -> float: ... + @typing.overload + def getQMixdN(self) -> typing.MutableSequence[float]: ... + def getR(self) -> float: ... + def getSubGroup(self) -> int: ... + def getXComp(self) -> float: ... + def hashCode(self) -> int: ... + def setGroupIndex(self, int: int) -> None: ... + def setGroupName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setLnGammaComp(self, double: float) -> None: ... + def setLnGammaCompdT(self, double: float) -> None: ... + def setLnGammaCompdTdT(self, double: float) -> None: ... + def setLnGammaMix(self, double: float) -> None: ... + def setLnGammaMixdT(self, double: float) -> None: ... + def setLnGammaMixdTdT(self, double: float) -> None: ... + def setLnGammaMixdn(self, double: float, int: int) -> None: ... + def setMainGroup(self, int: int) -> None: ... + def setN(self, int: int) -> None: ... + def setQ(self, double: float) -> None: ... + def setQComp(self, double: float) -> None: ... + def setQMix(self, double: float) -> None: ... + def setQMixdN(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setR(self, double: float) -> None: ... + def setSubGroup(self, int: int) -> None: ... + def setXComp(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.atomelement")``. + + Element: typing.Type[Element] + UNIFACgroup: typing.Type[UNIFACgroup] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/characterization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/characterization/__init__.pyi new file mode 100644 index 00000000..8a57c45d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/characterization/__init__.pyi @@ -0,0 +1,456 @@ + +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 neqsim +import jneqsim.thermo.system +import typing + + + +class Characterise(java.io.Serializable, java.lang.Cloneable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def characterisePlusFraction(self) -> None: ... + def clone(self) -> 'Characterise': ... + def getLumpingModel(self) -> 'LumpingModelInterface': ... + def getPlusFractionModel(self) -> 'PlusFractionModelInterface': ... + def getTBPModel(self) -> 'TBPModelInterface': ... + def setLumpingModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPlusFractionModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setTBPModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + +class CharacteriseInterface: + PVTsimMolarMass: typing.ClassVar[typing.MutableSequence[float]] = ... + def addCharacterizedPlusFraction(self) -> None: ... + def addHeavyEnd(self) -> None: ... + def addTBPFractions(self) -> None: ... + def generatePlusFractions(self, int: int, int2: int, double: float, double2: float) -> None: ... + def generateTBPFractions(self) -> None: ... + def getCoef(self, int: int) -> float: ... + def getCoefs(self) -> typing.MutableSequence[float]: ... + def getDensLastTBP(self) -> float: ... + def getDensPlus(self) -> float: ... + def getFirstPlusFractionNumber(self) -> int: ... + def getLastPlusFractionNumber(self) -> int: ... + def getMPlus(self) -> float: ... + @typing.overload + def getPlusCoefs(self, int: int) -> float: ... + @typing.overload + def getPlusCoefs(self) -> typing.MutableSequence[float]: ... + def getZPlus(self) -> float: ... + def groupTBPfractions(self) -> bool: ... + def hasPlusFraction(self) -> bool: ... + def isPseudocomponents(self) -> bool: ... + def removeTBPfraction(self) -> None: ... + @typing.overload + def setCoefs(self, double: float, int: int) -> None: ... + @typing.overload + def setCoefs(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setDensLastTBP(self, double: float) -> None: ... + def setMPlus(self, double: float) -> None: ... + def setNumberOfPseudocomponents(self, int: int) -> None: ... + def setPlusCoefs(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setPseudocomponents(self, boolean: bool) -> None: ... + def setZPlus(self, double: float) -> None: ... + def solve(self) -> None: ... + +class LumpingModelInterface: + def generateLumpedComposition(self, characterise: Characterise) -> None: ... + def getFractionOfHeavyEnd(self, int: int) -> float: ... + def getLumpedComponentName(self, int: int) -> java.lang.String: ... + def getLumpedComponentNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getName(self) -> java.lang.String: ... + def getNumberOfLumpedComponents(self) -> int: ... + def getNumberOfPseudoComponents(self) -> int: ... + def setNumberOfLumpedComponents(self, int: int) -> None: ... + def setNumberOfPseudoComponents(self, int: int) -> None: ... + +class NewtonSolveAB(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, tBPCharacterize: 'TBPCharacterize'): ... + def setJac(self) -> None: ... + def setfvec(self) -> None: ... + def solve(self) -> None: ... + +class NewtonSolveABCD(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, tBPCharacterize: 'TBPCharacterize'): ... + def setJac(self) -> None: ... + def setfvec(self) -> None: ... + def solve(self) -> None: ... + +class NewtonSolveCDplus(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, plusCharacterize: 'PlusCharacterize'): ... + def setJac(self) -> None: ... + def setfvec(self) -> None: ... + def solve(self) -> None: ... + +class OilAssayCharacterisation(java.lang.Cloneable, java.io.Serializable): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def addCut(self, assayCut: 'OilAssayCharacterisation.AssayCut') -> None: ... + def addCuts(self, collection: typing.Union[java.util.Collection['OilAssayCharacterisation.AssayCut'], typing.Sequence['OilAssayCharacterisation.AssayCut'], typing.Set['OilAssayCharacterisation.AssayCut']]) -> None: ... + def apply(self) -> None: ... + def clearCuts(self) -> None: ... + def clone(self) -> 'OilAssayCharacterisation': ... + def getCuts(self) -> java.util.List['OilAssayCharacterisation.AssayCut']: ... + def getTotalAssayMass(self) -> float: ... + def setThermoSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setTotalAssayMass(self, double: float) -> None: ... + class AssayCut(java.lang.Cloneable, java.io.Serializable): + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def clone(self) -> 'OilAssayCharacterisation.AssayCut': ... + def getMassFraction(self) -> float: ... + def getName(self) -> java.lang.String: ... + def getVolumeFraction(self) -> float: ... + def hasMassFraction(self) -> bool: ... + def hasMolarMass(self) -> bool: ... + def hasVolumeFraction(self) -> bool: ... + def resolveAverageBoilingPoint(self) -> float: ... + def resolveDensity(self) -> float: ... + def resolveMolarMass(self, double: float, double2: float) -> float: ... + def withApiGravity(self, double: float) -> 'OilAssayCharacterisation.AssayCut': ... + def withAverageBoilingPointCelsius(self, double: float) -> 'OilAssayCharacterisation.AssayCut': ... + def withAverageBoilingPointFahrenheit(self, double: float) -> 'OilAssayCharacterisation.AssayCut': ... + def withAverageBoilingPointKelvin(self, double: float) -> 'OilAssayCharacterisation.AssayCut': ... + def withDensity(self, double: float) -> 'OilAssayCharacterisation.AssayCut': ... + def withMassFraction(self, double: float) -> 'OilAssayCharacterisation.AssayCut': ... + def withMolarMass(self, double: float) -> 'OilAssayCharacterisation.AssayCut': ... + def withVolumeFraction(self, double: float) -> 'OilAssayCharacterisation.AssayCut': ... + def withVolumePercent(self, double: float) -> 'OilAssayCharacterisation.AssayCut': ... + def withWeightPercent(self, double: float) -> 'OilAssayCharacterisation.AssayCut': ... + +class PedersenPlusModelSolver(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, pedersenPlusModel: 'PlusFractionModel.PedersenPlusModel'): ... + def setJacAB(self) -> None: ... + def setJacCD(self) -> None: ... + def setfvecAB(self) -> None: ... + def setfvecCD(self) -> None: ... + def solve(self) -> None: ... + +class PlusFractionModel(java.io.Serializable): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getModel(self, string: typing.Union[java.lang.String, str]) -> 'PlusFractionModelInterface': ... + class PedersenPlusModel: ... + +class PlusFractionModelInterface(java.io.Serializable): + def characterizePlusFraction(self, tBPModelInterface: 'TBPModelInterface') -> bool: ... + def getCoef(self, int: int) -> float: ... + def getCoefs(self) -> typing.MutableSequence[float]: ... + def getDens(self) -> typing.MutableSequence[float]: ... + def getDensPlus(self) -> float: ... + def getFirstPlusFractionNumber(self) -> int: ... + def getFirstTBPFractionNumber(self) -> int: ... + def getLastPlusFractionNumber(self) -> int: ... + def getM(self) -> typing.MutableSequence[float]: ... + def getMPlus(self) -> float: ... + def getMaxPlusMolarMass(self) -> float: ... + def getName(self) -> java.lang.String: ... + def getNumberOfPlusPseudocomponents(self) -> float: ... + def getPlusComponentNumber(self) -> int: ... + def getZ(self) -> typing.MutableSequence[float]: ... + def getZPlus(self) -> float: ... + def hasPlusFraction(self) -> bool: ... + def setLastPlusFractionNumber(self, int: int) -> None: ... + +class PseudoComponentCombiner: + @staticmethod + def characterizeToReference(systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + @staticmethod + def combineReservoirFluids(int: int, collection: typing.Union[java.util.Collection[jneqsim.thermo.system.SystemInterface], typing.Sequence[jneqsim.thermo.system.SystemInterface], typing.Set[jneqsim.thermo.system.SystemInterface]]) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + @staticmethod + def combineReservoirFluids(int: int, *systemInterface: jneqsim.thermo.system.SystemInterface) -> jneqsim.thermo.system.SystemInterface: ... + +class Recombine: + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface): ... + def getGOR(self) -> float: ... + def getOilDesnity(self) -> float: ... + def getRecombinedSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def runRecombination(self) -> jneqsim.thermo.system.SystemInterface: ... + def setGOR(self, double: float) -> None: ... + def setOilDesnity(self, double: float) -> None: ... + +class TBPModelInterface: + def calcAcentricFactor(self, double: float, double2: float) -> float: ... + def calcAcentricFactorKeslerLee(self, double: float, double2: float) -> float: ... + def calcCriticalViscosity(self, double: float, double2: float) -> float: ... + def calcCriticalVolume(self, double: float, double2: float) -> float: ... + def calcPC(self, double: float, double2: float) -> float: ... + def calcParachorParameter(self, double: float, double2: float) -> float: ... + def calcRacketZ(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float) -> float: ... + def calcTB(self, double: float, double2: float) -> float: ... + def calcTC(self, double: float, double2: float) -> float: ... + def calcWatsonCharacterizationFactor(self, double: float, double2: float) -> float: ... + def calcm(self, double: float, double2: float) -> float: ... + def getName(self) -> java.lang.String: ... + def isCalcm(self) -> bool: ... + def setBoilingPoint(self, double: float) -> None: ... + +class WaxModelInterface(java.io.Serializable, java.lang.Cloneable): + def addTBPWax(self) -> None: ... + def clone(self) -> 'WaxModelInterface': ... + def getParameterWaxHeatOfFusion(self) -> typing.MutableSequence[float]: ... + def getParameterWaxTriplePointTemperature(self) -> typing.MutableSequence[float]: ... + def getWaxParameters(self) -> typing.MutableSequence[float]: ... + def removeWax(self) -> None: ... + @typing.overload + def setParameterWaxHeatOfFusion(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setParameterWaxHeatOfFusion(self, int: int, double: float) -> None: ... + @typing.overload + def setParameterWaxTriplePointTemperature(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setParameterWaxTriplePointTemperature(self, int: int, double: float) -> None: ... + def setWaxParameter(self, int: int, double: float) -> None: ... + def setWaxParameters(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + +class PlusCharacterize(java.io.Serializable, CharacteriseInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def addCharacterizedPlusFraction(self) -> None: ... + def addHeavyEnd(self) -> None: ... + def addPseudoTBPfraction(self, int: int, int2: int) -> None: ... + def addTBPFractions(self) -> None: ... + def characterizePlusFraction(self) -> None: ... + def generatePlusFractions(self, int: int, int2: int, double: float, double2: float) -> None: ... + def generateTBPFractions(self) -> None: ... + def getCarbonNumberVector(self) -> typing.MutableSequence[int]: ... + def getCoef(self, int: int) -> float: ... + def getCoefs(self) -> typing.MutableSequence[float]: ... + def getDensLastTBP(self) -> float: ... + def getDensPlus(self) -> float: ... + def getFirstPlusFractionNumber(self) -> int: ... + def getLastPlusFractionNumber(self) -> int: ... + def getLength(self) -> int: ... + def getMPlus(self) -> float: ... + def getNumberOfPseudocomponents(self) -> int: ... + @typing.overload + def getPlusCoefs(self, int: int) -> float: ... + @typing.overload + def getPlusCoefs(self) -> typing.MutableSequence[float]: ... + def getStartPlus(self) -> int: ... + def getZPlus(self) -> float: ... + def groupTBPfractions(self) -> bool: ... + def hasPlusFraction(self) -> bool: ... + def isPseudocomponents(self) -> bool: ... + def removeTBPfraction(self) -> None: ... + def setCarbonNumberVector(self, intArray: typing.Union[typing.List[int], jpype.JArray]) -> None: ... + @typing.overload + def setCoefs(self, double: float, int: int) -> None: ... + @typing.overload + def setCoefs(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setDensLastTBP(self, double: float) -> None: ... + def setDensPlus(self, double: float) -> None: ... + def setFirstPlusFractionNumber(self, int: int) -> None: ... + def setHeavyTBPtoPlus(self) -> None: ... + def setMPlus(self, double: float) -> None: ... + def setNumberOfPseudocomponents(self, int: int) -> None: ... + def setPlusCoefs(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setPseudocomponents(self, boolean: bool) -> None: ... + def setZPlus(self, double: float) -> None: ... + def solve(self) -> None: ... + +class TBPCharacterize(PlusCharacterize): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def addHeavyEnd(self) -> None: ... + def addPlusFraction(self) -> None: ... + def addTBPFractions(self) -> None: ... + def getCalcTBPfractions(self) -> typing.MutableSequence[float]: ... + def getCarbonNumberVector(self) -> typing.MutableSequence[int]: ... + def getDensPlus(self) -> float: ... + def getLength(self) -> int: ... + @typing.overload + def getPlusCoefs(self, int: int) -> float: ... + @typing.overload + def getPlusCoefs(self) -> typing.MutableSequence[float]: ... + def getTBP_M(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getTBPdens(self, int: int) -> float: ... + @typing.overload + def getTBPdens(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getTBPfractions(self, int: int) -> float: ... + @typing.overload + def getTBPfractions(self) -> typing.MutableSequence[float]: ... + def groupTBPfractions(self) -> bool: ... + def isPseudocomponents(self) -> bool: ... + def saveCharacterizedFluid(self) -> bool: ... + def setCalcTBPfractions(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setCarbonNumberVector(self, intArray: typing.Union[typing.List[int], jpype.JArray]) -> None: ... + @typing.overload + def setCoefs(self, double: float, int: int) -> None: ... + @typing.overload + def setCoefs(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setDensPlus(self, double: float) -> None: ... + def setPlusCoefs(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setTBP_M(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setTBPdens(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setTBPfractions(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def solve(self) -> None: ... + def solveAB(self) -> None: ... + +class LumpingModel(java.io.Serializable): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getModel(self, string: typing.Union[java.lang.String, str]) -> LumpingModelInterface: ... + class NoLumpingModel(jneqsim.thermo.characterization.LumpingModel.StandardLumpingModel): + def __init__(self, lumpingModel: 'LumpingModel'): ... + def generateLumpedComposition(self, characterise: Characterise) -> None: ... + def getFractionOfHeavyEnd(self, int: int) -> float: ... + class PVTLumpingModel(jneqsim.thermo.characterization.LumpingModel.StandardLumpingModel): + def __init__(self, lumpingModel: 'LumpingModel'): ... + def generateLumpedComposition(self, characterise: Characterise) -> None: ... + def getFractionOfHeavyEnd(self, int: int) -> float: ... + class StandardLumpingModel(LumpingModelInterface, java.lang.Cloneable, java.io.Serializable): + def __init__(self, lumpingModel: 'LumpingModel'): ... + def generateLumpedComposition(self, characterise: Characterise) -> None: ... + def getFractionOfHeavyEnd(self, int: int) -> float: ... + def getLumpedComponentName(self, int: int) -> java.lang.String: ... + def getLumpedComponentNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getName(self) -> java.lang.String: ... + def getNumberOfLumpedComponents(self) -> int: ... + def getNumberOfPseudoComponents(self) -> int: ... + def setNumberOfLumpedComponents(self, int: int) -> None: ... + def setNumberOfPseudoComponents(self, int: int) -> None: ... + +class TBPfractionModel(java.io.Serializable): + def __init__(self): ... + def getModel(self, string: typing.Union[java.lang.String, str]) -> TBPModelInterface: ... + class LeeKesler(jneqsim.thermo.characterization.TBPfractionModel.TBPBaseModel): + def __init__(self, tBPfractionModel: 'TBPfractionModel'): ... + def calcAcentricFactor(self, double: float, double2: float) -> float: ... + def calcPC(self, double: float, double2: float) -> float: ... + def calcRacketZ(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float) -> float: ... + def calcTC(self, double: float, double2: float) -> float: ... + class PedersenTBPModelPR(jneqsim.thermo.characterization.TBPfractionModel.PedersenTBPModelSRK): + def __init__(self, tBPfractionModel: 'TBPfractionModel'): ... + class PedersenTBPModelPR2(jneqsim.thermo.characterization.TBPfractionModel.PedersenTBPModelSRK): + def __init__(self, tBPfractionModel: 'TBPfractionModel'): ... + def calcTB(self, double: float, double2: float) -> float: ... + class PedersenTBPModelPRHeavyOil(jneqsim.thermo.characterization.TBPfractionModel.PedersenTBPModelPR): + def __init__(self, tBPfractionModel: 'TBPfractionModel'): ... + class PedersenTBPModelSRK(jneqsim.thermo.characterization.TBPfractionModel.TBPBaseModel): + def __init__(self, tBPfractionModel: 'TBPfractionModel'): ... + def calcPC(self, double: float, double2: float) -> float: ... + def calcRacketZ(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float) -> float: ... + def calcTB(self, double: float, double2: float) -> float: ... + def calcTC(self, double: float, double2: float) -> float: ... + def calcm(self, double: float, double2: float) -> float: ... + class PedersenTBPModelSRKHeavyOil(jneqsim.thermo.characterization.TBPfractionModel.PedersenTBPModelSRK): + def __init__(self, tBPfractionModel: 'TBPfractionModel'): ... + class RiaziDaubert(jneqsim.thermo.characterization.TBPfractionModel.PedersenTBPModelSRK): + def __init__(self, tBPfractionModel: 'TBPfractionModel'): ... + def calcAcentricFactor(self, double: float, double2: float) -> float: ... + def calcAcentricFactor2(self, double: float, double2: float) -> float: ... + def calcPC(self, double: float, double2: float) -> float: ... + def calcTB(self, double: float, double2: float) -> float: ... + def calcTC(self, double: float, double2: float) -> float: ... + class TBPBaseModel(TBPModelInterface, java.lang.Cloneable, java.io.Serializable): + def __init__(self, tBPfractionModel: 'TBPfractionModel'): ... + def calcAcentricFactor(self, double: float, double2: float) -> float: ... + def calcAcentricFactorKeslerLee(self, double: float, double2: float) -> float: ... + def calcCriticalViscosity(self, double: float, double2: float) -> float: ... + def calcCriticalVolume(self, double: float, double2: float) -> float: ... + def calcParachorParameter(self, double: float, double2: float) -> float: ... + def calcRacketZ(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float) -> float: ... + def calcTB(self, double: float, double2: float) -> float: ... + def calcWatsonCharacterizationFactor(self, double: float, double2: float) -> float: ... + def calcm(self, double: float, double2: float) -> float: ... + def getBoilingPoint(self) -> float: ... + def getName(self) -> java.lang.String: ... + def isCalcm(self) -> bool: ... + def setBoilingPoint(self, double: float) -> None: ... + class TwuModel(jneqsim.thermo.characterization.TBPfractionModel.TBPBaseModel): + def __init__(self, tBPfractionModel: 'TBPfractionModel'): ... + def calcCriticalVolume(self, double: float, double2: float) -> float: ... + def calcPC(self, double: float, double2: float) -> float: ... + def calcRacketZ(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float) -> float: ... + def calcTC(self, double: float, double2: float) -> float: ... + def calculateTfunc(self, double: float, double2: float) -> float: ... + def computeGradient(self, double: float, double2: float) -> float: ... + def solveMW(self, double: float) -> float: ... + +class WaxCharacterise(java.io.Serializable, java.lang.Cloneable): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def clone(self) -> 'WaxCharacterise': ... + @typing.overload + def getModel(self) -> WaxModelInterface: ... + @typing.overload + def getModel(self, string: typing.Union[java.lang.String, str]) -> WaxModelInterface: ... + def setModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setModelName(self, string: typing.Union[java.lang.String, str]) -> None: ... + class PedersenWaxModel(jneqsim.thermo.characterization.WaxCharacterise.WaxBaseModel): + def __init__(self, waxCharacterise: 'WaxCharacterise'): ... + def addTBPWax(self) -> None: ... + def calcHeatOfFusion(self, int: int) -> float: ... + def calcPCwax(self, int: int, string: typing.Union[java.lang.String, str]) -> float: ... + def calcParaffinDensity(self, int: int) -> float: ... + def calcTriplePointTemperature(self, int: int) -> float: ... + def removeWax(self) -> None: ... + class WaxBaseModel(WaxModelInterface): + def __init__(self, waxCharacterise: 'WaxCharacterise'): ... + def addTBPWax(self) -> None: ... + def clone(self) -> 'WaxCharacterise.WaxBaseModel': ... + def getParameterWaxHeatOfFusion(self) -> typing.MutableSequence[float]: ... + def getParameterWaxTriplePointTemperature(self) -> typing.MutableSequence[float]: ... + def getWaxParameters(self) -> typing.MutableSequence[float]: ... + @typing.overload + def setParameterWaxHeatOfFusion(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setParameterWaxHeatOfFusion(self, int: int, double: float) -> None: ... + @typing.overload + def setParameterWaxTriplePointTemperature(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setParameterWaxTriplePointTemperature(self, int: int, double: float) -> None: ... + def setWaxParameter(self, int: int, double: float) -> None: ... + def setWaxParameters(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.characterization")``. + + Characterise: typing.Type[Characterise] + CharacteriseInterface: typing.Type[CharacteriseInterface] + LumpingModel: typing.Type[LumpingModel] + LumpingModelInterface: typing.Type[LumpingModelInterface] + NewtonSolveAB: typing.Type[NewtonSolveAB] + NewtonSolveABCD: typing.Type[NewtonSolveABCD] + NewtonSolveCDplus: typing.Type[NewtonSolveCDplus] + OilAssayCharacterisation: typing.Type[OilAssayCharacterisation] + PedersenPlusModelSolver: typing.Type[PedersenPlusModelSolver] + PlusCharacterize: typing.Type[PlusCharacterize] + PlusFractionModel: typing.Type[PlusFractionModel] + PlusFractionModelInterface: typing.Type[PlusFractionModelInterface] + PseudoComponentCombiner: typing.Type[PseudoComponentCombiner] + Recombine: typing.Type[Recombine] + TBPCharacterize: typing.Type[TBPCharacterize] + TBPModelInterface: typing.Type[TBPModelInterface] + TBPfractionModel: typing.Type[TBPfractionModel] + WaxCharacterise: typing.Type[WaxCharacterise] + WaxModelInterface: typing.Type[WaxModelInterface] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/component/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/component/__init__.pyi new file mode 100644 index 00000000..c066de2c --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/component/__init__.pyi @@ -0,0 +1,1915 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.thermo +import jneqsim.thermo.atomelement +import jneqsim.thermo.component.attractiveeosterm +import jneqsim.thermo.component.repulsiveeosterm +import jneqsim.thermo.phase +import typing + + + +class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.Cloneable): + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + def addMoles(self, double: float) -> None: ... + @typing.overload + def addMolesChemReac(self, double: float, double2: float) -> None: ... + @typing.overload + def addMolesChemReac(self, double: float) -> None: ... + def calcActivity(self) -> bool: ... + 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 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: ... + def getAcentricFactor(self) -> float: ... + def getAntoineASolid(self) -> float: ... + def getAntoineBSolid(self) -> float: ... + def getAntoineCSolid(self) -> float: ... + def getAntoineVaporPressure(self, double: float) -> float: ... + def getAntoineVaporPressuredT(self, double: float) -> float: ... + def getAntoineVaporTemperature(self, double: float) -> float: ... + def getAssociationEnergy(self) -> float: ... + def getAssociationEnergySAFT(self) -> float: ... + def getAssociationScheme(self) -> java.lang.String: ... + def getAssociationVolume(self) -> float: ... + def getAssociationVolumeSAFT(self) -> float: ... + def getAttractiveTerm(self) -> jneqsim.thermo.component.attractiveeosterm.AttractiveTermInterface: ... + def getAttractiveTermNumber(self) -> int: ... + def getCASnumber(self) -> java.lang.String: ... + def getCCsolidVaporPressure(self, double: float) -> float: ... + def getCCsolidVaporPressuredT(self, double: float) -> float: ... + @typing.overload + def getChemicalPotential(self, double: float, double2: float) -> float: ... + @typing.overload + def getChemicalPotential(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getChemicalPotentialIdealReference(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getChemicalPotentialdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getChemicalPotentialdNTV(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getChemicalPotentialdP(self) -> float: ... + def getChemicalPotentialdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getChemicalPotentialdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getComponentName(self) -> java.lang.String: ... + @staticmethod + def getComponentNameFromAlias(string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @staticmethod + def getComponentNameMap() -> java.util.LinkedHashMap[java.lang.String, java.lang.String]: ... + def getComponentNumber(self) -> int: ... + def getComponentType(self) -> java.lang.String: ... + def getCp0(self, double: float) -> float: ... + def getCpA(self) -> float: ... + def getCpB(self) -> float: ... + def getCpC(self) -> float: ... + def getCpD(self) -> float: ... + def getCpE(self) -> float: ... + def getCriticalCompressibilityFactor(self) -> float: ... + def getCriticalViscosity(self) -> float: ... + def getCriticalVolume(self) -> float: ... + def getCv0(self, double: float) -> float: ... + def getDebyeDipoleMoment(self) -> float: ... + def getDiElectricConstant(self, double: float) -> float: ... + def getDiElectricConstantdT(self, double: float) -> float: ... + def getDiElectricConstantdTdT(self, double: float) -> float: ... + def getElements(self) -> jneqsim.thermo.atomelement.Element: ... + def getEnthalpy(self, double: float) -> float: ... + def getEntropy(self, double: float, double2: float) -> float: ... + def getEpsikSAFT(self) -> float: ... + def getFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getFormulae(self) -> java.lang.String: ... + def getFugacityCoefficient(self) -> float: ... + def getGibbsEnergy(self, double: float, double2: float) -> float: ... + def getGibbsEnergyOfFormation(self) -> float: ... + def getGresTP(self, double: float) -> float: ... + def getHID(self, double: float) -> float: ... + def getHeatOfFusion(self) -> float: ... + def getHeatOfVapourization(self, double: float) -> float: ... + def getHenryCoef(self, double: float) -> float: ... + def getHenryCoefParameter(self) -> typing.MutableSequence[float]: ... + def getHenryCoefdT(self, double: float) -> float: ... + def getHresTP(self, double: float) -> float: ... + def getHsub(self) -> float: ... + def getIdEntropy(self, double: float) -> float: ... + def getIdealGasAbsoluteEntropy(self) -> float: ... + def getIdealGasEnthalpyOfFormation(self) -> float: ... + def getIdealGasGibbsEnergyOfFormation(self) -> float: ... + def getIndex(self) -> int: ... + def getIonicCharge(self) -> float: ... + def getK(self) -> float: ... + def getLennardJonesEnergyParameter(self) -> float: ... + def getLennardJonesMolecularDiameter(self) -> float: ... + def getLiquidConductivityParameter(self, int: int) -> float: ... + def getLiquidViscosityModel(self) -> int: ... + def getLiquidViscosityParameter(self, int: int) -> float: ... + def getLogFugacityCoefficient(self) -> float: ... + def getMatiascopemanParams(self) -> typing.MutableSequence[float]: ... + def getMatiascopemanSolidParams(self) -> typing.MutableSequence[float]: ... + def getMeltingPointTemperature(self) -> float: ... + def getMolality(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getMolarMass(self) -> float: ... + @typing.overload + def getMolarMass(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMolarity(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getName(self) -> java.lang.String: ... + @typing.overload + def getNormalBoilingPoint(self) -> float: ... + @typing.overload + def getNormalBoilingPoint(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getNormalLiquidDensity(self) -> float: ... + @typing.overload + def getNormalLiquidDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getNumberOfAssociationSites(self) -> int: ... + def getNumberOfMolesInPhase(self) -> float: ... + def getNumberOfmoles(self) -> float: ... + def getOrginalNumberOfAssociationSites(self) -> int: ... + @typing.overload + def getPC(self) -> float: ... + @typing.overload + def getPC(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getParachorParameter(self) -> float: ... + def getPaulingAnionicDiameter(self) -> float: ... + def getPureComponentCpLiquid(self, double: float) -> float: ... + def getPureComponentCpSolid(self, double: float) -> float: ... + def getPureComponentHeatOfVaporization(self, double: float) -> float: ... + def getPureComponentLiquidDensity(self, double: float) -> float: ... + def getPureComponentSolidDensity(self, double: float) -> float: ... + def getRacketZ(self) -> float: ... + def getRacketZCPA(self) -> float: ... + def getRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getReferencePotential(self) -> float: ... + def getReferenceStateType(self) -> java.lang.String: ... + def getSchwartzentruberParams(self) -> typing.MutableSequence[float]: ... + def getSigmaSAFTi(self) -> float: ... + def getSolidVaporPressure(self, double: float) -> float: ... + def getSolidVaporPressuredT(self, double: float) -> float: ... + def getSphericalCoreRadius(self) -> float: ... + def getSresTP(self, double: float) -> float: ... + def getStokesCationicDiameter(self) -> float: ... + def getSurfTensInfluenceParam(self, int: int) -> float: ... + def getSurfaceTenisionInfluenceParameter(self, double: float) -> float: ... + @typing.overload + def getTC(self) -> float: ... + @typing.overload + def getTC(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getTotalFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getTriplePointDensity(self) -> float: ... + def getTriplePointPressure(self) -> float: ... + def getTriplePointTemperature(self) -> float: ... + def getTwuCoonParams(self) -> typing.MutableSequence[float]: ... + def getViscosityCorrectionFactor(self) -> float: ... + def getViscosityFrictionK(self) -> float: ... + def getVoli(self) -> float: ... + def getVolumeCorrection(self) -> float: ... + def getVolumeCorrectionConst(self) -> float: ... + def getVolumeCorrectionT(self) -> float: ... + def getVolumeCorrectionT_CPA(self) -> float: ... + def getdfugdn(self, int: int) -> float: ... + def getdfugdp(self) -> float: ... + def getdfugdt(self) -> float: ... + def getdfugdx(self, int: int) -> float: ... + def getdrhodN(self) -> float: ... + def getmSAFTi(self) -> float: ... + def getx(self) -> float: ... + def getz(self) -> float: ... + def init(self, double: float, double2: float, double3: float, double4: float, int: int) -> None: ... + def insertComponentIntoDatabase(self, string: typing.Union[java.lang.String, str]) -> None: ... + def isHydrateFormer(self) -> bool: ... + def isHydrocarbon(self) -> bool: ... + def isInert(self) -> bool: ... + def isIsIon(self) -> bool: ... + def isIsNormalComponent(self) -> bool: ... + def isIsPlusFraction(self) -> bool: ... + def isIsTBPfraction(self) -> bool: ... + def isWaxFormer(self) -> bool: ... + def logfugcoefdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> typing.MutableSequence[float]: ... + def logfugcoefdNi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int) -> float: ... + def logfugcoefdP(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def logfugcoefdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def reducedPressure(self, double: float) -> float: ... + def reducedTemperature(self, double: float) -> float: ... + def setAcentricFactor(self, double: float) -> None: ... + def setAntoineASolid(self, double: float) -> None: ... + def setAntoineBSolid(self, double: float) -> None: ... + def setAntoineCSolid(self, double: float) -> None: ... + def setAssociationEnergy(self, double: float) -> None: ... + def setAssociationEnergySAFT(self, double: float) -> None: ... + def setAssociationScheme(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setAssociationVolume(self, double: float) -> None: ... + def setAssociationVolumeSAFT(self, double: float) -> None: ... + def setAttractiveTerm(self, int: int) -> None: ... + def setCASnumber(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setComponentName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setComponentNumber(self, int: int) -> None: ... + def setComponentType(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setCpA(self, double: float) -> None: ... + def setCpB(self, double: float) -> None: ... + def setCpC(self, double: float) -> None: ... + def setCpD(self, double: float) -> None: ... + def setCpE(self, double: float) -> None: ... + def setCriticalCompressibilityFactor(self, double: float) -> None: ... + def setCriticalViscosity(self, double: float) -> None: ... + def setCriticalVolume(self, double: float) -> None: ... + def setEpsikSAFT(self, double: float) -> None: ... + def setFormulae(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setFugacityCoefficient(self, double: float) -> None: ... + def setHeatOfFusion(self, double: float) -> None: ... + def setHenryCoefParameter(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setIdealGasEnthalpyOfFormation(self, double: float) -> None: ... + def setIsHydrateFormer(self, boolean: bool) -> None: ... + def setIsIon(self, boolean: bool) -> None: ... + def setIsNormalComponent(self, boolean: bool) -> None: ... + def setIsPlusFraction(self, boolean: bool) -> None: ... + def setIsTBPfraction(self, boolean: bool) -> None: ... + def setK(self, double: float) -> None: ... + def setLennardJonesEnergyParameter(self, double: float) -> None: ... + def setLennardJonesMolecularDiameter(self, double: float) -> None: ... + def setLiquidConductivityParameter(self, double: float, int: int) -> None: ... + def setLiquidViscosityModel(self, int: int) -> None: ... + def setLiquidViscosityParameter(self, double: float, int: int) -> None: ... + @typing.overload + def setMatiascopemanParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setMatiascopemanParams(self, int: int, double: float) -> None: ... + @typing.overload + def setMolarMass(self, double: float) -> None: ... + @typing.overload + def setMolarMass(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setNormalBoilingPoint(self, double: float) -> None: ... + def setNormalLiquidDensity(self, double: float) -> None: ... + def setNumberOfAssociationSites(self, int: int) -> None: ... + def setNumberOfMolesInPhase(self, double: float) -> None: ... + def setNumberOfmoles(self, double: float) -> None: ... + @typing.overload + def setPC(self, double: float) -> None: ... + @typing.overload + def setPC(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setParachorParameter(self, double: float) -> None: ... + def setProperties(self, componentInterface: 'ComponentInterface') -> None: ... + def setRacketZ(self, double: float) -> None: ... + def setRacketZCPA(self, double: float) -> None: ... + def setReferencePotential(self, double: float) -> None: ... + def setSchwartzentruberParams(self, int: int, double: float) -> None: ... + def setSigmaSAFTi(self, double: float) -> None: ... + def setSolidCheck(self, boolean: bool) -> None: ... + def setSphericalCoreRadius(self, double: float) -> None: ... + def setStokesCationicDiameter(self, double: float) -> None: ... + def setSurfTensInfluenceParam(self, int: int, double: float) -> None: ... + @typing.overload + def setTC(self, double: float) -> None: ... + @typing.overload + def setTC(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTriplePointTemperature(self, double: float) -> None: ... + def setTwuCoonParams(self, int: int, double: float) -> None: ... + def setViscosityAssociationFactor(self, double: float) -> None: ... + def setViscosityFrictionK(self, double: float) -> None: ... + def setVolumeCorrection(self, double: float) -> None: ... + def setVolumeCorrectionConst(self, double: float) -> None: ... + def setVolumeCorrectionT(self, double: float) -> None: ... + def setVolumeCorrectionT_CPA(self, double: float) -> None: ... + def setWaxFormer(self, boolean: bool) -> None: ... + def seta(self, double: float) -> None: ... + def setb(self, double: float) -> None: ... + def setdfugdn(self, int: int, double: float) -> None: ... + def setdfugdp(self, double: float) -> None: ... + def setdfugdt(self, double: float) -> None: ... + def setdfugdx(self, int: int, double: float) -> None: ... + def setmSAFTi(self, double: float) -> None: ... + def setx(self, double: float) -> None: ... + def setz(self, double: float) -> None: ... + +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 + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + @typing.overload + def addMolesChemReac(self, double: float) -> None: ... + @typing.overload + def addMolesChemReac(self, double: float, double2: float) -> None: ... + def calcActivity(self) -> bool: ... + def clone(self) -> 'Component': ... + 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 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: ... + def getAcentricFactor(self) -> float: ... + def getAntoineASolid(self) -> float: ... + def getAntoineBSolid(self) -> float: ... + def getAntoineCSolid(self) -> float: ... + def getAntoineVaporPressure(self, double: float) -> float: ... + def getAntoineVaporPressuredT(self, double: float) -> float: ... + def getAntoineVaporTemperature(self, double: float) -> float: ... + def getAssociationEnergy(self) -> float: ... + def getAssociationEnergySAFT(self) -> float: ... + def getAssociationScheme(self) -> java.lang.String: ... + def getAssociationVolume(self) -> float: ... + def getAssociationVolumeSAFT(self) -> float: ... + def getAttractiveTerm(self) -> jneqsim.thermo.component.attractiveeosterm.AttractiveTermInterface: ... + def getAttractiveTermNumber(self) -> int: ... + def getCASnumber(self) -> java.lang.String: ... + def getCCsolidVaporPressure(self, double: float) -> float: ... + def getCCsolidVaporPressuredT(self, double: float) -> float: ... + @typing.overload + def getChemicalPotential(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getChemicalPotential(self, double: float, double2: float) -> float: ... + def getChemicalPotentialIdealReference(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getChemicalPotentialdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getChemicalPotentialdNTV(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getChemicalPotentialdP(self) -> float: ... + @typing.overload + def getChemicalPotentialdP(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getChemicalPotentialdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getChemicalPotentialdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getComponentName(self) -> java.lang.String: ... + def getComponentNumber(self) -> int: ... + def getComponentType(self) -> java.lang.String: ... + def getCp0(self, double: float) -> float: ... + def getCpA(self) -> float: ... + def getCpB(self) -> float: ... + def getCpC(self) -> float: ... + def getCpD(self) -> float: ... + def getCpE(self) -> float: ... + def getCriticalCompressibilityFactor(self) -> float: ... + def getCriticalViscosity(self) -> float: ... + def getCriticalVolume(self) -> float: ... + def getCv0(self, double: float) -> float: ... + def getDebyeDipoleMoment(self) -> float: ... + def getDiElectricConstant(self, double: float) -> float: ... + def getDiElectricConstantdT(self, double: float) -> float: ... + def getDiElectricConstantdTdT(self, double: float) -> float: ... + def getElements(self) -> jneqsim.thermo.atomelement.Element: ... + def getEnthalpy(self, double: float) -> float: ... + def getEntropy(self, double: float, double2: float) -> float: ... + def getEpsikSAFT(self) -> float: ... + def getFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getFormulae(self) -> java.lang.String: ... + def getFugacityCoefficient(self) -> float: ... + def getFugacitydN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getGibbsEnergy(self, double: float, double2: float) -> float: ... + def getGibbsEnergyOfFormation(self) -> float: ... + def getGresTP(self, double: float) -> float: ... + def getHID(self, double: float) -> float: ... + def getHeatOfFusion(self) -> float: ... + def getHeatOfVapourization(self, double: float) -> float: ... + def getHenryCoef(self, double: float) -> float: ... + def getHenryCoefParameter(self) -> typing.MutableSequence[float]: ... + def getHenryCoefdT(self, double: float) -> float: ... + def getHresTP(self, double: float) -> float: ... + def getHsub(self) -> float: ... + def getIdEntropy(self, double: float) -> float: ... + def getIdealGasAbsoluteEntropy(self) -> float: ... + def getIdealGasEnthalpyOfFormation(self) -> float: ... + def getIdealGasGibbsEnergyOfFormation(self) -> float: ... + def getIndex(self) -> int: ... + def getIonicCharge(self) -> float: ... + def getIonicDiameter(self) -> float: ... + def getK(self) -> float: ... + def getLennardJonesEnergyParameter(self) -> float: ... + def getLennardJonesMolecularDiameter(self) -> float: ... + def getLiquidConductivityParameter(self, int: int) -> float: ... + def getLiquidViscosityModel(self) -> int: ... + def getLiquidViscosityParameter(self, int: int) -> float: ... + @typing.overload + def getMatiascopemanParams(self, int: int) -> float: ... + @typing.overload + def getMatiascopemanParams(self) -> typing.MutableSequence[float]: ... + def getMatiascopemanParamsPR(self) -> typing.MutableSequence[float]: ... + def getMatiascopemanParamsUMRPRU(self) -> typing.MutableSequence[float]: ... + def getMatiascopemanSolidParams(self) -> typing.MutableSequence[float]: ... + def getMeltingPointTemperature(self) -> float: ... + def getMolality(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getMolarMass(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getMolarMass(self) -> float: ... + def getMolarity(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getName(self) -> java.lang.String: ... + @typing.overload + def getNormalBoilingPoint(self) -> float: ... + @typing.overload + def getNormalBoilingPoint(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getNormalLiquidDensity(self) -> float: ... + @typing.overload + def getNormalLiquidDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getNumberOfAssociationSites(self) -> int: ... + def getNumberOfMolesInPhase(self) -> float: ... + def getNumberOfmoles(self) -> float: ... + def getOrginalNumberOfAssociationSites(self) -> int: ... + @typing.overload + def getPC(self) -> float: ... + @typing.overload + def getPC(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getParachorParameter(self) -> float: ... + def getPaulingAnionicDiameter(self) -> float: ... + def getPureComponentCpLiquid(self, double: float) -> float: ... + def getPureComponentCpSolid(self, double: float) -> float: ... + def getPureComponentHeatOfVaporization(self, double: float) -> float: ... + def getPureComponentLiquidDensity(self, double: float) -> float: ... + def getPureComponentSolidDensity(self, double: float) -> float: ... + def getRacketZ(self) -> float: ... + def getRacketZCPA(self) -> float: ... + def getRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getReferenceEnthalpy(self) -> float: ... + def getReferencePotential(self) -> float: ... + def getReferenceStateType(self) -> java.lang.String: ... + def getSchwartzentruberParams(self) -> typing.MutableSequence[float]: ... + def getSigmaSAFTi(self) -> float: ... + def getSolidVaporPressure(self, double: float) -> float: ... + def getSolidVaporPressuredT(self, double: float) -> float: ... + def getSphericalCoreRadius(self) -> float: ... + def getSresTP(self, double: float) -> float: ... + def getStandardDensity(self) -> float: ... + def getStokesCationicDiameter(self) -> float: ... + def getSurfTensInfluenceParam(self, int: int) -> float: ... + def getSurfaceTenisionInfluenceParameter(self, double: float) -> float: ... + @typing.overload + def getTC(self) -> float: ... + @typing.overload + def getTC(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getTotalFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getTriplePointDensity(self) -> float: ... + def getTriplePointPressure(self) -> float: ... + def getTriplePointTemperature(self) -> float: ... + def getTwuCoonParams(self) -> typing.MutableSequence[float]: ... + def getViscosityCorrectionFactor(self) -> float: ... + def getViscosityFrictionK(self) -> float: ... + def getVoli(self) -> float: ... + def getVolumeCorrection(self) -> float: ... + def getVolumeCorrectionConst(self) -> float: ... + def getVolumeCorrectionT(self) -> float: ... + def getVolumeCorrectionT_CPA(self) -> float: ... + def getdfugdn(self, int: int) -> float: ... + def getdfugdp(self) -> float: ... + def getdfugdt(self) -> float: ... + def getdfugdx(self, int: int) -> float: ... + def getdrhodN(self) -> float: ... + def getmSAFTi(self) -> float: ... + def getx(self) -> float: ... + def getz(self) -> float: ... + def init(self, double: float, double2: float, double3: float, double4: float, int: int) -> None: ... + def insertComponentIntoDatabase(self, string: typing.Union[java.lang.String, str]) -> None: ... + def isHydrateFormer(self) -> bool: ... + def isHydrocarbon(self) -> bool: ... + def isInert(self) -> bool: ... + def isIsHydrateFormer(self) -> bool: ... + def isIsIon(self) -> bool: ... + def isIsNormalComponent(self) -> bool: ... + def isIsPlusFraction(self) -> bool: ... + def isIsTBPfraction(self) -> bool: ... + def isWaxFormer(self) -> bool: ... + def logfugcoefdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> typing.MutableSequence[float]: ... + def logfugcoefdNi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int) -> float: ... + def logfugcoefdP(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def logfugcoefdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def reducedPressure(self, double: float) -> float: ... + def reducedTemperature(self, double: float) -> float: ... + def setAcentricFactor(self, double: float) -> None: ... + def setAntoineASolid(self, double: float) -> None: ... + def setAntoineBSolid(self, double: float) -> None: ... + def setAntoineCSolid(self, double: float) -> None: ... + def setAssociationEnergy(self, double: float) -> None: ... + def setAssociationEnergySAFT(self, double: float) -> None: ... + def setAssociationScheme(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setAssociationVolume(self, double: float) -> None: ... + def setAssociationVolumeSAFT(self, double: float) -> None: ... + def setAttractiveTerm(self, int: int) -> None: ... + def setCASnumber(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setComponentName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setComponentNumber(self, int: int) -> None: ... + def setComponentType(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setCpA(self, double: float) -> None: ... + def setCpB(self, double: float) -> None: ... + def setCpC(self, double: float) -> None: ... + def setCpD(self, double: float) -> None: ... + def setCpE(self, double: float) -> None: ... + def setCriticalCompressibilityFactor(self, double: float) -> None: ... + def setCriticalViscosity(self, double: float) -> None: ... + def setCriticalVolume(self, double: float) -> None: ... + def setEpsikSAFT(self, double: float) -> None: ... + def setFormulae(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setFugacityCoefficient(self, double: float) -> None: ... + def setHeatOfFusion(self, double: float) -> None: ... + def setHenryCoefParameter(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setIdealGasEnthalpyOfFormation(self, double: float) -> None: ... + def setIsHydrateFormer(self, boolean: bool) -> None: ... + def setIsIon(self, boolean: bool) -> None: ... + def setIsNormalComponent(self, boolean: bool) -> None: ... + def setIsPlusFraction(self, boolean: bool) -> None: ... + def setIsTBPfraction(self, boolean: bool) -> None: ... + def setK(self, double: float) -> None: ... + def setLennardJonesEnergyParameter(self, double: float) -> None: ... + def setLennardJonesMolecularDiameter(self, double: float) -> None: ... + def setLiquidConductivityParameter(self, double: float, int: int) -> None: ... + def setLiquidViscosityModel(self, int: int) -> None: ... + def setLiquidViscosityParameter(self, double: float, int: int) -> None: ... + @typing.overload + def setMatiascopemanParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setMatiascopemanParams(self, int: int, double: float) -> None: ... + def setMatiascopemanParamsPR(self, int: int, double: float) -> None: ... + def setMatiascopemanSolidParams(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setMolarMass(self, double: float) -> None: ... + @typing.overload + def setMolarMass(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setNormalBoilingPoint(self, double: float) -> None: ... + def setNormalLiquidDensity(self, double: float) -> None: ... + def setNumberOfAssociationSites(self, int: int) -> None: ... + def setNumberOfMolesInPhase(self, double: float) -> None: ... + def setNumberOfmoles(self, double: float) -> None: ... + @typing.overload + def setPC(self, double: float) -> None: ... + @typing.overload + def setPC(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setParachorParameter(self, double: float) -> None: ... + def setPaulingAnionicDiameter(self, double: float) -> None: ... + def setProperties(self, componentInterface: ComponentInterface) -> None: ... + def setRacketZ(self, double: float) -> None: ... + def setRacketZCPA(self, double: float) -> None: ... + def setReferenceEnthalpy(self, double: float) -> None: ... + def setReferencePotential(self, double: float) -> None: ... + def setSchwartzentruberParams(self, int: int, double: float) -> None: ... + def setSigmaSAFTi(self, double: float) -> None: ... + def setSolidCheck(self, boolean: bool) -> None: ... + def setSphericalCoreRadius(self, double: float) -> None: ... + def setStandardDensity(self, double: float) -> None: ... + def setStokesCationicDiameter(self, double: float) -> None: ... + def setSurfTensInfluenceParam(self, int: int, double: float) -> None: ... + @typing.overload + def setTC(self, double: float) -> None: ... + @typing.overload + def setTC(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTriplePointTemperature(self, double: float) -> None: ... + def setTwuCoonParams(self, int: int, double: float) -> None: ... + def setViscosityAssociationFactor(self, double: float) -> None: ... + def setViscosityFrictionK(self, double: float) -> None: ... + def setVoli(self, double: float) -> None: ... + def setVolumeCorrection(self, double: float) -> None: ... + def setVolumeCorrectionConst(self, double: float) -> None: ... + def setVolumeCorrectionT(self, double: float) -> None: ... + def setVolumeCorrectionT_CPA(self, double: float) -> None: ... + def setWaxFormer(self, boolean: bool) -> None: ... + def seta(self, double: float) -> None: ... + def setb(self, double: float) -> None: ... + def setdfugdn(self, int: int, double: float) -> None: ... + def setdfugdp(self, double: float) -> None: ... + def setdfugdt(self, double: float) -> None: ... + def setdfugdx(self, int: int, double: float) -> None: ... + def setmSAFTi(self, double: float) -> None: ... + def setx(self, double: float) -> None: ... + def setz(self, double: float) -> None: ... + +class ComponentEosInterface(ComponentInterface): + def aT(self, double: float) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def diffaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def getAder(self) -> float: ... + def getAi(self) -> float: ... + def getAiT(self) -> float: ... + def getAij(self, int: int) -> float: ... + def getBder(self) -> float: ... + def getBi(self) -> float: ... + def getBij(self, int: int) -> float: ... + def getDeltaEosParameters(self) -> typing.MutableSequence[float]: ... + def geta(self) -> float: ... + def getaDiffDiffT(self) -> float: ... + def getaDiffT(self) -> float: ... + def getaT(self) -> float: ... + def getb(self) -> float: ... + def getdAdT(self) -> float: ... + def getdAdTdn(self) -> float: ... + def getdAdndn(self, int: int) -> float: ... + def getdBdT(self) -> float: ... + def getdBdndT(self) -> float: ... + def getdBdndn(self, int: int) -> float: ... + def setAder(self, double: float) -> None: ... + def setBder(self, double: float) -> None: ... + def setdAdT(self, double: float) -> None: ... + def setdAdTdT(self, double: float) -> None: ... + def setdAdTdn(self, double: float) -> None: ... + def setdAdndn(self, int: int, double: float) -> None: ... + def setdBdTdT(self, double: float) -> None: ... + def setdBdndT(self, double: float) -> None: ... + def setdBdndn(self, int: int, double: float) -> None: ... + +class ComponentGEInterface(ComponentInterface): + @typing.overload + def getGamma(self) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + def getGammaRefCor(self) -> float: ... + def getlnGamma(self) -> float: ... + def getlnGammadn(self, int: int) -> float: ... + def getlnGammadt(self) -> float: ... + def getlnGammadtdt(self) -> float: ... + def setlnGammadn(self, int: int, double: float) -> None: ... + +class ComponentCPAInterface(ComponentEosInterface): + def dFCPAdNdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdVdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXidXj(self, int: int, int2: int, int3: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getXsite(self) -> typing.MutableSequence[float]: ... + def getXsiteOld(self) -> typing.MutableSequence[float]: ... + def getXsitedT(self) -> typing.MutableSequence[float]: ... + def getXsitedTdT(self) -> typing.MutableSequence[float]: ... + def getXsitedV(self) -> typing.MutableSequence[float]: ... + def setXsite(self, int: int, double: float) -> None: ... + def setXsiteOld(self, int: int, double: float) -> None: ... + def setXsitedT(self, int: int, double: float) -> None: ... + def setXsitedTdT(self, int: int, double: float) -> None: ... + def setXsitedV(self, int: int, double: float) -> None: ... + def setXsitedni(self, int: int, int2: int, double: float) -> None: ... + +class ComponentEos(Component, ComponentEosInterface): + a: float = ... + b: float = ... + m: float = ... + alpha: float = ... + aT: float = ... + aDiffT: float = ... + Bi: float = ... + 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 + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentEos': ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getAder(self) -> float: ... + def getAi(self) -> float: ... + def getAiT(self) -> float: ... + def getAij(self, int: int) -> float: ... + def getAresnTV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getAttractiveParameter(self) -> jneqsim.thermo.component.attractiveeosterm.AttractiveTermInterface: ... + def getAttractiveTerm(self) -> jneqsim.thermo.component.attractiveeosterm.AttractiveTermInterface: ... + def getBder(self) -> float: ... + def getBi(self) -> float: ... + def getBij(self, int: int) -> float: ... + @typing.overload + def getChemicalPotential(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getChemicalPotential(self, double: float, double2: float) -> float: ... + def getDeltaEosParameters(self) -> typing.MutableSequence[float]: ... + def getSurfaceTenisionInfluenceParameter(self, double: float) -> float: ... + def geta(self) -> float: ... + def getaDiffDiffT(self) -> float: ... + def getaDiffT(self) -> float: ... + def getaT(self) -> float: ... + def getb(self) -> float: ... + def getdAdT(self) -> float: ... + def getdAdTdT(self) -> float: ... + def getdAdTdn(self) -> float: ... + def getdAdndn(self, int: int) -> float: ... + def getdBdT(self) -> float: ... + def getdBdndT(self) -> float: ... + def getdBdndn(self, int: int) -> float: ... + def getdUdSdnV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getdUdVdnS(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getdUdnSV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getdUdndnSV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int) -> float: ... + def init(self, double: float, double2: float, double3: float, double4: float, int: int) -> None: ... + def logfugcoefdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> typing.MutableSequence[float]: ... + def logfugcoefdNi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int) -> float: ... + def logfugcoefdP(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def logfugcoefdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def setAder(self, double: float) -> None: ... + def setAttractiveParameter(self, attractiveTermInterface: jneqsim.thermo.component.attractiveeosterm.AttractiveTermInterface) -> None: ... + def setAttractiveTerm(self, int: int) -> None: ... + def setBder(self, double: float) -> None: ... + def seta(self, double: float) -> None: ... + def setb(self, double: float) -> None: ... + def setdAdT(self, double: float) -> None: ... + def setdAdTdT(self, double: float) -> None: ... + def setdAdTdn(self, double: float) -> None: ... + def setdAdndn(self, int: int, double: float) -> None: ... + def setdBdTdT(self, double: float) -> None: ... + def setdBdndT(self, double: float) -> None: ... + def setdBdndn(self, int: int, double: float) -> None: ... + +class ComponentGE(Component, ComponentGEInterface): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def fugcoefDiffPres(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def fugcoefDiffTemp(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + @typing.overload + def getGamma(self) -> float: ... + def getGammaRefCor(self) -> float: ... + def getlnGamma(self) -> float: ... + def getlnGammadn(self, int: int) -> float: ... + def getlnGammadt(self) -> float: ... + def getlnGammadtdt(self) -> float: ... + def setlnGammadn(self, int: int, double: float) -> None: ... + +class ComponentHydrate(Component): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calcCKI(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calcChemPotEmpty(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, int2: int) -> float: ... + def calcChemPotIdealWater(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, int2: int) -> float: ... + def calcYKI(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def delt(self, double: float, double2: float, int: int, int2: int, componentInterface: ComponentInterface) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + @typing.overload + def getCavprwat(self, int: int, int2: int) -> float: ... + @typing.overload + def getCavprwat(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getDGfHydrate(self) -> typing.MutableSequence[float]: ... + def getDHfHydrate(self) -> typing.MutableSequence[float]: ... + def getEmptyHydrateStructureVapourPressure(self, int: int, double: float) -> float: ... + def getEmptyHydrateVapourPressureConstant(self, int: int, int2: int) -> float: ... + def getHydrateStructure(self) -> int: ... + def getLennardJonesEnergyParameterHydrate(self) -> float: ... + def getLennardJonesMolecularDiameterHydrate(self) -> float: ... + def getMolarVolumeHydrate(self, int: int, double: float) -> float: ... + def getPot(self, double: float, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getSphericalCoreRadiusHydrate(self) -> float: ... + def potIntegral(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def readHydrateParameters(self) -> None: ... + @typing.overload + def setDGfHydrate(self, double: float, int: int) -> None: ... + @typing.overload + def setDGfHydrate(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setDHfHydrate(self, double: float, int: int) -> None: ... + @typing.overload + def setDHfHydrate(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setEmptyHydrateVapourPressureConstant(self, int: int, int2: int, double: float) -> None: ... + def setHydrateStructure(self, int: int) -> None: ... + def setLennardJonesEnergyParameterHydrate(self, double: float) -> None: ... + def setLennardJonesMolecularDiameterHydrate(self, double: float) -> None: ... + def setRefFug(self, int: int, double: float) -> None: ... + def setSolidRefFluidPhase(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def setSphericalCoreRadiusHydrate(self, double: float) -> None: ... + +class ComponentHydrateKluda(Component): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calcCKI(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calcYKI(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def delt(self, int: int, double: float, double2: float, int2: int, int3: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dfugdt(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getEmptyHydrateStructureVapourPressure(self, int: int, double: float) -> float: ... + def getEmptyHydrateStructureVapourPressuredT(self, int: int, double: float) -> float: ... + def getPot(self, int: int, double: float, int2: int, int3: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def potIntegral(self, int: int, int2: int, int3: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def setRefFug(self, int: int, double: float) -> None: ... + def setStructure(self, int: int) -> None: ... + +class ComponentIdealGas(Component): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def clone(self) -> 'ComponentIdealGas': ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def logfugcoefdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> typing.MutableSequence[float]: ... + def logfugcoefdNi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int) -> float: ... + def logfugcoefdP(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def logfugcoefdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + +class ComponentAmmoniaEos(ComponentEos): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + def alpha(self, double: float) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentAmmoniaEos': ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def diffaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getVolumeCorrection(self) -> float: ... + def logfugcoefdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> typing.MutableSequence[float]: ... + def logfugcoefdP(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def logfugcoefdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + +class ComponentDesmukhMather(ComponentGE): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + @typing.overload + def getGamma(self) -> float: ... + def getLngamma(self) -> float: ... + def getMolality(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + +class ComponentGERG2004(ComponentEos): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def alpha(self, double: float) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentGERG2004': ... + def diffaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getVolumeCorrection(self) -> float: ... + +class ComponentGERG2008Eos(ComponentEos): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + def alpha(self, double: float) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentGERG2008Eos': ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def diffaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getVolumeCorrection(self) -> float: ... + def logfugcoefdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> typing.MutableSequence[float]: ... + def logfugcoefdNi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int) -> float: ... + def logfugcoefdP(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def logfugcoefdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + +class ComponentGEUniquac(ComponentGE): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + @typing.overload + def fugcoefDiffPres(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoefDiffPres(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + @typing.overload + def fugcoefDiffTemp(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoefDiffTemp(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + @typing.overload + def getGamma(self) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + def getlnGammadn(self, int: int) -> float: ... + def getlnGammadt(self) -> float: ... + def getq(self) -> float: ... + def getr(self) -> float: ... + +class ComponentGEWilson(ComponentGE): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + def getCharEnergyParamter(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int) -> float: ... + @typing.overload + def getGamma(self) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + def getWilsonActivityCoefficient(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getWilsonInteractionEnergy(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + +class ComponentGeDuanSun(ComponentGE): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getGamma(self) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + def getGammaNRTL(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> float: ... + def getGammaPitzer(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, double3: float) -> float: ... + def getLngamma(self) -> float: ... + def getq(self) -> float: ... + def getr(self) -> float: ... + +class ComponentGeNRTL(ComponentGE): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + @typing.overload + def getGamma(self) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + def getLngamma(self) -> float: ... + def getq(self) -> float: ... + def getr(self) -> float: ... + +class ComponentGePitzer(ComponentGE): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getGamma(self) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + def getMolality(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + +class ComponentHydrateBallard(ComponentHydrate): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calcCKI(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calcYKI(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def delt(self, double: float, double2: float, int: int, int2: int, componentInterface: ComponentInterface) -> float: ... + @typing.overload + def delt(self, double: float, double2: float, int: int, int2: int) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getPot(self, double: float, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def potIntegral(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + +class ComponentHydrateGF(ComponentHydrate): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calcCKI(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calcYKI(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def fugcoef2(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + +class ComponentHydratePVTsim(ComponentHydrate): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calcCKI(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calcDeltaChemPot(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, int2: int) -> float: ... + def calcYKI(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + +class ComponentHydrateStatoil(ComponentHydrate): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calcCKI(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calcYKI(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def delt(self, double: float, double2: float, int: int, int2: int, componentInterface: ComponentInterface) -> float: ... + @typing.overload + def delt(self, double: float, double2: float, int: int, int2: int) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getPot(self, double: float, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def potIntegral(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + +class ComponentLeachmanEos(ComponentEos): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + def alpha(self, double: float) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentLeachmanEos': ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def diffaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getVolumeCorrection(self) -> float: ... + +class ComponentPR(ComponentEos): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentPR': ... + def getQpure(self, double: float) -> float: ... + def getSurfaceTenisionInfluenceParameter(self, double: float) -> float: ... + def getVolumeCorrection(self) -> float: ... + def getdQpuredT(self, double: float) -> float: ... + def getdQpuredTdT(self, double: float) -> float: ... + +class ComponentRK(ComponentEos): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentRK': ... + def getQpure(self, double: float) -> float: ... + def getVolumeCorrection(self) -> float: ... + def getdQpuredT(self, double: float) -> float: ... + def getdQpuredTdT(self, double: float) -> float: ... + +class ComponentSpanWagnerEos(ComponentEos): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + def alpha(self, double: float) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentSpanWagnerEos': ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def diffaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getVolumeCorrection(self) -> float: ... + +class ComponentSrk(ComponentEos): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentSrk': ... + def getQpure(self, double: float) -> float: ... + def getSurfaceTenisionInfluenceParameter(self, double: float) -> float: ... + def getVolumeCorrection(self) -> float: ... + def getdQpuredT(self, double: float) -> float: ... + def getdQpuredTdT(self, double: float) -> float: ... + +class ComponentTST(ComponentEos): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentTST': ... + def getQpure(self, double: float) -> float: ... + def getVolumeCorrection(self) -> float: ... + def getdQpuredT(self, double: float) -> float: ... + def getdQpuredTdT(self, double: float) -> float: ... + +class ComponentVegaEos(ComponentEos): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + def alpha(self, double: float) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentVegaEos': ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def diffaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getVolumeCorrection(self) -> float: ... + +class ComponentWater(ComponentEos): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + def alpha(self, double: float) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentWater': ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def diffaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getVolumeCorrection(self) -> float: ... + +class ComponentBNS(ComponentPR): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int, double3: float, double4: float, double5: float, double6: float, double7: float, double8: float, double9: float): ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentBNS': ... + +class ComponentBWRS(ComponentSrk): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def clone(self) -> 'ComponentBWRS': ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def getABWRS(self, int: int) -> float: ... + @typing.overload + def getABWRS(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getBE(self, int: int) -> float: ... + @typing.overload + def getBE(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getBEdT(self, int: int) -> float: ... + @typing.overload + def getBEdT(self) -> typing.MutableSequence[float]: ... + def getBP(self, int: int) -> float: ... + @typing.overload + def getBPdT(self, int: int) -> float: ... + @typing.overload + def getBPdT(self) -> typing.MutableSequence[float]: ... + def getELdn(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getFexpdn(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getFpoldn(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getGammaBWRS(self) -> float: ... + def getRhoc(self) -> float: ... + def getdRhodn(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def init(self, double: float, double2: float, double3: float, double4: float, int: int) -> None: ... + def setABWRS(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setBE(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setBEdT(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setBP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setBPdT(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setGammaBWRS(self, double: float) -> None: ... + def setRefPhaseBWRS(self, phaseBWRSEos: jneqsim.thermo.phase.PhaseBWRSEos) -> None: ... + def setRhoc(self, double: float) -> None: ... + +class ComponentCSPsrk(ComponentSrk): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def clone(self) -> 'ComponentCSPsrk': ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getF_scale_mix_i(self) -> float: ... + def getH_scale_mix_i(self) -> float: ... + def getRefPhaseBWRS(self) -> jneqsim.thermo.phase.PhaseCSPsrkEos: ... + def init(self, double: float, double2: float, double3: float, double4: float, int: int) -> None: ... + def setF_scale_mix_i(self, double: float) -> None: ... + def setH_scale_mix_i(self, double: float) -> None: ... + def setRefPhaseBWRS(self, phaseCSPsrkEos: jneqsim.thermo.phase.PhaseCSPsrkEos) -> None: ... + +class ComponentEOSCGEos(ComponentGERG2008Eos): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def clone(self) -> 'ComponentEOSCGEos': ... + +class ComponentGENRTLmodifiedHV(ComponentGeNRTL): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + @typing.overload + def getGamma(self) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + +class ComponentGENRTLmodifiedWS(ComponentGeNRTL): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + @typing.overload + def getGamma(self) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + def getlnGammadn(self, int: int) -> float: ... + def getlnGammadt(self) -> float: ... + +class ComponentGEUnifac(ComponentGEUniquac): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def addUNIFACgroup(self, int: int, int2: int) -> None: ... + def calclnGammak(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + @typing.overload + def fugcoefDiffPres(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoefDiffPres(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + @typing.overload + def fugcoefDiffTemp(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def fugcoefDiffTemp(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + @typing.overload + def getGamma(self) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + def getNumberOfUNIFACgroups(self) -> int: ... + def getQ(self) -> float: ... + def getR(self) -> float: ... + def getUnifacGroup(self, int: int) -> jneqsim.thermo.atomelement.UNIFACgroup: ... + def getUnifacGroup2(self, int: int) -> jneqsim.thermo.atomelement.UNIFACgroup: ... + def getUnifacGroups(self) -> typing.MutableSequence[jneqsim.thermo.atomelement.UNIFACgroup]: ... + def getUnifacGroups2(self) -> java.util.ArrayList[jneqsim.thermo.atomelement.UNIFACgroup]: ... + def setQ(self, double: float) -> None: ... + def setR(self, double: float) -> None: ... + def setUnifacGroups(self, arrayList: java.util.ArrayList[jneqsim.thermo.atomelement.UNIFACgroup]) -> None: ... + +class ComponentGEUniquacmodifiedHV(ComponentGEUniquac): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + @typing.overload + def getGamma(self) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + +class ComponentKentEisenberg(ComponentGeNRTL): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + +class ComponentModifiedFurstElectrolyteEos(ComponentSrk): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def FLRN(self) -> float: ... + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + def calcGammaLRdn(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcSolventdiElectricdn(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcSolventdiElectricdndT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcSolventdiElectricdndn(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def calcXLRdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def calcdiElectricdn(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcdiElectricdndT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcdiElectricdndV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcdiElectricdndn(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def clone(self) -> 'ComponentModifiedFurstElectrolyteEos': ... + def dAlphaLRdndn(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dEpsIonicdNi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dEpsIonicdNidV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dEpsdNi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dEpsdNidV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFBorndN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFBorndNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFBorndNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFLRdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFLRdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFLRdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFLRdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFSR2dN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFSR2dNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFSR2dNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFSR2dNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getAlphai(self) -> float: ... + def getBornVal(self) -> float: ... + def getDiElectricConstantdn(self) -> float: ... + def getEpsIonici(self) -> float: ... + def getEpsi(self) -> float: ... + def getIonicCoVolume(self) -> float: ... + def getSolventDiElectricConstantdn(self) -> float: ... + def getXBorni(self) -> float: ... + def getXLRi(self) -> float: ... + def initFurstParam(self) -> None: ... + +class ComponentModifiedFurstElectrolyteEosMod2004(ComponentSrk): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def FLRN(self) -> float: ... + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + def calcGammaLRdn(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcSolventdiElectricdn(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcSolventdiElectricdndT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcSolventdiElectricdndn(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def calcXLRdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def calcdiElectricdn(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcdiElectricdndT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcdiElectricdndV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcdiElectricdndn(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def clone(self) -> 'ComponentModifiedFurstElectrolyteEosMod2004': ... + def dAlphaLRdndn(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dEpsIonicdNi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dEpsIonicdNidV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dEpsdNi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dEpsdNidV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFBorndN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFBorndNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFBorndNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFLRdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFLRdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFLRdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFLRdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFSR2dN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFSR2dNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFSR2dNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFSR2dNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getAlphai(self) -> float: ... + def getBornVal(self) -> float: ... + def getDiElectricConstantdn(self) -> float: ... + def getEpsIonici(self) -> float: ... + def getEpsi(self) -> float: ... + def getIonicCoVolume(self) -> float: ... + def getSolventDiElectricConstantdn(self) -> float: ... + def getXBorni(self) -> float: ... + def getXLRi(self) -> float: ... + def initFurstParam(self) -> None: ... + +class ComponentPCSAFT(ComponentSrk): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + def calcF1dispSumTermdn(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcF2dispSumTermdn(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcdahsSAFTdi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcdghsSAFTdi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcdmSAFTdi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def calcdnSAFTdi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def clone(self) -> 'ComponentPCSAFT': ... + def dF_DISP1_SAFTdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dF_DISP2_SAFTdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dF_HC_SAFTdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getDghsSAFTdi(self) -> float: ... + def getDlogghsSAFTdi(self) -> float: ... + def getDmSAFTdi(self) -> float: ... + def getDnSAFTdi(self) -> float: ... + def getdSAFTi(self) -> float: ... + def getdahsSAFTdi(self) -> float: ... + def init(self, double: float, double2: float, double3: float, double4: float, int: int) -> None: ... + def setDghsSAFTdi(self, double: float) -> None: ... + def setDlogghsSAFTdi(self, double: float) -> None: ... + def setDmSAFTdi(self, double: float) -> None: ... + def setDnSAFTdi(self, double: float) -> None: ... + def setdSAFTi(self, double: float) -> None: ... + def setdahsSAFTdi(self, double: float) -> None: ... + +class ComponentPRvolcor(ComponentPR): + Cij: typing.MutableSequence[float] = ... + Ci: float = ... + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + def calcc(self) -> float: ... + def calccT(self) -> float: ... + def calccTT(self) -> float: ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getCi(self) -> float: ... + def getCiT(self) -> float: ... + def getCij(self, int: int) -> float: ... + def getFC(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getVolumeCorrection(self) -> float: ... + def getc(self) -> float: ... + def getcT(self) -> float: ... + def getcTT(self) -> float: ... + def init(self, double: float, double2: float, double3: float, double4: float, int: int) -> None: ... + +class ComponentPrCPA(ComponentPR, ComponentCPAInterface): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calc_lngi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calc_lngi2(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentPrCPA': ... + def dFCPAdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getVolumeCorrection(self) -> float: ... + def getXsite(self) -> typing.MutableSequence[float]: ... + def setAttractiveTerm(self, int: int) -> None: ... + @typing.overload + def setXsite(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setXsite(self, int: int, double: float) -> None: ... + +class ComponentSolid(ComponentSrk): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + @typing.overload + def fugcoef(self, double: float, double2: float) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def fugcoef2(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getMolarVolumeSolid(self) -> float: ... + def getVolumeCorrection2(self) -> float: ... + def setSolidRefFluidPhase(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + +class ComponentSoreideWhitson(ComponentPR): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def clone(self) -> 'ComponentSoreideWhitson': ... + +class ComponentSrkCPA(ComponentSrk, ComponentCPAInterface): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float, phaseInterface: jneqsim.thermo.phase.PhaseInterface): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface): ... + def calc_hCPAdn(self) -> float: ... + def calc_lngi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calc_lngidV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calc_lngij(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentSrkCPA': ... + def dFCPAdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFCPAdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdNdXidXdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdVdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXidXj(self, int: int, int2: int, int3: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXidni(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getSurfaceTenisionInfluenceParameter(self, double: float) -> float: ... + def getVolumeCorrection(self) -> float: ... + def getXsite(self) -> typing.MutableSequence[float]: ... + def getXsiteOld(self) -> typing.MutableSequence[float]: ... + def getXsitedT(self) -> typing.MutableSequence[float]: ... + def getXsitedTdT(self) -> typing.MutableSequence[float]: ... + def getXsitedV(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getXsitedni(self, int: int, int2: int) -> float: ... + @typing.overload + def getXsitedni(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def resizeXsitedni(self, int: int) -> None: ... + def setAttractiveTerm(self, int: int) -> None: ... + @typing.overload + def setXsite(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setXsite(self, int: int, double: float) -> None: ... + @typing.overload + def setXsiteOld(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setXsiteOld(self, int: int, double: float) -> None: ... + def setXsitedT(self, int: int, double: float) -> None: ... + def setXsitedTdT(self, int: int, double: float) -> None: ... + def setXsitedV(self, int: int, double: float) -> None: ... + @typing.overload + def setXsitedni(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setXsitedni(self, int: int, int2: int, double: float) -> None: ... + def seta(self, double: float) -> None: ... + def setb(self, double: float) -> None: ... + +class ComponentSrkPeneloux(ComponentSrk): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentSrkPeneloux': ... + def getVolumeCorrection(self) -> float: ... + +class ComponentSrkvolcor(ComponentSrk): + Cij: typing.MutableSequence[float] = ... + Ci: float = ... + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def Finit(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, double3: float, double4: float, int: int, int2: int) -> None: ... + def calcc(self) -> float: ... + def calccT(self) -> float: ... + def calccTT(self) -> float: ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getCi(self) -> float: ... + def getCiT(self) -> float: ... + def getCij(self, int: int) -> float: ... + def getFC(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getVolumeCorrection(self) -> float: ... + def getc(self) -> float: ... + def getcT(self) -> float: ... + def getcTT(self) -> float: ... + def init(self, double: float, double2: float, double3: float, double4: float, int: int) -> None: ... + +class ComponentUMRCPA(ComponentPR, ComponentCPAInterface): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calc_hCPAdn(self) -> float: ... + def calc_lngi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calc_lngidV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calc_lngij(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentUMRCPA': ... + def createComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def dFCPAdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFCPAdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdNdXidXdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdVdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXidXj(self, int: int, int2: int, int3: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXidni(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getSurfaceTenisionInfluenceParameter(self, double: float) -> float: ... + def getVolumeCorrection(self) -> float: ... + def getXsite(self) -> typing.MutableSequence[float]: ... + def getXsiteOld(self) -> typing.MutableSequence[float]: ... + def getXsitedT(self) -> typing.MutableSequence[float]: ... + def getXsitedTdT(self) -> typing.MutableSequence[float]: ... + def getXsitedV(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getXsitedni(self, int: int, int2: int) -> float: ... + @typing.overload + def getXsitedni(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def setAttractiveTerm(self, int: int) -> None: ... + @typing.overload + def setXsite(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setXsite(self, int: int, double: float) -> None: ... + @typing.overload + def setXsiteOld(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setXsiteOld(self, int: int, double: float) -> None: ... + def setXsitedT(self, int: int, double: float) -> None: ... + def setXsitedTdT(self, int: int, double: float) -> None: ... + def setXsitedV(self, int: int, double: float) -> None: ... + @typing.overload + def setXsitedni(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setXsitedni(self, int: int, int2: int, double: float) -> None: ... + def seta(self, double: float) -> None: ... + def setb(self, double: float) -> None: ... + +class ComponentElectrolyteCPA(ComponentModifiedFurstElectrolyteEos, ComponentCPAInterface): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calc_hCPAdn(self) -> float: ... + def calc_lngi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calc_lngidV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calc_lngij(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentElectrolyteCPA': ... + def dFCPAdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFCPAdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdNdXidXdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdVdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXidXj(self, int: int, int2: int, int3: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXidni(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getSurfaceTenisionInfluenceParameter(self, double: float) -> float: ... + def getVolumeCorrection(self) -> float: ... + def getXsite(self) -> typing.MutableSequence[float]: ... + def getXsiteOld(self) -> typing.MutableSequence[float]: ... + def getXsitedT(self) -> typing.MutableSequence[float]: ... + def getXsitedTdT(self) -> typing.MutableSequence[float]: ... + def getXsitedV(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getXsitedni(self, int: int, int2: int) -> float: ... + @typing.overload + def getXsitedni(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def setAttractiveTerm(self, int: int) -> None: ... + @typing.overload + def setXsite(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setXsite(self, int: int, double: float) -> None: ... + @typing.overload + def setXsiteOld(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setXsiteOld(self, int: int, double: float) -> None: ... + def setXsitedT(self, int: int, double: float) -> None: ... + def setXsitedTdT(self, int: int, double: float) -> None: ... + def setXsitedV(self, int: int, double: float) -> None: ... + @typing.overload + def setXsitedni(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setXsitedni(self, int: int, int2: int, double: float) -> None: ... + def seta(self, double: float) -> None: ... + def setb(self, double: float) -> None: ... + +class ComponentElectrolyteCPAOld(ComponentModifiedFurstElectrolyteEos, ComponentCPAInterface): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calc_lngi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calc_lngidV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calca(self) -> float: ... + def calcb(self) -> float: ... + def clone(self) -> 'ComponentElectrolyteCPAOld': ... + def dFCPAdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdNdXidXdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdVdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXidXj(self, int: int, int2: int, int3: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getVolumeCorrection(self) -> float: ... + def getXsite(self) -> typing.MutableSequence[float]: ... + def getXsiteOld(self) -> typing.MutableSequence[float]: ... + def getXsitedT(self) -> typing.MutableSequence[float]: ... + def getXsitedTdT(self) -> typing.MutableSequence[float]: ... + def getXsitedV(self) -> typing.MutableSequence[float]: ... + def setAttractiveTerm(self, int: int) -> None: ... + @typing.overload + def setXsite(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setXsite(self, int: int, double: float) -> None: ... + @typing.overload + def setXsiteOld(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setXsiteOld(self, int: int, double: float) -> None: ... + def setXsitedT(self, int: int, double: float) -> None: ... + def setXsitedTdT(self, int: int, double: float) -> None: ... + def setXsitedV(self, int: int, double: float) -> None: ... + def setXsitedni(self, int: int, int2: int, double: float) -> None: ... + def seta(self, double: float) -> None: ... + def setb(self, double: float) -> None: ... + +class ComponentGEUnifacPSRK(ComponentGEUnifac): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calcaij(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int) -> float: ... + def calcaijdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int) -> float: ... + def calclnGammak(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def calclnGammakdT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + @typing.overload + def getGamma(self) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + +class ComponentGEUnifacUMRPRU(ComponentGEUnifac): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calcGammaNumericalDerivatives(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> None: ... + def calcSum2Comp(self) -> None: ... + def calcSum2CompdTdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def calcTempExpaij(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def calcUnifacGroupParams(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def calcUnifacGroupParamsdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def calcaij(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int) -> float: ... + def calcaijdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int) -> float: ... + def calcaijdTdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int) -> float: ... + def calclnGammak(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def calclnGammakdTdT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def calclnGammakdn(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int) -> None: ... + @typing.overload + def getGamma(self) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> float: ... + @typing.overload + def getGamma(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> float: ... + def getaij(self, int: int, int2: int) -> float: ... + def getaijdT(self, int: int, int2: int) -> float: ... + def getaijdTdT(self, int: int, int2: int) -> float: ... + +class ComponentPCSAFTa(ComponentPCSAFT, ComponentCPAInterface): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calc_lngi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calc_lngidV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def clone(self) -> 'ComponentPCSAFTa': ... + def dFCPAdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFCPAdNdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdNdXidXdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdVdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFCPAdXidXj(self, int: int, int2: int, int3: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def dFdN(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdN(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int2: int, double: float, double2: float) -> float: ... + def dFdNdT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def dFdNdV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, double: float, double2: float) -> float: ... + def getXsite(self) -> typing.MutableSequence[float]: ... + def getXsiteOld(self) -> typing.MutableSequence[float]: ... + def getXsitedT(self) -> typing.MutableSequence[float]: ... + def getXsitedTdT(self) -> typing.MutableSequence[float]: ... + def getXsitedV(self) -> typing.MutableSequence[float]: ... + @typing.overload + def setXsite(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setXsite(self, int: int, double: float) -> None: ... + @typing.overload + def setXsiteOld(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def setXsiteOld(self, int: int, double: float) -> None: ... + def setXsitedT(self, int: int, double: float) -> None: ... + def setXsitedTdT(self, int: int, double: float) -> None: ... + def setXsitedV(self, int: int, double: float) -> None: ... + def setXsitedni(self, int: int, int2: int, double: float) -> None: ... + +class ComponentSrkCPAs(ComponentSrkCPA): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float, phaseInterface: jneqsim.thermo.phase.PhaseInterface): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface): ... + def calc_lngi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calc_lngidV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calc_lngij(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def clone(self) -> 'ComponentSrkCPAs': ... + +class ComponentWax(ComponentSolid): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + @typing.overload + def fugcoef(self, double: float, double2: float) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def fugcoef2(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + +class ComponentWaxWilson(ComponentSolid): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + @typing.overload + def fugcoef(self, double: float, double2: float) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def fugcoef2(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getCharEnergyParamter(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int, int2: int) -> float: ... + def getWilsonActivityCoefficient(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getWilsonInteractionEnergy(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + +class ComponentWonWax(ComponentSolid): + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + @typing.overload + def fugcoef(self, double: float, double2: float) -> float: ... + @typing.overload + def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def fugcoef2(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getWonActivityCoefficient(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getWonParam(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getWonVolume(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + +class ComponentElectrolyteCPAstatoil(ComponentElectrolyteCPA): + @typing.overload + def __init__(self, int: int, double: float, double2: float, double3: float, double4: float, double5: float): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int): ... + def calc_lngi(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calc_lngidV(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def calc_lngij(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def clone(self) -> 'ComponentElectrolyteCPAstatoil': ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.component")``. + + Component: typing.Type[Component] + ComponentAmmoniaEos: typing.Type[ComponentAmmoniaEos] + ComponentBNS: typing.Type[ComponentBNS] + ComponentBWRS: typing.Type[ComponentBWRS] + ComponentCPAInterface: typing.Type[ComponentCPAInterface] + ComponentCSPsrk: typing.Type[ComponentCSPsrk] + ComponentDesmukhMather: typing.Type[ComponentDesmukhMather] + ComponentEOSCGEos: typing.Type[ComponentEOSCGEos] + ComponentElectrolyteCPA: typing.Type[ComponentElectrolyteCPA] + ComponentElectrolyteCPAOld: typing.Type[ComponentElectrolyteCPAOld] + ComponentElectrolyteCPAstatoil: typing.Type[ComponentElectrolyteCPAstatoil] + ComponentEos: typing.Type[ComponentEos] + ComponentEosInterface: typing.Type[ComponentEosInterface] + ComponentGE: typing.Type[ComponentGE] + ComponentGEInterface: typing.Type[ComponentGEInterface] + ComponentGENRTLmodifiedHV: typing.Type[ComponentGENRTLmodifiedHV] + ComponentGENRTLmodifiedWS: typing.Type[ComponentGENRTLmodifiedWS] + ComponentGERG2004: typing.Type[ComponentGERG2004] + ComponentGERG2008Eos: typing.Type[ComponentGERG2008Eos] + ComponentGEUnifac: typing.Type[ComponentGEUnifac] + ComponentGEUnifacPSRK: typing.Type[ComponentGEUnifacPSRK] + ComponentGEUnifacUMRPRU: typing.Type[ComponentGEUnifacUMRPRU] + ComponentGEUniquac: typing.Type[ComponentGEUniquac] + ComponentGEUniquacmodifiedHV: typing.Type[ComponentGEUniquacmodifiedHV] + ComponentGEWilson: typing.Type[ComponentGEWilson] + ComponentGeDuanSun: typing.Type[ComponentGeDuanSun] + ComponentGeNRTL: typing.Type[ComponentGeNRTL] + ComponentGePitzer: typing.Type[ComponentGePitzer] + ComponentHydrate: typing.Type[ComponentHydrate] + ComponentHydrateBallard: typing.Type[ComponentHydrateBallard] + ComponentHydrateGF: typing.Type[ComponentHydrateGF] + ComponentHydrateKluda: typing.Type[ComponentHydrateKluda] + ComponentHydratePVTsim: typing.Type[ComponentHydratePVTsim] + ComponentHydrateStatoil: typing.Type[ComponentHydrateStatoil] + ComponentIdealGas: typing.Type[ComponentIdealGas] + ComponentInterface: typing.Type[ComponentInterface] + ComponentKentEisenberg: typing.Type[ComponentKentEisenberg] + ComponentLeachmanEos: typing.Type[ComponentLeachmanEos] + ComponentModifiedFurstElectrolyteEos: typing.Type[ComponentModifiedFurstElectrolyteEos] + ComponentModifiedFurstElectrolyteEosMod2004: typing.Type[ComponentModifiedFurstElectrolyteEosMod2004] + ComponentPCSAFT: typing.Type[ComponentPCSAFT] + ComponentPCSAFTa: typing.Type[ComponentPCSAFTa] + ComponentPR: typing.Type[ComponentPR] + ComponentPRvolcor: typing.Type[ComponentPRvolcor] + ComponentPrCPA: typing.Type[ComponentPrCPA] + ComponentRK: typing.Type[ComponentRK] + ComponentSolid: typing.Type[ComponentSolid] + ComponentSoreideWhitson: typing.Type[ComponentSoreideWhitson] + ComponentSpanWagnerEos: typing.Type[ComponentSpanWagnerEos] + ComponentSrk: typing.Type[ComponentSrk] + ComponentSrkCPA: typing.Type[ComponentSrkCPA] + ComponentSrkCPAs: typing.Type[ComponentSrkCPAs] + ComponentSrkPeneloux: typing.Type[ComponentSrkPeneloux] + ComponentSrkvolcor: typing.Type[ComponentSrkvolcor] + ComponentTST: typing.Type[ComponentTST] + ComponentUMRCPA: typing.Type[ComponentUMRCPA] + ComponentVegaEos: typing.Type[ComponentVegaEos] + ComponentWater: typing.Type[ComponentWater] + ComponentWax: typing.Type[ComponentWax] + ComponentWaxWilson: typing.Type[ComponentWaxWilson] + ComponentWonWax: typing.Type[ComponentWonWax] + attractiveeosterm: jneqsim.thermo.component.attractiveeosterm.__module_protocol__ + repulsiveeosterm: jneqsim.thermo.component.repulsiveeosterm.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/component/attractiveeosterm/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/component/attractiveeosterm/__init__.pyi new file mode 100644 index 00000000..aa4dd6da --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/component/attractiveeosterm/__init__.pyi @@ -0,0 +1,308 @@ + +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 jpype +import jneqsim.thermo.component +import typing + + + +class AttractiveTermInterface(java.lang.Cloneable, java.io.Serializable): + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermInterface': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def getParameters(self, int: int) -> float: ... + def getm(self) -> float: ... + def init(self) -> None: ... + def setParameters(self, int: int, double: float) -> None: ... + def setm(self, double: float) -> None: ... + +class AttractiveTermBaseClass(AttractiveTermInterface): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermBaseClass': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + def getParameters(self, int: int) -> float: ... + def getm(self) -> float: ... + def setParameters(self, int: int, double: float) -> None: ... + def setm(self, double: float) -> None: ... + +class AttractiveTermMollerup(AttractiveTermBaseClass): + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface, doubleArray: typing.Union[typing.List[float], jpype.JArray]): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermMollerup': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def init(self) -> None: ... + +class AttractiveTermPr(AttractiveTermBaseClass): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermPr': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def init(self) -> None: ... + def setm(self, double: float) -> None: ... + +class AttractiveTermRk(AttractiveTermBaseClass): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermRk': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def init(self) -> None: ... + +class AttractiveTermSchwartzentruber(AttractiveTermBaseClass): + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface, doubleArray: typing.Union[typing.List[float], jpype.JArray]): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermSchwartzentruber': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def init(self) -> None: ... + +class AttractiveTermSrk(AttractiveTermBaseClass): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermSrk': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def init(self) -> None: ... + def setm(self, double: float) -> None: ... + +class AttractiveTermTwuCoon(AttractiveTermBaseClass): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermTwuCoon': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def init(self) -> None: ... + +class AttractiveTermTwuCoonParam(AttractiveTermBaseClass): + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface, doubleArray: typing.Union[typing.List[float], jpype.JArray]): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermTwuCoonParam': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def init(self) -> None: ... + +class AttractiveTermTwuCoonStatoil(AttractiveTermBaseClass): + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface, doubleArray: typing.Union[typing.List[float], jpype.JArray]): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermTwuCoonStatoil': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def init(self) -> None: ... + +class AttractiveTermCPAstatoil(AttractiveTermSrk): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermCPAstatoil': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def init(self) -> None: ... + +class AttractiveTermGERG(AttractiveTermPr): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def AttractiveTermGERG(self) -> typing.Any: ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def diffaT(self, double: float) -> float: ... + def diffalphaTGERG(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaTGERG(self, double: float) -> float: ... + +class AttractiveTermMatCop(AttractiveTermSrk): + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface, doubleArray: typing.Union[typing.List[float], jpype.JArray]): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermMatCop': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def init(self) -> None: ... + +class AttractiveTermMatCopPR(AttractiveTermPr): + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface, doubleArray: typing.Union[typing.List[float], jpype.JArray]): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermMatCopPR': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + +class AttractiveTermMatCopPRUMR(AttractiveTermPr): + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface, doubleArray: typing.Union[typing.List[float], jpype.JArray]): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermMatCopPRUMR': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + +class AttractiveTermPr1978(AttractiveTermPr): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def clone(self) -> 'AttractiveTermPr1978': ... + def init(self) -> None: ... + def setm(self, double: float) -> None: ... + +class AttractiveTermPrGassem2001(AttractiveTermPr): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermPrGassem2001': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def init(self) -> None: ... + +class AttractiveTermTwu(AttractiveTermSrk): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermTwu': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def init(self) -> None: ... + +class AttractiveTermUMRPRU(AttractiveTermPr): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def clone(self) -> 'AttractiveTermUMRPRU': ... + def init(self) -> None: ... + +class AtractiveTermMatCopPRUMRNew(AttractiveTermMatCopPRUMR): + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + @typing.overload + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface, doubleArray: typing.Union[typing.List[float], jpype.JArray]): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AtractiveTermMatCopPRUMRNew': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + +class AttractiveTermPrDanesh(AttractiveTermPr1978): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermPrDanesh': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def init(self) -> None: ... + +class AttractiveTermPrDelft1998(AttractiveTermPr1978): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def aT(self, double: float) -> float: ... + def alpha(self, double: float) -> float: ... + def clone(self) -> 'AttractiveTermPrDelft1998': ... + def diffaT(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + +class AttractiveTermSoreideWhitson(AttractiveTermPr1978): + def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + def alpha(self, double: float) -> float: ... + def diffalphaT(self, double: float) -> float: ... + def diffdiffalphaT(self, double: float) -> float: ... + def setSalinityFromPhase(self, double: float) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.component.attractiveeosterm")``. + + AtractiveTermMatCopPRUMRNew: typing.Type[AtractiveTermMatCopPRUMRNew] + AttractiveTermBaseClass: typing.Type[AttractiveTermBaseClass] + AttractiveTermCPAstatoil: typing.Type[AttractiveTermCPAstatoil] + AttractiveTermGERG: typing.Type[AttractiveTermGERG] + AttractiveTermInterface: typing.Type[AttractiveTermInterface] + AttractiveTermMatCop: typing.Type[AttractiveTermMatCop] + AttractiveTermMatCopPR: typing.Type[AttractiveTermMatCopPR] + AttractiveTermMatCopPRUMR: typing.Type[AttractiveTermMatCopPRUMR] + AttractiveTermMollerup: typing.Type[AttractiveTermMollerup] + AttractiveTermPr: typing.Type[AttractiveTermPr] + AttractiveTermPr1978: typing.Type[AttractiveTermPr1978] + AttractiveTermPrDanesh: typing.Type[AttractiveTermPrDanesh] + AttractiveTermPrDelft1998: typing.Type[AttractiveTermPrDelft1998] + AttractiveTermPrGassem2001: typing.Type[AttractiveTermPrGassem2001] + AttractiveTermRk: typing.Type[AttractiveTermRk] + AttractiveTermSchwartzentruber: typing.Type[AttractiveTermSchwartzentruber] + AttractiveTermSoreideWhitson: typing.Type[AttractiveTermSoreideWhitson] + AttractiveTermSrk: typing.Type[AttractiveTermSrk] + AttractiveTermTwu: typing.Type[AttractiveTermTwu] + AttractiveTermTwuCoon: typing.Type[AttractiveTermTwuCoon] + AttractiveTermTwuCoonParam: typing.Type[AttractiveTermTwuCoonParam] + AttractiveTermTwuCoonStatoil: typing.Type[AttractiveTermTwuCoonStatoil] + AttractiveTermUMRPRU: typing.Type[AttractiveTermUMRPRU] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/component/repulsiveeosterm/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/component/repulsiveeosterm/__init__.pyi new file mode 100644 index 00000000..e32f2399 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/component/repulsiveeosterm/__init__.pyi @@ -0,0 +1,18 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import typing + + + +class RepulsiveTermInterface: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.component.repulsiveeosterm")``. + + RepulsiveTermInterface: typing.Type[RepulsiveTermInterface] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/mixingrule/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/mixingrule/__init__.pyi new file mode 100644 index 00000000..a42d2a30 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/mixingrule/__init__.pyi @@ -0,0 +1,412 @@ + +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 jpype +import neqsim +import jneqsim.thermo +import jneqsim.thermo.component +import jneqsim.thermo.phase +import typing + + + +class MixingRuleHandler(jneqsim.thermo.ThermodynamicConstantsInterface): + def __init__(self): ... + def getName(self) -> java.lang.String: ... + +class MixingRuleTypeInterface: + def getValue(self) -> int: ... + +class MixingRulesInterface(java.io.Serializable, java.lang.Cloneable): + def getName(self) -> java.lang.String: ... + +class CPAMixingRuleType(java.lang.Enum['CPAMixingRuleType'], MixingRuleTypeInterface): + CPA_RADOCH: typing.ClassVar['CPAMixingRuleType'] = ... + PCSAFTA_RADOCH: typing.ClassVar['CPAMixingRuleType'] = ... + @staticmethod + def byName(string: typing.Union[java.lang.String, str]) -> 'CPAMixingRuleType': ... + @staticmethod + def byValue(int: int) -> 'CPAMixingRuleType': ... + def getValue(self) -> int: ... + _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]) -> 'CPAMixingRuleType': ... + @staticmethod + def values() -> typing.MutableSequence['CPAMixingRuleType']: ... + +class CPAMixingRulesInterface(MixingRulesInterface): + def calcDelta(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltaNog(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltadN(self, int: int, int2: int, int3: int, int4: int, int5: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int6: int) -> float: ... + def calcDeltadT(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltadTdT(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltadTdV(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltadV(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcXi(self, intArray: typing.Union[typing.List[typing.MutableSequence[typing.MutableSequence[int]]], jpype.JArray], intArray2: typing.Union[typing.List[typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[int]]]], jpype.JArray], int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + +class ElectrolyteMixingRulesInterface(MixingRulesInterface): + def calcW(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcWT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcWTT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcWi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcWiT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + @typing.overload + def calcWij(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + @typing.overload + def calcWij(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def getWij(self, int: int, int2: int, double: float) -> float: ... + def getWijParameter(self, int: int, int2: int) -> float: ... + def getWijT(self, int: int, int2: int, double: float) -> float: ... + def getWijTT(self, int: int, int2: int, double: float) -> float: ... + def gettWijT1Parameter(self, int: int, int2: int) -> float: ... + def gettWijT2Parameter(self, int: int, int2: int) -> float: ... + def setWijParameter(self, int: int, int2: int, double: float) -> None: ... + def setWijT1Parameter(self, int: int, int2: int, double: float) -> None: ... + def setWijT2Parameter(self, int: int, int2: int, double: float) -> None: ... + +class EosMixingRuleType(java.lang.Enum['EosMixingRuleType'], MixingRuleTypeInterface): + NO: typing.ClassVar['EosMixingRuleType'] = ... + CLASSIC: typing.ClassVar['EosMixingRuleType'] = ... + CLASSIC_HV: typing.ClassVar['EosMixingRuleType'] = ... + HV: typing.ClassVar['EosMixingRuleType'] = ... + WS: typing.ClassVar['EosMixingRuleType'] = ... + CPA_MIX: typing.ClassVar['EosMixingRuleType'] = ... + CLASSIC_T: typing.ClassVar['EosMixingRuleType'] = ... + CLASSIC_T_CPA: typing.ClassVar['EosMixingRuleType'] = ... + CLASSIC_TX_CPA: typing.ClassVar['EosMixingRuleType'] = ... + SOREIDE_WHITSON: typing.ClassVar['EosMixingRuleType'] = ... + CLASSIC_T2: typing.ClassVar['EosMixingRuleType'] = ... + @staticmethod + def byName(string: typing.Union[java.lang.String, str]) -> 'EosMixingRuleType': ... + @staticmethod + def byValue(int: int) -> 'EosMixingRuleType': ... + def getValue(self) -> int: ... + _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]) -> 'EosMixingRuleType': ... + @staticmethod + def values() -> typing.MutableSequence['EosMixingRuleType']: ... + +class EosMixingRulesInterface(MixingRulesInterface): + def calcA(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcATT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAiT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAij(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def calcB(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcBi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcBij(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def getBinaryInteractionParameter(self, int: int, int2: int) -> float: ... + def getBinaryInteractionParameterT1(self, int: int, int2: int) -> float: ... + def getBinaryInteractionParameters(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getBmixType(self) -> int: ... + def getGEPhase(self) -> jneqsim.thermo.phase.PhaseInterface: ... + def setBinaryInteractionParameter(self, int: int, int2: int, double: float) -> None: ... + def setBinaryInteractionParameterT1(self, int: int, int2: int, double: float) -> None: ... + def setBinaryInteractionParameterij(self, int: int, int2: int, double: float) -> None: ... + def setBinaryInteractionParameterji(self, int: int, int2: int, double: float) -> None: ... + def setBmixType(self, int: int) -> None: ... + def setCalcEOSInteractionParameters(self, boolean: bool) -> None: ... + def setMixingRuleGEModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setnEOSkij(self, double: float) -> None: ... + +class HVMixingRulesInterface(EosMixingRulesInterface): + def getHVDijParameter(self, int: int, int2: int) -> float: ... + def getHVDijTParameter(self, int: int, int2: int) -> float: ... + def getHValphaParameter(self, int: int, int2: int) -> float: ... + def getKijWongSandler(self, int: int, int2: int) -> float: ... + def setHVDijParameter(self, int: int, int2: int, double: float) -> None: ... + def setHVDijTParameter(self, int: int, int2: int, double: float) -> None: ... + def setHValphaParameter(self, int: int, int2: int, double: float) -> None: ... + def setKijWongSandler(self, int: int, int2: int, double: float) -> None: ... + +class CPAMixingRuleHandler(MixingRuleHandler): + def __init__(self): ... + def clone(self) -> 'CPAMixingRuleHandler': ... + def getInteractionMatrix(self, intArray: typing.Union[typing.List[int], jpype.JArray], intArray2: typing.Union[typing.List[int], jpype.JArray]) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def getMixingRule(self, int: int) -> CPAMixingRulesInterface: ... + @typing.overload + def getMixingRule(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> CPAMixingRulesInterface: ... + @typing.overload + def getMixingRule(self, mixingRuleTypeInterface: typing.Union[MixingRuleTypeInterface, typing.Callable]) -> CPAMixingRulesInterface: ... + def resetMixingRule(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> MixingRulesInterface: ... + def setAssociationScheme(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def setCrossAssociationScheme(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + class CPA_Radoch(jneqsim.thermo.mixingrule.CPAMixingRuleHandler.CPA_Radoch_base): + def __init__(self, cPAMixingRuleHandler: 'CPAMixingRuleHandler'): ... + @typing.overload + def calcDelta(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + @typing.overload + def calcDelta(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def calcDeltaNog(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltadN(self, int: int, int2: int, int3: int, int4: int, int5: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int6: int) -> float: ... + def calcDeltadT(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltadTdT(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltadTdV(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltadV(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def getCrossAssociationEnergy(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def getCrossAssociationVolume(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def getName(self) -> java.lang.String: ... + class CPA_Radoch_base(CPAMixingRulesInterface): + def __init__(self, cPAMixingRuleHandler: 'CPAMixingRuleHandler'): ... + def calcDelta(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltaNog(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltadN(self, int: int, int2: int, int3: int, int4: int, int5: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int6: int) -> float: ... + def calcDeltadT(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltadTdT(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltadTdV(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + def calcDeltadV(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + @typing.overload + def calcXi(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + @typing.overload + def calcXi(self, intArray: typing.Union[typing.List[typing.MutableSequence[typing.MutableSequence[int]]], jpype.JArray], intArray2: typing.Union[typing.List[typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[int]]]], jpype.JArray], int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + class PCSAFTa_Radoch(jneqsim.thermo.mixingrule.CPAMixingRuleHandler.CPA_Radoch): + def __init__(self, cPAMixingRuleHandler: 'CPAMixingRuleHandler'): ... + @typing.overload + def calcDelta(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + @typing.overload + def calcDelta(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + @typing.overload + def getCrossAssociationEnergy(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + @typing.overload + def getCrossAssociationEnergy(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + @typing.overload + def getCrossAssociationVolume(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + @typing.overload + def getCrossAssociationVolume(self, int: int, int2: int, int3: int, int4: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int5: int) -> float: ... + +class EosMixingRuleHandler(MixingRuleHandler): + mixingRuleGEModel: java.lang.String = ... + Atot: float = ... + Btot: float = ... + Ai: float = ... + Bi: float = ... + A: float = ... + B: float = ... + intparam: typing.MutableSequence[typing.MutableSequence[float]] = ... + intparamT: typing.MutableSequence[typing.MutableSequence[float]] = ... + WSintparam: typing.MutableSequence[typing.MutableSequence[float]] = ... + intparamij: typing.MutableSequence[typing.MutableSequence[float]] = ... + intparamji: typing.MutableSequence[typing.MutableSequence[float]] = ... + intparamTType: typing.MutableSequence[typing.MutableSequence[int]] = ... + nEOSkij: float = ... + calcEOSInteractionParameters: typing.ClassVar[bool] = ... + def __init__(self): ... + def clone(self) -> 'EosMixingRuleHandler': ... + def displayInteractionCoefficients(self, string: typing.Union[java.lang.String, str], phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getClassicOrHV(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getClassicOrWS(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getElectrolyteMixingRule(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> ElectrolyteMixingRulesInterface: ... + def getHVDij(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getHVDijT(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getHValpha(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + def getMixingRule(self, int: int) -> EosMixingRulesInterface: ... + @typing.overload + def getMixingRule(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> EosMixingRulesInterface: ... + def getMixingRuleName(self) -> java.lang.String: ... + def getNRTLDij(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getNRTLDijT(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getNRTLalpha(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getSRKbinaryInteractionParameters(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getWSintparam(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def isCalcEOSInteractionParameters(self) -> bool: ... + def resetMixingRule(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> EosMixingRulesInterface: ... + def setCalcEOSInteractionParameters(self, boolean: bool) -> None: ... + def setMixingRuleGEModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setMixingRuleName(self, string: typing.Union[java.lang.String, str]) -> None: ... + class ClassicSRK(jneqsim.thermo.mixingrule.EosMixingRuleHandler.ClassicVdW): + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler'): ... + def calcA(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcATT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAiT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAij(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def clone(self) -> 'EosMixingRuleHandler.ClassicSRK': ... + def getkij(self, double: float, int: int, int2: int) -> float: ... + class ClassicSRKT(jneqsim.thermo.mixingrule.EosMixingRuleHandler.ClassicSRK): + @typing.overload + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler'): ... + @typing.overload + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler', int: int): ... + def calcATT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAiT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAiTT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def clone(self) -> 'EosMixingRuleHandler.ClassicSRKT': ... + def getkij(self, double: float, int: int, int2: int) -> float: ... + def getkijdT(self, double: float, int: int, int2: int) -> float: ... + def getkijdTdT(self, double: float, int: int, int2: int) -> float: ... + class ClassicSRKT2(jneqsim.thermo.mixingrule.EosMixingRuleHandler.ClassicSRKT): + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler'): ... + def clone(self) -> 'EosMixingRuleHandler.ClassicSRKT': ... + def getkij(self, double: float, int: int, int2: int) -> float: ... + def getkijdT(self, double: float, int: int, int2: int) -> float: ... + def getkijdTdT(self, double: float, int: int, int2: int) -> float: ... + class ClassicSRKT2x(jneqsim.thermo.mixingrule.EosMixingRuleHandler.ClassicSRKT2): + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler'): ... + def calcA(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAiT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAij(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + @typing.overload + def getkij(self, double: float, int: int, int2: int) -> float: ... + @typing.overload + def getkij(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, int: int, int2: int) -> float: ... + def getkijdn(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, int2: int, int3: int) -> float: ... + def getkijdndn(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, int3: int, int4: int) -> float: ... + class ClassicVdW(EosMixingRulesInterface): + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler'): ... + def calcA(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcATT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAiT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAij(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def calcB(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcBFull(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcBi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcBi2(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcBiFull(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcBij(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def clone(self) -> 'EosMixingRuleHandler.ClassicVdW': ... + def equals(self, object: typing.Any) -> bool: ... + def getA(self) -> float: ... + def getB(self) -> float: ... + def getBinaryInteractionParameter(self, int: int, int2: int) -> float: ... + def getBinaryInteractionParameterT1(self, int: int, int2: int) -> float: ... + def getBinaryInteractionParameters(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getBmixType(self) -> int: ... + def getGEPhase(self) -> jneqsim.thermo.phase.PhaseInterface: ... + def getName(self) -> java.lang.String: ... + def getbij(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface, componentEosInterface2: jneqsim.thermo.component.ComponentEosInterface) -> float: ... + def prettyPrintKij(self) -> None: ... + def setBinaryInteractionParameter(self, int: int, int2: int, double: float) -> None: ... + def setBinaryInteractionParameterT1(self, int: int, int2: int, double: float) -> None: ... + def setBinaryInteractionParameterij(self, int: int, int2: int, double: float) -> None: ... + def setBinaryInteractionParameterji(self, int: int, int2: int, double: float) -> None: ... + def setBmixType(self, int: int) -> None: ... + def setCalcEOSInteractionParameters(self, boolean: bool) -> None: ... + def setMixingRuleGEModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setnEOSkij(self, double: float) -> None: ... + class ElectrolyteMixRule(ElectrolyteMixingRulesInterface): + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler', phaseInterface: jneqsim.thermo.phase.PhaseInterface): ... + def calcW(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcWT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcWTT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcWi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcWiT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + @typing.overload + def calcWij(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + @typing.overload + def calcWij(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def getName(self) -> java.lang.String: ... + def getWij(self, int: int, int2: int, double: float) -> float: ... + def getWijParameter(self, int: int, int2: int) -> float: ... + def getWijT(self, int: int, int2: int, double: float) -> float: ... + def getWijTT(self, int: int, int2: int, double: float) -> float: ... + def gettWijT1Parameter(self, int: int, int2: int) -> float: ... + def gettWijT2Parameter(self, int: int, int2: int) -> float: ... + def setWijParameter(self, int: int, int2: int, double: float) -> None: ... + def setWijT1Parameter(self, int: int, int2: int, double: float) -> None: ... + def setWijT2Parameter(self, int: int, int2: int, double: float) -> None: ... + class SRKHuronVidal(jneqsim.thermo.mixingrule.EosMixingRuleHandler.ClassicSRK, HVMixingRulesInterface): + @typing.overload + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler', phaseInterface: jneqsim.thermo.phase.PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]): ... + @typing.overload + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler', phaseInterface: jneqsim.thermo.phase.PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]): ... + def calcA(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAiT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAij(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + def getHVDijParameter(self, int: int, int2: int) -> float: ... + def getHVDijTParameter(self, int: int, int2: int) -> float: ... + def getHValphaParameter(self, int: int, int2: int) -> float: ... + def getKijWongSandler(self, int: int, int2: int) -> float: ... + def setHVDijParameter(self, int: int, int2: int, double: float) -> None: ... + def setHVDijTParameter(self, int: int, int2: int, double: float) -> None: ... + def setHValphaParameter(self, int: int, int2: int, double: float) -> None: ... + def setKijWongSandler(self, int: int, int2: int, double: float) -> None: ... + class SRKHuronVidal2(jneqsim.thermo.mixingrule.EosMixingRuleHandler.ClassicSRK, HVMixingRulesInterface): + @typing.overload + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler', phaseInterface: jneqsim.thermo.phase.PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]): ... + @typing.overload + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler', phaseInterface: jneqsim.thermo.phase.PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]): ... + def calcA(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcATT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAiT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAij(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def getGEPhase(self) -> jneqsim.thermo.phase.PhaseInterface: ... + def getHVDijParameter(self, int: int, int2: int) -> float: ... + def getHVDijTParameter(self, int: int, int2: int) -> float: ... + def getHValphaParameter(self, int: int, int2: int) -> float: ... + def getKijWongSandler(self, int: int, int2: int) -> float: ... + def init(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> None: ... + def setHVDijParameter(self, int: int, int2: int, double: float) -> None: ... + def setHVDijTParameter(self, int: int, int2: int, double: float) -> None: ... + def setHValphaParameter(self, int: int, int2: int, double: float) -> None: ... + def setKijWongSandler(self, int: int, int2: int, double: float) -> None: ... + class WhitsonSoreideMixingRule(jneqsim.thermo.mixingrule.EosMixingRuleHandler.ClassicSRK): + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler'): ... + def calcA(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcATT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAiT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAij(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def getkijWhitsonSoreideAqueous(self, componentEosInterfaceArray: typing.Union[typing.List[jneqsim.thermo.component.ComponentEosInterface], jpype.JArray], double: float, double2: float, int: int, int2: int) -> float: ... + class WongSandlerMixingRule(jneqsim.thermo.mixingrule.EosMixingRuleHandler.SRKHuronVidal2): + @typing.overload + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler', phaseInterface: jneqsim.thermo.phase.PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]): ... + @typing.overload + def __init__(self, eosMixingRuleHandler: 'EosMixingRuleHandler', phaseInterface: jneqsim.thermo.phase.PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]): ... + def calcA(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcATT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAiT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAij(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def calcB(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcBT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcBTT(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcBi(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcBiT(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcBij(self, int: int, int2: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def init(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, double: float, double2: float, int: int) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.mixingrule")``. + + CPAMixingRuleHandler: typing.Type[CPAMixingRuleHandler] + CPAMixingRuleType: typing.Type[CPAMixingRuleType] + CPAMixingRulesInterface: typing.Type[CPAMixingRulesInterface] + ElectrolyteMixingRulesInterface: typing.Type[ElectrolyteMixingRulesInterface] + EosMixingRuleHandler: typing.Type[EosMixingRuleHandler] + EosMixingRuleType: typing.Type[EosMixingRuleType] + EosMixingRulesInterface: typing.Type[EosMixingRulesInterface] + HVMixingRulesInterface: typing.Type[HVMixingRulesInterface] + MixingRuleHandler: typing.Type[MixingRuleHandler] + MixingRuleTypeInterface: typing.Type[MixingRuleTypeInterface] + MixingRulesInterface: typing.Type[MixingRulesInterface] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/phase/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/phase/__init__.pyi new file mode 100644 index 00000000..b0704802 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/phase/__init__.pyi @@ -0,0 +1,3001 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.physicalproperties +import jneqsim.physicalproperties.system +import jneqsim.thermo +import jneqsim.thermo.component +import jneqsim.thermo.mixingrule +import jneqsim.thermo.system +import org.netlib.util +import typing + + + +class PhaseGEInterface: + def getExcessGibbsEnergy(self, phaseInterface: 'PhaseInterface', int: int, double: float, double2: float, phaseType: 'PhaseType') -> float: ... + def setAlpha(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDij(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDijT(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + +class PhaseInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.Cloneable): + def FB(self) -> float: ... + def FBB(self) -> float: ... + def FBD(self) -> float: ... + def FBT(self) -> float: ... + def FBV(self) -> float: ... + def FD(self) -> float: ... + def FDT(self) -> float: ... + def FDV(self) -> float: ... + def FT(self) -> float: ... + def FTT(self) -> float: ... + def FTV(self) -> float: ... + def FV(self) -> float: ... + def FVV(self) -> float: ... + def Fn(self) -> float: ... + def FnB(self) -> float: ... + def FnV(self) -> float: ... + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def addMoles(self, int: int, double: float) -> None: ... + @typing.overload + def addMolesChemReac(self, int: int, double: float, double2: float) -> None: ... + @typing.overload + def addMolesChemReac(self, int: int, double: float) -> None: ... + def calcA(self, phaseInterface: 'PhaseInterface', double: float, double2: float, int: int) -> float: ... + def calcAT(self, int: int, phaseInterface: 'PhaseInterface', double: float, double2: float, int2: int) -> float: ... + def calcAi(self, int: int, phaseInterface: 'PhaseInterface', double: float, double2: float, int2: int) -> float: ... + def calcAiT(self, int: int, phaseInterface: 'PhaseInterface', double: float, double2: float, int2: int) -> float: ... + def calcAij(self, int: int, int2: int, phaseInterface: 'PhaseInterface', double: float, double2: float, int3: int) -> float: ... + def calcB(self, phaseInterface: 'PhaseInterface', double: float, double2: float, int: int) -> float: ... + def calcBi(self, int: int, phaseInterface: 'PhaseInterface', double: float, double2: float, int2: int) -> float: ... + def calcBij(self, int: int, int2: int, phaseInterface: 'PhaseInterface', double: float, double2: float, int3: int) -> float: ... + def calcMolarVolume(self, boolean: bool) -> None: ... + def calcR(self) -> float: ... + def clone(self) -> 'PhaseInterface': ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def fBB(self) -> float: ... + def fBV(self) -> float: ... + def fVV(self) -> float: ... + def fb(self) -> float: ... + def fv(self) -> float: ... + def gBB(self) -> float: ... + def gBV(self) -> float: ... + def gV(self) -> float: ... + def gVV(self) -> float: ... + def gb(self) -> float: ... + def getA(self) -> float: ... + def getAT(self) -> float: ... + def getATT(self) -> float: ... + @typing.overload + def getActivityCoefficient(self, int: int) -> float: ... + @typing.overload + def getActivityCoefficient(self, int: int, int2: int) -> float: ... + def getActivityCoefficientSymetric(self, int: int) -> float: ... + def getActivityCoefficientUnSymetric(self, int: int) -> float: ... + def getAlpha0_EOSCG(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlpha0_GERG2008(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + @typing.overload + def getAlpha0_Leachman(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + @typing.overload + def getAlpha0_Leachman(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlpha0_Vega(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlphares_EOSCG(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + def getAlphares_GERG2008(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + @typing.overload + def getAlphares_Leachman(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + @typing.overload + def getAlphares_Leachman(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + def getAlphares_Vega(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + def getAntoineVaporPressure(self, double: float) -> float: ... + def getB(self) -> float: ... + def getBeta(self) -> float: ... + @typing.overload + def getComponent(self, int: int) -> jneqsim.thermo.component.ComponentInterface: ... + @typing.overload + def getComponent(self, string: typing.Union[java.lang.String, str]) -> jneqsim.thermo.component.ComponentInterface: ... + def getComponentNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getComponentWithIndex(self, int: int) -> jneqsim.thermo.component.ComponentInterface: ... + def getComponents(self) -> typing.MutableSequence[jneqsim.thermo.component.ComponentInterface]: ... + def getComposition(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getCompressibilityX(self) -> float: ... + def getCompressibilityY(self) -> float: ... + def getCorrectedVolume(self) -> float: ... + @typing.overload + def getCp(self) -> float: ... + @typing.overload + def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getCp0(self) -> float: ... + def getCpres(self) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getDensity_AGA8(self) -> float: ... + def getDensity_EOSCG(self) -> float: ... + def getDensity_GERG2008(self) -> float: ... + @typing.overload + def getDensity_Leachman(self) -> float: ... + @typing.overload + def getDensity_Leachman(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getDensity_Vega(self) -> float: ... + @typing.overload + def getEnthalpy(self) -> float: ... + @typing.overload + def getEnthalpy(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getEnthalpydP(self) -> float: ... + def getEnthalpydT(self) -> float: ... + @typing.overload + def getEntropy(self) -> float: ... + @typing.overload + def getEntropy(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getEntropydP(self) -> float: ... + def getEntropydT(self) -> float: ... + def getExcessGibbsEnergy(self) -> float: ... + def getExcessGibbsEnergySymetric(self) -> float: ... + def getFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getFugacity(self, int: int) -> float: ... + @typing.overload + def getFugacity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getGamma(self) -> float: ... + def getGamma2(self) -> float: ... + def getGibbsEnergy(self) -> float: ... + def getGresTP(self) -> float: ... + def getHelmholtzEnergy(self) -> float: ... + def getHresTP(self) -> float: ... + def getInfiniteDiluteFugacity(self, int: int, int2: int) -> float: ... + def getInitType(self) -> int: ... + @typing.overload + def getInternalEnergy(self) -> float: ... + @typing.overload + def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getIsobaricThermalExpansivity(self) -> float: ... + def getIsothermalCompressibility(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getKappa(self) -> float: ... + def getLogActivityCoefficient(self, int: int, int2: int) -> float: ... + @typing.overload + def getLogInfiniteDiluteFugacity(self, int: int) -> float: ... + @typing.overload + def getLogInfiniteDiluteFugacity(self, int: int, int2: int) -> float: ... + def getLogPureComponentFugacity(self, int: int) -> float: ... + def getMass(self) -> float: ... + def getMeanIonicActivity(self, int: int, int2: int) -> float: ... + def getMixGibbsEnergy(self) -> float: ... + def getMixingRule(self) -> jneqsim.thermo.mixingrule.MixingRulesInterface: ... + def getMixingRuleType(self) -> jneqsim.thermo.mixingrule.MixingRuleTypeInterface: ... + def getModelName(self) -> java.lang.String: ... + def getMolalMeanIonicActivity(self, int: int, int2: int) -> float: ... + def getMolarComposition(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getMolarMass(self) -> float: ... + @typing.overload + def getMolarMass(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getMolarVolume(self) -> float: ... + @typing.overload + def getMolarVolume(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMoleFraction(self) -> float: ... + def getNumberOfComponents(self) -> int: ... + def getNumberOfIonicComponents(self) -> int: ... + def getNumberOfMolecularComponents(self) -> int: ... + def getNumberOfMolesInPhase(self) -> float: ... + def getOsmoticCoefficient(self, int: int) -> float: ... + def getOsmoticCoefficientOfWater(self) -> float: ... + def getPhase(self) -> 'PhaseInterface': ... + def getPhaseFraction(self) -> float: ... + def getPhaseTypeName(self) -> java.lang.String: ... + def getPhysicalProperties(self) -> jneqsim.physicalproperties.system.PhysicalProperties: ... + def getPhysicalPropertyModel(self) -> jneqsim.physicalproperties.system.PhysicalPropertyModel: ... + @typing.overload + def getPressure(self) -> float: ... + @typing.overload + def getPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getProperties_EOSCG(self) -> typing.MutableSequence[float]: ... + def getProperties_GERG2008(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getProperties_Leachman(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getProperties_Leachman(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getProperties_Vega(self) -> typing.MutableSequence[float]: ... + def getPseudoCriticalPressure(self) -> float: ... + def getPseudoCriticalTemperature(self) -> float: ... + @typing.overload + def getPureComponentFugacity(self, int: int) -> float: ... + @typing.overload + def getPureComponentFugacity(self, int: int, boolean: bool) -> float: ... + @typing.overload + def getRefPhase(self, int: int) -> 'PhaseInterface': ... + @typing.overload + def getRefPhase(self) -> typing.MutableSequence['PhaseInterface']: ... + @typing.overload + def getSoundSpeed(self) -> float: ... + @typing.overload + def getSoundSpeed(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getSresTP(self) -> float: ... + @typing.overload + def getTemperature(self) -> float: ... + @typing.overload + def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getThermalConductivity(self) -> float: ... + @typing.overload + def getThermalConductivity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getTotalVolume(self) -> float: ... + def getType(self) -> 'PhaseType': ... + @typing.overload + def getViscosity(self) -> float: ... + @typing.overload + def getViscosity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getVolume(self) -> float: ... + @typing.overload + def getVolume(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getWaterDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getWtFrac(self, int: int) -> float: ... + @typing.overload + def getWtFrac(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getWtFraction(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> float: ... + def getWtFractionOfWaxFormingComponents(self) -> float: ... + def getZ(self) -> float: ... + def getZvolcorr(self) -> float: ... + def geta(self, phaseInterface: 'PhaseInterface', double: float, double2: float, int: int) -> float: ... + def getb(self, phaseInterface: 'PhaseInterface', double: float, double2: float, int: int) -> float: ... + def getcomponentArray(self) -> typing.MutableSequence[jneqsim.thermo.component.ComponentInterface]: ... + def getdPdTVn(self) -> float: ... + def getdPdVTn(self) -> float: ... + def getdPdrho(self) -> float: ... + def getdrhodN(self) -> float: ... + def getdrhodP(self) -> float: ... + def getdrhodT(self) -> float: ... + def getg(self) -> float: ... + def getpH(self) -> float: ... + @typing.overload + def hasComponent(self, string: typing.Union[java.lang.String, str], boolean: bool) -> bool: ... + @typing.overload + def hasComponent(self, string: typing.Union[java.lang.String, str]) -> bool: ... + def hasPlusFraction(self) -> bool: ... + def hasTBPFraction(self) -> bool: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: 'PhaseType', double2: float) -> None: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def initPhysicalProperties(self) -> None: ... + @typing.overload + def initPhysicalProperties(self, physicalPropertyType: jneqsim.physicalproperties.PhysicalPropertyType) -> None: ... + @typing.overload + def initPhysicalProperties(self, string: typing.Union[java.lang.String, str]) -> None: ... + def initRefPhases(self, boolean: bool) -> None: ... + def isConstantPhaseVolume(self) -> bool: ... + def isMixingRuleDefined(self) -> bool: ... + def molarVolume(self, double: float, double2: float, double3: float, double4: float, phaseType: 'PhaseType') -> float: ... + def normalize(self) -> None: ... + def removeComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float) -> None: ... + def resetMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def resetPhysicalProperties(self) -> None: ... + def setAttractiveTerm(self, int: int) -> None: ... + def setBeta(self, double: float) -> None: ... + def setComponentArray(self, componentInterfaceArray: typing.Union[typing.List[jneqsim.thermo.component.ComponentInterface], jpype.JArray]) -> None: ... + def setConstantPhaseVolume(self, boolean: bool) -> None: ... + def setEmptyFluid(self) -> None: ... + def setInitType(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + def setMixingRuleGEModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setMolarVolume(self, double: float) -> None: ... + def setMoleFractions(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setNumberOfComponents(self, int: int) -> None: ... + def setParams(self, phaseInterface: 'PhaseInterface', doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setPhaseTypeName(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setPhysicalProperties(self, physicalPropertyModel: jneqsim.physicalproperties.system.PhysicalPropertyModel) -> None: ... + @typing.overload + def setPhysicalProperties(self) -> None: ... + def setPhysicalPropertyModel(self, physicalPropertyModel: jneqsim.physicalproperties.system.PhysicalPropertyModel) -> None: ... + def setPpm(self, physicalPropertyModel: jneqsim.physicalproperties.system.PhysicalPropertyModel) -> None: ... + def setPressure(self, double: float) -> None: ... + def setProperties(self, phaseInterface: 'PhaseInterface') -> None: ... + @typing.overload + def setRefPhase(self, int: int, phaseInterface: 'PhaseInterface') -> None: ... + @typing.overload + def setRefPhase(self, phaseInterfaceArray: typing.Union[typing.List['PhaseInterface'], jpype.JArray]) -> None: ... + def setTemperature(self, double: float) -> None: ... + def setTotalVolume(self, double: float) -> None: ... + def setType(self, phaseType: 'PhaseType') -> None: ... + @typing.overload + def useVolumeCorrection(self) -> bool: ... + @typing.overload + def useVolumeCorrection(self, boolean: bool) -> None: ... + +class PhaseType(java.lang.Enum['PhaseType']): + LIQUID: typing.ClassVar['PhaseType'] = ... + GAS: typing.ClassVar['PhaseType'] = ... + OIL: typing.ClassVar['PhaseType'] = ... + AQUEOUS: typing.ClassVar['PhaseType'] = ... + HYDRATE: typing.ClassVar['PhaseType'] = ... + WAX: typing.ClassVar['PhaseType'] = ... + SOLID: typing.ClassVar['PhaseType'] = ... + SOLIDCOMPLEX: typing.ClassVar['PhaseType'] = ... + @staticmethod + def byDesc(string: typing.Union[java.lang.String, str]) -> 'PhaseType': ... + @staticmethod + def byName(string: typing.Union[java.lang.String, str]) -> 'PhaseType': ... + @staticmethod + def byValue(int: int) -> 'PhaseType': ... + def getDesc(self) -> java.lang.String: ... + def getValue(self) -> int: ... + _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]) -> 'PhaseType': ... + @staticmethod + def values() -> typing.MutableSequence['PhaseType']: ... + +class StateOfMatter(java.lang.Enum['StateOfMatter']): + GAS: typing.ClassVar['StateOfMatter'] = ... + LIQUID: typing.ClassVar['StateOfMatter'] = ... + SOLID: typing.ClassVar['StateOfMatter'] = ... + @staticmethod + def fromPhaseType(phaseType: PhaseType) -> 'StateOfMatter': ... + @staticmethod + def isGas(phaseType: PhaseType) -> bool: ... + @staticmethod + def isLiquid(phaseType: PhaseType) -> bool: ... + @staticmethod + def isSolid(phaseType: PhaseType) -> bool: ... + _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]) -> 'StateOfMatter': ... + @staticmethod + def values() -> typing.MutableSequence['StateOfMatter']: ... + +class Phase(PhaseInterface): + numberOfComponents: int = ... + componentArray: typing.MutableSequence[jneqsim.thermo.component.ComponentInterface] = ... + calcMolarVolume: bool = ... + physicalPropertyHandler: jneqsim.physicalproperties.PhysicalPropertyHandler = ... + chemSyst: bool = ... + thermoPropertyModelName: java.lang.String = ... + numberOfMolesInPhase: float = ... + def __init__(self): ... + def FB(self) -> float: ... + def FBB(self) -> float: ... + def FBD(self) -> float: ... + def FBT(self) -> float: ... + def FBV(self) -> float: ... + def FD(self) -> float: ... + def FDT(self) -> float: ... + def FDV(self) -> float: ... + def FT(self) -> float: ... + def FTT(self) -> float: ... + def FTV(self) -> float: ... + def FV(self) -> float: ... + def FVV(self) -> float: ... + def Fn(self) -> float: ... + def FnB(self) -> float: ... + def FnV(self) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + def addMoles(self, int: int, double: float) -> None: ... + @typing.overload + def addMolesChemReac(self, int: int, double: float) -> None: ... + @typing.overload + def addMolesChemReac(self, int: int, double: float, double2: float) -> None: ... + @typing.overload + def calcA(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + @typing.overload + def calcA(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAT(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAi(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAiT(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAij(self, int: int, int2: int, phaseInterface: PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def calcB(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcBi(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcBij(self, int: int, int2: int, phaseInterface: PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def calcDiElectricConstant(self, double: float) -> float: ... + def calcDiElectricConstantdT(self, double: float) -> float: ... + def calcDiElectricConstantdTdT(self, double: float) -> float: ... + def calcMolarVolume(self, boolean: bool) -> None: ... + def calcR(self) -> float: ... + def clone(self) -> 'Phase': ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + def fBB(self) -> float: ... + def fBV(self) -> float: ... + def fVV(self) -> float: ... + def fb(self) -> float: ... + def fv(self) -> float: ... + def gBB(self) -> float: ... + def gBV(self) -> float: ... + def gV(self) -> float: ... + def gVV(self) -> float: ... + def gb(self) -> float: ... + def getA(self) -> float: ... + def getAT(self) -> float: ... + def getATT(self) -> float: ... + @typing.overload + def getActivityCoefficient(self, int: int) -> float: ... + @typing.overload + def getActivityCoefficient(self, int: int, int2: int) -> float: ... + def getActivityCoefficientSymetric(self, int: int) -> float: ... + def getActivityCoefficientUnSymetric(self, int: int) -> float: ... + def getAiT(self) -> float: ... + def getAlpha0_EOSCG(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlpha0_GERG2008(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + @typing.overload + def getAlpha0_Leachman(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + @typing.overload + def getAlpha0_Leachman(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlpha0_Vega(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlphares_EOSCG(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + def getAlphares_GERG2008(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + @typing.overload + def getAlphares_Leachman(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + @typing.overload + def getAlphares_Leachman(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + def getAlphares_Vega(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + def getAntoineVaporPressure(self, double: float) -> float: ... + def getB(self) -> float: ... + def getBeta(self) -> float: ... + def getBi(self) -> float: ... + @typing.overload + def getComponent(self, int: int) -> jneqsim.thermo.component.ComponentInterface: ... + @typing.overload + def getComponent(self, string: typing.Union[java.lang.String, str]) -> jneqsim.thermo.component.ComponentInterface: ... + def getComponentNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getComponentWithIndex(self, int: int) -> jneqsim.thermo.component.ComponentInterface: ... + def getComponents(self) -> typing.MutableSequence[jneqsim.thermo.component.ComponentInterface]: ... + def getComposition(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getCompressibilityX(self) -> float: ... + def getCompressibilityY(self) -> float: ... + def getCorrectedVolume(self) -> float: ... + @typing.overload + def getCp(self) -> float: ... + @typing.overload + def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getCp0(self) -> float: ... + def getCpres(self) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getCvres(self) -> float: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getDensity_AGA8(self) -> float: ... + def getDensity_EOSCG(self) -> float: ... + def getDensity_GERG2008(self) -> float: ... + @typing.overload + def getDensity_Leachman(self) -> float: ... + @typing.overload + def getDensity_Leachman(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getDensity_Vega(self) -> float: ... + def getDiElectricConstant(self) -> float: ... + @typing.overload + def getEnthalpy(self) -> float: ... + @typing.overload + def getEnthalpy(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getEnthalpydP(self) -> float: ... + def getEnthalpydT(self) -> float: ... + @typing.overload + def getEntropy(self) -> float: ... + @typing.overload + def getEntropy(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getEntropydP(self) -> float: ... + def getEntropydT(self) -> float: ... + def getExcessGibbsEnergy(self) -> float: ... + def getExcessGibbsEnergySymetric(self) -> float: ... + def getFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getFugacity(self, int: int) -> float: ... + @typing.overload + def getFugacity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getGamma(self) -> float: ... + def getGibbsEnergy(self) -> float: ... + def getGresTP(self) -> float: ... + def getHID(self) -> float: ... + def getHelmholtzEnergy(self) -> float: ... + def getHresTP(self) -> float: ... + def getHresdP(self) -> float: ... + @typing.overload + def getInfiniteDiluteFugacity(self, int: int) -> float: ... + @typing.overload + def getInfiniteDiluteFugacity(self, int: int, int2: int) -> float: ... + def getInitType(self) -> int: ... + @typing.overload + def getInternalEnergy(self) -> float: ... + @typing.overload + def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getIsobaricThermalExpansivity(self) -> float: ... + def getIsothermalCompressibility(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getKappa(self) -> float: ... + def getLogActivityCoefficient(self, int: int, int2: int) -> float: ... + @typing.overload + def getLogInfiniteDiluteFugacity(self, int: int) -> float: ... + @typing.overload + def getLogInfiniteDiluteFugacity(self, int: int, int2: int) -> float: ... + @typing.overload + def getLogPureComponentFugacity(self, int: int) -> float: ... + @typing.overload + def getLogPureComponentFugacity(self, int: int, boolean: bool) -> float: ... + def getMass(self) -> float: ... + def getMeanIonicActivity(self, int: int, int2: int) -> float: ... + def getMixGibbsEnergy(self) -> float: ... + def getMixingRuleType(self) -> jneqsim.thermo.mixingrule.MixingRuleTypeInterface: ... + def getModelName(self) -> java.lang.String: ... + def getMolalMeanIonicActivity(self, int: int, int2: int) -> float: ... + def getMolarComposition(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getMolarMass(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getMolarMass(self) -> float: ... + @typing.overload + def getMolarVolume(self) -> float: ... + @typing.overload + def getMolarVolume(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMoleFraction(self) -> float: ... + def getNumberOfComponents(self) -> int: ... + def getNumberOfIonicComponents(self) -> int: ... + def getNumberOfMolecularComponents(self) -> int: ... + def getNumberOfMolesInPhase(self) -> float: ... + def getOsmoticCoefficient(self, int: int) -> float: ... + def getOsmoticCoefficientOfWater(self) -> float: ... + def getPhase(self) -> PhaseInterface: ... + def getPhysicalProperties(self) -> jneqsim.physicalproperties.system.PhysicalProperties: ... + def getPhysicalPropertyModel(self) -> jneqsim.physicalproperties.system.PhysicalPropertyModel: ... + @typing.overload + def getPressure(self) -> float: ... + @typing.overload + def getPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getProperties_EOSCG(self) -> typing.MutableSequence[float]: ... + def getProperties_GERG2008(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getProperties_Leachman(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getProperties_Leachman(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getProperties_Vega(self) -> typing.MutableSequence[float]: ... + def getPseudoCriticalPressure(self) -> float: ... + def getPseudoCriticalTemperature(self) -> float: ... + @typing.overload + def getPureComponentFugacity(self, int: int) -> float: ... + @typing.overload + def getPureComponentFugacity(self, int: int, boolean: bool) -> float: ... + @typing.overload + def getRefPhase(self, int: int) -> PhaseInterface: ... + @typing.overload + def getRefPhase(self) -> typing.MutableSequence[PhaseInterface]: ... + @typing.overload + def getSoundSpeed(self) -> float: ... + @typing.overload + def getSoundSpeed(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getSresTP(self) -> float: ... + def getSresTV(self) -> float: ... + @typing.overload + def getTemperature(self) -> float: ... + @typing.overload + def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getThermalConductivity(self) -> float: ... + @typing.overload + def getThermalConductivity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getThermoPropertyModelName(self) -> java.lang.String: ... + def getTotalVolume(self) -> float: ... + def getType(self) -> PhaseType: ... + @typing.overload + def getViscosity(self) -> float: ... + @typing.overload + def getViscosity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getVolume(self) -> float: ... + @typing.overload + def getVolume(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getWaterDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getWtFrac(self, int: int) -> float: ... + @typing.overload + def getWtFrac(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getWtFraction(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> float: ... + def getWtFractionOfWaxFormingComponents(self) -> float: ... + def getZ(self) -> float: ... + def getZvolcorr(self) -> float: ... + def geta(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def getb(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def getcomponentArray(self) -> typing.MutableSequence[jneqsim.thermo.component.ComponentInterface]: ... + def getdPdTVn(self) -> float: ... + def getdPdVTn(self) -> float: ... + def getdPdrho(self) -> float: ... + def getdrhodN(self) -> float: ... + def getdrhodP(self) -> float: ... + def getdrhodT(self) -> float: ... + def getg(self) -> float: ... + def getpH(self) -> float: ... + def getpH_old(self) -> float: ... + def groupTBPfractions(self) -> typing.MutableSequence[float]: ... + @typing.overload + def hasComponent(self, string: typing.Union[java.lang.String, str], boolean: bool) -> bool: ... + @typing.overload + def hasComponent(self, string: typing.Union[java.lang.String, str]) -> bool: ... + def hasPlusFraction(self) -> bool: ... + def hasTBPFraction(self) -> bool: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + @typing.overload + def initPhysicalProperties(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def initPhysicalProperties(self) -> None: ... + @typing.overload + def initPhysicalProperties(self, physicalPropertyType: jneqsim.physicalproperties.PhysicalPropertyType) -> None: ... + @typing.overload + def initRefPhases(self, boolean: bool) -> None: ... + @typing.overload + def initRefPhases(self, boolean: bool, string: typing.Union[java.lang.String, str]) -> None: ... + def isConstantPhaseVolume(self) -> bool: ... + def isMixingRuleDefined(self) -> bool: ... + def normalize(self) -> None: ... + def removeComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float) -> None: ... + def resetPhysicalProperties(self) -> None: ... + def setAttractiveTerm(self, int: int) -> None: ... + def setBeta(self, double: float) -> None: ... + def setComponentArray(self, componentInterfaceArray: typing.Union[typing.List[jneqsim.thermo.component.ComponentInterface], jpype.JArray]) -> None: ... + def setConstantPhaseVolume(self, boolean: bool) -> None: ... + def setEmptyFluid(self) -> None: ... + def setInitType(self, int: int) -> None: ... + def setMolarVolume(self, double: float) -> None: ... + def setMoleFractions(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setNumberOfComponents(self, int: int) -> None: ... + def setParams(self, phaseInterface: PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setPhysicalProperties(self) -> None: ... + @typing.overload + def setPhysicalProperties(self, physicalPropertyModel: jneqsim.physicalproperties.system.PhysicalPropertyModel) -> None: ... + def setPhysicalPropertyModel(self, physicalPropertyModel: jneqsim.physicalproperties.system.PhysicalPropertyModel) -> None: ... + def setPpm(self, physicalPropertyModel: jneqsim.physicalproperties.system.PhysicalPropertyModel) -> None: ... + def setPressure(self, double: float) -> None: ... + def setProperties(self, phaseInterface: PhaseInterface) -> None: ... + @typing.overload + def setRefPhase(self, int: int, phaseInterface: PhaseInterface) -> None: ... + @typing.overload + def setRefPhase(self, phaseInterfaceArray: typing.Union[typing.List[PhaseInterface], jpype.JArray]) -> None: ... + def setTemperature(self, double: float) -> None: ... + def setTotalVolume(self, double: float) -> None: ... + def setType(self, phaseType: PhaseType) -> None: ... + @typing.overload + def useVolumeCorrection(self) -> bool: ... + @typing.overload + def useVolumeCorrection(self, boolean: bool) -> None: ... + +class PhaseEosInterface(PhaseInterface): + def F(self) -> float: ... + def calcPressure(self) -> float: ... + def calcPressuredV(self) -> float: ... + def dFdN(self, int: int) -> float: ... + def dFdNdN(self, int: int, int2: int) -> float: ... + def dFdNdT(self, int: int) -> float: ... + def dFdNdV(self, int: int) -> float: ... + def displayInteractionCoefficients(self, string: typing.Union[java.lang.String, str]) -> None: ... + def getAresTV(self) -> float: ... + def getEosMixingRule(self) -> jneqsim.thermo.mixingrule.EosMixingRulesInterface: ... + def getMixingRuleName(self) -> java.lang.String: ... + @typing.overload + def getMolarVolume(self) -> float: ... + @typing.overload + def getMolarVolume(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getPressureAttractive(self) -> float: ... + def getPressureRepulsive(self) -> float: ... + def getSresTV(self) -> float: ... + +class PhaseCPAInterface(PhaseEosInterface): + def getCpaMixingRule(self) -> jneqsim.thermo.mixingrule.CPAMixingRulesInterface: ... + def getCrossAssosiationScheme(self, int: int, int2: int, int3: int, int4: int) -> int: ... + def getGcpa(self) -> float: ... + def getGcpav(self) -> float: ... + def getHcpatot(self) -> float: ... + def getTotalNumberOfAccociationSites(self) -> int: ... + def setTotalNumberOfAccociationSites(self, int: int) -> None: ... + +class PhaseDefault(Phase): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, componentInterface: jneqsim.thermo.component.ComponentInterface): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def getGibbsEnergy(self) -> float: ... + def getMixingRule(self) -> jneqsim.thermo.mixingrule.EosMixingRulesInterface: ... + @typing.overload + def getMolarVolume(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getMolarVolume(self) -> float: ... + @typing.overload + def getSoundSpeed(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getSoundSpeed(self) -> float: ... + def molarVolume(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def resetMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def setComponentType(self, componentInterface: jneqsim.thermo.component.ComponentInterface) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def setMixingRuleGEModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class PhaseEos(Phase, PhaseEosInterface): + delta1: float = ... + delta2: float = ... + def __init__(self): ... + def F(self) -> float: ... + def FB(self) -> float: ... + def FBB(self) -> float: ... + def FBD(self) -> float: ... + def FBT(self) -> float: ... + def FBV(self) -> float: ... + def FD(self) -> float: ... + def FDT(self) -> float: ... + def FDV(self) -> float: ... + def FT(self) -> float: ... + def FTT(self) -> float: ... + def FTV(self) -> float: ... + def FV(self) -> float: ... + def FVV(self) -> float: ... + def FVVV(self) -> float: ... + def Fn(self) -> float: ... + def FnB(self) -> float: ... + def FnV(self) -> float: ... + @typing.overload + def calcA(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + @typing.overload + def calcA(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + @typing.overload + def calcAT(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + @typing.overload + def calcAT(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcATT(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcAi(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAiT(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcAij(self, int: int, int2: int, phaseInterface: PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def calcB(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcBi(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcBij(self, int: int, int2: int, phaseInterface: PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def calcPressure(self) -> float: ... + def calcPressuredV(self) -> float: ... + def calcf(self) -> float: ... + def calcg(self) -> float: ... + def clone(self) -> 'PhaseEos': ... + def dFdN(self, int: int) -> float: ... + def dFdNdN(self, int: int, int2: int) -> float: ... + def dFdNdT(self, int: int) -> float: ... + def dFdNdV(self, int: int) -> float: ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def dFdxMatrix(self) -> typing.MutableSequence[float]: ... + def dFdxMatrixSimple(self) -> typing.MutableSequence[float]: ... + def dFdxdxMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def dFdxdxMatrixSimple(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def displayInteractionCoefficients(self, string: typing.Union[java.lang.String, str]) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def fBB(self) -> float: ... + def fBV(self) -> float: ... + def fVV(self) -> float: ... + def fVVV(self) -> float: ... + def fb(self) -> float: ... + def fv(self) -> float: ... + def gBB(self) -> float: ... + def gBV(self) -> float: ... + def gV(self) -> float: ... + def gVV(self) -> float: ... + def gVVV(self) -> float: ... + def gb(self) -> float: ... + def getA(self) -> float: ... + def getAT(self) -> float: ... + def getATT(self) -> float: ... + def getAresTV(self) -> float: ... + def getB(self) -> float: ... + def getCpres(self) -> float: ... + def getCvres(self) -> float: ... + def getEosMixingRule(self) -> jneqsim.thermo.mixingrule.EosMixingRulesInterface: ... + def getF(self) -> float: ... + def getGradientVector(self) -> typing.MutableSequence[float]: ... + def getGresTP(self) -> float: ... + def getHresTP(self) -> float: ... + def getHresdP(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + def getKappa(self) -> float: ... + def getMixingRule(self) -> jneqsim.thermo.mixingrule.EosMixingRulesInterface: ... + def getMixingRuleName(self) -> java.lang.String: ... + def getPressureAttractive(self) -> float: ... + def getPressureRepulsive(self) -> float: ... + @typing.overload + def getSoundSpeed(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getSoundSpeed(self) -> float: ... + def getSresTP(self) -> float: ... + def getSresTV(self) -> float: ... + def getUSVHessianMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def geta(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def getb(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def getdPdTVn(self) -> float: ... + def getdPdVTn(self) -> float: ... + def getdPdrho(self) -> float: ... + def getdTVndSVnJaobiMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getdUdSVn(self) -> float: ... + def getdUdSdSVn(self) -> float: ... + def getdUdSdVn(self, phaseInterface: PhaseInterface) -> float: ... + def getdUdVSn(self) -> float: ... + def getdUdVdVSn(self, phaseInterface: PhaseInterface) -> float: ... + def getdVdrho(self) -> float: ... + def getdrhodN(self) -> float: ... + def getdrhodP(self) -> float: ... + def getdrhodT(self) -> float: ... + def getf_loc(self) -> float: ... + def getg(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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 molarVolume2(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def resetMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def setMixingRuleGEModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class PhaseGE(Phase, PhaseGEInterface): + def __init__(self): ... + @typing.overload + def getActivityCoefficient(self, int: int, int2: int) -> float: ... + @typing.overload + def getActivityCoefficient(self, int: int) -> float: ... + def getActivityCoefficientInfDil(self, int: int) -> float: ... + def getActivityCoefficientInfDilWater(self, int: int, int2: int) -> float: ... + def getActivityCoefficientSymetric(self, int: int) -> float: ... + @typing.overload + def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCp(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getEnthalpy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEnthalpy(self) -> float: ... + @typing.overload + def getEntropy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEntropy(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + def getMixingRule(self) -> jneqsim.thermo.mixingrule.EosMixingRulesInterface: ... + @typing.overload + def getMolarVolume(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getMolarVolume(self) -> float: ... + @typing.overload + def getSoundSpeed(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getSoundSpeed(self) -> float: ... + def getZ(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, double2: float, double3: float, double4: float, int: int, phaseType: PhaseType, int2: int) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + def resetMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def setMixingRuleGEModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class PhaseHydrate(Phase): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhaseHydrate': ... + def getMixingRule(self) -> jneqsim.thermo.mixingrule.MixingRulesInterface: ... + @typing.overload + def getSoundSpeed(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getSoundSpeed(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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 resetMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def setMixingRuleGEModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setSolidRefFluidPhase(self, phaseInterface: PhaseInterface) -> None: ... + +class PhaseIdealGas(Phase, jneqsim.thermo.ThermodynamicConstantsInterface): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhaseIdealGas': ... + def getCpres(self) -> float: ... + def getCvres(self) -> float: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getHresTP(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + def getMixingRule(self) -> jneqsim.thermo.mixingrule.EosMixingRulesInterface: ... + @typing.overload + def getSoundSpeed(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getSoundSpeed(self) -> float: ... + def getSresTP(self) -> float: ... + def getZ(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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 resetMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def setMixingRuleGEModel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPressure(self, double: float) -> None: ... + def setTemperature(self, double: float) -> None: ... + +class PhaseAmmoniaEos(PhaseEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcPressure(self) -> float: ... + def calcPressuredV(self) -> float: ... + def clone(self) -> 'PhaseAmmoniaEos': ... + def dFdN(self, int: int) -> float: ... + def dFdNdN(self, int: int, int2: int) -> float: ... + def dFdNdT(self, int: int) -> float: ... + def dFdNdV(self, int: int) -> float: ... + def getAlpha0(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlphares(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + @typing.overload + def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCp(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getEnthalpy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEnthalpy(self) -> float: ... + @typing.overload + def getEntropy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEntropy(self) -> float: ... + def getGibbsEnergy(self) -> float: ... + def getHresTP(self) -> float: ... + @typing.overload + def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getInternalEnergy(self) -> float: ... + def getIsothermalCompressibility(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + @typing.overload + def getSoundSpeed(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getSoundSpeed(self) -> float: ... + @typing.overload + def getThermalConductivity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getThermalConductivity(self) -> float: ... + @typing.overload + def getViscosity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getViscosity(self) -> float: ... + def getdPdTVn(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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: ... + +class PhaseDesmukhMather(PhaseGE): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + @typing.overload + def getActivityCoefficient(self, int: int) -> float: ... + @typing.overload + def getActivityCoefficient(self, int: int, int2: int) -> float: ... + def getAij(self, int: int, int2: int) -> float: ... + def getBetaDesMatij(self, int: int, int2: int) -> float: ... + def getBij(self, int: int, int2: int) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + def getGibbsEnergy(self) -> float: ... + def getIonicStrength(self) -> float: ... + def getSolventDensity(self) -> float: ... + def getSolventMolarMass(self) -> float: ... + def getSolventWeight(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + @typing.overload + def init(self, double: float, double2: float, double3: float, double4: float, int: int, phaseType: PhaseType, int2: int) -> None: ... + def molarVolume(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def setAij(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setAlpha(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setBij(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDij(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDijT(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + +class PhaseDuanSun(PhaseGE): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + @typing.overload + def getExcessGibbsEnergy(self) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + def getGibbsEnergy(self) -> float: ... + def molarVolume(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def setAlpha(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDij(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDijT(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + +class PhaseGENRTL(PhaseGE): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + @typing.overload + def getExcessGibbsEnergy(self) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + def getGibbsEnergy(self) -> float: ... + def molarVolume(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def setAlpha(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDij(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDijT(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + +class PhaseGERG2004Eos(PhaseEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhaseGERG2004Eos': ... + @typing.overload + def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCp(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getEnthalpy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEnthalpy(self) -> float: ... + @typing.overload + def getEntropy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEntropy(self) -> float: ... + def getGibbsEnergy(self) -> float: ... + @typing.overload + def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getInternalEnergy(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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 setxFracGERG(self) -> None: ... + +class PhaseGERG2008Eos(PhaseEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcPressure(self) -> float: ... + def calcPressuredV(self) -> float: ... + def clone(self) -> 'PhaseGERG2008Eos': ... + def dFdN(self, int: int) -> float: ... + def dFdNdN(self, int: int, int2: int) -> float: ... + def dFdNdT(self, int: int) -> float: ... + def dFdNdV(self, int: int) -> float: ... + def dFdTdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def getAlpha0(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlphaRes(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + @typing.overload + def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCp(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getEnthalpy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEnthalpy(self) -> float: ... + @typing.overload + def getEntropy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEntropy(self) -> float: ... + def getGibbsEnergy(self) -> float: ... + def getGresTP(self) -> float: ... + def getHresTP(self) -> float: ... + @typing.overload + def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getInternalEnergy(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + def getZ(self) -> float: ... + def getdPdTVn(self) -> float: ... + def getdPdVTn(self) -> float: ... + def getdPdrho(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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: ... + +class PhaseGEUniquac(PhaseGE): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + @typing.overload + def getExcessGibbsEnergy(self) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + def getGibbsEnergy(self) -> float: ... + def molarVolume(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def setAlpha(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDij(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDijT(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + +class PhaseGEWilson(PhaseGE): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + @typing.overload + def getExcessGibbsEnergy(self) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + def getGibbsEnergy(self) -> float: ... + def molarVolume(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def setAlpha(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDij(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDijT(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + +class PhaseLeachmanEos(PhaseEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcPressure(self) -> float: ... + def calcPressuredV(self) -> float: ... + def clone(self) -> 'PhaseLeachmanEos': ... + def dFdN(self, int: int) -> float: ... + def dFdNdN(self, int: int, int2: int) -> float: ... + def dFdNdT(self, int: int) -> float: ... + def dFdNdV(self, int: int) -> float: ... + @typing.overload + def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCp(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getEnthalpy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEnthalpy(self) -> float: ... + @typing.overload + def getEntropy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEntropy(self) -> float: ... + def getGibbsEnergy(self) -> float: ... + @typing.overload + def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getInternalEnergy(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + def getZ(self) -> float: ... + def getdPdTVn(self) -> float: ... + def getdPdVTn(self) -> float: ... + def getdPdrho(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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: ... + +class PhasePitzer(PhaseGE): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + @typing.overload + def getActivityCoefficient(self, int: int, int2: int) -> float: ... + @typing.overload + def getActivityCoefficient(self, int: int) -> float: ... + def getBeta0ij(self, int: int, int2: int) -> float: ... + def getBeta1ij(self, int: int, int2: int) -> float: ... + @typing.overload + def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCp(self) -> float: ... + def getCphiij(self, int: int, int2: int) -> float: ... + def getCpres(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCv(self) -> float: ... + def getCvres(self) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + def getHresTP(self) -> float: ... + def getHresdP(self) -> float: ... + def getIonicStrength(self) -> float: ... + def getSolventWeight(self) -> float: ... + def getSresTP(self) -> float: ... + def getSresTV(self) -> float: ... + def molarVolume(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def setAlpha(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setBinaryParameters(self, int: int, int2: int, double: float, double2: float, double3: float) -> None: ... + def setDij(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def setDijT(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + +class PhasePrEos(PhaseEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhasePrEos': ... + +class PhaseRK(PhaseEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhaseRK': ... + +class PhaseSpanWagnerEos(PhaseEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhaseSpanWagnerEos': ... + @typing.overload + def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCp(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getEnthalpy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEnthalpy(self) -> float: ... + @typing.overload + def getEntropy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEntropy(self) -> float: ... + def getGibbsEnergy(self) -> float: ... + @typing.overload + def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getInternalEnergy(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + @typing.overload + def getSoundSpeed(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getSoundSpeed(self) -> float: ... + def getZ(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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: ... + +class PhaseSrkEos(PhaseEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhaseSrkEos': ... + +class PhaseTSTEos(PhaseEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhaseTSTEos': ... + +class PhaseVegaEos(PhaseEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcPressure(self) -> float: ... + def calcPressuredV(self) -> float: ... + def clone(self) -> 'PhaseVegaEos': ... + def dFdN(self, int: int) -> float: ... + def dFdNdN(self, int: int, int2: int) -> float: ... + def dFdNdT(self, int: int) -> float: ... + def dFdNdV(self, int: int) -> float: ... + @typing.overload + def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCp(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getEnthalpy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEnthalpy(self) -> float: ... + @typing.overload + def getEntropy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEntropy(self) -> float: ... + def getGibbsEnergy(self) -> float: ... + @typing.overload + def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getInternalEnergy(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + def getZ(self) -> float: ... + def getdPdTVn(self) -> float: ... + def getdPdVTn(self) -> float: ... + def getdPdrho(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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: ... + +class PhaseWaterIAPWS(PhaseEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcPressure(self) -> float: ... + def calcPressuredV(self) -> float: ... + def clone(self) -> 'PhaseWaterIAPWS': ... + @typing.overload + def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCp(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getEnthalpy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEnthalpy(self) -> float: ... + @typing.overload + def getEntropy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEntropy(self) -> float: ... + def getGibbsEnergy(self) -> float: ... + @typing.overload + def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getInternalEnergy(self) -> float: ... + @typing.overload + def getSoundSpeed(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getSoundSpeed(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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: ... + +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]): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhaseBNS': ... + def setBnsBips(self, double: float) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + +class PhaseBWRSEos(PhaseSrkEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcPVT(self) -> None: ... + def calcPressure2(self) -> float: ... + def clone(self) -> 'PhaseBWRSEos': ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def getEL(self) -> float: ... + def getELdRho(self) -> float: ... + def getELdRhodedRho(self) -> float: ... + def getELdRhodedRhodedRho(self) -> float: ... + def getF(self) -> float: ... + def getFdRho(self) -> float: ... + def getFexp(self) -> float: ... + def getFexpdT(self) -> float: ... + def getFexpdV(self) -> float: ... + def getFexpdVdV(self) -> float: ... + def getFexpdVdVdV(self) -> float: ... + def getFpol(self) -> float: ... + def getFpoldRho(self) -> float: ... + def getFpoldT(self) -> float: ... + def getFpoldV(self) -> float: ... + def getFpoldVdV(self) -> float: ... + def getFpoldVdVdV(self) -> float: ... + def getGammadRho(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + def getMolarDensity(self) -> float: ... + def getdFdN(self) -> float: ... + def getdRhodV(self) -> float: ... + def getdRhodVdV(self) -> float: ... + def getdRhodVdVdV(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + def molarVolume2(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + +class PhaseCSPsrkEos(PhaseSrkEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhaseCSPsrkEos': ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def getAcrefBWRSPhase(self) -> float: ... + def getBrefBWRSPhase(self) -> float: ... + def getF(self) -> float: ... + def getF_scale_mix(self) -> float: ... + def getH_scale_mix(self) -> float: ... + def getRefBWRSPhase(self) -> PhaseSrkEos: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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 setAcrefBWRSPhase(self, double: float) -> None: ... + def setBrefBWRSPhase(self, double: float) -> None: ... + def setF_scale_mix(self, double: float) -> None: ... + def setH_scale_mix(self, double: float) -> None: ... + def setRefBWRSPhase(self, phaseBWRSEos: PhaseBWRSEos) -> None: ... + +class PhaseEOSCGEos(PhaseGERG2008Eos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhaseEOSCGEos': ... + def dFdN(self, int: int) -> float: ... + def dFdNdN(self, int: int, int2: int) -> float: ... + def dFdNdT(self, int: int) -> float: ... + def dFdNdV(self, int: int) -> float: ... + def getAlpha0_GERG2008(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlphares_GERG2008(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + def getProperties_GERG2008(self) -> typing.MutableSequence[float]: ... + def getdPdTVn(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + +class PhaseGENRTLmodifiedHV(PhaseGENRTL): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + @typing.overload + def __init__(self, phaseInterface: PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + @typing.overload + def getExcessGibbsEnergy(self) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + def getGibbsEnergy(self) -> float: ... + def getHresTP(self) -> float: ... + def setDijT(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def setParams(self, phaseInterface: PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + +class PhaseGEUnifac(PhaseGEUniquac): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcaij(self) -> None: ... + def checkGroups(self) -> None: ... + def getAij(self, int: int, int2: int) -> float: ... + def getBij(self, int: int, int2: int) -> float: ... + def getCij(self, int: int, int2: int) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + def getGibbsEnergy(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, double2: float, double3: float, double4: float, int: int, phaseType: PhaseType, int2: int) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + def setAij(self, int: int, int2: int, double: float) -> None: ... + def setBij(self, int: int, int2: int, double: float) -> None: ... + def setCij(self, int: int, int2: int, double: float) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + +class PhaseGEUniquacmodifiedHV(PhaseGEUniquac): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + @typing.overload + def getExcessGibbsEnergy(self) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + +class PhaseKentEisenberg(PhaseGENRTL): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + @typing.overload + def getActivityCoefficient(self, int: int) -> float: ... + @typing.overload + def getActivityCoefficient(self, int: int, int2: int) -> float: ... + +class PhaseModifiedFurstElectrolyteEos(PhaseSrkEos): + def __init__(self): ... + def FBorn(self) -> float: ... + def FBornD(self) -> float: ... + def FBornDD(self) -> float: ... + def FBornDX(self) -> float: ... + def FBornT(self) -> float: ... + def FBornTD(self) -> float: ... + def FBornTT(self) -> float: ... + def FBornTX(self) -> float: ... + def FBornX(self) -> float: ... + def FBornXX(self) -> float: ... + def FLR(self) -> float: ... + def FLRGammaLR(self) -> float: ... + def FLRV(self) -> float: ... + def FLRVV(self) -> float: ... + def FLRXLR(self) -> float: ... + def FSR2(self) -> float: ... + def FSR2T(self) -> float: ... + def FSR2TT(self) -> float: ... + def FSR2TV(self) -> float: ... + def FSR2TW(self) -> float: ... + def FSR2Teps(self) -> float: ... + def FSR2Tn(self) -> float: ... + def FSR2V(self) -> float: ... + def FSR2VV(self) -> float: ... + def FSR2VVV(self) -> float: ... + def FSR2VVeps(self) -> float: ... + def FSR2VW(self) -> float: ... + def FSR2W(self) -> float: ... + def FSR2WW(self) -> float: ... + def FSR2eps(self) -> float: ... + def FSR2epsV(self) -> float: ... + def FSR2epsW(self) -> float: ... + def FSR2epseps(self) -> float: ... + def FSR2epsepsV(self) -> float: ... + def FSR2epsepseps(self) -> float: ... + def FSR2n(self) -> float: ... + def FSR2nT(self) -> float: ... + def FSR2nV(self) -> float: ... + def FSR2nW(self) -> float: ... + def FSR2neps(self) -> float: ... + def FSR2nn(self) -> float: ... + def XBorndndn(self, int: int, int2: int) -> float: ... + def XLRdGammaLR(self) -> float: ... + def XLRdndn(self, int: int, int2: int) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcBornX(self) -> float: ... + def calcDiElectricConstant(self, double: float) -> float: ... + def calcDiElectricConstantdT(self, double: float) -> float: ... + def calcDiElectricConstantdTdT(self, double: float) -> float: ... + def calcDiElectricConstantdTdV(self, double: float) -> float: ... + def calcDiElectricConstantdV(self, double: float) -> float: ... + def calcDiElectricConstantdVdV(self, double: float) -> float: ... + def calcEps(self) -> float: ... + def calcEpsIonic(self) -> float: ... + def calcEpsIonicdV(self) -> float: ... + def calcEpsIonicdVdV(self) -> float: ... + def calcEpsV(self) -> float: ... + def calcEpsVV(self) -> float: ... + def calcGammaLRdV(self) -> float: ... + def calcShieldingParameter(self) -> float: ... + def calcSolventDiElectricConstant(self, double: float) -> float: ... + def calcSolventDiElectricConstantdT(self, double: float) -> float: ... + def calcSolventDiElectricConstantdTdT(self, double: float) -> float: ... + def calcW(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcWi(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcWiT(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcWij(self, int: int, int2: int, phaseInterface: PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def calcXLR(self) -> float: ... + def clone(self) -> 'PhaseModifiedFurstElectrolyteEos': ... + def dFBorndT(self) -> float: ... + def dFBorndTdT(self) -> float: ... + def dFLRdT(self) -> float: ... + def dFLRdTdT(self) -> float: ... + def dFLRdTdV(self) -> float: ... + def dFLRdV(self) -> float: ... + def dFLRdVdV(self) -> float: ... + def dFLRdVdVdV(self) -> float: ... + def dFSR2dT(self) -> float: ... + def dFSR2dTdT(self) -> float: ... + def dFSR2dTdV(self) -> float: ... + def dFSR2dV(self) -> float: ... + def dFSR2dVdV(self) -> float: ... + def dFSR2dVdVdV(self) -> float: ... + def dFdAlphaLR(self) -> float: ... + def dFdAlphaLRdAlphaLR(self) -> float: ... + def dFdAlphaLRdGamma(self) -> float: ... + def dFdAlphaLRdV(self) -> float: ... + def dFdAlphaLRdX(self) -> float: ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def getAlphaLR2(self) -> float: ... + def getAlphaLRT(self) -> float: ... + def getAlphaLRV(self) -> float: ... + def getDiElectricConstantdT(self) -> float: ... + def getDiElectricConstantdV(self) -> float: ... + def getDielectricConstant(self) -> float: ... + def getDielectricT(self) -> float: ... + def getDielectricV(self) -> float: ... + def getElectrolyteMixingRule(self) -> jneqsim.thermo.mixingrule.ElectrolyteMixingRulesInterface: ... + def getEps(self) -> float: ... + def getEpsIonic(self) -> float: ... + def getEpsIonicdV(self) -> float: ... + def getEpsIonicdVdV(self) -> float: ... + def getEpsdV(self) -> float: ... + def getEpsdVdV(self) -> float: ... + def getF(self) -> float: ... + def getShieldingParameter(self) -> float: ... + def getSolventDiElectricConstant(self) -> float: ... + def getSolventDiElectricConstantdT(self) -> float: ... + def getSolventDiElectricConstantdTdT(self) -> float: ... + def getW(self) -> float: ... + def getWT(self) -> float: ... + def getXLR(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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 reInitFurstParam(self) -> None: ... + def setFurstIonicCoefficient(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def volInit(self) -> None: ... + +class PhaseModifiedFurstElectrolyteEosMod2004(PhaseSrkEos): + def __init__(self): ... + def FBorn(self) -> float: ... + def FBornD(self) -> float: ... + def FBornDD(self) -> float: ... + def FBornDX(self) -> float: ... + def FBornT(self) -> float: ... + def FBornTD(self) -> float: ... + def FBornTT(self) -> float: ... + def FBornTX(self) -> float: ... + def FBornX(self) -> float: ... + def FBornXX(self) -> float: ... + def FLR(self) -> float: ... + def FLRGammaLR(self) -> float: ... + def FLRV(self) -> float: ... + def FLRVV(self) -> float: ... + def FLRXLR(self) -> float: ... + def FSR2(self) -> float: ... + def FSR2T(self) -> float: ... + def FSR2TT(self) -> float: ... + def FSR2TV(self) -> float: ... + def FSR2TW(self) -> float: ... + def FSR2Teps(self) -> float: ... + def FSR2Tn(self) -> float: ... + def FSR2V(self) -> float: ... + def FSR2VV(self) -> float: ... + def FSR2VVV(self) -> float: ... + def FSR2VVeps(self) -> float: ... + def FSR2VW(self) -> float: ... + def FSR2W(self) -> float: ... + def FSR2WW(self) -> float: ... + def FSR2eps(self) -> float: ... + def FSR2epsV(self) -> float: ... + def FSR2epsW(self) -> float: ... + def FSR2epseps(self) -> float: ... + def FSR2epsepsV(self) -> float: ... + def FSR2epsepseps(self) -> float: ... + def FSR2n(self) -> float: ... + def FSR2nT(self) -> float: ... + def FSR2nV(self) -> float: ... + def FSR2nW(self) -> float: ... + def FSR2neps(self) -> float: ... + def FSR2nn(self) -> float: ... + def XBorndndn(self, int: int, int2: int) -> float: ... + def XLRdGammaLR(self) -> float: ... + def XLRdndn(self, int: int, int2: int) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcBornX(self) -> float: ... + def calcDiElectricConstant(self, double: float) -> float: ... + def calcDiElectricConstantdT(self, double: float) -> float: ... + def calcDiElectricConstantdTdT(self, double: float) -> float: ... + def calcDiElectricConstantdTdV(self, double: float) -> float: ... + def calcDiElectricConstantdV(self, double: float) -> float: ... + def calcDiElectricConstantdVdV(self, double: float) -> float: ... + def calcEps(self) -> float: ... + def calcEpsIonic(self) -> float: ... + def calcEpsIonicdV(self) -> float: ... + def calcEpsIonicdVdV(self) -> float: ... + def calcEpsV(self) -> float: ... + def calcEpsVV(self) -> float: ... + def calcGammaLRdV(self) -> float: ... + def calcShieldingParameter(self) -> float: ... + def calcSolventDiElectricConstant(self, double: float) -> float: ... + def calcSolventDiElectricConstantdT(self, double: float) -> float: ... + def calcSolventDiElectricConstantdTdT(self, double: float) -> float: ... + def calcW(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcWi(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcWiT(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcWij(self, int: int, int2: int, phaseInterface: PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def calcXLR(self) -> float: ... + def clone(self) -> 'PhaseModifiedFurstElectrolyteEosMod2004': ... + def dFBorndT(self) -> float: ... + def dFBorndTdT(self) -> float: ... + def dFLRdT(self) -> float: ... + def dFLRdTdT(self) -> float: ... + def dFLRdTdV(self) -> float: ... + def dFLRdV(self) -> float: ... + def dFLRdVdV(self) -> float: ... + def dFLRdVdVdV(self) -> float: ... + def dFSR2dT(self) -> float: ... + def dFSR2dTdT(self) -> float: ... + def dFSR2dTdV(self) -> float: ... + def dFSR2dV(self) -> float: ... + def dFSR2dVdV(self) -> float: ... + def dFSR2dVdVdV(self) -> float: ... + def dFdAlphaLR(self) -> float: ... + def dFdAlphaLRdAlphaLR(self) -> float: ... + def dFdAlphaLRdGamma(self) -> float: ... + def dFdAlphaLRdV(self) -> float: ... + def dFdAlphaLRdX(self) -> float: ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def getAlphaLR2(self) -> float: ... + def getAlphaLRT(self) -> float: ... + def getAlphaLRV(self) -> float: ... + def getDiElectricConstantdT(self) -> float: ... + def getDiElectricConstantdV(self) -> float: ... + def getDielectricConstant(self) -> float: ... + def getDielectricT(self) -> float: ... + def getDielectricV(self) -> float: ... + def getElectrolyteMixingRule(self) -> jneqsim.thermo.mixingrule.ElectrolyteMixingRulesInterface: ... + def getEps(self) -> float: ... + def getEpsIonic(self) -> float: ... + def getEpsIonicdV(self) -> float: ... + def getEpsIonicdVdV(self) -> float: ... + def getEpsdV(self) -> float: ... + def getEpsdVdV(self) -> float: ... + def getF(self) -> float: ... + def getShieldingParameter(self) -> float: ... + def getSolventDiElectricConstant(self) -> float: ... + def getSolventDiElectricConstantdT(self) -> float: ... + def getSolventDiElectricConstantdTdT(self) -> float: ... + def getW(self) -> float: ... + def getWT(self) -> float: ... + def getXLR(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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 reInitFurstParam(self) -> None: ... + def setFurstIonicCoefficient(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def volInit(self) -> None: ... + +class PhasePCSAFT(PhaseSrkEos): + def __init__(self): ... + def F_DISP1_SAFT(self) -> float: ... + def F_DISP2_SAFT(self) -> float: ... + def F_HC_SAFT(self) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcF1dispI1(self) -> float: ... + def calcF1dispI1dN(self) -> float: ... + def calcF1dispI1dNdN(self) -> float: ... + def calcF1dispI1dm(self) -> float: ... + def calcF1dispSumTerm(self) -> float: ... + def calcF2dispI2(self) -> float: ... + def calcF2dispI2dN(self) -> float: ... + def calcF2dispI2dNdN(self) -> float: ... + def calcF2dispI2dm(self) -> float: ... + def calcF2dispSumTerm(self) -> float: ... + def calcF2dispZHC(self) -> float: ... + def calcF2dispZHCdN(self) -> float: ... + def calcF2dispZHCdNdN(self) -> float: ... + def calcF2dispZHCdm(self) -> float: ... + def calcdF1dispI1dT(self) -> float: ... + def calcdF1dispI1dTdT(self) -> float: ... + def calcdF1dispI1dTdV(self) -> float: ... + def calcdF1dispSumTermdT(self) -> float: ... + def calcdF1dispSumTermdTdT(self) -> float: ... + def calcdF2dispI2dT(self) -> float: ... + def calcdF2dispI2dTdT(self) -> float: ... + def calcdF2dispI2dTdV(self) -> float: ... + def calcdF2dispSumTermdT(self) -> float: ... + def calcdF2dispSumTermdTdT(self) -> float: ... + def calcdF2dispZHCdT(self) -> float: ... + def calcdF2dispZHCdTdT(self) -> float: ... + def calcdF2dispZHCdTdV(self) -> float: ... + def calcdSAFT(self) -> float: ... + def calcdmeanSAFT(self) -> float: ... + def calcmSAFT(self) -> float: ... + def calcmdSAFT(self) -> float: ... + def calcmmin1SAFT(self) -> float: ... + def clone(self) -> 'PhasePCSAFT': ... + def dF_DISP1_SAFTdT(self) -> float: ... + def dF_DISP1_SAFTdTdT(self) -> float: ... + def dF_DISP1_SAFTdTdV(self) -> float: ... + def dF_DISP1_SAFTdV(self) -> float: ... + def dF_DISP1_SAFTdVdV(self) -> float: ... + def dF_DISP2_SAFTdT(self) -> float: ... + def dF_DISP2_SAFTdTdT(self) -> float: ... + def dF_DISP2_SAFTdTdV(self) -> float: ... + def dF_DISP2_SAFTdV(self) -> float: ... + def dF_DISP2_SAFTdVdV(self) -> float: ... + def dF_HC_SAFTdT(self) -> float: ... + def dF_HC_SAFTdTdT(self) -> float: ... + def dF_HC_SAFTdTdV(self) -> float: ... + def dF_HC_SAFTdV(self) -> float: ... + def dF_HC_SAFTdVdV(self) -> float: ... + def dF_HC_SAFTdVdVdV(self) -> float: ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def getAHSSAFT(self) -> float: ... + def getDSAFT(self) -> float: ... + def getDgHSSAFTdN(self) -> float: ... + def getDmeanSAFT(self) -> float: ... + def getDnSAFTdV(self) -> float: ... + def getF(self) -> float: ... + def getF1dispI1(self) -> float: ... + def getF1dispSumTerm(self) -> float: ... + def getF1dispVolTerm(self) -> float: ... + def getF2dispI2(self) -> float: ... + def getF2dispSumTerm(self) -> float: ... + def getF2dispZHC(self) -> float: ... + def getF2dispZHCdN(self) -> float: ... + def getF2dispZHCdm(self) -> float: ... + def getGhsSAFT(self) -> float: ... + def getMmin1SAFT(self) -> float: ... + def getNSAFT(self) -> float: ... + def getNmSAFT(self) -> float: ... + def getVolumeSAFT(self) -> float: ... + def getaSAFT(self, int: int, double: float, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> float: ... + def getaSAFTdm(self, int: int, double: float, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> float: ... + def getd2DSAFTdTdT(self) -> float: ... + def getdDSAFTdT(self) -> float: ... + def getmSAFT(self) -> float: ... + def getmdSAFT(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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 molarVolume22(self, double: float, double2: float, double3: float, double4: float, int: int) -> float: ... + def setAHSSAFT(self, double: float) -> None: ... + def setDSAFT(self, double: float) -> None: ... + def setDgHSSAFTdN(self, double: float) -> None: ... + def setDmeanSAFT(self, double: float) -> None: ... + def setDnSAFTdV(self, double: float) -> None: ... + def setF1dispVolTerm(self, double: float) -> None: ... + def setF2dispI2(self, double: float) -> None: ... + def setF2dispSumTerm(self, double: float) -> None: ... + def setF2dispZHC(self, double: float) -> None: ... + def setF2dispZHCdm(self, double: float) -> None: ... + def setGhsSAFT(self, double: float) -> None: ... + def setMmin1SAFT(self, double: float) -> None: ... + def setNSAFT(self, double: float) -> None: ... + def setNmSAFT(self, double: float) -> None: ... + def setVolumeSAFT(self, double: float) -> None: ... + def setmSAFT(self, double: float) -> None: ... + def setmdSAFT(self, double: float) -> None: ... + def volInit(self) -> None: ... + +class PhasePrCPA(PhasePrEos, PhaseCPAInterface): + cpaSelect: jneqsim.thermo.mixingrule.CPAMixingRuleHandler = ... + cpamix: jneqsim.thermo.mixingrule.CPAMixingRulesInterface = ... + def __init__(self): ... + def FCPA(self) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calc_g(self) -> float: ... + def calc_hCPA(self) -> float: ... + def calc_hCPAdT(self) -> float: ... + def calc_hCPAdTdT(self) -> float: ... + def calc_lngV(self) -> float: ... + def calc_lngVV(self) -> float: ... + def calc_lngVVV(self) -> float: ... + def calc_lngni(self, int: int) -> float: ... + def clone(self) -> 'PhasePrCPA': ... + def dFCPAdT(self) -> float: ... + def dFCPAdTdT(self) -> float: ... + def dFCPAdV(self) -> float: ... + def dFCPAdVdV(self) -> float: ... + def dFCPAdVdVdV(self) -> float: ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def getCpaMixingRule(self) -> jneqsim.thermo.mixingrule.CPAMixingRulesInterface: ... + def getCrossAssosiationScheme(self, int: int, int2: int, int3: int, int4: int) -> int: ... + def getF(self) -> float: ... + def getGcpa(self) -> float: ... + def getGcpav(self) -> float: ... + def getHcpatot(self) -> float: ... + def getTotalNumberOfAccociationSites(self) -> int: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + def setHcpatot(self, double: float) -> None: ... + def setTotalNumberOfAccociationSites(self, int: int) -> None: ... + def solveX(self) -> bool: ... + +class PhasePrEosvolcor(PhasePrEos): + C: float = ... + Ctot: float = ... + def __init__(self): ... + def F(self) -> float: ... + def FBC(self) -> float: ... + def FC(self) -> float: ... + def FCC(self) -> float: ... + def FCD(self) -> float: ... + def FCV(self) -> float: ... + def FTC(self) -> float: ... + def FnC(self) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcC(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcCT(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcCi(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcCiT(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcCij(self, int: int, int2: int, phaseInterface: PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def calcf(self) -> float: ... + def calcg(self) -> float: ... + def clone(self) -> 'PhasePrEosvolcor': ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def fBB(self) -> float: ... + def fBV(self) -> float: ... + def fVV(self) -> float: ... + def fVVV(self) -> float: ... + def fb(self) -> float: ... + def fbc(self) -> float: ... + def fc(self) -> float: ... + def fcc(self) -> float: ... + def fcv(self) -> float: ... + def fv(self) -> float: ... + def gBB(self) -> float: ... + def gBC(self) -> float: ... + def gBV(self) -> float: ... + def gCC(self) -> float: ... + def gCV(self) -> float: ... + def gV(self) -> float: ... + def gVV(self) -> float: ... + def gVVV(self) -> float: ... + def gb(self) -> float: ... + def gc(self) -> float: ... + def getC(self) -> float: ... + def getCT(self) -> float: ... + def getCTT(self) -> float: ... + def getc(self) -> float: ... + def getcij(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface, componentEosInterface2: jneqsim.thermo.component.ComponentEosInterface) -> float: ... + def getcijT(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface, componentEosInterface2: jneqsim.thermo.component.ComponentEosInterface) -> float: ... + def getcijTT(self, componentPRvolcor: jneqsim.thermo.component.ComponentPRvolcor, componentPRvolcor2: jneqsim.thermo.component.ComponentPRvolcor) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + +class PhaseSolid(PhaseSrkEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhaseSolid': ... + def getDensityTemp(self) -> float: ... + @typing.overload + def getEnthalpy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEnthalpy(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + def setSolidRefFluidPhase(self, phaseInterface: PhaseInterface) -> None: ... + +class PhaseSoreideWhitson(PhasePrEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def addSalinity(self, double: float) -> None: ... + def clone(self) -> 'PhaseSoreideWhitson': ... + def getSalinity(self, double: float) -> float: ... + def getSalinityConcentration(self) -> float: ... + def setSalinityConcentration(self, double: float) -> None: ... + +class PhaseSrkCPA(PhaseSrkEos, PhaseCPAInterface): + cpaSelect: jneqsim.thermo.mixingrule.CPAMixingRuleHandler = ... + cpamix: jneqsim.thermo.mixingrule.CPAMixingRulesInterface = ... + def __init__(self): ... + def FCPA(self) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcDelta(self) -> None: ... + def calcPressure(self) -> float: ... + def calcRootVolFinder(self, phaseType: PhaseType) -> float: ... + def calcXsitedV(self) -> None: ... + def calc_g(self) -> float: ... + def calc_hCPA(self) -> float: ... + def calc_lngV(self) -> float: ... + def calc_lngVV(self) -> float: ... + def calc_lngVVV(self) -> float: ... + def clone(self) -> 'PhaseSrkCPA': ... + def croeneckerProduct(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def dFCPAdT(self) -> float: ... + def dFCPAdTdT(self) -> float: ... + def dFCPAdTdV(self) -> float: ... + def dFCPAdV(self) -> float: ... + def dFCPAdVdV(self) -> float: ... + def dFCPAdVdVdV(self) -> float: ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def getCpaMixingRule(self) -> jneqsim.thermo.mixingrule.CPAMixingRulesInterface: ... + def getCrossAssosiationScheme(self, int: int, int2: int, int3: int, int4: int) -> int: ... + def getF(self) -> float: ... + def getGcpa(self) -> float: ... + def getGcpav(self) -> float: ... + def getHcpatot(self) -> float: ... + def getTotalNumberOfAccociationSites(self) -> int: ... + def getdFdNtemp(self) -> typing.MutableSequence[float]: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + def initCPAMatrix(self, int: int) -> None: ... + def initCPAMatrixOld(self, int: int) -> None: ... + def initOld2(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 molarVolume2(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def molarVolumeChangePhase(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def molarVolumeOld(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def setGcpav(self, double: float) -> None: ... + def setHcpatot(self, double: float) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def setTotalNumberOfAccociationSites(self, int: int) -> None: ... + def solveX(self) -> bool: ... + def solveX2(self, int: int) -> bool: ... + def solveX2Old(self, int: int) -> bool: ... + def solveXOld(self) -> bool: ... + +class PhaseSrkCPA_proceduralMatrices(PhaseSrkEos, PhaseCPAInterface): + cpaSelect: jneqsim.thermo.mixingrule.CPAMixingRuleHandler = ... + cpamix: jneqsim.thermo.mixingrule.CPAMixingRulesInterface = ... + def __init__(self): ... + def FCPA(self) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcDelta(self) -> None: ... + def calcPressure(self) -> float: ... + def calcRootVolFinder(self, phaseType: PhaseType) -> float: ... + def calcXsitedV(self) -> None: ... + def calc_g(self) -> float: ... + def calc_hCPA(self) -> float: ... + def calc_lngV(self) -> float: ... + def calc_lngVV(self) -> float: ... + def calc_lngVVV(self) -> float: ... + def clone(self) -> PhaseSrkCPA: ... + def croeneckerProduct(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def dFCPAdT(self) -> float: ... + def dFCPAdTdT(self) -> float: ... + def dFCPAdTdV(self) -> float: ... + def dFCPAdV(self) -> float: ... + def dFCPAdVdV(self) -> float: ... + def dFCPAdVdVdV(self) -> float: ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def getCpaMixingRule(self) -> jneqsim.thermo.mixingrule.CPAMixingRulesInterface: ... + def getCrossAssosiationScheme(self, int: int, int2: int, int3: int, int4: int) -> int: ... + def getF(self) -> float: ... + def getGcpa(self) -> float: ... + def getGcpav(self) -> float: ... + def getHcpatot(self) -> float: ... + def getTotalNumberOfAccociationSites(self) -> int: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + def initCPAMatrix(self, int: int) -> None: ... + def molarVolume(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def molarVolume2(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def molarVolumeChangePhase(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def setGcpav(self, double: float) -> None: ... + def setHcpatot(self, double: float) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def setTotalNumberOfAccociationSites(self, int: int) -> None: ... + def solveX(self) -> bool: ... + def solveX2(self, int: int) -> bool: ... + +class PhaseSrkEosvolcor(PhaseSrkEos): + C: float = ... + Ctot: float = ... + def __init__(self): ... + def F(self) -> float: ... + def FBC(self) -> float: ... + def FC(self) -> float: ... + def FCC(self) -> float: ... + def FCD(self) -> float: ... + def FCV(self) -> float: ... + def FTC(self) -> float: ... + def FnC(self) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcC(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcCT(self, phaseInterface: PhaseInterface, double: float, double2: float, int: int) -> float: ... + def calcCi(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcCiT(self, int: int, phaseInterface: PhaseInterface, double: float, double2: float, int2: int) -> float: ... + def calcCij(self, int: int, int2: int, phaseInterface: PhaseInterface, double: float, double2: float, int3: int) -> float: ... + def calcf(self) -> float: ... + def calcg(self) -> float: ... + def clone(self) -> 'PhaseSrkEosvolcor': ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def fBB(self) -> float: ... + def fBV(self) -> float: ... + def fVV(self) -> float: ... + def fVVV(self) -> float: ... + def fb(self) -> float: ... + def fbc(self) -> float: ... + def fc(self) -> float: ... + def fcc(self) -> float: ... + def fcv(self) -> float: ... + def fv(self) -> float: ... + def gBB(self) -> float: ... + def gBC(self) -> float: ... + def gBV(self) -> float: ... + def gCC(self) -> float: ... + def gCV(self) -> float: ... + def gV(self) -> float: ... + def gVV(self) -> float: ... + def gVVV(self) -> float: ... + def gb(self) -> float: ... + def gc(self) -> float: ... + def getC(self) -> float: ... + def getCT(self) -> float: ... + def getCTT(self) -> float: ... + def getc(self) -> float: ... + def getcij(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface, componentEosInterface2: jneqsim.thermo.component.ComponentEosInterface) -> float: ... + def getcijT(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface, componentEosInterface2: jneqsim.thermo.component.ComponentEosInterface) -> float: ... + def getcijTT(self, componentSrkvolcor: jneqsim.thermo.component.ComponentSrkvolcor, componentSrkvolcor2: jneqsim.thermo.component.ComponentSrkvolcor) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + +class PhaseSrkPenelouxEos(PhaseSrkEos): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhaseSrkPenelouxEos': ... + +class PhaseUMRCPA(PhasePrEos, PhaseCPAInterface): + cpaSelect: jneqsim.thermo.mixingrule.CPAMixingRuleHandler = ... + cpamix: jneqsim.thermo.mixingrule.CPAMixingRulesInterface = ... + def __init__(self): ... + def FCPA(self) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcDelta(self) -> None: ... + def calcPressure(self) -> float: ... + def calcRootVolFinder(self, phaseType: PhaseType) -> float: ... + def calcXsitedV(self) -> None: ... + def calc_g(self) -> float: ... + def calc_hCPA(self) -> float: ... + def calc_lngV(self) -> float: ... + def calc_lngVV(self) -> float: ... + def calc_lngVVV(self) -> float: ... + def clone(self) -> 'PhaseUMRCPA': ... + def croeneckerProduct(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def dFCPAdT(self) -> float: ... + def dFCPAdTdT(self) -> float: ... + def dFCPAdTdV(self) -> float: ... + def dFCPAdV(self) -> float: ... + def dFCPAdVdV(self) -> float: ... + def dFCPAdVdVdV(self) -> float: ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def getCpaMixingRule(self) -> jneqsim.thermo.mixingrule.CPAMixingRulesInterface: ... + def getCrossAssosiationScheme(self, int: int, int2: int, int3: int, int4: int) -> int: ... + def getF(self) -> float: ... + def getGcpa(self) -> float: ... + def getGcpav(self) -> float: ... + def getHcpatot(self) -> float: ... + def getTotalNumberOfAccociationSites(self) -> int: ... + def getdFdNtemp(self) -> typing.MutableSequence[float]: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + def initCPAMatrix(self, int: int) -> None: ... + def initCPAMatrixOld(self, int: int) -> None: ... + def initOld2(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 molarVolume2(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def molarVolumeChangePhase(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def molarVolumeOld(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def setGcpav(self, double: float) -> None: ... + def setHcpatot(self, double: float) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def setTotalNumberOfAccociationSites(self, int: int) -> None: ... + def solveX(self) -> bool: ... + def solveX2(self, int: int) -> bool: ... + def solveX2Old(self, int: int) -> bool: ... + def solveXOld(self) -> bool: ... + +class PhaseElectrolyteCPA(PhaseModifiedFurstElectrolyteEos, PhaseCPAInterface): + cpaSelect: jneqsim.thermo.mixingrule.CPAMixingRuleHandler = ... + cpamix: jneqsim.thermo.mixingrule.CPAMixingRulesInterface = ... + def __init__(self): ... + def FCPA(self) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcDelta(self) -> None: ... + def calcPressure(self) -> float: ... + def calcRootVolFinder(self, phaseType: PhaseType) -> float: ... + def calcXsitedV(self) -> None: ... + def calc_g(self) -> float: ... + def calc_hCPA(self) -> float: ... + def calc_lngV(self) -> float: ... + def calc_lngVV(self) -> float: ... + def calc_lngVVV(self) -> float: ... + def clone(self) -> 'PhaseElectrolyteCPA': ... + def croeneckerProduct(self, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def dFCPAdT(self) -> float: ... + def dFCPAdTdT(self) -> float: ... + def dFCPAdTdV(self) -> float: ... + def dFCPAdV(self) -> float: ... + def dFCPAdVdV(self) -> float: ... + def dFCPAdVdVdV(self) -> float: ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def getCpaMixingRule(self) -> jneqsim.thermo.mixingrule.CPAMixingRulesInterface: ... + def getCrossAssosiationScheme(self, int: int, int2: int, int3: int, int4: int) -> int: ... + def getF(self) -> float: ... + def getGcpa(self) -> float: ... + def getGcpav(self) -> float: ... + def getHcpatot(self) -> float: ... + def getTotalNumberOfAccociationSites(self) -> int: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + def initCPAMatrix(self, int: int) -> None: ... + def molarVolume(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def molarVolume2(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def molarVolumeChangePhase(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def setGcpav(self, double: float) -> None: ... + def setHcpatot(self, double: float) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def setTotalNumberOfAccociationSites(self, int: int) -> None: ... + def solveX(self) -> bool: ... + def solveX2(self, int: int) -> bool: ... + +class PhaseElectrolyteCPAOld(PhaseModifiedFurstElectrolyteEos, PhaseCPAInterface): + cpaSelect: jneqsim.thermo.mixingrule.CPAMixingRuleHandler = ... + cpamix: jneqsim.thermo.mixingrule.CPAMixingRulesInterface = ... + def __init__(self): ... + def FCPA(self) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcXsitedT(self) -> None: ... + def calc_g(self) -> float: ... + def calc_hCPA(self) -> float: ... + def calc_hCPAdT(self) -> float: ... + def calc_hCPAdTdT(self) -> float: ... + def calc_lngV(self) -> float: ... + def calc_lngVV(self) -> float: ... + def calc_lngVVV(self) -> float: ... + def calc_lngni(self, int: int) -> float: ... + def clone(self) -> 'PhaseElectrolyteCPAOld': ... + def dFCPAdT(self) -> float: ... + def dFCPAdTdT(self) -> float: ... + def dFCPAdV(self) -> float: ... + def dFCPAdVdV(self) -> float: ... + def dFCPAdVdVdV(self) -> float: ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def getCpaMixingRule(self) -> jneqsim.thermo.mixingrule.CPAMixingRulesInterface: ... + def getCrossAssosiationScheme(self, int: int, int2: int, int3: int, int4: int) -> int: ... + def getF(self) -> float: ... + def getGcpa(self) -> float: ... + def getGcpav(self) -> float: ... + def getHcpatot(self) -> float: ... + def getTotalNumberOfAccociationSites(self) -> int: ... + def getdFdVdXdXdVtotal(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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 molarVolume2(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def molarVolume3(self, double: float, double2: float, double3: float, double4: float, phaseType: PhaseType) -> float: ... + def setGcpav(self, double: float) -> None: ... + def setHcpatot(self, double: float) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def setTotalNumberOfAccociationSites(self, int: int) -> None: ... + def setXsiteOld(self) -> None: ... + def setXsitedV(self, double: float) -> None: ... + def solveX(self) -> bool: ... + +class PhaseGENRTLmodifiedWS(PhaseGENRTLmodifiedHV): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray], doubleArray4: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + @typing.overload + def __init__(self, phaseInterface: PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + @typing.overload + def getExcessGibbsEnergy(self) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + +class PhaseGEUnifacPSRK(PhaseGEUnifac): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcbij(self) -> None: ... + def calccij(self) -> None: ... + @typing.overload + def getExcessGibbsEnergy(self) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + +class PhaseGEUnifacUMRPRU(PhaseGEUnifac): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: PhaseInterface, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], doubleArray2: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray], stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray], doubleArray3: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcCommontemp(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> None: ... + def calcaij(self) -> None: ... + def calcbij(self) -> None: ... + def calccij(self) -> None: ... + @typing.overload + def getExcessGibbsEnergy(self) -> float: ... + @typing.overload + def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + def getFCommontemp(self) -> float: ... + def getQmix(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getQmixdN(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getVCommontemp(self) -> float: ... + def initQmix(self) -> None: ... + def initQmixdN(self) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + +class PhasePCSAFTRahmat(PhasePCSAFT): + def __init__(self): ... + def F_DISP1_SAFT(self) -> float: ... + def F_DISP2_SAFT(self) -> float: ... + def F_HC_SAFT(self) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calcF1dispI1(self) -> float: ... + def calcF1dispI1dN(self) -> float: ... + def calcF1dispI1dNdN(self) -> float: ... + def calcF1dispI1dNdNdN(self) -> float: ... + def calcF1dispI1dm(self) -> float: ... + def calcF1dispSumTerm(self) -> float: ... + def calcF2dispI2(self) -> float: ... + def calcF2dispI2dN(self) -> float: ... + def calcF2dispI2dNdN(self) -> float: ... + def calcF2dispI2dNdNdN(self) -> float: ... + def calcF2dispI2dm(self) -> float: ... + def calcF2dispSumTerm(self) -> float: ... + def calcF2dispZHC(self) -> float: ... + def calcF2dispZHCdN(self) -> float: ... + def calcF2dispZHCdNdN(self) -> float: ... + def calcF2dispZHCdNdNdN(self) -> float: ... + def calcF2dispZHCdm(self) -> float: ... + def calcdF1dispI1dT(self) -> float: ... + def calcdF1dispSumTermdT(self) -> float: ... + def calcdF2dispI2dT(self) -> float: ... + def calcdF2dispSumTermdT(self) -> float: ... + def calcdF2dispZHCdT(self) -> float: ... + def calcdSAFT(self) -> float: ... + def calcdmeanSAFT(self) -> float: ... + def calcmSAFT(self) -> float: ... + def calcmdSAFT(self) -> float: ... + def calcmmin1SAFT(self) -> float: ... + def clone(self) -> 'PhasePCSAFTRahmat': ... + def dF_DISP1_SAFTdT(self) -> float: ... + def dF_DISP1_SAFTdV(self) -> float: ... + def dF_DISP1_SAFTdVdV(self) -> float: ... + def dF_DISP1_SAFTdVdVdV(self) -> float: ... + def dF_DISP2_SAFTdT(self) -> float: ... + def dF_DISP2_SAFTdV(self) -> float: ... + def dF_DISP2_SAFTdVdV(self) -> float: ... + def dF_DISP2_SAFTdVdVdV(self) -> float: ... + def dF_HC_SAFTdT(self) -> float: ... + def dF_HC_SAFTdV(self) -> float: ... + def dF_HC_SAFTdVdV(self) -> float: ... + def dF_HC_SAFTdVdVdV(self) -> float: ... + def dFdT(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def getF(self) -> float: ... + def getaSAFT(self, int: int, double: float, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> float: ... + def getaSAFTdm(self, int: int, double: float, doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> float: ... + def getdDSAFTdT(self) -> float: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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 volInit(self) -> None: ... + +class PhasePCSAFTa(PhasePCSAFT, PhaseCPAInterface): + cpaSelect: jneqsim.thermo.mixingrule.CPAMixingRuleHandler = ... + cpamix: jneqsim.thermo.mixingrule.CPAMixingRulesInterface = ... + def __init__(self): ... + def FCPA(self) -> float: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calc_hCPA(self) -> float: ... + def calc_hCPAdT(self) -> float: ... + def calc_hCPAdTdT(self) -> float: ... + def calc_lngni(self, int: int) -> float: ... + def clone(self) -> 'PhasePCSAFTa': ... + def dFCPAdT(self) -> float: ... + def dFCPAdTdT(self) -> float: ... + def dFCPAdV(self) -> float: ... + def dFCPAdVdV(self) -> float: ... + def dFCPAdVdVdV(self) -> float: ... + def dFdT(self) -> float: ... + def dFdTdT(self) -> float: ... + def dFdTdV(self) -> float: ... + def dFdV(self) -> float: ... + def dFdVdV(self) -> float: ... + def dFdVdVdV(self) -> float: ... + def getCpaMixingRule(self) -> jneqsim.thermo.mixingrule.CPAMixingRulesInterface: ... + def getCrossAssosiationScheme(self, int: int, int2: int, int3: int, int4: int) -> int: ... + def getF(self) -> float: ... + def getGcpa(self) -> float: ... + def getGcpav(self) -> float: ... + def getHcpatot(self) -> float: ... + def getTotalNumberOfAccociationSites(self) -> int: ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @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 setHcpatot(self, double: float) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + def setTotalNumberOfAccociationSites(self, int: int) -> None: ... + def solveX(self) -> bool: ... + def volInit(self) -> None: ... + +class PhasePureComponentSolid(PhaseSolid): + def __init__(self): ... + def clone(self) -> 'PhasePureComponentSolid': ... + +class PhaseSolidComplex(PhaseSolid): + def __init__(self): ... + def clone(self) -> 'PhaseSolidComplex': ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + +class PhaseSrkCPAs(PhaseSrkCPA): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calc_g(self) -> float: ... + def calc_lngV(self) -> float: ... + def calc_lngVV(self) -> float: ... + def calc_lngVVV(self) -> float: ... + def clone(self) -> 'PhaseSrkCPAs': ... + +class PhaseWax(PhaseSolid): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def clone(self) -> 'PhaseWax': ... + @typing.overload + def init(self) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, double2: float) -> None: ... + @typing.overload + def init(self, double: float, int: int, int2: int, phaseType: PhaseType, double2: float) -> None: ... + +class PhaseElectrolyteCPAstatoil(PhaseElectrolyteCPA): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calc_g(self) -> float: ... + def calc_lngV(self) -> float: ... + def calc_lngVV(self) -> float: ... + def calc_lngVVV(self) -> float: ... + def clone(self) -> 'PhaseElectrolyteCPAstatoil': ... + +class PhaseSrkCPAsOld(PhaseSrkCPAs): + def __init__(self): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, int: int) -> None: ... + def calc_g(self) -> float: ... + def calc_lngV(self) -> float: ... + def calc_lngVV(self) -> float: ... + def calc_lngVVV(self) -> float: ... + def clone(self) -> 'PhaseSrkCPAsOld': ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.phase")``. + + Phase: typing.Type[Phase] + PhaseAmmoniaEos: typing.Type[PhaseAmmoniaEos] + PhaseBNS: typing.Type[PhaseBNS] + PhaseBWRSEos: typing.Type[PhaseBWRSEos] + PhaseCPAInterface: typing.Type[PhaseCPAInterface] + PhaseCSPsrkEos: typing.Type[PhaseCSPsrkEos] + PhaseDefault: typing.Type[PhaseDefault] + PhaseDesmukhMather: typing.Type[PhaseDesmukhMather] + PhaseDuanSun: typing.Type[PhaseDuanSun] + PhaseEOSCGEos: typing.Type[PhaseEOSCGEos] + PhaseElectrolyteCPA: typing.Type[PhaseElectrolyteCPA] + PhaseElectrolyteCPAOld: typing.Type[PhaseElectrolyteCPAOld] + PhaseElectrolyteCPAstatoil: typing.Type[PhaseElectrolyteCPAstatoil] + PhaseEos: typing.Type[PhaseEos] + PhaseEosInterface: typing.Type[PhaseEosInterface] + PhaseGE: typing.Type[PhaseGE] + PhaseGEInterface: typing.Type[PhaseGEInterface] + PhaseGENRTL: typing.Type[PhaseGENRTL] + PhaseGENRTLmodifiedHV: typing.Type[PhaseGENRTLmodifiedHV] + PhaseGENRTLmodifiedWS: typing.Type[PhaseGENRTLmodifiedWS] + PhaseGERG2004Eos: typing.Type[PhaseGERG2004Eos] + PhaseGERG2008Eos: typing.Type[PhaseGERG2008Eos] + PhaseGEUnifac: typing.Type[PhaseGEUnifac] + PhaseGEUnifacPSRK: typing.Type[PhaseGEUnifacPSRK] + PhaseGEUnifacUMRPRU: typing.Type[PhaseGEUnifacUMRPRU] + PhaseGEUniquac: typing.Type[PhaseGEUniquac] + PhaseGEUniquacmodifiedHV: typing.Type[PhaseGEUniquacmodifiedHV] + PhaseGEWilson: typing.Type[PhaseGEWilson] + PhaseHydrate: typing.Type[PhaseHydrate] + PhaseIdealGas: typing.Type[PhaseIdealGas] + PhaseInterface: typing.Type[PhaseInterface] + PhaseKentEisenberg: typing.Type[PhaseKentEisenberg] + PhaseLeachmanEos: typing.Type[PhaseLeachmanEos] + PhaseModifiedFurstElectrolyteEos: typing.Type[PhaseModifiedFurstElectrolyteEos] + PhaseModifiedFurstElectrolyteEosMod2004: typing.Type[PhaseModifiedFurstElectrolyteEosMod2004] + PhasePCSAFT: typing.Type[PhasePCSAFT] + PhasePCSAFTRahmat: typing.Type[PhasePCSAFTRahmat] + PhasePCSAFTa: typing.Type[PhasePCSAFTa] + PhasePitzer: typing.Type[PhasePitzer] + PhasePrCPA: typing.Type[PhasePrCPA] + PhasePrEos: typing.Type[PhasePrEos] + PhasePrEosvolcor: typing.Type[PhasePrEosvolcor] + PhasePureComponentSolid: typing.Type[PhasePureComponentSolid] + PhaseRK: typing.Type[PhaseRK] + PhaseSolid: typing.Type[PhaseSolid] + PhaseSolidComplex: typing.Type[PhaseSolidComplex] + PhaseSoreideWhitson: typing.Type[PhaseSoreideWhitson] + PhaseSpanWagnerEos: typing.Type[PhaseSpanWagnerEos] + PhaseSrkCPA: typing.Type[PhaseSrkCPA] + PhaseSrkCPA_proceduralMatrices: typing.Type[PhaseSrkCPA_proceduralMatrices] + PhaseSrkCPAs: typing.Type[PhaseSrkCPAs] + PhaseSrkCPAsOld: typing.Type[PhaseSrkCPAsOld] + PhaseSrkEos: typing.Type[PhaseSrkEos] + PhaseSrkEosvolcor: typing.Type[PhaseSrkEosvolcor] + PhaseSrkPenelouxEos: typing.Type[PhaseSrkPenelouxEos] + PhaseTSTEos: typing.Type[PhaseTSTEos] + PhaseType: typing.Type[PhaseType] + PhaseUMRCPA: typing.Type[PhaseUMRCPA] + PhaseVegaEos: typing.Type[PhaseVegaEos] + PhaseWaterIAPWS: typing.Type[PhaseWaterIAPWS] + PhaseWax: typing.Type[PhaseWax] + StateOfMatter: typing.Type[StateOfMatter] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/system/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/system/__init__.pyi new file mode 100644 index 00000000..58e99733 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/system/__init__.pyi @@ -0,0 +1,1614 @@ + +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.chemicalreactions +import jneqsim.physicalproperties +import jneqsim.physicalproperties.interfaceproperties +import jneqsim.physicalproperties.system +import jneqsim.standards +import jneqsim.thermo.characterization +import jneqsim.thermo.component +import jneqsim.thermo.mixingrule +import jneqsim.thermo.phase +import typing + + + +class SystemInterface(java.lang.Cloneable, java.io.Serializable): + def addCapeOpenProperty(self, string: typing.Union[java.lang.String, str]) -> None: ... + def addCharacterized(self, 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], doubleArray3: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float, int2: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], int: int) -> None: ... + @typing.overload + def addComponent(self, componentInterface: jneqsim.thermo.component.ComponentInterface) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponents(self, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def addComponents(self, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray], doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def addFluid(self, systemInterface: 'SystemInterface') -> 'SystemInterface': ... + @typing.overload + def addFluid(self, systemInterface: 'SystemInterface', int: int) -> 'SystemInterface': ... + @staticmethod + def addFluids(systemInterface: 'SystemInterface', systemInterface2: 'SystemInterface') -> 'SystemInterface': ... + def addGasToLiquid(self, double: float) -> None: ... + def addLiquidToGas(self, double: float) -> None: ... + @typing.overload + def addOilFractions(self, 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], doubleArray3: typing.Union[typing.List[float], jpype.JArray], boolean: bool) -> None: ... + @typing.overload + def addOilFractions(self, 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], doubleArray3: typing.Union[typing.List[float], jpype.JArray], boolean: bool, boolean2: bool, int: int) -> None: ... + def addPhase(self) -> None: ... + @typing.overload + def addPhaseFractionToPhase(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addPhaseFractionToPhase(self, double: float, 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]) -> None: ... + def addPlusFraction(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float) -> None: ... + def addSalt(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def addSolidComplexPhase(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addTBPfraction(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float) -> None: ... + @typing.overload + def addTBPfraction(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float, double5: float, double6: float) -> None: ... + def addTBPfraction2(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float) -> None: ... + def addTBPfraction3(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float) -> None: ... + def addTBPfraction4(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float) -> None: ... + def addToComponentNames(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def allowPhaseShift(self) -> bool: ... + @typing.overload + def allowPhaseShift(self, boolean: bool) -> None: ... + def autoSelectMixingRule(self) -> None: ... + def autoSelectModel(self) -> 'SystemInterface': ... + def calcHenrysConstant(self, string: typing.Union[java.lang.String, str]) -> float: ... + def calcInterfaceProperties(self) -> None: ... + def calcKIJ(self, boolean: bool) -> None: ... + def calcResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def calc_x_y(self) -> None: ... + def calc_x_y_nonorm(self) -> None: ... + def calculateDensityFromBoilingPoint(self, double: float, double2: float) -> float: ... + def calculateMolarMassFromDensityAndBoilingPoint(self, double: float, double2: float) -> float: ... + def changeComponentName(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @staticmethod + def characterizeToReference(systemInterface: 'SystemInterface', systemInterface2: 'SystemInterface') -> 'SystemInterface': ... + @typing.overload + def checkStability(self) -> bool: ... + @typing.overload + def checkStability(self, boolean: bool) -> None: ... + def chemicalReactionInit(self) -> None: ... + def clearAll(self) -> None: ... + def clone(self) -> 'SystemInterface': ... + @staticmethod + def combineReservoirFluids(int: int, *systemInterface: 'SystemInterface') -> '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: ... + @typing.overload + def display(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def display(self) -> None: ... + def doMultiPhaseCheck(self) -> bool: ... + def doSolidPhaseCheck(self) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def getBeta(self) -> float: ... + @typing.overload + def getBeta(self, int: int) -> float: ... + def getCASNumbers(self) -> typing.MutableSequence[java.lang.String]: ... + def getCapeOpenProperties10(self) -> typing.MutableSequence[java.lang.String]: ... + def getCapeOpenProperties11(self) -> typing.MutableSequence[java.lang.String]: ... + def getCharacterization(self) -> jneqsim.thermo.characterization.Characterise: ... + def getChemicalReactionOperations(self) -> jneqsim.chemicalreactions.ChemicalReactionOperations: ... + def getCompFormulaes(self) -> typing.MutableSequence[java.lang.String]: ... + def getCompIDs(self) -> typing.MutableSequence[java.lang.String]: ... + def getCompNames(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getComponent(self, int: int) -> jneqsim.thermo.component.ComponentInterface: ... + @typing.overload + def getComponent(self, string: typing.Union[java.lang.String, str]) -> jneqsim.thermo.component.ComponentInterface: ... + def getComponentNameTag(self) -> java.lang.String: ... + def getComponentNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getCorrectedVolume(self) -> float: ... + def getCorrectedVolumeFraction(self, int: int) -> float: ... + @typing.overload + def getCp(self) -> float: ... + @typing.overload + def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getEmptySystemClone(self) -> 'SystemInterface': ... + @typing.overload + def getEnthalpy(self) -> float: ... + @typing.overload + def getEnthalpy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEntropy(self) -> float: ... + @typing.overload + def getEntropy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergy(self, double: float) -> float: ... + @typing.overload + def getExergy(self, double: float, string: typing.Union[java.lang.String, str]) -> float: ... + def getFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getFluidInfo(self) -> java.lang.String: ... + def getFluidName(self) -> java.lang.String: ... + def getGamma(self) -> float: ... + def getGamma2(self) -> float: ... + def getGasPhase(self) -> jneqsim.thermo.phase.PhaseInterface: ... + def getGibbsEnergy(self) -> float: ... + def getHeatOfVaporization(self) -> float: ... + def getHelmholtzEnergy(self) -> float: ... + def getHydrateCheck(self) -> bool: ... + def getIdealLiquidDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getInterfacialTension(self, int: int, int2: int) -> float: ... + @typing.overload + def getInterfacialTension(self, int: int, int2: int, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getInterfacialTension(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getInternalEnergy(self) -> float: ... + @typing.overload + def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getInterphaseProperties(self) -> jneqsim.physicalproperties.interfaceproperties.InterphasePropertiesInterface: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getKappa(self) -> float: ... + @typing.overload + def getKinematicViscosity(self) -> float: ... + @typing.overload + def getKinematicViscosity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getKvector(self) -> typing.MutableSequence[float]: ... + def getLiquidPhase(self) -> jneqsim.thermo.phase.PhaseInterface: ... + def getLiquidVolume(self) -> float: ... + def getLowestGibbsEnergyPhase(self) -> jneqsim.thermo.phase.PhaseInterface: ... + def getMass(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMaxNumberOfPhases(self) -> int: ... + def getMixingRule(self) -> jneqsim.thermo.mixingrule.MixingRuleTypeInterface: ... + def getMixingRuleName(self) -> java.lang.String: ... + def getModelName(self) -> java.lang.String: ... + def getMolarComposition(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getMolarMass(self) -> float: ... + @typing.overload + def getMolarMass(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMolarRate(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getMolarVolume(self) -> float: ... + @typing.overload + def getMolarVolume(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMoleFraction(self, int: int) -> float: ... + def getMoleFractionsSum(self) -> float: ... + def getMolecularWeights(self) -> typing.MutableSequence[float]: ... + def getNormalBoilingPointTemperatures(self) -> typing.MutableSequence[float]: ... + def getNumberOfComponents(self) -> int: ... + def getNumberOfMoles(self) -> float: ... + def getNumberOfOilFractionComponents(self) -> int: ... + def getNumberOfPhases(self) -> int: ... + def getOilAssayCharacterisation(self) -> jneqsim.thermo.characterization.OilAssayCharacterisation: ... + def getOilFractionIDs(self) -> typing.MutableSequence[int]: ... + def getOilFractionLiquidDensityAt25C(self) -> typing.MutableSequence[float]: ... + def getOilFractionMolecularMass(self) -> typing.MutableSequence[float]: ... + def getOilFractionNormalBoilingPoints(self) -> typing.MutableSequence[float]: ... + def getPC(self) -> float: ... + @typing.overload + def getPhase(self, int: int) -> jneqsim.thermo.phase.PhaseInterface: ... + @typing.overload + def getPhase(self, string: typing.Union[java.lang.String, str]) -> jneqsim.thermo.phase.PhaseInterface: ... + @typing.overload + def getPhase(self, phaseType: jneqsim.thermo.phase.PhaseType) -> jneqsim.thermo.phase.PhaseInterface: ... + def getPhaseFraction(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getPhaseIndex(self, int: int) -> int: ... + @typing.overload + def getPhaseIndex(self, string: typing.Union[java.lang.String, str]) -> int: ... + @typing.overload + def getPhaseIndex(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> int: ... + @typing.overload + def getPhaseNumberOfPhase(self, phaseType: jneqsim.thermo.phase.PhaseType) -> int: ... + @typing.overload + def getPhaseNumberOfPhase(self, string: typing.Union[java.lang.String, str]) -> int: ... + def getPhaseOfType(self, string: typing.Union[java.lang.String, str]) -> jneqsim.thermo.phase.PhaseInterface: ... + def getPhases(self) -> typing.MutableSequence[jneqsim.thermo.phase.PhaseInterface]: ... + @typing.overload + def getPressure(self) -> float: ... + @typing.overload + def getPressure(self, int: int) -> float: ... + @typing.overload + def getPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getProperties(self) -> 'SystemProperties': ... + @typing.overload + def getProperty(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getProperty(self, string: typing.Union[java.lang.String, str], int: int) -> float: ... + @typing.overload + def getProperty(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], int: int) -> float: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + @typing.overload + def getSoundSpeed(self) -> float: ... + @typing.overload + def getSoundSpeed(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getStandard(self) -> jneqsim.standards.StandardInterface: ... + @typing.overload + def getStandard(self, string: typing.Union[java.lang.String, str]) -> jneqsim.standards.StandardInterface: ... + def getTC(self) -> float: ... + @typing.overload + def getTemperature(self) -> float: ... + @typing.overload + def getTemperature(self, int: int) -> float: ... + @typing.overload + def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getThermalConductivity(self) -> float: ... + @typing.overload + def getThermalConductivity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getTotalNumberOfMoles(self) -> float: ... + @typing.overload + def getViscosity(self) -> float: ... + @typing.overload + def getViscosity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getVolume(self) -> float: ... + @typing.overload + def getVolume(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getVolumeFraction(self, int: int) -> float: ... + def getWaxCharacterisation(self) -> jneqsim.thermo.characterization.WaxCharacterise: ... + def getWaxModel(self) -> jneqsim.thermo.characterization.WaxModelInterface: ... + def getWeightBasedComposition(self) -> typing.MutableSequence[float]: ... + def getWtFraction(self, int: int) -> float: ... + def getZ(self) -> float: ... + def getZvolcorr(self) -> float: ... + def getdVdPtn(self) -> float: ... + def getdVdTpn(self) -> float: ... + def getzvector(self) -> typing.MutableSequence[float]: ... + @typing.overload + def hasComponent(self, string: typing.Union[java.lang.String, str]) -> bool: ... + @typing.overload + def hasComponent(self, string: typing.Union[java.lang.String, str], boolean: bool) -> bool: ... + @typing.overload + def hasPhaseType(self, phaseType: jneqsim.thermo.phase.PhaseType) -> bool: ... + @typing.overload + def hasPhaseType(self, string: typing.Union[java.lang.String, str]) -> bool: ... + def hasPlusFraction(self) -> bool: ... + def hasSolidPhase(self) -> bool: ... + def hashCode(self) -> int: ... + @typing.overload + def init(self, int: int) -> None: ... + @typing.overload + def init(self, int: int, int2: int) -> None: ... + def initBeta(self) -> None: ... + def initNumeric(self) -> None: ... + @typing.overload + def initPhysicalProperties(self) -> None: ... + @typing.overload + def initPhysicalProperties(self, physicalPropertyType: jneqsim.physicalproperties.PhysicalPropertyType) -> None: ... + @typing.overload + def initPhysicalProperties(self, string: typing.Union[java.lang.String, str]) -> None: ... + def initProperties(self) -> None: ... + def initRefPhases(self) -> None: ... + def initThermoProperties(self) -> None: ... + def initTotalNumberOfMoles(self, double: float) -> None: ... + def init_x_y(self) -> None: ... + def invertPhaseTypes(self) -> None: ... + @typing.overload + def isChemicalSystem(self) -> bool: ... + @typing.overload + def isChemicalSystem(self, boolean: bool) -> None: ... + def isForcePhaseTypes(self) -> bool: ... + @typing.overload + def isImplementedCompositionDeriativesofFugacity(self) -> bool: ... + @typing.overload + def isImplementedCompositionDeriativesofFugacity(self, boolean: bool) -> None: ... + def isImplementedPressureDeriativesofFugacity(self) -> bool: ... + def isImplementedTemperatureDeriativesofFugacity(self) -> bool: ... + def isInitialized(self) -> bool: ... + def isMultiphaseWaxCheck(self) -> bool: ... + def isNumericDerivatives(self) -> bool: ... + def isPhase(self, int: int) -> bool: ... + def normalizeBeta(self) -> None: ... + def orderByDensity(self) -> None: ... + @typing.overload + def phaseToSystem(self, int: int) -> 'SystemInterface': ... + @typing.overload + def phaseToSystem(self, int: int, int2: int) -> 'SystemInterface': ... + @typing.overload + def phaseToSystem(self, string: typing.Union[java.lang.String, str]) -> 'SystemInterface': ... + @typing.overload + def phaseToSystem(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> 'SystemInterface': ... + def prettyPrint(self) -> None: ... + def reInitPhaseType(self) -> None: ... + def readFluid(self, string: typing.Union[java.lang.String, str]) -> None: ... + def readObject(self, int: int) -> 'SystemInterface': ... + def readObjectFromFile(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> 'SystemInterface': ... + def removeComponent(self, string: typing.Union[java.lang.String, str]) -> None: ... + def removePhase(self, int: int) -> None: ... + def removePhaseKeepTotalComposition(self, int: int) -> None: ... + def renameComponent(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def replacePhase(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def reset(self) -> None: ... + def resetCharacterisation(self) -> None: ... + def resetDatabase(self) -> None: ... + def resetPhysicalProperties(self) -> None: ... + def reset_x_y(self) -> None: ... + def save(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def saveFluid(self, int: int) -> None: ... + @typing.overload + def saveFluid(self, int: int, string: typing.Union[java.lang.String, str]) -> None: ... + def saveObject(self, int: int, string: typing.Union[java.lang.String, str]) -> None: ... + def saveObjectToFile(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def saveToDataBase(self) -> None: ... + def setAllComponentsInPhase(self, int: int) -> None: ... + def setAllPhaseType(self, phaseType: jneqsim.thermo.phase.PhaseType) -> None: ... + def setAttractiveTerm(self, int: int) -> None: ... + @typing.overload + def setBeta(self, double: float) -> None: ... + @typing.overload + def setBeta(self, int: int, double: float) -> None: ... + @typing.overload + def setBinaryInteractionParameter(self, int: int, int2: int, double: float) -> None: ... + @typing.overload + def setBinaryInteractionParameter(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], double: float) -> None: ... + def setBmixType(self, int: int) -> None: ... + @typing.overload + def setComponentCriticalParameters(self, int: int, double: float, double2: float, double3: float) -> None: ... + @typing.overload + def setComponentCriticalParameters(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float) -> None: ... + def setComponentFlowRates(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], string: typing.Union[java.lang.String, str]) -> None: ... + def setComponentNameTag(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setComponentNameTagOnNormalComponents(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setComponentNames(self, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def setComponentVolumeCorrection(self, int: int, double: float) -> None: ... + @typing.overload + def setComponentVolumeCorrection(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def setEmptyFluid(self) -> None: ... + def setFluidInfo(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setFluidName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setForcePhaseTypes(self, boolean: bool) -> None: ... + @typing.overload + def setForceSinglePhase(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setForceSinglePhase(self, phaseType: jneqsim.thermo.phase.PhaseType) -> None: ... + def setHeavyTBPfractionAsPlusFraction(self) -> bool: ... + def setHydrateCheck(self, boolean: bool) -> None: ... + def setImplementedCompositionDeriativesofFugacity(self, boolean: bool) -> None: ... + def setImplementedPressureDeriativesofFugacity(self, boolean: bool) -> None: ... + def setImplementedTemperatureDeriativesofFugacity(self, boolean: bool) -> None: ... + def setMaxNumberOfPhases(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setModel(self, string: typing.Union[java.lang.String, str]) -> 'SystemInterface': ... + def setMolarComposition(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setMolarCompositionOfNamedComponents(self, string: typing.Union[java.lang.String, str], doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setMolarCompositionOfPlusFluid(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setMolarCompositionPlus(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setMolarFlowRates(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setMultiPhaseCheck(self, boolean: bool) -> None: ... + def setMultiphaseWaxCheck(self, boolean: bool) -> None: ... + def setNumberOfPhases(self, int: int) -> None: ... + def setNumericDerivatives(self, boolean: bool) -> None: ... + def setPC(self, double: float) -> None: ... + def setPhase(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int) -> None: ... + def setPhaseIndex(self, int: int, int2: int) -> None: ... + @typing.overload + def setPhaseType(self, int: int, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setPhaseType(self, int: int, phaseType: jneqsim.thermo.phase.PhaseType) -> None: ... + @typing.overload + def setPhysicalPropertyModel(self, int: int) -> None: ... + @typing.overload + def setPhysicalPropertyModel(self, physicalPropertyModel: jneqsim.physicalproperties.system.PhysicalPropertyModel) -> None: ... + @typing.overload + def setPressure(self, double: float) -> None: ... + @typing.overload + def setPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setSolidPhaseCheck(self, boolean: bool) -> None: ... + @typing.overload + def setSolidPhaseCheck(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setStandard(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setTC(self, double: float) -> None: ... + @typing.overload + def setTemperature(self, double: float) -> None: ... + @typing.overload + def setTemperature(self, double: float, int: int) -> None: ... + @typing.overload + def setTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTotalFlowRate(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTotalNumberOfMoles(self, double: float) -> None: ... + def setUseTVasIndependentVariables(self, boolean: bool) -> None: ... + def toCompJson(self) -> java.lang.String: ... + def toJson(self) -> java.lang.String: ... + def tuneModel(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + def useVolumeCorrection(self, boolean: bool) -> None: ... + def write(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], boolean: bool) -> None: ... + +class SystemProperties: + nCols: typing.ClassVar[int] = ... + def __init__(self, systemInterface: SystemInterface): ... + def getProperties(self) -> java.util.HashMap[java.lang.String, float]: ... + @staticmethod + def getPropertyNames() -> typing.MutableSequence[java.lang.String]: ... + def getValues(self) -> typing.MutableSequence[float]: ... + +class SystemThermo(SystemInterface): + characterization: jneqsim.thermo.characterization.Characterise = ... + componentNameTag: java.lang.String = ... + maxNumberOfPhases: int = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def addCapeOpenProperty(self, string: typing.Union[java.lang.String, str]) -> None: ... + def addCharacterized(self, 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], doubleArray3: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float, int2: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], int: int) -> None: ... + @typing.overload + def addComponent(self, componentInterface: jneqsim.thermo.component.ComponentInterface) -> None: ... + @typing.overload + def addFluid(self, systemInterface: SystemInterface) -> SystemInterface: ... + @typing.overload + def addFluid(self, systemInterface: SystemInterface, int: int) -> SystemInterface: ... + def addGasToLiquid(self, double: float) -> None: ... + def addHydratePhase(self) -> None: ... + def addHydratePhase2(self) -> None: ... + def addLiquidToGas(self, double: float) -> None: ... + @typing.overload + def addOilFractions(self, 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], doubleArray3: typing.Union[typing.List[float], jpype.JArray], boolean: bool) -> None: ... + @typing.overload + def addOilFractions(self, 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], doubleArray3: typing.Union[typing.List[float], jpype.JArray], boolean: bool, boolean2: bool, int: int) -> None: ... + def addPhase(self) -> None: ... + @typing.overload + def addPhaseFractionToPhase(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addPhaseFractionToPhase(self, double: float, 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]) -> None: ... + def addPlusFraction(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float) -> None: ... + def addSalt(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def addSolidComplexPhase(self, string: typing.Union[java.lang.String, str]) -> None: ... + def addSolidPhase(self) -> None: ... + @typing.overload + def addTBPfraction(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float) -> None: ... + @typing.overload + def addTBPfraction(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float, double5: float, double6: float) -> None: ... + def addTBPfraction2(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float) -> None: ... + def addTBPfraction3(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float) -> None: ... + def addTBPfraction4(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float) -> None: ... + def addToComponentNames(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def allowPhaseShift(self) -> bool: ... + @typing.overload + def allowPhaseShift(self, boolean: bool) -> None: ... + def autoSelectMixingRule(self) -> None: ... + def autoSelectModel(self) -> SystemInterface: ... + def calcHenrysConstant(self, string: typing.Union[java.lang.String, str]) -> float: ... + def calcInterfaceProperties(self) -> None: ... + def calcKIJ(self, boolean: bool) -> None: ... + def calc_x_y(self) -> None: ... + def calc_x_y_nonorm(self) -> None: ... + def calculateDensityFromBoilingPoint(self, double: float, double2: float) -> float: ... + def calculateMolarMassFromDensityAndBoilingPoint(self, double: float, double2: float) -> float: ... + def changeComponentName(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def checkStability(self) -> bool: ... + @typing.overload + def checkStability(self, boolean: bool) -> None: ... + def chemicalReactionInit(self) -> None: ... + def clearAll(self) -> None: ... + def clone(self) -> 'SystemThermo': ... + 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: ... + @typing.overload + def display(self) -> None: ... + @typing.overload + def display(self, string: typing.Union[java.lang.String, str]) -> None: ... + def doMultiPhaseCheck(self) -> bool: ... + def doSolidPhaseCheck(self) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def getAntoineVaporPressure(self, double: float) -> float: ... + @typing.overload + def getBeta(self) -> float: ... + @typing.overload + def getBeta(self, int: int) -> float: ... + def getCASNumbers(self) -> typing.MutableSequence[java.lang.String]: ... + def getCapeOpenProperties10(self) -> typing.MutableSequence[java.lang.String]: ... + def getCapeOpenProperties11(self) -> typing.MutableSequence[java.lang.String]: ... + def getCharacterization(self) -> jneqsim.thermo.characterization.Characterise: ... + def getChemicalReactionOperations(self) -> jneqsim.chemicalreactions.ChemicalReactionOperations: ... + def getCompFormulaes(self) -> typing.MutableSequence[java.lang.String]: ... + def getCompIDs(self) -> typing.MutableSequence[java.lang.String]: ... + def getCompNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getComponentNameTag(self) -> java.lang.String: ... + def getCorrectedVolume(self) -> float: ... + def getCorrectedVolumeFraction(self, int: int) -> float: ... + @typing.overload + def getCp(self) -> float: ... + @typing.overload + def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getCv(self) -> float: ... + @typing.overload + def getCv(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getEmptySystemClone(self) -> SystemInterface: ... + @typing.overload + def getEnthalpy(self) -> float: ... + @typing.overload + def getEnthalpy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getEntropy(self) -> float: ... + @typing.overload + def getEntropy(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getExergy(self, double: float) -> float: ... + @typing.overload + def getExergy(self, double: float, string: typing.Union[java.lang.String, str]) -> float: ... + def getFlowRate(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getFluidInfo(self) -> java.lang.String: ... + def getFluidName(self) -> java.lang.String: ... + def getGamma(self) -> float: ... + def getGasPhase(self) -> jneqsim.thermo.phase.PhaseInterface: ... + def getGibbsEnergy(self) -> float: ... + def getHeatOfVaporization(self) -> float: ... + def getHelmholtzEnergy(self) -> float: ... + def getHydrateCheck(self) -> bool: ... + def getIdealLiquidDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getInterfacialTension(self, int: int, int2: int) -> float: ... + @typing.overload + def getInterfacialTension(self, int: int, int2: int, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getInterfacialTension(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getInternalEnergy(self) -> float: ... + @typing.overload + def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getInterphaseProperties(self) -> jneqsim.physicalproperties.interfaceproperties.InterphasePropertiesInterface: ... + @typing.overload + def getJouleThomsonCoefficient(self) -> float: ... + @typing.overload + def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getKappa(self) -> float: ... + @typing.overload + def getKinematicViscosity(self) -> float: ... + @typing.overload + def getKinematicViscosity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getKvector(self) -> typing.MutableSequence[float]: ... + def getLiquidPhase(self) -> jneqsim.thermo.phase.PhaseInterface: ... + def getLiquidVolume(self) -> float: ... + def getLowestGibbsEnergyPhase(self) -> jneqsim.thermo.phase.PhaseInterface: ... + def getMass(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMaxNumberOfPhases(self) -> int: ... + def getMixingRule(self) -> jneqsim.thermo.mixingrule.MixingRuleTypeInterface: ... + def getMixingRuleName(self) -> java.lang.String: ... + def getModelName(self) -> java.lang.String: ... + def getMolarComposition(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getMolarMass(self) -> float: ... + @typing.overload + def getMolarMass(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMolarRate(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getMolarVolume(self) -> float: ... + @typing.overload + def getMolarVolume(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMoleFraction(self, int: int) -> float: ... + def getMoleFractionsSum(self) -> float: ... + def getMolecularWeights(self) -> typing.MutableSequence[float]: ... + def getNormalBoilingPointTemperatures(self) -> typing.MutableSequence[float]: ... + def getNumberOfComponents(self) -> int: ... + def getNumberOfOilFractionComponents(self) -> int: ... + def getNumberOfPhases(self) -> int: ... + def getOilAssayCharacterisation(self) -> jneqsim.thermo.characterization.OilAssayCharacterisation: ... + def getOilFractionIDs(self) -> typing.MutableSequence[int]: ... + def getOilFractionLiquidDensityAt25C(self) -> typing.MutableSequence[float]: ... + def getOilFractionMolecularMass(self) -> typing.MutableSequence[float]: ... + def getOilFractionNormalBoilingPoints(self) -> typing.MutableSequence[float]: ... + def getPC(self) -> float: ... + @typing.overload + def getPhase(self, int: int) -> jneqsim.thermo.phase.PhaseInterface: ... + @typing.overload + def getPhase(self, string: typing.Union[java.lang.String, str]) -> jneqsim.thermo.phase.PhaseInterface: ... + @typing.overload + def getPhase(self, phaseType: jneqsim.thermo.phase.PhaseType) -> jneqsim.thermo.phase.PhaseInterface: ... + def getPhaseFraction(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getPhaseIndex(self, int: int) -> int: ... + @typing.overload + def getPhaseIndex(self, string: typing.Union[java.lang.String, str]) -> int: ... + @typing.overload + def getPhaseIndex(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> int: ... + @typing.overload + def getPhaseNumberOfPhase(self, string: typing.Union[java.lang.String, str]) -> int: ... + @typing.overload + def getPhaseNumberOfPhase(self, phaseType: jneqsim.thermo.phase.PhaseType) -> int: ... + def getPhaseOfType(self, string: typing.Union[java.lang.String, str]) -> jneqsim.thermo.phase.PhaseInterface: ... + def getPhases(self) -> typing.MutableSequence[jneqsim.thermo.phase.PhaseInterface]: ... + @typing.overload + def getPressure(self) -> float: ... + @typing.overload + def getPressure(self, int: int) -> float: ... + @typing.overload + def getPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getProperties(self) -> SystemProperties: ... + @typing.overload + def getProperty(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getProperty(self, string: typing.Union[java.lang.String, str], int: int) -> float: ... + @typing.overload + def getProperty(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], int: int) -> float: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + @typing.overload + def getSoundSpeed(self) -> float: ... + @typing.overload + def getSoundSpeed(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getStandard(self) -> jneqsim.standards.StandardInterface: ... + @typing.overload + def getStandard(self, string: typing.Union[java.lang.String, str]) -> jneqsim.standards.StandardInterface: ... + def getSumBeta(self) -> float: ... + def getTC(self) -> float: ... + @typing.overload + def getTemperature(self, int: int) -> float: ... + @typing.overload + def getTemperature(self) -> float: ... + @typing.overload + def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getThermalConductivity(self) -> float: ... + @typing.overload + def getThermalConductivity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getTotalNumberOfMoles(self) -> float: ... + @typing.overload + def getViscosity(self) -> float: ... + @typing.overload + def getViscosity(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getVolume(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getVolume(self) -> float: ... + def getVolumeFraction(self, int: int) -> float: ... + def getWaxCharacterisation(self) -> jneqsim.thermo.characterization.WaxCharacterise: ... + def getWaxModel(self) -> jneqsim.thermo.characterization.WaxModelInterface: ... + def getWeightBasedComposition(self) -> typing.MutableSequence[float]: ... + def getWtFraction(self, int: int) -> float: ... + def getZ(self) -> float: ... + def getZvolcorr(self) -> float: ... + def getdPdVtn(self) -> float: ... + def getdVdPtn(self) -> float: ... + def getdVdTpn(self) -> float: ... + def getzvector(self) -> typing.MutableSequence[float]: ... + @typing.overload + def hasPhaseType(self, phaseType: jneqsim.thermo.phase.PhaseType) -> bool: ... + @typing.overload + def hasPhaseType(self, string: typing.Union[java.lang.String, str]) -> bool: ... + def hasPlusFraction(self) -> bool: ... + def hasTBPFraction(self) -> bool: ... + @typing.overload + def init(self, int: int) -> None: ... + @typing.overload + def init(self, int: int, int2: int) -> None: ... + @typing.overload + def initAnalytic(self, int: int) -> None: ... + @typing.overload + def initAnalytic(self, int: int, int2: int) -> None: ... + def initBeta(self) -> None: ... + @typing.overload + def initNumeric(self) -> None: ... + @typing.overload + def initNumeric(self, int: int) -> None: ... + @typing.overload + def initNumeric(self, int: int, int2: int) -> None: ... + @typing.overload + def initPhysicalProperties(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def initPhysicalProperties(self) -> None: ... + @typing.overload + def initPhysicalProperties(self, physicalPropertyType: jneqsim.physicalproperties.PhysicalPropertyType) -> None: ... + def initRefPhases(self) -> None: ... + def initTotalNumberOfMoles(self, double: float) -> None: ... + def init_x_y(self) -> None: ... + def invertPhaseTypes(self) -> None: ... + def isBetaValid(self) -> bool: ... + @typing.overload + def isChemicalSystem(self) -> bool: ... + @typing.overload + def isChemicalSystem(self, boolean: bool) -> None: ... + def isForcePhaseTypes(self) -> bool: ... + @typing.overload + def isImplementedCompositionDeriativesofFugacity(self) -> bool: ... + @typing.overload + def isImplementedCompositionDeriativesofFugacity(self, boolean: bool) -> None: ... + def isImplementedPressureDeriativesofFugacity(self) -> bool: ... + def isImplementedTemperatureDeriativesofFugacity(self) -> bool: ... + def isInitialized(self) -> bool: ... + def isMultiphaseWaxCheck(self) -> bool: ... + def isNumericDerivatives(self) -> bool: ... + def isPhase(self, int: int) -> bool: ... + def normalizeBeta(self) -> None: ... + def orderByDensity(self) -> None: ... + @typing.overload + def phaseToSystem(self, int: int) -> SystemInterface: ... + @typing.overload + def phaseToSystem(self, int: int, int2: int) -> SystemInterface: ... + @typing.overload + def phaseToSystem(self, string: typing.Union[java.lang.String, str]) -> SystemInterface: ... + @typing.overload + def phaseToSystem(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> SystemInterface: ... + def reInitPhaseInformation(self) -> None: ... + def reInitPhaseType(self) -> None: ... + def readFluid(self, string: typing.Union[java.lang.String, str]) -> None: ... + def readObject(self, int: int) -> SystemInterface: ... + def readObjectFromFile(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> SystemInterface: ... + def removeComponent(self, string: typing.Union[java.lang.String, str]) -> None: ... + def removePhase(self, int: int) -> None: ... + def removePhaseKeepTotalComposition(self, int: int) -> None: ... + def renameComponent(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def replacePhase(self, int: int, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + def reset(self) -> None: ... + def resetCharacterisation(self) -> None: ... + def resetDatabase(self) -> None: ... + def resetPhysicalProperties(self) -> None: ... + def reset_x_y(self) -> None: ... + def save(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def saveFluid(self, int: int) -> None: ... + @typing.overload + def saveFluid(self, int: int, string: typing.Union[java.lang.String, str]) -> None: ... + def saveObject(self, int: int, string: typing.Union[java.lang.String, str]) -> None: ... + def saveObjectToFile(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def saveToDataBase(self) -> None: ... + def setAllComponentsInPhase(self, int: int) -> None: ... + def setAllPhaseType(self, phaseType: jneqsim.thermo.phase.PhaseType) -> None: ... + def setAttractiveTerm(self, int: int) -> None: ... + @typing.overload + def setBeta(self, double: float) -> None: ... + @typing.overload + def setBeta(self, int: int, double: float) -> None: ... + @typing.overload + def setBinaryInteractionParameter(self, int: int, int2: int, double: float) -> None: ... + @typing.overload + def setBinaryInteractionParameter(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], double: float) -> None: ... + def setBmixType(self, int: int) -> None: ... + @typing.overload + def setComponentCriticalParameters(self, int: int, double: float, double2: float, double3: float) -> None: ... + @typing.overload + def setComponentCriticalParameters(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float) -> None: ... + def setComponentFlowRates(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], string: typing.Union[java.lang.String, str]) -> None: ... + def setComponentNameTag(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setComponentNameTagOnNormalComponents(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setComponentNames(self, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def setComponentVolumeCorrection(self, int: int, double: float) -> None: ... + @typing.overload + def setComponentVolumeCorrection(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def setEmptyFluid(self) -> None: ... + def setFluidInfo(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setFluidName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setForcePhaseTypes(self, boolean: bool) -> None: ... + @typing.overload + def setForceSinglePhase(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setForceSinglePhase(self, phaseType: jneqsim.thermo.phase.PhaseType) -> None: ... + def setHeavyTBPfractionAsPlusFraction(self) -> bool: ... + def setHydrateCheck(self, boolean: bool) -> None: ... + def setImplementedCompositionDeriativesofFugacity(self, boolean: bool) -> None: ... + def setImplementedPressureDeriativesofFugacity(self, boolean: bool) -> None: ... + def setImplementedTemperatureDeriativesofFugacity(self, boolean: bool) -> None: ... + def setLastTBPasPlus(self) -> bool: ... + def setMaxNumberOfPhases(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + @typing.overload + def setMixingRule(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def setMixingRuleGEmodel(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setMixingRuleParametersForComponent(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setModel(self, string: typing.Union[java.lang.String, str]) -> SystemInterface: ... + def setModelName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setMolarComposition(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setMolarCompositionOfNamedComponents(self, string: typing.Union[java.lang.String, str], doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setMolarCompositionOfPlusFluid(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setMolarCompositionPlus(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setMolarFlowRates(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def setMultiPhaseCheck(self, boolean: bool) -> None: ... + def setMultiphaseWaxCheck(self, boolean: bool) -> None: ... + def setNumberOfPhases(self, int: int) -> None: ... + def setNumericDerivatives(self, boolean: bool) -> None: ... + def setPC(self, double: float) -> None: ... + def setPhase(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, int: int) -> None: ... + def setPhaseIndex(self, int: int, int2: int) -> None: ... + @typing.overload + def setPhaseType(self, int: int, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setPhaseType(self, int: int, phaseType: jneqsim.thermo.phase.PhaseType) -> None: ... + @typing.overload + def setPressure(self, double: float) -> None: ... + @typing.overload + def setPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setSolidPhaseCheck(self, boolean: bool) -> None: ... + @typing.overload + def setSolidPhaseCheck(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setStandard(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setTC(self, double: float) -> None: ... + @typing.overload + def setTemperature(self, double: float, int: int) -> None: ... + @typing.overload + def setTemperature(self, double: float) -> None: ... + @typing.overload + def setTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTotalFlowRate(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setTotalNumberOfMoles(self, double: float) -> None: ... + def setUseTVasIndependentVariables(self, boolean: bool) -> None: ... + def toCompJson(self) -> java.lang.String: ... + def toJson(self) -> java.lang.String: ... + def tuneModel(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + def useTVasIndependentVariables(self) -> bool: ... + def useVolumeCorrection(self, boolean: bool) -> None: ... + @typing.overload + def write(self) -> java.lang.String: ... + @typing.overload + def write(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], boolean: bool) -> None: ... + +class SystemEos(SystemThermo): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def equals(self, object: typing.Any) -> bool: ... + +class SystemIdealGas(SystemThermo): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemIdealGas': ... + +class SystemAmmoniaEos(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + @typing.overload + def addComponent(self, componentInterface: jneqsim.thermo.component.ComponentInterface) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float, int2: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], int: int) -> None: ... + def clone(self) -> 'SystemAmmoniaEos': ... + +class SystemBWRSEos(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemBWRSEos': ... + +class SystemBnsEos(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float, double7: float, boolean: bool): ... + def clone(self) -> 'SystemBnsEos': ... + def setAssociatedGas(self, boolean: bool) -> None: ... + @typing.overload + def setComposition(self, double: float, double2: float, double3: float, double4: float) -> None: ... + @typing.overload + def setComposition(self, double: float, double2: float, double3: float, double4: float, double5: float, boolean: bool) -> None: ... + @typing.overload + def setMixingRule(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def setRelativeDensity(self, double: float) -> None: ... + +class SystemDesmukhMather(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemDesmukhMather': ... + +class SystemDuanSun(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + @typing.overload + def addComponent(self, componentInterface: jneqsim.thermo.component.ComponentInterface) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float, int2: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], int: int) -> None: ... + def clone(self) -> 'SystemDuanSun': ... + +class SystemEOSCGEos(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemEOSCGEos': ... + def commonInitialization(self) -> None: ... + +class SystemGERG2004Eos(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemGERG2004Eos': ... + def commonInitialization(self) -> None: ... + +class SystemGERG2008Eos(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemGERG2008Eos': ... + def commonInitialization(self) -> None: ... + +class SystemGEWilson(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemGEWilson': ... + +class SystemKentEisenberg(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemKentEisenberg': ... + +class SystemLeachmanEos(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + @typing.overload + def addComponent(self, componentInterface: jneqsim.thermo.component.ComponentInterface) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float, int2: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], int: int) -> None: ... + def clone(self) -> 'SystemLeachmanEos': ... + def commonInitialization(self) -> None: ... + +class SystemNRTL(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemNRTL': ... + +class SystemPitzer(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemPitzer': ... + @typing.overload + def setMixingRule(self, int: int) -> None: ... + @typing.overload + def setMixingRule(self, mixingRuleTypeInterface: typing.Union[jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable]) -> None: ... + @typing.overload + def setMixingRule(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def setMixingRule(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + +class SystemPrEos(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemPrEos': ... + +class SystemRKEos(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemRKEos': ... + +class SystemSpanWagnerEos(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + @typing.overload + def addComponent(self, componentInterface: jneqsim.thermo.component.ComponentInterface) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float, int2: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], int: int) -> None: ... + def clone(self) -> 'SystemSpanWagnerEos': ... + def commonInitialization(self) -> None: ... + +class SystemSrkEos(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemSrkEos': ... + +class SystemTSTEos(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemTSTEos': ... + +class SystemUNIFAC(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemUNIFAC': ... + +class SystemUNIFACpsrk(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemUNIFACpsrk': ... + +class SystemVegaEos(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float, int2: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + @typing.overload + def addComponent(self, componentInterface: jneqsim.thermo.component.ComponentInterface) -> None: ... + def clone(self) -> 'SystemVegaEos': ... + def commonInitialization(self) -> None: ... + +class SystemWaterIF97(SystemEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float, int2: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + @typing.overload + def addComponent(self, componentInterface: jneqsim.thermo.component.ComponentInterface) -> None: ... + def clone(self) -> 'SystemWaterIF97': ... + def commonInitialization(self) -> None: ... + +class SystemCSPsrkEos(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemCSPsrkEos': ... + +class SystemFurstElectrolyteEos(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + def clone(self) -> 'SystemFurstElectrolyteEos': ... + +class SystemFurstElectrolyteEosMod2004(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + def clone(self) -> 'SystemFurstElectrolyteEosMod2004': ... + +class SystemGERGwaterEos(SystemPrEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemGERGwaterEos': ... + +class SystemPCSAFT(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + @typing.overload + def addTBPfraction(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float) -> None: ... + @typing.overload + def addTBPfraction(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float, double5: float, double6: float) -> None: ... + def clone(self) -> 'SystemPCSAFT': ... + def commonInitialization(self) -> None: ... + +class SystemPCSAFTa(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemPCSAFTa': ... + +class SystemPrCPA(SystemPrEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemPrCPA': ... + +class SystemPrDanesh(SystemPrEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemPrDanesh': ... + +class SystemPrEos1978(SystemPrEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemPrEos1978': ... + +class SystemPrEosDelft1998(SystemPrEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemPrEosDelft1998': ... + +class SystemPrEosvolcor(SystemPrEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + +class SystemPrGassemEos(SystemPrEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemPrGassemEos': ... + +class SystemPrMathiasCopeman(SystemPrEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemPrMathiasCopeman': ... + +class SystemPsrkEos(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemPsrkEos': ... + +class SystemSrkCPA(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float) -> None: ... + @typing.overload + def addComponent(self, int: int, double: float, int2: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, double2: float, double3: float, double4: float) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, int: int) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addComponent(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str], int: int) -> None: ... + @typing.overload + def addComponent(self, componentInterface: jneqsim.thermo.component.ComponentInterface) -> None: ... + def clone(self) -> 'SystemSrkCPA': ... + def commonInitialization(self) -> None: ... + +class SystemSrkEosvolcor(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + +class SystemSrkMathiasCopeman(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemSrkMathiasCopeman': ... + +class SystemSrkPenelouxEos(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemSrkPenelouxEos': ... + +class SystemSrkSchwartzentruberEos(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemSrkSchwartzentruberEos': ... + +class SystemSrkTwuCoonEos(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemSrkTwuCoonEos': ... + +class SystemSrkTwuCoonParamEos(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemSrkTwuCoonParamEos': ... + +class SystemSrkTwuCoonStatoilEos(SystemSrkEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemSrkTwuCoonStatoilEos': ... + +class SystemUMRCPAEoS(SystemPrEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + +class SystemUMRPRUEos(SystemPrEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemUMRPRUEos': ... + def commonInitialization(self) -> None: ... + +class SystemElectrolyteCPA(SystemFurstElectrolyteEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + def clone(self) -> 'SystemElectrolyteCPA': ... + +class SystemElectrolyteCPAstatoil(SystemFurstElectrolyteEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + def clone(self) -> 'SystemElectrolyteCPAstatoil': ... + +class SystemSoreideWhitson(SystemPrEos1978): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + @typing.overload + def addSalinity(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def addSalinity(self, string: typing.Union[java.lang.String, str], double: float, string2: typing.Union[java.lang.String, str]) -> None: ... + def calcSalinity(self) -> bool: ... + def clone(self) -> 'SystemSoreideWhitson': ... + def getSalinity(self) -> float: ... + def setSalinity(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + +class SystemSrkCPAs(SystemSrkCPA): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemSrkCPAs': ... + +class SystemUMRPRUMCEos(SystemUMRPRUEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemUMRPRUMCEos': ... + +class SystemSrkCPAstatoil(SystemSrkCPAs): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + @typing.overload + def __init__(self, double: float, double2: float, boolean: bool): ... + def clone(self) -> 'SystemSrkCPAstatoil': ... + +class SystemUMRPRUMCEosNew(SystemUMRPRUMCEos): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.system")``. + + SystemAmmoniaEos: typing.Type[SystemAmmoniaEos] + SystemBWRSEos: typing.Type[SystemBWRSEos] + SystemBnsEos: typing.Type[SystemBnsEos] + SystemCSPsrkEos: typing.Type[SystemCSPsrkEos] + SystemDesmukhMather: typing.Type[SystemDesmukhMather] + SystemDuanSun: typing.Type[SystemDuanSun] + SystemEOSCGEos: typing.Type[SystemEOSCGEos] + SystemElectrolyteCPA: typing.Type[SystemElectrolyteCPA] + SystemElectrolyteCPAstatoil: typing.Type[SystemElectrolyteCPAstatoil] + SystemEos: typing.Type[SystemEos] + SystemFurstElectrolyteEos: typing.Type[SystemFurstElectrolyteEos] + SystemFurstElectrolyteEosMod2004: typing.Type[SystemFurstElectrolyteEosMod2004] + SystemGERG2004Eos: typing.Type[SystemGERG2004Eos] + SystemGERG2008Eos: typing.Type[SystemGERG2008Eos] + SystemGERGwaterEos: typing.Type[SystemGERGwaterEos] + SystemGEWilson: typing.Type[SystemGEWilson] + SystemIdealGas: typing.Type[SystemIdealGas] + SystemInterface: typing.Type[SystemInterface] + SystemKentEisenberg: typing.Type[SystemKentEisenberg] + SystemLeachmanEos: typing.Type[SystemLeachmanEos] + SystemNRTL: typing.Type[SystemNRTL] + SystemPCSAFT: typing.Type[SystemPCSAFT] + SystemPCSAFTa: typing.Type[SystemPCSAFTa] + SystemPitzer: typing.Type[SystemPitzer] + SystemPrCPA: typing.Type[SystemPrCPA] + SystemPrDanesh: typing.Type[SystemPrDanesh] + SystemPrEos: typing.Type[SystemPrEos] + SystemPrEos1978: typing.Type[SystemPrEos1978] + SystemPrEosDelft1998: typing.Type[SystemPrEosDelft1998] + SystemPrEosvolcor: typing.Type[SystemPrEosvolcor] + SystemPrGassemEos: typing.Type[SystemPrGassemEos] + SystemPrMathiasCopeman: typing.Type[SystemPrMathiasCopeman] + SystemProperties: typing.Type[SystemProperties] + SystemPsrkEos: typing.Type[SystemPsrkEos] + SystemRKEos: typing.Type[SystemRKEos] + SystemSoreideWhitson: typing.Type[SystemSoreideWhitson] + SystemSpanWagnerEos: typing.Type[SystemSpanWagnerEos] + SystemSrkCPA: typing.Type[SystemSrkCPA] + SystemSrkCPAs: typing.Type[SystemSrkCPAs] + SystemSrkCPAstatoil: typing.Type[SystemSrkCPAstatoil] + SystemSrkEos: typing.Type[SystemSrkEos] + SystemSrkEosvolcor: typing.Type[SystemSrkEosvolcor] + SystemSrkMathiasCopeman: typing.Type[SystemSrkMathiasCopeman] + SystemSrkPenelouxEos: typing.Type[SystemSrkPenelouxEos] + SystemSrkSchwartzentruberEos: typing.Type[SystemSrkSchwartzentruberEos] + SystemSrkTwuCoonEos: typing.Type[SystemSrkTwuCoonEos] + SystemSrkTwuCoonParamEos: typing.Type[SystemSrkTwuCoonParamEos] + SystemSrkTwuCoonStatoilEos: typing.Type[SystemSrkTwuCoonStatoilEos] + SystemTSTEos: typing.Type[SystemTSTEos] + SystemThermo: typing.Type[SystemThermo] + SystemUMRCPAEoS: typing.Type[SystemUMRCPAEoS] + SystemUMRPRUEos: typing.Type[SystemUMRPRUEos] + SystemUMRPRUMCEos: typing.Type[SystemUMRPRUMCEos] + SystemUMRPRUMCEosNew: typing.Type[SystemUMRPRUMCEosNew] + SystemUNIFAC: typing.Type[SystemUNIFAC] + SystemUNIFACpsrk: typing.Type[SystemUNIFACpsrk] + SystemVegaEos: typing.Type[SystemVegaEos] + SystemWaterIF97: typing.Type[SystemWaterIF97] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/Vega/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/Vega/__init__.pyi new file mode 100644 index 00000000..012a82bc --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/Vega/__init__.pyi @@ -0,0 +1,55 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.thermo.phase +import org.netlib.util +import typing + + + +class NeqSimVega: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface): ... + def getAlpha0_Vega(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlphares_Vega(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getDensity(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getMolarDensity(self) -> float: ... + @typing.overload + def getMolarDensity(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getPressure(self) -> float: ... + def getProperties(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def propertiesVega(self) -> typing.MutableSequence[float]: ... + @typing.overload + def propertiesVega(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> typing.MutableSequence[float]: ... + def setPhase(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + +class Vega: + def __init__(self): ... + def DensityVega(self, int: int, double: float, double2: float, doubleW: org.netlib.util.doubleW, intW: org.netlib.util.intW, stringW: org.netlib.util.StringW) -> None: ... + def PressureVega(self, double: float, double2: float, doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW) -> None: ... + def SetupVega(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def propertiesVega(self, double: float, double2: float, doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW, doubleW3: org.netlib.util.doubleW, doubleW4: org.netlib.util.doubleW, doubleW5: org.netlib.util.doubleW, doubleW6: org.netlib.util.doubleW, doubleW7: org.netlib.util.doubleW, doubleW8: org.netlib.util.doubleW, doubleW9: org.netlib.util.doubleW, doubleW10: org.netlib.util.doubleW, doubleW11: org.netlib.util.doubleW, doubleW12: org.netlib.util.doubleW, doubleW13: org.netlib.util.doubleW, doubleW14: org.netlib.util.doubleW, doubleW15: org.netlib.util.doubleW, doubleW16: org.netlib.util.doubleW) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.Vega")``. + + NeqSimVega: typing.Type[NeqSimVega] + Vega: typing.Type[Vega] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/__init__.pyi new file mode 100644 index 00000000..6b2ca979 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/__init__.pyi @@ -0,0 +1,37 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.thermo.util.Vega +import jneqsim.thermo.util.benchmark +import jneqsim.thermo.util.constants +import jneqsim.thermo.util.empiric +import jneqsim.thermo.util.gerg +import jneqsim.thermo.util.humidair +import jneqsim.thermo.util.jni +import jneqsim.thermo.util.leachman +import jneqsim.thermo.util.readwrite +import jneqsim.thermo.util.referenceequations +import jneqsim.thermo.util.spanwagner +import jneqsim.thermo.util.steam +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util")``. + + Vega: jneqsim.thermo.util.Vega.__module_protocol__ + benchmark: jneqsim.thermo.util.benchmark.__module_protocol__ + constants: jneqsim.thermo.util.constants.__module_protocol__ + empiric: jneqsim.thermo.util.empiric.__module_protocol__ + gerg: jneqsim.thermo.util.gerg.__module_protocol__ + humidair: jneqsim.thermo.util.humidair.__module_protocol__ + jni: jneqsim.thermo.util.jni.__module_protocol__ + leachman: jneqsim.thermo.util.leachman.__module_protocol__ + readwrite: jneqsim.thermo.util.readwrite.__module_protocol__ + referenceequations: jneqsim.thermo.util.referenceequations.__module_protocol__ + spanwagner: jneqsim.thermo.util.spanwagner.__module_protocol__ + steam: jneqsim.thermo.util.steam.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/benchmark/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/benchmark/__init__.pyi new file mode 100644 index 00000000..af230659 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/benchmark/__init__.pyi @@ -0,0 +1,35 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import typing + + + +class TPflash_benchmark: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class TPflash_benchmark_UMR: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class TPflash_benchmark_fullcomp: + def __init__(self): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.benchmark")``. + + TPflash_benchmark: typing.Type[TPflash_benchmark] + TPflash_benchmark_UMR: typing.Type[TPflash_benchmark_UMR] + TPflash_benchmark_fullcomp: typing.Type[TPflash_benchmark_fullcomp] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/constants/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/constants/__init__.pyi new file mode 100644 index 00000000..deb46998 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/constants/__init__.pyi @@ -0,0 +1,31 @@ + +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 typing + + + +class FurstElectrolyteConstants(java.io.Serializable): + furstParams: typing.ClassVar[typing.MutableSequence[float]] = ... + furstParamsCPA: typing.ClassVar[typing.MutableSequence[float]] = ... + furstParamsCPA_MDEA: typing.ClassVar[typing.MutableSequence[float]] = ... + @staticmethod + def getFurstParam(int: int) -> float: ... + @staticmethod + def getFurstParamMDEA(int: int) -> float: ... + @staticmethod + def setFurstParam(int: int, double: float) -> None: ... + @staticmethod + def setFurstParams(string: typing.Union[java.lang.String, str]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.constants")``. + + FurstElectrolyteConstants: typing.Type[FurstElectrolyteConstants] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/empiric/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/empiric/__init__.pyi new file mode 100644 index 00000000..a039a5cc --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/empiric/__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.lang +import jpype +import typing + + + +class BukacekWaterInGas: + def __init__(self): ... + @staticmethod + def getWaterInGas(double: float, double2: float) -> float: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @staticmethod + def waterDewPointTemperature(double: float, double2: float) -> float: ... + +class DuanSun: + def __init__(self): ... + def bublePointPressure(self, double: float, double2: float, double3: float) -> float: ... + def calcCO2solubility(self, double: float, double2: float, double3: float) -> float: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class Water: + def __init__(self): ... + def density(self) -> float: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @staticmethod + def waterDensity(double: float) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.empiric")``. + + BukacekWaterInGas: typing.Type[BukacekWaterInGas] + DuanSun: typing.Type[DuanSun] + Water: typing.Type[Water] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/gerg/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/gerg/__init__.pyi new file mode 100644 index 00000000..cbfa3ab6 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/gerg/__init__.pyi @@ -0,0 +1,155 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.thermo.phase +import org.netlib.util +import typing + + + +class DETAIL: + def __init__(self): ... + def DensityDetail(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, intW: org.netlib.util.intW, stringW: org.netlib.util.StringW) -> None: ... + def MolarMassDetail(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW) -> None: ... + def PressureDetail(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW) -> None: ... + def PropertiesDetail(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW, doubleW3: org.netlib.util.doubleW, doubleW4: org.netlib.util.doubleW, doubleW5: org.netlib.util.doubleW, doubleW6: org.netlib.util.doubleW, doubleW7: org.netlib.util.doubleW, doubleW8: org.netlib.util.doubleW, doubleW9: org.netlib.util.doubleW, doubleW10: org.netlib.util.doubleW, doubleW11: org.netlib.util.doubleW, doubleW12: org.netlib.util.doubleW, doubleW13: org.netlib.util.doubleW, doubleW14: org.netlib.util.doubleW, doubleW15: org.netlib.util.doubleW) -> None: ... + def SetupDetail(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def sq(self, double: float) -> float: ... + +class EOSCG: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, eOSCGCorrelationBackend: 'EOSCGCorrelationBackend'): ... + def alpha0(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleWArray: typing.Union[typing.List[org.netlib.util.doubleW], jpype.JArray]) -> None: ... + def alphar(self, int: int, int2: int, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleWArray: typing.Union[typing.List[typing.MutableSequence[org.netlib.util.doubleW]], jpype.JArray]) -> None: ... + def density(self, int: int, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, intW: org.netlib.util.intW, stringW: org.netlib.util.StringW) -> None: ... + def molarMass(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW) -> None: ... + def pressure(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW) -> None: ... + def properties(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW, doubleW3: org.netlib.util.doubleW, doubleW4: org.netlib.util.doubleW, doubleW5: org.netlib.util.doubleW, doubleW6: org.netlib.util.doubleW, doubleW7: org.netlib.util.doubleW, doubleW8: org.netlib.util.doubleW, doubleW9: org.netlib.util.doubleW, doubleW10: org.netlib.util.doubleW, doubleW11: org.netlib.util.doubleW, doubleW12: org.netlib.util.doubleW, doubleW13: org.netlib.util.doubleW, doubleW14: org.netlib.util.doubleW, doubleW15: org.netlib.util.doubleW, doubleW16: org.netlib.util.doubleW) -> None: ... + def setup(self) -> None: ... + +class EOSCGCorrelationBackend: + def __init__(self): ... + def alpha0(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleWArray: typing.Union[typing.List[org.netlib.util.doubleW], jpype.JArray]) -> None: ... + def alphar(self, int: int, int2: int, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleWArray: typing.Union[typing.List[typing.MutableSequence[org.netlib.util.doubleW]], jpype.JArray]) -> None: ... + def density(self, int: int, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, intW: org.netlib.util.intW, stringW: org.netlib.util.StringW) -> None: ... + def molarMass(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW) -> None: ... + def pressure(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW) -> None: ... + def properties(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW, doubleW3: org.netlib.util.doubleW, doubleW4: org.netlib.util.doubleW, doubleW5: org.netlib.util.doubleW, doubleW6: org.netlib.util.doubleW, doubleW7: org.netlib.util.doubleW, doubleW8: org.netlib.util.doubleW, doubleW9: org.netlib.util.doubleW, doubleW10: org.netlib.util.doubleW, doubleW11: org.netlib.util.doubleW, doubleW12: org.netlib.util.doubleW, doubleW13: org.netlib.util.doubleW, doubleW14: org.netlib.util.doubleW, doubleW15: org.netlib.util.doubleW, doubleW16: org.netlib.util.doubleW) -> None: ... + def setup(self) -> None: ... + +class EOSCGModel: + def __init__(self): ... + def DensityEOSCG(self, int: int, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, intW: org.netlib.util.intW, stringW: org.netlib.util.StringW) -> None: ... + def MolarMassEOSCG(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW) -> None: ... + def PressureEOSCG(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW) -> None: ... + def PropertiesEOSCG(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW, doubleW3: org.netlib.util.doubleW, doubleW4: org.netlib.util.doubleW, doubleW5: org.netlib.util.doubleW, doubleW6: org.netlib.util.doubleW, doubleW7: org.netlib.util.doubleW, doubleW8: org.netlib.util.doubleW, doubleW9: org.netlib.util.doubleW, doubleW10: org.netlib.util.doubleW, doubleW11: org.netlib.util.doubleW, doubleW12: org.netlib.util.doubleW, doubleW13: org.netlib.util.doubleW, doubleW14: org.netlib.util.doubleW, doubleW15: org.netlib.util.doubleW, doubleW16: org.netlib.util.doubleW) -> None: ... + def SetupEOSCG(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class GERG2008: + def __init__(self): ... + def DensityGERG(self, int: int, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, intW: org.netlib.util.intW, stringW: org.netlib.util.StringW) -> None: ... + def MolarMassGERG(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW) -> None: ... + def PressureGERG(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW) -> None: ... + def PropertiesGERG(self, double: float, double2: float, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW, doubleW3: org.netlib.util.doubleW, doubleW4: org.netlib.util.doubleW, doubleW5: org.netlib.util.doubleW, doubleW6: org.netlib.util.doubleW, doubleW7: org.netlib.util.doubleW, doubleW8: org.netlib.util.doubleW, doubleW9: org.netlib.util.doubleW, doubleW10: org.netlib.util.doubleW, doubleW11: org.netlib.util.doubleW, doubleW12: org.netlib.util.doubleW, doubleW13: org.netlib.util.doubleW, doubleW14: org.netlib.util.doubleW, doubleW15: org.netlib.util.doubleW, doubleW16: org.netlib.util.doubleW) -> None: ... + def SetupGERG(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + +class NeqSimAGA8Detail: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface): ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getDensity(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getMolarDensity(self) -> float: ... + @typing.overload + def getMolarDensity(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getMolarMass(self) -> float: ... + def getPressure(self) -> float: ... + def getProperties(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def normalizeComposition(self) -> None: ... + @typing.overload + def propertiesDetail(self) -> typing.MutableSequence[float]: ... + @typing.overload + def propertiesDetail(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> typing.MutableSequence[float]: ... + def setPhase(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + +class NeqSimEOSCG: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface): ... + def getAlpha0_EOSCG(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlphares_EOSCG(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getDensity(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getMolarDensity(self) -> float: ... + @typing.overload + def getMolarDensity(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getMolarMass(self) -> float: ... + def getPressure(self) -> float: ... + def getProperties(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> typing.MutableSequence[float]: ... + def normalizeComposition(self) -> None: ... + def propertiesEOSCG(self) -> typing.MutableSequence[float]: ... + def setPhase(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + +class NeqSimGERG2008: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface): ... + def getAlpha0_GERG2008(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlphares_GERG2008(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getDensity(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getMolarDensity(self) -> float: ... + @typing.overload + def getMolarDensity(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getMolarMass(self) -> float: ... + def getPressure(self) -> float: ... + def getProperties(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def normalizeComposition(self) -> None: ... + @typing.overload + def propertiesGERG(self) -> typing.MutableSequence[float]: ... + @typing.overload + def propertiesGERG(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> typing.MutableSequence[float]: ... + def setPhase(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.gerg")``. + + DETAIL: typing.Type[DETAIL] + EOSCG: typing.Type[EOSCG] + EOSCGCorrelationBackend: typing.Type[EOSCGCorrelationBackend] + EOSCGModel: typing.Type[EOSCGModel] + GERG2008: typing.Type[GERG2008] + NeqSimAGA8Detail: typing.Type[NeqSimAGA8Detail] + NeqSimEOSCG: typing.Type[NeqSimEOSCG] + NeqSimGERG2008: typing.Type[NeqSimGERG2008] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/humidair/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/humidair/__init__.pyi new file mode 100644 index 00000000..7be24693 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/humidair/__init__.pyi @@ -0,0 +1,30 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import typing + + + +class HumidAir: + @staticmethod + def cairSat(double: float) -> float: ... + @staticmethod + def dewPointTemperature(double: float, double2: float) -> float: ... + @staticmethod + def enthalpy(double: float, double2: float) -> float: ... + @staticmethod + def humidityRatioFromRH(double: float, double2: float, double3: float) -> float: ... + @staticmethod + def relativeHumidity(double: float, double2: float, double3: float) -> float: ... + @staticmethod + def saturationPressureWater(double: float) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.humidair")``. + + HumidAir: typing.Type[HumidAir] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/jni/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/jni/__init__.pyi new file mode 100644 index 00000000..41c4037d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/jni/__init__.pyi @@ -0,0 +1,53 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import typing + + + +class GERG2004EOS: + nameList: typing.MutableSequence[java.lang.String] = ... + def __init__(self): ... + @staticmethod + def AOTPX(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, double19: float, double20: float, int: int) -> float: ... + @staticmethod + def CPOTPX(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, double19: float, double20: float, int: int) -> float: ... + @staticmethod + def CVOTPX(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, double19: float, double20: float, int: int) -> float: ... + @staticmethod + def GOTPX(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, double19: float, double20: float, int: int) -> float: ... + @staticmethod + def HOTPX(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, double19: float, double20: float, int: int) -> float: ... + @staticmethod + def POTDX(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, double19: float, double20: float) -> float: ... + @staticmethod + def RJTOTPX(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, double19: float, double20: float, int: int) -> float: ... + @staticmethod + def SALLOTPX(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, double19: float, double20: float, int: int) -> typing.MutableSequence[float]: ... + @staticmethod + def SFUGOTPX(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, double19: float, double20: float, int: int) -> typing.MutableSequence[float]: ... + @staticmethod + def SOTPX(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, double19: float, double20: float, int: int) -> float: ... + @staticmethod + def SPHIOTPX(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, double19: float, double20: float, int: int) -> typing.MutableSequence[float]: ... + @staticmethod + def UOTPX(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, double19: float, double20: float, int: int) -> float: ... + @staticmethod + def WOTPX(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, double19: float, double20: float, int: int) -> float: ... + @staticmethod + def ZOTPX(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, double19: float, double20: float, int: int) -> float: ... + def getNameList(self) -> typing.MutableSequence[java.lang.String]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.jni")``. + + GERG2004EOS: typing.Type[GERG2004EOS] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/leachman/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/leachman/__init__.pyi new file mode 100644 index 00000000..da6badba --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/leachman/__init__.pyi @@ -0,0 +1,58 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.thermo.phase +import org.netlib.util +import typing + + + +class Leachman: + def __init__(self): ... + def DensityLeachman(self, int: int, double: float, double2: float, doubleW: org.netlib.util.doubleW, intW: org.netlib.util.intW, stringW: org.netlib.util.StringW) -> None: ... + def PressureLeachman(self, double: float, double2: float, doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW) -> None: ... + @typing.overload + def SetupLeachman(self) -> None: ... + @typing.overload + def SetupLeachman(self, string: typing.Union[java.lang.String, str]) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def propertiesLeachman(self, double: float, double2: float, doubleW: org.netlib.util.doubleW, doubleW2: org.netlib.util.doubleW, doubleW3: org.netlib.util.doubleW, doubleW4: org.netlib.util.doubleW, doubleW5: org.netlib.util.doubleW, doubleW6: org.netlib.util.doubleW, doubleW7: org.netlib.util.doubleW, doubleW8: org.netlib.util.doubleW, doubleW9: org.netlib.util.doubleW, doubleW10: org.netlib.util.doubleW, doubleW11: org.netlib.util.doubleW, doubleW12: org.netlib.util.doubleW, doubleW13: org.netlib.util.doubleW, doubleW14: org.netlib.util.doubleW, doubleW15: org.netlib.util.doubleW, doubleW16: org.netlib.util.doubleW) -> None: ... + +class NeqSimLeachman: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, string: typing.Union[java.lang.String, str]): ... + def getAlpha0_Leachman(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlphares_Leachman(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + @typing.overload + def getDensity(self) -> float: ... + @typing.overload + def getDensity(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + @typing.overload + def getMolarDensity(self) -> float: ... + @typing.overload + def getMolarDensity(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + def getPressure(self) -> float: ... + def getProperties(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> typing.MutableSequence[float]: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + @typing.overload + def propertiesLeachman(self) -> typing.MutableSequence[float]: ... + @typing.overload + def propertiesLeachman(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> typing.MutableSequence[float]: ... + def setPhase(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.leachman")``. + + Leachman: typing.Type[Leachman] + NeqSimLeachman: typing.Type[NeqSimLeachman] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/readwrite/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/readwrite/__init__.pyi new file mode 100644 index 00000000..664bf364 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/readwrite/__init__.pyi @@ -0,0 +1,53 @@ + +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 jpype +import jneqsim.thermo.system +import typing + + + +class EclipseFluidReadWrite: + pseudoName: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + @staticmethod + def read(string: typing.Union[java.lang.String, str]) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + @staticmethod + def read(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + @staticmethod + def read(string: typing.Union[java.lang.String, str], stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> jneqsim.thermo.system.SystemInterface: ... + @staticmethod + def readE300File(string: typing.Union[java.lang.String, str]) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + @staticmethod + def setComposition(systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + @staticmethod + def setComposition(systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + +class TablePrinter(java.io.Serializable): + def __init__(self): ... + @staticmethod + def convertDoubleToString(doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + @typing.overload + @staticmethod + def printTable(doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + @typing.overload + @staticmethod + def printTable(stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.readwrite")``. + + EclipseFluidReadWrite: typing.Type[EclipseFluidReadWrite] + TablePrinter: typing.Type[TablePrinter] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/referenceequations/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/referenceequations/__init__.pyi new file mode 100644 index 00000000..66ccfabd --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/referenceequations/__init__.pyi @@ -0,0 +1,41 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.thermo.phase +import org.netlib.util +import typing + + + +class Ammonia2023: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface): ... + def getAlpha0(self) -> typing.MutableSequence[org.netlib.util.doubleW]: ... + def getAlphaRes(self) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... + def getDensity(self) -> float: ... + def getThermalConductivity(self) -> float: ... + def getViscosity(self) -> float: ... + def properties(self) -> typing.MutableSequence[float]: ... + def setPhase(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + +class methaneBWR32: + def __init__(self): ... + def calcPressure(self, double: float, double2: float) -> float: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def molDens(self, double: float, double2: float, boolean: bool) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.referenceequations")``. + + Ammonia2023: typing.Type[Ammonia2023] + methaneBWR32: typing.Type[methaneBWR32] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/spanwagner/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/spanwagner/__init__.pyi new file mode 100644 index 00000000..53a1bcd4 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/spanwagner/__init__.pyi @@ -0,0 +1,21 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.thermo.phase +import typing + + + +class NeqSimSpanWagner: + @staticmethod + def getProperties(double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> typing.MutableSequence[float]: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.spanwagner")``. + + NeqSimSpanWagner: typing.Type[NeqSimSpanWagner] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/steam/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/steam/__init__.pyi new file mode 100644 index 00000000..7853ef0c --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/steam/__init__.pyi @@ -0,0 +1,36 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import typing + + + +class Iapws_if97: + @staticmethod + def T4_p(double: float) -> float: ... + @staticmethod + def cp_pt(double: float, double2: float) -> float: ... + @staticmethod + def h_pt(double: float, double2: float) -> float: ... + @staticmethod + def p4_T(double: float) -> float: ... + @staticmethod + def psat_t(double: float) -> float: ... + @staticmethod + def s_pt(double: float, double2: float) -> float: ... + @staticmethod + def tsat_p(double: float) -> float: ... + @staticmethod + def v_pt(double: float, double2: float) -> float: ... + @staticmethod + def w_pt(double: float, double2: float) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.steam")``. + + Iapws_if97: typing.Type[Iapws_if97] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/__init__.pyi new file mode 100644 index 00000000..25972564 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/__init__.pyi @@ -0,0 +1,220 @@ + +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.api.ioc +import jneqsim.thermo.system +import jneqsim.thermodynamicoperations.chemicalequilibrium +import jneqsim.thermodynamicoperations.flashops +import jneqsim.thermodynamicoperations.phaseenvelopeops +import jneqsim.thermodynamicoperations.propertygenerator +import org.jfree.chart +import typing + + + +class OperationInterface(java.lang.Runnable, java.io.Serializable): + def addData(self, string: typing.Union[java.lang.String, str], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def displayResult(self) -> None: ... + def get(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class ThermodynamicOperations(java.io.Serializable, java.lang.Cloneable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def OLGApropTable(self, double: float, double2: float, int: int, double3: float, double4: float, int2: int, string: typing.Union[java.lang.String, str], int3: int) -> None: ... + def OLGApropTablePH(self, double: float, double2: float, int: int, double3: float, double4: float, int2: int, string: typing.Union[java.lang.String, str], int3: int) -> None: ... + @typing.overload + def PHflash(self, double: float) -> None: ... + @typing.overload + def PHflash(self, double: float, int: int) -> None: ... + @typing.overload + def PHflash(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def PHflash2(self, double: float, int: int) -> None: ... + def PHflashGERG2008(self, double: float) -> None: ... + def PHflashLeachman(self, double: float) -> None: ... + def PHflashVega(self, double: float) -> None: ... + def PHsolidFlash(self, double: float) -> None: ... + @typing.overload + def PSflash(self, double: float) -> None: ... + @typing.overload + def PSflash(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def PSflash2(self, double: float) -> None: ... + def PSflashGERG2008(self, double: float) -> None: ... + def PSflashLeachman(self, double: float) -> None: ... + def PSflashVega(self, double: float) -> None: ... + @typing.overload + def PUflash(self, double: float) -> None: ... + @typing.overload + def PUflash(self, double: float, double2: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def PUflash(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def PVrefluxFlash(self, double: float, int: int) -> None: ... + def TPSolidflash(self) -> None: ... + def TPVflash(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def TPflash(self) -> None: ... + @typing.overload + def TPflash(self, boolean: bool) -> None: ... + def TPflashSoreideWhitson(self) -> None: ... + def TPgradientFlash(self, double: float, double2: float) -> jneqsim.thermo.system.SystemInterface: ... + @typing.overload + def TSflash(self, double: float) -> None: ... + @typing.overload + def TSflash(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def TVflash(self, double: float) -> None: ... + @typing.overload + def TVflash(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def TVfractionFlash(self, double: float) -> None: ... + @typing.overload + def VHflash(self, double: float, double2: float) -> None: ... + @typing.overload + def VHflash(self, double: float, double2: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def VSflash(self, double: float, double2: float) -> None: ... + @typing.overload + def VSflash(self, double: float, double2: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def VUflash(self, double: float, double2: float) -> None: ... + @typing.overload + def VUflash(self, double: float, double2: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def addData(self, string: typing.Union[java.lang.String, str], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def addIonToScaleSaturation(self, int: int, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def bubblePointPressureFlash(self) -> None: ... + @typing.overload + def bubblePointPressureFlash(self, boolean: bool) -> None: ... + def bubblePointTemperatureFlash(self) -> None: ... + def calcCricoP(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]) -> None: ... + def calcCricoT(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]) -> None: ... + def calcCricondenBar(self) -> float: ... + def calcHPTphaseEnvelope(self) -> None: ... + def calcImobilePhaseHydrateTemperature(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcIonComposition(self, int: int) -> None: ... + @typing.overload + def calcPTphaseEnvelope(self) -> None: ... + @typing.overload + def calcPTphaseEnvelope(self, boolean: bool) -> None: ... + @typing.overload + def calcPTphaseEnvelope(self, boolean: bool, double: float) -> None: ... + @typing.overload + def calcPTphaseEnvelope(self, double: float) -> None: ... + @typing.overload + def calcPTphaseEnvelope(self, double: float, double2: float) -> None: ... + def calcPTphaseEnvelope2(self) -> None: ... + def calcPTphaseEnvelopeNew(self) -> None: ... + def calcPTphaseEnvelopeNew3(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float) -> None: ... + def calcPloadingCurve(self) -> None: ... + def calcSaltSaturation(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def calcSolidComlexTemperature(self) -> None: ... + @typing.overload + def calcSolidComlexTemperature(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + def calcTOLHydrateFormationTemperature(self) -> float: ... + def calcWAT(self) -> None: ... + def checkScalePotential(self, int: int) -> None: ... + def chemicalEquilibrium(self) -> None: ... + def constantPhaseFractionPressureFlash(self, double: float) -> None: ... + def constantPhaseFractionTemperatureFlash(self, double: float) -> None: ... + def criticalPointFlash(self) -> None: ... + def dTPflash(self, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def dewPointMach(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], double: float) -> None: ... + def dewPointPressureFlash(self) -> None: ... + def dewPointPressureFlashHC(self) -> None: ... + def dewPointTemperatureCondensationRate(self) -> float: ... + @typing.overload + def dewPointTemperatureFlash(self) -> None: ... + @typing.overload + def dewPointTemperatureFlash(self, boolean: bool) -> None: ... + def display(self) -> None: ... + def displayResult(self) -> None: ... + def flash(self, flashType: 'ThermodynamicOperations.FlashType', double: float, double2: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def freezingPointTemperatureFlash(self) -> None: ... + @typing.overload + def freezingPointTemperatureFlash(self, string: typing.Union[java.lang.String, str]) -> None: ... + def get(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getData(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getDataPoints(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getJfreeChart(self) -> org.jfree.chart.JFreeChart: ... + def getOperation(self) -> OperationInterface: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def getThermoOperationThread(self) -> java.lang.Thread: ... + def hydrateEquilibriumLine(self, double: float, double2: float) -> None: ... + def hydrateFormationPressure(self) -> None: ... + @typing.overload + def hydrateFormationTemperature(self) -> None: ... + @typing.overload + def hydrateFormationTemperature(self, double: float) -> None: ... + @typing.overload + def hydrateFormationTemperature(self, int: int) -> None: ... + def hydrateInhibitorConcentration(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def hydrateInhibitorConcentrationSet(self, string: typing.Union[java.lang.String, str], double: float) -> None: ... + def isRunAsThread(self) -> bool: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def propertyFlash(self, list: java.util.List[float], list2: java.util.List[float], int: int, list3: java.util.List[typing.Union[java.lang.String, str]], list4: java.util.List[java.util.List[float]]) -> jneqsim.api.ioc.CalculationResult: ... + def run(self) -> None: ... + def saturateWithWater(self) -> None: ... + def setResultTable(self, stringArray: typing.Union[typing.List[typing.MutableSequence[java.lang.String]], jpype.JArray]) -> None: ... + def setRunAsThread(self, boolean: bool) -> None: ... + def setSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> None: ... + def setThermoOperationThread(self, thread: java.lang.Thread) -> None: ... + def waitAndCheckForFinishedCalculation(self, int: int) -> bool: ... + def waitToFinishCalculation(self) -> None: ... + def waterDewPointLine(self, double: float, double2: float) -> None: ... + def waterDewPointTemperatureFlash(self) -> None: ... + def waterDewPointTemperatureMultiphaseFlash(self) -> None: ... + def waterPrecipitationTemperature(self) -> None: ... + class FlashType(java.lang.Enum['ThermodynamicOperations.FlashType']): + TP: typing.ClassVar['ThermodynamicOperations.FlashType'] = ... + PT: typing.ClassVar['ThermodynamicOperations.FlashType'] = ... + PH: typing.ClassVar['ThermodynamicOperations.FlashType'] = ... + PS: typing.ClassVar['ThermodynamicOperations.FlashType'] = ... + TV: typing.ClassVar['ThermodynamicOperations.FlashType'] = ... + TS: typing.ClassVar['ThermodynamicOperations.FlashType'] = ... + _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]) -> 'ThermodynamicOperations.FlashType': ... + @staticmethod + def values() -> typing.MutableSequence['ThermodynamicOperations.FlashType']: ... + +class BaseOperation(OperationInterface): + def __init__(self): ... + def addData(self, string: typing.Union[java.lang.String, str], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def get(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermodynamicoperations")``. + + BaseOperation: typing.Type[BaseOperation] + OperationInterface: typing.Type[OperationInterface] + ThermodynamicOperations: typing.Type[ThermodynamicOperations] + chemicalequilibrium: jneqsim.thermodynamicoperations.chemicalequilibrium.__module_protocol__ + flashops: jneqsim.thermodynamicoperations.flashops.__module_protocol__ + phaseenvelopeops: jneqsim.thermodynamicoperations.phaseenvelopeops.__module_protocol__ + propertygenerator: jneqsim.thermodynamicoperations.propertygenerator.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/chemicalequilibrium/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/chemicalequilibrium/__init__.pyi new file mode 100644 index 00000000..83f601bf --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/chemicalequilibrium/__init__.pyi @@ -0,0 +1,29 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jneqsim.thermo.system +import jneqsim.thermodynamicoperations +import org.jfree.chart +import typing + + + +class ChemicalEquilibrium(jneqsim.thermodynamicoperations.BaseOperation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def displayResult(self) -> None: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermodynamicoperations.chemicalequilibrium")``. + + ChemicalEquilibrium: typing.Type[ChemicalEquilibrium] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/flashops/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/flashops/__init__.pyi new file mode 100644 index 00000000..3ffbf3d9 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/flashops/__init__.pyi @@ -0,0 +1,441 @@ + +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 jpype +import jneqsim.thermo +import jneqsim.thermo.system +import jneqsim.thermodynamicoperations +import jneqsim.thermodynamicoperations.flashops.saturationops +import org.jfree.chart +import typing + + + +class Flash(jneqsim.thermodynamicoperations.BaseOperation): + minGibsPhaseLogZ: typing.MutableSequence[float] = ... + minGibsLogFugCoef: typing.MutableSequence[float] = ... + def __init__(self): ... + def addData(self, string: typing.Union[java.lang.String, str], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def displayResult(self) -> None: ... + def findLowestGibbsEnergyPhase(self) -> int: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def solidPhaseFlash(self) -> None: ... + def stabilityAnalysis(self) -> None: ... + def stabilityCheck(self) -> bool: ... + +class RachfordRice(java.io.Serializable): + def __init__(self): ... + def calcBeta(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + def calcBetaMichelsen2001(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + def calcBetaNielsen2023(self, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + def calcBetaS(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> float: ... + def getBeta(self) -> typing.MutableSequence[float]: ... + @staticmethod + def getMethod() -> java.lang.String: ... + @staticmethod + def setMethod(string: typing.Union[java.lang.String, str]) -> None: ... + +class SysNewtonRhapsonPHflash(jneqsim.thermo.ThermodynamicConstantsInterface): + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int, int2: int): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int, int2: int, int3: int): ... + def init(self) -> None: ... + def setJac(self) -> None: ... + def setSpec(self, double: float) -> None: ... + def setfvec(self) -> None: ... + def setu(self) -> None: ... + def solve(self, int: int) -> int: ... + +class SysNewtonRhapsonTPflash(java.io.Serializable): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int, int2: int): ... + def init(self) -> None: ... + def setJac(self) -> None: ... + def setfvec(self) -> None: ... + def setu(self) -> None: ... + def solve(self) -> float: ... + +class SysNewtonRhapsonTPflashNew(java.io.Serializable): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int, int2: int): ... + def init(self) -> None: ... + def setJac(self) -> None: ... + def setfvec(self) -> None: ... + def setu(self) -> None: ... + def solve(self, int: int) -> None: ... + +class CalcIonicComposition(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int): ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def run(self) -> None: ... + +class CriticalPointFlash(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcMmatrix(self) -> None: ... + def calcMmatrixHeidemann(self) -> None: ... + def calcdpd(self) -> float: ... + def run(self) -> None: ... + +class ImprovedVUflashQfunc(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + def calcdQdP(self) -> float: ... + def calcdQdPP(self) -> float: ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class OptimizedVUflash(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class PHflash(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, int: int): ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + def solveQ2(self) -> float: ... + +class PHflashGERG2008(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + def solveQ2(self) -> float: ... + +class PHflashLeachman(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class PHflashSingleComp(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, int: int): ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + +class PHflashVega(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class PHsolidFlash(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + +class PSflashSingleComp(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, int: int): ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + +class PUflash(Flash): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class PVrefluxflash(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, int: int): ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + +class QfuncFlash(Flash): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, int: int): ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class TPflash(Flash): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, boolean: bool): ... + def accselerateSucsSubs(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def resetK(self) -> None: ... + def run(self) -> None: ... + def setNewK(self) -> None: ... + def sucsSubs(self) -> None: ... + +class TPgradientFlash(Flash): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def run(self) -> None: ... + def setJac(self) -> None: ... + def setNewX(self) -> None: ... + def setfvec(self) -> None: ... + +class TVflash(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + def calcdQdV(self) -> float: ... + def calcdQdVdP(self) -> float: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class TVfractionFlash(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + def calcdQdV(self) -> float: ... + def calcdQdVdP(self) -> float: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class VHflash(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + +class VHflashQfunc(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + def calcdQdP(self) -> float: ... + def calcdQdPP(self) -> float: ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class VSflash(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + def calcdQdP(self) -> float: ... + def calcdQdPP(self) -> float: ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class VUflash(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + +class VUflashQfunc(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + def calcdQdP(self) -> float: ... + def calcdQdPP(self) -> float: ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class VUflashSingleComp(Flash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def run(self) -> None: ... + +class PSFlash(QfuncFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, int: int): ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def onPhaseSolve(self) -> None: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class PSFlashGERG2008(QfuncFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class PSFlashLeachman(QfuncFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class PSFlashVega(QfuncFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class SaturateWithWater(QfuncFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def run(self) -> None: ... + +class SolidFlash(TPflash): + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, boolean: bool): ... + def calcE(self) -> None: ... + def calcMultiPhaseBeta(self) -> None: ... + def calcQ(self) -> float: ... + def calcSolidBeta(self) -> None: ... + def checkGibbs(self) -> None: ... + def checkX(self) -> None: ... + def run(self) -> None: ... + def setSolidComponent(self, int: int) -> None: ... + def setXY(self) -> None: ... + def solveBeta(self, boolean: bool) -> None: ... + +class SolidFlash1(TPflash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcE(self) -> None: ... + def calcGradientAndHesian(self) -> None: ... + def calcMultiPhaseBeta(self) -> None: ... + def calcQ(self) -> float: ... + def calcQbeta(self) -> None: ... + def calcSolidBeta(self) -> float: ... + def checkAndAddSolidPhase(self) -> int: ... + def checkGibbs(self) -> None: ... + def checkX(self) -> None: ... + def run(self) -> None: ... + def setXY(self) -> None: ... + def solveBeta(self) -> None: ... + def solvebeta1(self) -> float: ... + +class SolidFlash12(TPflash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcE(self) -> None: ... + def calcMultiPhaseBeta(self) -> None: ... + def calcQ(self) -> float: ... + def calcSolidBeta(self) -> None: ... + def checkAndAddSolidPhase(self) -> int: ... + def checkGibbs(self) -> None: ... + def checkX(self) -> None: ... + def run(self) -> None: ... + def setXY(self) -> None: ... + def solveBeta(self) -> None: ... + def solvebeta1(self) -> float: ... + +class TPmultiflash(TPflash): + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, boolean: bool): ... + def calcE(self) -> None: ... + def calcMultiPhaseBeta(self) -> None: ... + def calcQ(self) -> float: ... + def run(self) -> None: ... + def setDoubleArrays(self) -> None: ... + def setXY(self) -> None: ... + def solveBeta(self) -> float: ... + def stabilityAnalysis(self) -> None: ... + def stabilityAnalysis2(self) -> None: ... + def stabilityAnalysis3(self) -> None: ... + +class TPmultiflashWAX(TPflash): + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, boolean: bool): ... + def calcE(self) -> None: ... + def calcMultiPhaseBeta(self) -> None: ... + def calcQ(self) -> float: ... + def run(self) -> None: ... + def setXY(self) -> None: ... + def solveBeta(self, boolean: bool) -> None: ... + def stabilityAnalysis(self) -> None: ... + +class TSFlash(QfuncFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + def calcdQdT(self) -> float: ... + def calcdQdTT(self) -> float: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def onPhaseSolve(self) -> None: ... + def run(self) -> None: ... + def solveQ(self) -> float: ... + +class dTPflash(TPflash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]): ... + def run(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermodynamicoperations.flashops")``. + + CalcIonicComposition: typing.Type[CalcIonicComposition] + CriticalPointFlash: typing.Type[CriticalPointFlash] + Flash: typing.Type[Flash] + ImprovedVUflashQfunc: typing.Type[ImprovedVUflashQfunc] + OptimizedVUflash: typing.Type[OptimizedVUflash] + PHflash: typing.Type[PHflash] + PHflashGERG2008: typing.Type[PHflashGERG2008] + PHflashLeachman: typing.Type[PHflashLeachman] + PHflashSingleComp: typing.Type[PHflashSingleComp] + PHflashVega: typing.Type[PHflashVega] + PHsolidFlash: typing.Type[PHsolidFlash] + PSFlash: typing.Type[PSFlash] + PSFlashGERG2008: typing.Type[PSFlashGERG2008] + PSFlashLeachman: typing.Type[PSFlashLeachman] + PSFlashVega: typing.Type[PSFlashVega] + PSflashSingleComp: typing.Type[PSflashSingleComp] + PUflash: typing.Type[PUflash] + PVrefluxflash: typing.Type[PVrefluxflash] + QfuncFlash: typing.Type[QfuncFlash] + RachfordRice: typing.Type[RachfordRice] + SaturateWithWater: typing.Type[SaturateWithWater] + SolidFlash: typing.Type[SolidFlash] + SolidFlash1: typing.Type[SolidFlash1] + SolidFlash12: typing.Type[SolidFlash12] + SysNewtonRhapsonPHflash: typing.Type[SysNewtonRhapsonPHflash] + SysNewtonRhapsonTPflash: typing.Type[SysNewtonRhapsonTPflash] + SysNewtonRhapsonTPflashNew: typing.Type[SysNewtonRhapsonTPflashNew] + TPflash: typing.Type[TPflash] + TPgradientFlash: typing.Type[TPgradientFlash] + TPmultiflash: typing.Type[TPmultiflash] + TPmultiflashWAX: typing.Type[TPmultiflashWAX] + TSFlash: typing.Type[TSFlash] + TVflash: typing.Type[TVflash] + TVfractionFlash: typing.Type[TVfractionFlash] + VHflash: typing.Type[VHflash] + VHflashQfunc: typing.Type[VHflashQfunc] + VSflash: typing.Type[VSflash] + VUflash: typing.Type[VUflash] + VUflashQfunc: typing.Type[VUflashQfunc] + VUflashSingleComp: typing.Type[VUflashSingleComp] + dTPflash: typing.Type[dTPflash] + saturationops: jneqsim.thermodynamicoperations.flashops.saturationops.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/flashops/saturationops/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/flashops/saturationops/__init__.pyi new file mode 100644 index 00000000..5f2ae08a --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/flashops/saturationops/__init__.pyi @@ -0,0 +1,316 @@ + +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 jpype +import jneqsim.thermo +import jneqsim.thermo.system +import jneqsim.thermodynamicoperations +import org.jfree.chart +import typing + + + +class ConstantDutyFlashInterface(jneqsim.thermodynamicoperations.OperationInterface): + def isSuperCritical(self) -> bool: ... + +class CricondenBarTemp(java.io.Serializable): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int, int2: int): ... + def init(self) -> None: ... + def setJac(self) -> None: ... + def setfvec(self) -> None: ... + def setu(self) -> None: ... + def solve(self) -> float: ... + +class CricondenBarTemp1(java.io.Serializable): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def displayResult(self) -> None: ... + def get(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def init(self) -> None: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + def setJac(self) -> None: ... + def setfvec(self) -> None: ... + def setu(self) -> None: ... + def solve(self) -> float: ... + +class ConstantDutyFlash(ConstantDutyFlashInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def addData(self, string: typing.Union[java.lang.String, str], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def displayResult(self) -> None: ... + def get(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def isSuperCritical(self) -> bool: ... + def run(self) -> None: ... + def setSuperCritical(self, boolean: bool) -> None: ... + +class ConstantDutyPressureFlash(ConstantDutyFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class ConstantDutyTemperatureFlash(ConstantDutyFlash): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class AddIonToScaleSaturation(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class BubblePointPressureFlash(ConstantDutyPressureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class BubblePointPressureFlashDer(ConstantDutyPressureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class BubblePointTemperatureFlash(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class BubblePointTemperatureNoDer(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class CalcSaltSatauration(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str]): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class CheckScalePotential(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int): ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class CricondebarFlash(ConstantDutyPressureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcx(self) -> float: ... + def initMoleFraction(self) -> float: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + def run2(self) -> None: ... + def setJac(self) -> None: ... + def setfvec(self) -> None: ... + +class DewPointPressureFlash(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class DewPointTemperatureFlash(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class DewPointTemperatureFlashDer(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class FreezeOut(ConstantDutyTemperatureFlash, jneqsim.thermo.ThermodynamicConstantsInterface): + FCompTemp: typing.MutableSequence[float] = ... + FCompNames: typing.MutableSequence[java.lang.String] = ... + noFreezeFlash: bool = ... + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class FreezingPointTemperatureFlash(ConstantDutyTemperatureFlash, jneqsim.thermo.ThermodynamicConstantsInterface): + noFreezeFlash: bool = ... + Niterations: int = ... + name: java.lang.String = ... + phaseName: java.lang.String = ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, boolean: bool): ... + def calcFunc(self) -> float: ... + @typing.overload + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + def printToFile(self, string: typing.Union[java.lang.String, str], stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray], doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + def run(self) -> None: ... + +class FreezingPointTemperatureFlashOld(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class FreezingPointTemperatureFlashTR(ConstantDutyTemperatureFlash, jneqsim.thermo.ThermodynamicConstantsInterface): + noFreezeFlash: bool = ... + Niterations: int = ... + FCompNames: typing.MutableSequence[java.lang.String] = ... + FCompTemp: typing.MutableSequence[float] = ... + compnr: int = ... + name: java.lang.String = ... + CCequation: bool = ... + @typing.overload + def __init__(self, boolean: bool): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, boolean: bool): ... + def getNiterations(self) -> int: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class FugTestConstP(ConstantDutyTemperatureFlash, jneqsim.thermo.ThermodynamicConstantsInterface): + temp: float = ... + pres: float = ... + testSystem: jneqsim.thermo.system.SystemInterface = ... + testSystem2: jneqsim.thermo.system.SystemInterface = ... + testOps: jneqsim.thermodynamicoperations.ThermodynamicOperations = ... + testOps2: jneqsim.thermodynamicoperations.ThermodynamicOperations = ... + compNumber: int = ... + compName: java.lang.String = ... + compNameGiven: bool = ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + def PrintToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def initTestSystem2(self, int: int) -> None: ... + def run(self) -> None: ... + +class HCdewPointPressureFlash(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class HydrateEquilibriumLine(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def run(self) -> None: ... + +class HydrateFormationPressureFlash(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + def setFug(self) -> None: ... + +class HydrateFormationTemperatureFlash(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + def run2(self) -> None: ... + def setFug(self) -> None: ... + def stop(self) -> None: ... + +class HydrateInhibitorConcentrationFlash(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], double: float): ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + def stop(self) -> None: ... + +class HydrateInhibitorwtFlash(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], double: float): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + def stop(self) -> None: ... + +class SolidComplexTemperatureCalc(ConstantDutyTemperatureFlash): + Kcomplex: typing.ClassVar[float] = ... + HrefComplex: typing.ClassVar[float] = ... + TrefComplex: typing.ClassVar[float] = ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + def getHrefComplex(self) -> float: ... + def getKcomplex(self) -> float: ... + def getTrefComplex(self) -> float: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + def runOld(self) -> None: ... + def setHrefComplex(self, double: float) -> None: ... + def setKcomplex(self, double: float) -> None: ... + def setTrefComplex(self, double: float) -> None: ... + +class WATcalc(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class WaterDewPointEquilibriumLine(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def run(self) -> None: ... + +class WaterDewPointTemperatureFlash(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class WaterDewPointTemperatureMultiphaseFlash(ConstantDutyTemperatureFlash): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermodynamicoperations.flashops.saturationops")``. + + AddIonToScaleSaturation: typing.Type[AddIonToScaleSaturation] + BubblePointPressureFlash: typing.Type[BubblePointPressureFlash] + BubblePointPressureFlashDer: typing.Type[BubblePointPressureFlashDer] + BubblePointTemperatureFlash: typing.Type[BubblePointTemperatureFlash] + BubblePointTemperatureNoDer: typing.Type[BubblePointTemperatureNoDer] + CalcSaltSatauration: typing.Type[CalcSaltSatauration] + CheckScalePotential: typing.Type[CheckScalePotential] + ConstantDutyFlash: typing.Type[ConstantDutyFlash] + ConstantDutyFlashInterface: typing.Type[ConstantDutyFlashInterface] + ConstantDutyPressureFlash: typing.Type[ConstantDutyPressureFlash] + ConstantDutyTemperatureFlash: typing.Type[ConstantDutyTemperatureFlash] + CricondebarFlash: typing.Type[CricondebarFlash] + CricondenBarTemp: typing.Type[CricondenBarTemp] + CricondenBarTemp1: typing.Type[CricondenBarTemp1] + DewPointPressureFlash: typing.Type[DewPointPressureFlash] + DewPointTemperatureFlash: typing.Type[DewPointTemperatureFlash] + DewPointTemperatureFlashDer: typing.Type[DewPointTemperatureFlashDer] + FreezeOut: typing.Type[FreezeOut] + FreezingPointTemperatureFlash: typing.Type[FreezingPointTemperatureFlash] + FreezingPointTemperatureFlashOld: typing.Type[FreezingPointTemperatureFlashOld] + FreezingPointTemperatureFlashTR: typing.Type[FreezingPointTemperatureFlashTR] + FugTestConstP: typing.Type[FugTestConstP] + HCdewPointPressureFlash: typing.Type[HCdewPointPressureFlash] + HydrateEquilibriumLine: typing.Type[HydrateEquilibriumLine] + HydrateFormationPressureFlash: typing.Type[HydrateFormationPressureFlash] + HydrateFormationTemperatureFlash: typing.Type[HydrateFormationTemperatureFlash] + HydrateInhibitorConcentrationFlash: typing.Type[HydrateInhibitorConcentrationFlash] + HydrateInhibitorwtFlash: typing.Type[HydrateInhibitorwtFlash] + SolidComplexTemperatureCalc: typing.Type[SolidComplexTemperatureCalc] + WATcalc: typing.Type[WATcalc] + WaterDewPointEquilibriumLine: typing.Type[WaterDewPointEquilibriumLine] + WaterDewPointTemperatureFlash: typing.Type[WaterDewPointTemperatureFlash] + WaterDewPointTemperatureMultiphaseFlash: typing.Type[WaterDewPointTemperatureMultiphaseFlash] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/__init__.pyi new file mode 100644 index 00000000..10fb5fe4 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/__init__.pyi @@ -0,0 +1,17 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import jneqsim.thermodynamicoperations.phaseenvelopeops.multicomponentenvelopeops +import jneqsim.thermodynamicoperations.phaseenvelopeops.reactivecurves +import typing + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermodynamicoperations.phaseenvelopeops")``. + + multicomponentenvelopeops: jneqsim.thermodynamicoperations.phaseenvelopeops.multicomponentenvelopeops.__module_protocol__ + reactivecurves: jneqsim.thermodynamicoperations.phaseenvelopeops.reactivecurves.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/multicomponentenvelopeops/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/multicomponentenvelopeops/__init__.pyi new file mode 100644 index 00000000..bfda6fe4 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/multicomponentenvelopeops/__init__.pyi @@ -0,0 +1,203 @@ + +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 jneqsim.thermodynamicoperations +import org.jfree.chart +import typing + + + +class HPTphaseEnvelope(jneqsim.thermodynamicoperations.BaseOperation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def displayResult(self) -> None: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class PTphaseEnvelope(jneqsim.thermodynamicoperations.BaseOperation): + points2: typing.MutableSequence[typing.MutableSequence[float]] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], double: float, double2: float, boolean: bool): ... + def addData(self, string: typing.Union[java.lang.String, str], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def calcHydrateLine(self) -> None: ... + def displayResult(self) -> None: ... + def get(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def isBubblePointFirst(self) -> bool: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + def setBubblePointFirst(self, boolean: bool) -> None: ... + def tempKWilson(self, double: float, double2: float) -> float: ... + +class PTphaseEnvelope1(jneqsim.thermodynamicoperations.BaseOperation): + points2: typing.MutableSequence[typing.MutableSequence[float]] = ... + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], double: float, double2: float, boolean: bool): ... + def displayResult(self) -> None: ... + def get(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def isBubblePointFirst(self) -> bool: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + def setBubblePointFirst(self, boolean: bool) -> None: ... + +class PTphaseEnvelopeMay(jneqsim.thermodynamicoperations.BaseOperation): + points2: typing.MutableSequence[typing.MutableSequence[float]] = ... + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], double: float, double2: float, boolean: bool): ... + def addData(self, string: typing.Union[java.lang.String, str], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def calcHydrateLine(self) -> None: ... + def displayResult(self) -> None: ... + def get(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def isBubblePointFirst(self) -> bool: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + def setBubblePointFirst(self, boolean: bool) -> None: ... + def tempKWilson(self, double: float, double2: float) -> float: ... + +class PTphaseEnvelopeNew(jneqsim.thermodynamicoperations.BaseOperation): + points2: typing.MutableSequence[typing.MutableSequence[float]] = ... + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], double: float, double2: float): ... + def displayResult(self) -> None: ... + def get(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class PTphaseEnvelopeNew2(jneqsim.thermodynamicoperations.BaseOperation): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], double: float, double2: float, boolean: bool): ... + def calcHydrateLine(self) -> None: ... + def displayResult(self) -> None: ... + def get(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def isBubblePointFirst(self) -> bool: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + def setBubblePointFirst(self, boolean: bool) -> None: ... + def tempKWilson(self, double: float, double2: float) -> float: ... + +class PTphaseEnvelopeNew3(jneqsim.thermodynamicoperations.OperationInterface): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float, double3: float, double4: float, double5: float, double6: float): ... + def addData(self, string: typing.Union[java.lang.String, str], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def coarse(self) -> None: ... + def displayResult(self) -> None: ... + def findBettaTransitionsAndRefine(self) -> None: ... + def get(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getBettaMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getBettaTransitionRegion(self) -> typing.MutableSequence[typing.MutableSequence[bool]]: ... + def getCricondenbar(self) -> float: ... + def getCricondentherm(self) -> float: ... + def getDewPointPressures(self) -> typing.MutableSequence[float]: ... + def getDewPointTemperatures(self) -> typing.MutableSequence[float]: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getPhaseMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getPressurePhaseEnvelope(self) -> java.util.List[float]: ... + def getPressures(self) -> typing.MutableSequence[float]: ... + def getRefinedTransitionPoints(self) -> java.util.List[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getTemperaturePhaseEnvelope(self) -> java.util.List[float]: ... + def getTemperatures(self) -> typing.MutableSequence[float]: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class SysNewtonRhapsonPhaseEnvelope(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int, int2: int): ... + def calcCrit(self) -> None: ... + def calcInc(self, int: int) -> None: ... + def calcInc2(self, int: int) -> None: ... + def calc_x_y(self) -> None: ... + def findSpecEq(self) -> None: ... + def findSpecEqInit(self) -> None: ... + def getNpCrit(self) -> int: ... + def init(self) -> None: ... + def setJac(self) -> None: ... + def setJac2(self) -> None: ... + def setfvec(self) -> None: ... + def setfvec22(self) -> None: ... + def setu(self) -> None: ... + def sign(self, double: float, double2: float) -> float: ... + def solve(self, int: int) -> None: ... + def useAsSpecEq(self, int: int) -> None: ... + +class SysNewtonRhapsonPhaseEnvelope2(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcInc(self, int: int) -> None: ... + def calcInc2(self, int: int) -> None: ... + def critPassed(self) -> bool: ... + def findSpecEq(self) -> None: ... + def findSpecEqInit(self) -> None: ... + def getNpCrit(self) -> int: ... + def init(self) -> None: ... + @staticmethod + def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + def setJac(self) -> None: ... + def setfvec(self) -> None: ... + def setu(self) -> None: ... + def sign(self, double: float, double2: float) -> float: ... + def solve(self, int: int) -> None: ... + +class CricondenBarFlash(PTphaseEnvelope): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], double: 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 funcP(self) -> None: ... + def funcT(self) -> None: ... + def init(self) -> None: ... + def run(self) -> None: ... + def setNewK(self) -> None: ... + def setNewX(self) -> None: ... + +class CricondenThermFlash(PTphaseEnvelope): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], double: 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 funcP(self) -> None: ... + def funcT(self) -> None: ... + def init(self) -> None: ... + def run(self) -> None: ... + def setNewK(self) -> None: ... + def setNewX(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermodynamicoperations.phaseenvelopeops.multicomponentenvelopeops")``. + + CricondenBarFlash: typing.Type[CricondenBarFlash] + CricondenThermFlash: typing.Type[CricondenThermFlash] + HPTphaseEnvelope: typing.Type[HPTphaseEnvelope] + PTphaseEnvelope: typing.Type[PTphaseEnvelope] + PTphaseEnvelope1: typing.Type[PTphaseEnvelope1] + PTphaseEnvelopeMay: typing.Type[PTphaseEnvelopeMay] + PTphaseEnvelopeNew: typing.Type[PTphaseEnvelopeNew] + PTphaseEnvelopeNew2: typing.Type[PTphaseEnvelopeNew2] + PTphaseEnvelopeNew3: typing.Type[PTphaseEnvelopeNew3] + SysNewtonRhapsonPhaseEnvelope: typing.Type[SysNewtonRhapsonPhaseEnvelope] + SysNewtonRhapsonPhaseEnvelope2: typing.Type[SysNewtonRhapsonPhaseEnvelope2] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/reactivecurves/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/reactivecurves/__init__.pyi new file mode 100644 index 00000000..b9d76258 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/reactivecurves/__init__.pyi @@ -0,0 +1,48 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.thermo.system +import jneqsim.thermodynamicoperations +import org.jfree.chart +import typing + + + +class PloadingCurve(jneqsim.thermodynamicoperations.OperationInterface): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def addData(self, string: typing.Union[java.lang.String, str], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + def displayResult(self) -> None: ... + def get(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + +class PloadingCurve2(jneqsim.thermodynamicoperations.BaseOperation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def displayResult(self) -> None: ... + def get(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + def getJFreeChart(self, string: typing.Union[java.lang.String, str]) -> org.jfree.chart.JFreeChart: ... + def getPoints(self, int: int) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getResultTable(self) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... + def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def run(self) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermodynamicoperations.phaseenvelopeops.reactivecurves")``. + + PloadingCurve: typing.Type[PloadingCurve] + PloadingCurve2: typing.Type[PloadingCurve2] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/propertygenerator/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/propertygenerator/__init__.pyi new file mode 100644 index 00000000..28533b78 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/propertygenerator/__init__.pyi @@ -0,0 +1,130 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import jpype +import jneqsim.thermo.system +import jneqsim.thermodynamicoperations +import typing + + + +class OLGApropertyTableGenerator(jneqsim.thermodynamicoperations.BaseOperation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcPhaseEnvelope(self) -> None: ... + def displayResult(self) -> None: ... + def run(self) -> None: ... + def setPressureRange(self, double: float, double2: float, int: int) -> None: ... + def setTemperatureRange(self, double: float, double2: float, int: int) -> None: ... + def writeOLGAinpFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class OLGApropertyTableGeneratorKeywordFormat(jneqsim.thermodynamicoperations.BaseOperation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcBubP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcBubT(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcDewP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcPhaseEnvelope(self) -> None: ... + def displayResult(self) -> None: ... + def initCalc(self) -> None: ... + def run(self) -> None: ... + def setPressureRange(self, double: float, double2: float, int: int) -> None: ... + def setTemperatureRange(self, double: float, double2: float, int: int) -> None: ... + def writeOLGAinpFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class OLGApropertyTableGeneratorWater(jneqsim.thermodynamicoperations.BaseOperation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcBubP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcBubT(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcDewP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcPhaseEnvelope(self) -> None: ... + def calcRSWTOB(self) -> None: ... + def displayResult(self) -> None: ... + def extrapolateTable(self) -> None: ... + def initCalc(self) -> None: ... + def run(self) -> None: ... + def setFileName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPressureRange(self, double: float, double2: float, int: int) -> None: ... + def setTemperatureRange(self, double: float, double2: float, int: int) -> None: ... + def writeOLGAinpFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def writeOLGAinpFile2(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class OLGApropertyTableGeneratorWaterEven(jneqsim.thermodynamicoperations.BaseOperation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcBubP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcBubT(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcDewP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcPhaseEnvelope(self) -> None: ... + def calcRSWTOB(self) -> None: ... + def displayResult(self) -> None: ... + def extrapolateTable(self) -> None: ... + def initCalc(self) -> None: ... + def run(self) -> None: ... + def setFileName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPressureRange(self, double: float, double2: float, int: int) -> None: ... + def setTemperatureRange(self, double: float, double2: float, int: int) -> None: ... + def writeOLGAinpFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def writeOLGAinpFile2(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class OLGApropertyTableGeneratorWaterKeywordFormat(jneqsim.thermodynamicoperations.BaseOperation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcBubP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcBubT(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcDewP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcPhaseEnvelope(self) -> None: ... + def calcRSWTOB(self) -> None: ... + def displayResult(self) -> None: ... + def initCalc(self) -> None: ... + def run(self) -> None: ... + def setPressureRange(self, double: float, double2: float, int: int) -> None: ... + def setTemperatureRange(self, double: float, double2: float, int: int) -> None: ... + def writeOLGAinpFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class OLGApropertyTableGeneratorWaterStudents(jneqsim.thermodynamicoperations.BaseOperation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcBubP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcBubT(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcDewP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcPhaseEnvelope(self) -> None: ... + def calcRSWTOB(self) -> None: ... + def displayResult(self) -> None: ... + def extrapolateTable(self) -> None: ... + def initCalc(self) -> None: ... + def run(self) -> None: ... + def setFileName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPressureRange(self, double: float, double2: float, int: int) -> None: ... + def setTemperatureRange(self, double: float, double2: float, int: int) -> None: ... + def writeOLGAinpFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def writeOLGAinpFile2(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class OLGApropertyTableGeneratorWaterStudentsPH(jneqsim.thermodynamicoperations.BaseOperation): + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... + def calcBubP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcBubT(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcDewP(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> typing.MutableSequence[float]: ... + def calcPhaseEnvelope(self) -> None: ... + def calcRSWTOB(self) -> None: ... + def displayResult(self) -> None: ... + def extrapolateTable(self) -> None: ... + def initCalc(self) -> None: ... + def run(self) -> None: ... + def setEnthalpyRange(self, double: float, double2: float, int: int) -> None: ... + def setFileName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setPressureRange(self, double: float, double2: float, int: int) -> None: ... + def writeOLGAinpFile(self, string: typing.Union[java.lang.String, str]) -> None: ... + def writeOLGAinpFile2(self, string: typing.Union[java.lang.String, str]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermodynamicoperations.propertygenerator")``. + + OLGApropertyTableGenerator: typing.Type[OLGApropertyTableGenerator] + OLGApropertyTableGeneratorKeywordFormat: typing.Type[OLGApropertyTableGeneratorKeywordFormat] + OLGApropertyTableGeneratorWater: typing.Type[OLGApropertyTableGeneratorWater] + OLGApropertyTableGeneratorWaterEven: typing.Type[OLGApropertyTableGeneratorWaterEven] + OLGApropertyTableGeneratorWaterKeywordFormat: typing.Type[OLGApropertyTableGeneratorWaterKeywordFormat] + OLGApropertyTableGeneratorWaterStudents: typing.Type[OLGApropertyTableGeneratorWaterStudents] + OLGApropertyTableGeneratorWaterStudentsPH: typing.Type[OLGApropertyTableGeneratorWaterStudentsPH] diff --git a/src/jneqsim-stubs/jneqsim-stubs/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/util/__init__.pyi new file mode 100644 index 00000000..3cc37148 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/util/__init__.pyi @@ -0,0 +1,108 @@ + +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.lang.annotation +import java.util.concurrent +import jneqsim.util.database +import jneqsim.util.exception +import jneqsim.util.generator +import jneqsim.util.serialization +import jneqsim.util.unit +import jneqsim.util.util +import typing + + + +class ExcludeFromJacocoGeneratedReport(java.lang.annotation.Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class NamedInterface: + def getName(self) -> java.lang.String: ... + def getTagName(self) -> java.lang.String: ... + def setName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setTagName(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class NeqSimLogging: + def __init__(self): ... + @staticmethod + def resetAllLoggers() -> None: ... + @staticmethod + def setGlobalLogging(string: typing.Union[java.lang.String, str]) -> None: ... + +class NeqSimThreadPool: + @staticmethod + def execute(runnable: typing.Union[java.lang.Runnable, typing.Callable]) -> None: ... + @staticmethod + def getDefaultPoolSize() -> int: ... + @staticmethod + def getKeepAliveTimeSeconds() -> int: ... + @staticmethod + def getMaxQueueCapacity() -> int: ... + @staticmethod + def getPool() -> java.util.concurrent.ExecutorService: ... + @staticmethod + def getPoolSize() -> int: ... + @staticmethod + def isAllowCoreThreadTimeout() -> bool: ... + @staticmethod + def isShutdown() -> bool: ... + @staticmethod + def isTerminated() -> bool: ... + _newCompletionService__T = typing.TypeVar('_newCompletionService__T') # + @staticmethod + def newCompletionService() -> java.util.concurrent.CompletionService[_newCompletionService__T]: ... + @staticmethod + def resetPoolSize() -> None: ... + @staticmethod + def setAllowCoreThreadTimeout(boolean: bool) -> None: ... + @staticmethod + def setKeepAliveTimeSeconds(long: int) -> None: ... + @staticmethod + def setMaxQueueCapacity(int: int) -> None: ... + @staticmethod + def setPoolSize(int: int) -> None: ... + @staticmethod + def shutdown() -> None: ... + @staticmethod + def shutdownAndAwait(long: int, timeUnit: java.util.concurrent.TimeUnit) -> bool: ... + @staticmethod + def shutdownNow() -> None: ... + _submit_1__T = typing.TypeVar('_submit_1__T') # + @typing.overload + @staticmethod + def submit(runnable: typing.Union[java.lang.Runnable, typing.Callable]) -> java.util.concurrent.Future[typing.Any]: ... + @typing.overload + @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 NamedBaseClass(NamedInterface, java.io.Serializable): + name: java.lang.String = ... + def __init__(self, string: typing.Union[java.lang.String, str]): ... + def getName(self) -> java.lang.String: ... + def getTagName(self) -> java.lang.String: ... + def setName(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setTagName(self, string: typing.Union[java.lang.String, str]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.util")``. + + ExcludeFromJacocoGeneratedReport: typing.Type[ExcludeFromJacocoGeneratedReport] + NamedBaseClass: typing.Type[NamedBaseClass] + NamedInterface: typing.Type[NamedInterface] + NeqSimLogging: typing.Type[NeqSimLogging] + NeqSimThreadPool: typing.Type[NeqSimThreadPool] + database: jneqsim.util.database.__module_protocol__ + exception: jneqsim.util.exception.__module_protocol__ + generator: jneqsim.util.generator.__module_protocol__ + serialization: jneqsim.util.serialization.__module_protocol__ + unit: jneqsim.util.unit.__module_protocol__ + util: jneqsim.util.util.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/util/database/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/util/database/__init__.pyi new file mode 100644 index 00000000..031de4c8 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/util/database/__init__.pyi @@ -0,0 +1,180 @@ + +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.sql +import jneqsim.util.util +import typing + + + +class AspenIP21Database(jneqsim.util.util.FileSystemSettings, java.io.Serializable): + def __init__(self): ... + @typing.overload + def getResultSet(self, string: typing.Union[java.lang.String, str]) -> java.sql.ResultSet: ... + @typing.overload + def getResultSet(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> java.sql.ResultSet: ... + def getStatement(self) -> java.sql.Statement: ... + def openConnection(self, string: typing.Union[java.lang.String, str]) -> java.sql.Connection: ... + def setStatement(self, statement: java.sql.Statement) -> None: ... + +class NeqSimBlobDatabase(jneqsim.util.util.FileSystemSettings, java.io.Serializable): + dataBasePath: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def createTemporaryTables(self) -> bool: ... + def execute(self, string: typing.Union[java.lang.String, str]) -> None: ... + def getConnection(self) -> java.sql.Connection: ... + @staticmethod + def getConnectionString() -> java.lang.String: ... + @staticmethod + def getDataBaseType() -> java.lang.String: ... + def getResultSet(self, string: typing.Union[java.lang.String, str]) -> java.sql.ResultSet: ... + def getStatement(self) -> java.sql.Statement: ... + def openConnection(self) -> java.sql.Connection: ... + @staticmethod + def setConnectionString(string: typing.Union[java.lang.String, str]) -> None: ... + def setCreateTemporaryTables(self, boolean: bool) -> None: ... + @typing.overload + @staticmethod + def setDataBaseType(string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + @staticmethod + def setDataBaseType(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @staticmethod + def setPassword(string: typing.Union[java.lang.String, str]) -> None: ... + def setStatement(self, statement: java.sql.Statement) -> None: ... + @staticmethod + def setUsername(string: typing.Union[java.lang.String, str]) -> None: ... + +class NeqSimDataBase(jneqsim.util.util.FileSystemSettings, java.io.Serializable, java.lang.AutoCloseable): + dataBasePath: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def close(self) -> None: ... + @staticmethod + def createTemporaryTables() -> bool: ... + def execute(self, string: typing.Union[java.lang.String, str]) -> bool: ... + def executeQuery(self, string: typing.Union[java.lang.String, str]) -> None: ... + @staticmethod + def getComponentNames() -> typing.MutableSequence[java.lang.String]: ... + def getConnection(self) -> java.sql.Connection: ... + @staticmethod + def getConnectionString() -> java.lang.String: ... + @staticmethod + def getDataBaseType() -> java.lang.String: ... + def getResultSet(self, string: typing.Union[java.lang.String, str]) -> java.sql.ResultSet: ... + def getStatement(self) -> java.sql.Statement: ... + @staticmethod + def hasComponent(string: typing.Union[java.lang.String, str]) -> bool: ... + @staticmethod + def hasTempComponent(string: typing.Union[java.lang.String, str]) -> bool: ... + @staticmethod + def initH2DatabaseFromCSVfiles() -> None: ... + def openConnection(self) -> java.sql.Connection: ... + @staticmethod + def replaceTable(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @staticmethod + def setConnectionString(string: typing.Union[java.lang.String, str]) -> None: ... + @staticmethod + def setCreateTemporaryTables(boolean: bool) -> None: ... + @typing.overload + @staticmethod + def setDataBaseType(string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + @staticmethod + def setDataBaseType(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @staticmethod + def setPassword(string: typing.Union[java.lang.String, str]) -> None: ... + def setStatement(self, statement: java.sql.Statement) -> None: ... + @staticmethod + def setUsername(string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + @staticmethod + def updateTable(string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + @staticmethod + def updateTable(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @staticmethod + def useExtendedComponentDatabase(boolean: bool) -> None: ... + +class NeqSimExperimentDatabase(jneqsim.util.util.FileSystemSettings, java.io.Serializable): + dataBasePath: typing.ClassVar[java.lang.String] = ... + username: typing.ClassVar[java.lang.String] = ... + password: typing.ClassVar[java.lang.String] = ... + connectionString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def createTemporaryTables(self) -> bool: ... + def execute(self, string: typing.Union[java.lang.String, str]) -> None: ... + def getConnection(self) -> java.sql.Connection: ... + @staticmethod + def getConnectionString() -> java.lang.String: ... + @staticmethod + def getDataBaseType() -> java.lang.String: ... + def getResultSet(self, string: typing.Union[java.lang.String, str]) -> java.sql.ResultSet: ... + def getStatement(self) -> java.sql.Statement: ... + def openConnection(self) -> java.sql.Connection: ... + @staticmethod + def setConnectionString(string: typing.Union[java.lang.String, str]) -> None: ... + def setCreateTemporaryTables(self, boolean: bool) -> None: ... + @typing.overload + @staticmethod + def setDataBaseType(string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + @staticmethod + def setDataBaseType(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @staticmethod + def setPassword(string: typing.Union[java.lang.String, str]) -> None: ... + def setStatement(self, statement: java.sql.Statement) -> None: ... + @staticmethod + def setUsername(string: typing.Union[java.lang.String, str]) -> None: ... + +class NeqSimFluidDataBase(jneqsim.util.util.FileSystemSettings, java.io.Serializable): + useOnlineBase: typing.ClassVar[bool] = ... + def __init__(self): ... + def execute(self, string: typing.Union[java.lang.String, str]) -> None: ... + def getConnection(self) -> java.sql.Connection: ... + @typing.overload + def getResultSet(self, string: typing.Union[java.lang.String, str]) -> java.sql.ResultSet: ... + @typing.overload + def getResultSet(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> java.sql.ResultSet: ... + def openConnection(self, string: typing.Union[java.lang.String, str]) -> java.sql.Connection: ... + +class NeqSimContractDataBase(NeqSimDataBase): + dataBasePath: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @staticmethod + def initH2DatabaseFromCSVfiles() -> None: ... + @typing.overload + @staticmethod + def updateTable(string: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + @staticmethod + def updateTable(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + +class NeqSimProcessDesignDataBase(NeqSimDataBase): + dataBasePath: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @staticmethod + def initH2DatabaseFromCSVfiles() -> None: ... + @typing.overload + @staticmethod + def updateTable(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + @typing.overload + @staticmethod + def updateTable(string: typing.Union[java.lang.String, str]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.util.database")``. + + AspenIP21Database: typing.Type[AspenIP21Database] + NeqSimBlobDatabase: typing.Type[NeqSimBlobDatabase] + NeqSimContractDataBase: typing.Type[NeqSimContractDataBase] + NeqSimDataBase: typing.Type[NeqSimDataBase] + NeqSimExperimentDatabase: typing.Type[NeqSimExperimentDatabase] + NeqSimFluidDataBase: typing.Type[NeqSimFluidDataBase] + NeqSimProcessDesignDataBase: typing.Type[NeqSimProcessDesignDataBase] diff --git a/src/jneqsim-stubs/jneqsim-stubs/util/exception/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/util/exception/__init__.pyi new file mode 100644 index 00000000..2319be75 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/util/exception/__init__.pyi @@ -0,0 +1,77 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import typing + + + +class ThermoException(java.lang.Exception): + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]): ... + +class InvalidInputException(ThermoException): + @typing.overload + def __init__(self, object: typing.Any, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, object: typing.Any, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]): ... + @typing.overload + 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]): ... + +class InvalidOutputException(ThermoException): + @typing.overload + def __init__(self, object: typing.Any, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, object: typing.Any, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]): ... + @typing.overload + 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]): ... + +class IsNaNException(ThermoException): + @typing.overload + def __init__(self, object: typing.Any, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]): ... + +class NotImplementedException(ThermoException): + @typing.overload + def __init__(self, object: typing.Any, string: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + +class NotInitializedException(ThermoException): + @typing.overload + def __init__(self, object: typing.Any, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, object: typing.Any, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]): ... + @typing.overload + 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]): ... + +class TooManyIterationsException(ThermoException): + @typing.overload + def __init__(self, object: typing.Any, string: typing.Union[java.lang.String, str], long: int): ... + @typing.overload + def __init__(self, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], long: int): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.util.exception")``. + + InvalidInputException: typing.Type[InvalidInputException] + InvalidOutputException: typing.Type[InvalidOutputException] + IsNaNException: typing.Type[IsNaNException] + NotImplementedException: typing.Type[NotImplementedException] + NotInitializedException: typing.Type[NotInitializedException] + ThermoException: typing.Type[ThermoException] + TooManyIterationsException: typing.Type[TooManyIterationsException] diff --git a/src/jneqsim-stubs/jneqsim-stubs/util/generator/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/util/generator/__init__.pyi new file mode 100644 index 00000000..cecd9fbe --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/util/generator/__init__.pyi @@ -0,0 +1,25 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jpype +import jneqsim.thermo.system +import typing + + + +class PropertyGenerator: + def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, doubleArray: typing.Union[typing.List[float], jpype.JArray], doubleArray2: typing.Union[typing.List[float], jpype.JArray]): ... + def calculate(self) -> java.util.HashMap[java.lang.String, typing.MutableSequence[float]]: ... + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.util.generator")``. + + PropertyGenerator: typing.Type[PropertyGenerator] diff --git a/src/jneqsim-stubs/jneqsim-stubs/util/serialization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/util/serialization/__init__.pyi new file mode 100644 index 00000000..bcd85c2b --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/util/serialization/__init__.pyi @@ -0,0 +1,32 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import typing + + + +class NeqSimXtream: + def __init__(self): ... + @staticmethod + def openNeqsim(string: typing.Union[java.lang.String, str]) -> typing.Any: ... + @staticmethod + def saveNeqsim(object: typing.Any, string: typing.Union[java.lang.String, str]) -> bool: ... + +class SerializationManager: + def __init__(self): ... + @staticmethod + def open(string: typing.Union[java.lang.String, str]) -> typing.Any: ... + @staticmethod + def save(object: typing.Any, string: typing.Union[java.lang.String, str]) -> None: ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.util.serialization")``. + + NeqSimXtream: typing.Type[NeqSimXtream] + SerializationManager: typing.Type[SerializationManager] diff --git a/src/jneqsim-stubs/jneqsim-stubs/util/unit/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/util/unit/__init__.pyi new file mode 100644 index 00000000..e555bf6d --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/util/unit/__init__.pyi @@ -0,0 +1,131 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import java.util +import jneqsim.thermo +import typing + + + +class NeqSimUnitSet: + def __init__(self): ... + def getComponentConcentrationUnit(self) -> java.lang.String: ... + def getFlowRateUnit(self) -> java.lang.String: ... + def getPressureUnit(self) -> java.lang.String: ... + def getTemperatureUnit(self) -> java.lang.String: ... + def setComponentConcentrationUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setFlowRateUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + @staticmethod + def setNeqSimUnits(string: typing.Union[java.lang.String, str]) -> None: ... + def setPressureUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + def setTemperatureUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... + +class Unit: + def getSIvalue(self) -> float: ... + @typing.overload + def getValue(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class Units: + activeUnits: typing.ClassVar[java.util.HashMap] = ... + defaultUnits: typing.ClassVar[java.util.HashMap] = ... + metricUnits: typing.ClassVar[java.util.HashMap] = ... + def __init__(self): ... + @staticmethod + def activateDefaultUnits() -> None: ... + @staticmethod + def activateFieldUnits() -> None: ... + @staticmethod + def activateMetricUnits() -> None: ... + @staticmethod + def activateSIUnits() -> None: ... + def getMolarVolumeUnits(self) -> typing.MutableSequence[java.lang.String]: ... + def getPressureUnits(self) -> typing.MutableSequence[java.lang.String]: ... + @staticmethod + def getSymbol(string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + @staticmethod + def getSymbolName(string: typing.Union[java.lang.String, str]) -> java.lang.String: ... + def getTemperatureUnits(self) -> typing.MutableSequence[java.lang.String]: ... + @staticmethod + def setUnit(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str], string3: typing.Union[java.lang.String, str]) -> None: ... + class UnitDescription: + symbol: java.lang.String = ... + symbolName: java.lang.String = ... + def __init__(self, units: 'Units', string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]): ... + +class BaseUnit(Unit, jneqsim.thermo.ThermodynamicConstantsInterface): + def __init__(self, double: float, string: typing.Union[java.lang.String, str]): ... + def getSIvalue(self) -> float: ... + @typing.overload + def getValue(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class EnergyUnit(BaseUnit): + def __init__(self, double: float, string: typing.Union[java.lang.String, str]): ... + def getConversionFactor(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class LengthUnit(BaseUnit): + def __init__(self, double: float, string: typing.Union[java.lang.String, str]): ... + +class PowerUnit(BaseUnit): + def __init__(self, double: float, string: typing.Union[java.lang.String, str]): ... + def getConversionFactor(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class PressureUnit(BaseUnit): + def __init__(self, double: float, string: typing.Union[java.lang.String, str]): ... + def getConversionFactor(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class RateUnit(BaseUnit): + def __init__(self, double: float, string: typing.Union[java.lang.String, str], double2: float, double3: float, double4: float): ... + def getConversionFactor(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getSIvalue(self) -> float: ... + @typing.overload + def getValue(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class TemperatureUnit(BaseUnit): + def __init__(self, double: float, string: typing.Union[java.lang.String, str]): ... + def getConversionFactor(self, string: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, double: float, string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> float: ... + @typing.overload + def getValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + +class TimeUnit(BaseUnit): + def __init__(self, double: float, string: typing.Union[java.lang.String, str]): ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.util.unit")``. + + BaseUnit: typing.Type[BaseUnit] + EnergyUnit: typing.Type[EnergyUnit] + LengthUnit: typing.Type[LengthUnit] + NeqSimUnitSet: typing.Type[NeqSimUnitSet] + PowerUnit: typing.Type[PowerUnit] + PressureUnit: typing.Type[PressureUnit] + RateUnit: typing.Type[RateUnit] + TemperatureUnit: typing.Type[TemperatureUnit] + TimeUnit: typing.Type[TimeUnit] + Unit: typing.Type[Unit] + Units: typing.Type[Units] diff --git a/src/jneqsim-stubs/jneqsim-stubs/util/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/util/util/__init__.pyi new file mode 100644 index 00000000..620e9bf8 --- /dev/null +++ b/src/jneqsim-stubs/jneqsim-stubs/util/util/__init__.pyi @@ -0,0 +1,35 @@ + +import sys +if sys.version_info >= (3, 8): + from typing import Protocol +else: + from typing_extensions import Protocol + +import java.lang +import typing + + + +class DoubleCloneable(java.lang.Cloneable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float): ... + def clone(self) -> 'DoubleCloneable': ... + def doubleValue(self) -> float: ... + def set(self, double: float) -> None: ... + +class FileSystemSettings: + root: typing.ClassVar[java.lang.String] = ... + tempDir: typing.ClassVar[java.lang.String] = ... + defaultFileTreeRoot: typing.ClassVar[java.lang.String] = ... + defaultDatabaseRootRoot: typing.ClassVar[java.lang.String] = ... + relativeFilePath: typing.ClassVar[java.lang.String] = ... + fileExtension: typing.ClassVar[java.lang.String] = ... + + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("jneqsim.util.util")``. + + DoubleCloneable: typing.Type[DoubleCloneable] + FileSystemSettings: typing.Type[FileSystemSettings] diff --git a/src/jneqsim-stubs/jpype-stubs/__init__.pyi b/src/jneqsim-stubs/jpype-stubs/__init__.pyi new file mode 100644 index 00000000..fe25482e --- /dev/null +++ b/src/jneqsim-stubs/jpype-stubs/__init__.pyi @@ -0,0 +1,23 @@ +import types +import typing + + +import sys +if sys.version_info >= (3, 8): + from typing import Literal +else: + from typing_extensions import Literal + +import neqsim + + +@typing.overload +def JPackage(__package_name: Literal['neqsim']) -> jneqsim.__module_protocol__: ... + + +@typing.overload +def JPackage(__package_name: str) -> types.ModuleType: ... + + +def JPackage(__package_name) -> types.ModuleType: ... + diff --git a/src/jneqsim-stubs/jpype-stubs/py.typed b/src/jneqsim-stubs/jpype-stubs/py.typed new file mode 100644 index 00000000..b648ac92 --- /dev/null +++ b/src/jneqsim-stubs/jpype-stubs/py.typed @@ -0,0 +1 @@ +partial diff --git a/src/neqsim/py.typed b/src/neqsim/py.typed new file mode 100644 index 00000000..e69de29b